root/pl/PLObjectOutput.java

//
//      ===========================================================================
//
//      Title:          PLObjectOutput.java
//      Description:    PL ObjectOutput
//      Author:         Rapha‘l Szwarc http://alt.textdrive.com/pl/
//      Creation Date:  Thu Dec 09 2004
//      Legal:          Copyright (C) 2004 Rapha‘l Szwarc
//
//      This software is provided 'as-is', without any express or implied warranty. 
//      In no event will the author be held liable for any damages arising from 
//      the use of this software.
//
//      Permission is granted to anyone to use this software for any purpose, 
//      including commercial applications, and to alter it and 
//      redistribute it freely, subject to the following restrictions:
//
//      1. The origin of this software must not be misrepresented; 
//      you must not claim that you wrote the original software. 
//      If you use this software in a product, an acknowledgment
//      in the product documentation would be appreciated but is not required.
//
//      2. Altered source versions must be plainly marked as such, 
//      and must not be misrepresented as being the original software.
//
//      3. This notice may not be removed or altered from any source distribution.
//
//      ---------------------------------------------------------------------------
//

package alt.dev.pl;

import java.io.ByteArrayOutputStream;
import java.io.OutputStream;
import java.io.ObjectOutput;
import java.io.IOException;

import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;

import java.util.logging.Logger;
import java.util.logging.Level;

public class PLObjectOutput extends Object implements ObjectOutput, PLWriter.Delegate
{

//      ===========================================================================
//      Constant(s)
//      ---------------------------------------------------------------------------

        private static final Logger     Log = Logger.getLogger( PLObjectOutput.class.getName() );

//      ===========================================================================
//      Class variable(s)
//      ---------------------------------------------------------------------------

//      ===========================================================================
//      Instance variable(s)
//      ---------------------------------------------------------------------------

        private OutputStream            _outputStream = null;
        private PLObjectOutput          _parent = null;
        private List                    _values = null;
        private boolean                 _isTraversing = false;
        private Map                     _userInfo = null;
        private int                     _aliasID = 0;
        private CountedSet              _aliasIDs = null;
        private Map                     _aliases = null;
        
//      ===========================================================================
//      Constructor method(s)
//      ---------------------------------------------------------------------------

        public PLObjectOutput(final OutputStream anOutputStream)
        {
                this();
                
                this.setOutputStream( anOutputStream );
        }

        PLObjectOutput(final PLObjectOutput aParent)
        {
                this();
                
                this.setParent( aParent );
        }
        
        PLObjectOutput()
        {
                super();
        }

//      ===========================================================================
//      Class method(s)
//      ---------------------------------------------------------------------------

        public static String toString(final Object anObject)
        {
                try
                {
                        ByteArrayOutputStream   anOutputStream = new ByteArrayOutputStream();
                        ObjectOutput            anObjectOutput = new PLObjectOutput( anOutputStream );
                        
                        anObjectOutput.writeObject( anObject );
                        anObjectOutput.close();
                       
                        return new String( anOutputStream.toByteArray(), PLWriter.Encoding );
                }
                catch (Exception anException)
                {
                        Log.log( Level.FINER, anException.getMessage(), anException );
                        Log.info( "Couldn't convert '" + anObject + "'." );
                }
                
                return null;
        }

//      ===========================================================================
//      Instance method(s)
//      ---------------------------------------------------------------------------

        private OutputStream outputStream()
        {
                return _outputStream;
        }
        
        private void setOutputStream(final OutputStream aValue)
        {
                if ( aValue != null )
                {
                        _outputStream = aValue;
                        
                        return;
                }
                
                throw new IllegalArgumentException( "PLObjectOutput.setOutputStream: value" );
        }
        
        private PLObjectOutput parent()
        {
                return _parent;
        }
        
        private void setParent(final PLObjectOutput aValue)
        {
                if ( aValue != null )
                {
                        _parent = aValue;
                        
                        return;
                }
                
                throw new IllegalArgumentException( "PLObjectOutput.setOutputStream: value" );
        }
        
        public List values()
        {
                if ( _values == null )
                {
                        this.setValues( new ArrayList() );
                }
                
                return _values;
        }
        
        private void setValues(final List aValue)
        {
                _values = aValue;
        }
        
        private boolean isTraversing()
        {
                return _isTraversing;
        }
        
        private void setIsTraversing(final boolean aValue)
        {
                _isTraversing = aValue;
        }
        
        public Map userInfo()
        {
                if ( _userInfo == null )
                {
                        _userInfo = new HashMap();
                }
        
                return _userInfo;
        }
        
//      ===========================================================================
//      DataOutput method(s)
//      ---------------------------------------------------------------------------

        public void write(final byte[] aValue) throws IOException
        {
                this.values().add( aValue );
        }

        public void write(final byte[] aValue, final int anOffset, final int aLength) throws IOException
        {
                byte[]  someBytes = new byte[ aLength ];
                
                System.arraycopy( aValue, anOffset, someBytes, 0, aLength );
                
                this.values().add( someBytes );
        }

        public void write(final int aValue) throws IOException
        {
                byte[]  someBytes = { (byte) aValue };
                
                this.values().add( someBytes );
        }

        public void writeBoolean(final boolean aValue) throws IOException
        {
                String  aDescription = Boolean.TYPE.getName() + ":" + Boolean.toString( aValue );
                
                this.values().add( aDescription );
        }

        public void writeByte(final int aValue) throws IOException
        {
                byte[]  someBytes = { (byte) aValue };
                
                this.values().add( someBytes );
        }

        public void writeBytes(final String aValue) throws IOException
        {
                this.values().add( aValue.getBytes() );
        }

        public void writeChar(final int aValue) throws IOException
        {
                String  aDescription = Character.toString( (char) aValue );
                
                this.values().add( aDescription );
        }

        public void writeChars(final String aValue) throws IOException
        {
                this.values().add( aValue );
        }

        public void writeDouble(final double aValue) throws IOException
        {
                String  aDescription = Double.TYPE.getName() + ":" + Double.toString( aValue );
                
                this.values().add( aDescription );
        }

        public void writeFloat(final float aValue) throws IOException
        {
                String  aDescription = Float.TYPE.getName() + ":" + Float.toString( aValue );
                
                this.values().add( aDescription );
        }

        public void writeInt(final int aValue) throws IOException
        {
                String  aDescription = Integer.TYPE.getName() + ":" + Integer.toString( aValue );
                
                this.values().add( aDescription );
        }

        public void writeLong(final long aValue) throws IOException
        {
                String  aDescription = Long.TYPE.getName() + ":" + Long.toString( aValue );
                
                this.values().add( aDescription );
        }

        public void writeShort(final int aValue) throws IOException
        {
                String  aDescription = Short.TYPE.getName() + ":" + Short.toString( (short) aValue );
                
                this.values().add( aDescription );
        }

        public void writeUTF(final String aValue) throws IOException
        {
                List    someValues = this.values();
                
                this.values().add( aValue );
        }

//      ===========================================================================
//      ObjectOutput method(s)
//      ---------------------------------------------------------------------------

        public void close() throws IOException
        {
                if ( this.outputStream() != null )
                {
                        this.outputStream().close();
                }
        }

        public void flush() throws IOException
        {
        }

        public void writeObject(final Object anObject) throws IOException
        {
                if ( this.parent() == null )
                {
                        PLWriter      aWriter = new PLWriter( this.outputStream() );
                        
                        aWriter.setDelegate( this );
                        
                        this.setIsTraversing( true );
                        PLObjectOutputWriter.writeObject( anObject, this );
                        this.aliases().clear();
                        this.setAliasID( 0 );
                        this.setIsTraversing( false );

                        aWriter.writeObject( anObject );
                }
                else
                {
                        Object  anotherObject = PLObjectOutputWriter.writeObject( anObject, this );
                
                        this.values().add( anotherObject );
                }
        }
        
//      ===========================================================================
//      PLWriter.Delegate method(s)
//      ---------------------------------------------------------------------------

        public Object valueForObject(final PLWriter aWriter, final Object anObject)
        {
                return PLObjectOutputWriter.writeObject( anObject, this );
        }

//      ===========================================================================
//      Aliases method(s)
//      ---------------------------------------------------------------------------

        private Map aliases()
        {
                if ( this.parent() == null )
                {
                        if ( _aliases == null )
                        {
                                _aliases = new HashMap();
                        }
                        
                        return _aliases;
                }
                
                return this.parent().aliases();
        }

        private int aliasID()
        {
                if ( this.parent() == null )
                {
                        return ( _aliasID += 1 );
                }
                
                return this.parent().aliasID();
        }
        
        private void setAliasID(final int aValue)
        {
                if ( this.parent() == null )
                {
                        _aliasID = aValue;
                        
                        return;
                }
                
                this.parent().setAliasID( aValue );
        }
        
        private CountedSet aliasIDs()
        {
                if ( this.parent() == null )
                {
                        if ( _aliasIDs == null )
                        {
                                _aliasIDs = new CountedSet();
                        }
                
                        return _aliasIDs;
                }
                
                return this.parent().aliasIDs();
        }
        
        public Object aliasID(final Object anObject)
        {
                Object  aKey = this.aliasKey( anObject );
                int     aCount = this.aliasIDs().countForObject( aKey );
                
                if ( aCount > 1 )
                {
                        Object  anAlias = this.alias( anObject );
                        
                        return anAlias.toString();
                }
                        
                return null;
        }
        
        private Object aliasKey(final Object anObject)
        {
                if ( anObject != null )
                {
                        StringBuffer    aBuffer = new StringBuffer( 24 );
                        
                        aBuffer.append( anObject.getClass().hashCode() );
                        aBuffer.append( '@' );
                        aBuffer.append( System.identityHashCode( anObject ) );
                        
                        return aBuffer.toString();
                }
                
                return null;
        }

        Object alias(final Object anObject)
        {
                if ( ( anObject != null ) && ( ( anObject instanceof Alias ) == false ) )
                {
                        Object  aKey = this.aliasKey( anObject );
                        Map     someAliases = this.aliases();
                        Object  anAlias = someAliases.get( aKey );
                        
                        if ( this.isTraversing() == true )
                        {
                                this.aliasIDs().add( aKey );
                        }
                                
                        if ( anAlias == null )
                        {
                                anAlias = new Alias( this.aliasID() );
                                
                                someAliases.put( aKey, anAlias );
                        }
                        else
                        {
                                return anAlias;
                        }
                }
                
                return anObject;
        }
        
//      ===========================================================================
//      Alias method(s)
//      ---------------------------------------------------------------------------

        static final class Alias extends Object
        {
        
                private int     _id = 0;
        
                private Alias(final int anID)
                {
                        super();
                        
                        _id = anID;
                }
                
                public final String toString()
                {
                        return Integer.toString( _id );
                }
                
        }

}