root/pl/PLObjectInputReader.java

//
//      ===========================================================================
//
//      Title:          PLObjectInputReader.java
//      Description:    [Description]
//      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.Externalizable;
import java.io.Serializable;
import java.io.IOException;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.ObjectStreamConstants;
import java.io.ObjectStreamClass;
import java.io.ObjectStreamField;
import java.io.ObjectInput;
import java.io.ObjectInputStream;

import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Proxy;
import java.lang.reflect.InvocationHandler;

import java.math.BigDecimal;
import java.math.BigInteger;

import java.net.InetAddress;
import java.net.URI;

import java.nio.charset.Charset;

import java.text.DateFormat;
import java.text.SimpleDateFormat;

import java.util.Arrays;
import java.util.Collections;
import java.util.Collection;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.IdentityHashMap;
import java.util.Iterator;

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

import java.util.Currency;
import java.util.Date;
import java.util.Locale;
import java.util.TimeZone;

public abstract class PLObjectInputReader extends Object
{

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

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

        private static final Class[]                    Classes = 
                                                        {
                                                                StringReader.class,
                                                                MapReader.class,
                                                                CollectionReader.class,
                                                        };
                                                        
        private static final String                     CustomPrefix = "x-";

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

        private static final PLObjectInputReader[]      _readers = new PLObjectInputReader[ Classes.length ];
        private static final Map                        _readersMap = new IdentityHashMap( Classes.length );

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

//      ===========================================================================
//      Constructor method(s)
//      ---------------------------------------------------------------------------

        protected PLObjectInputReader()
        {
                super();
        }

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

        static 
        {
                Class[] someClasses = PLObjectInputReader.Classes;
                int     count = someClasses.length;
                
                for ( int index = 0; index < count; index++ )
                {
                        Class   aClass = someClasses[ index ];
                        
                        try
                        {
                                PLObjectInputReader     aReader = (PLObjectInputReader) aClass.newInstance();
                                Class                   aType = aReader.type();
                                
                                if ( aType != null )
                                {
                                        if ( _readersMap.containsKey( aType ) == false )
                                        {
                                                _readers[ index ] = aReader;
                                                _readersMap.put( aType, aReader );
                                        }
                                        else
                                        {
                                                throw new IllegalArgumentException( "PLObjectInputReader: duplicate type in " + aClass );
                                        }
                                }
                                else
                                {
                                        throw new IllegalArgumentException( "PLObjectInputReader: null type in " + aClass );
                                }
                        }
                        catch (IllegalArgumentException anException)
                        {
                                throw anException;
                        }
                        catch (Throwable anException)
                        {
                                throw new RuntimeException( anException.getMessage(), anException );
                        }
                }
        }
                
        public static void registerReader(final PLObjectInputReader aReader)
        {
                if ( aReader != null )
                {
                        if ( aReader.type() != null )
                        {
                                if ( aReader.name() != null )
                                {
                                        if ( aReader.name().startsWith( PLObjectInputReader.CustomPrefix ) == true )
                                        {
                                                PLObjectInputReader.stringReader().registerCustomReader( aReader );
                                                PLObjectInputReader.mapReader().registerCustomReader( aReader );
                                                
                                                return;
                                        }

                                        throw new IllegalArgumentException( "PLObjectInputReader.registerReader: missing custom prefix name in " + aReader );
                                }

                                throw new IllegalArgumentException( "PLObjectInputReader.registerReader: null name in " + aReader );
                        }

                        throw new IllegalArgumentException( "PLObjectInputReader.registerReader: null type in " + aReader );
                }
                
                throw new IllegalArgumentException( "PLObjectInputReader.registerReader: null reader" );
        }
        
        private static PLObjectInputReader[] readers()
        {
                return _readers;
        }
        
        private static Map readersMap()
        {
                return _readersMap;
        }
        
        private static StringReader stringReader()
        {
                return (StringReader) PLObjectInputReader.readers()[ 0 ];
        }
        
        private static MapReader mapReader()
        {
                return (MapReader) PLObjectInputReader.readers()[ 1 ];
        }
        
        public static PLObjectInputReader readerForObject(final Object anObject, final PLObjectInput anInput)
        {
                if ( anObject != null )
                {
                        Map                     aMap = PLObjectInputReader.readersMap();
                        PLObjectInputReader     aReader = (PLObjectInputReader) aMap.get( anObject.getClass() );
                        
                        if ( aReader == null )
                        {
                                PLObjectInputReader[]   someReaders = PLObjectInputReader.readers();
                                int                     count = someReaders.length;
                                
                                for ( int index = 0; index < count; index++ )
                                {
                                        PLObjectInputReader      anotherReader = someReaders[ index ];
                                        
                                        if ( anotherReader.canHandleObject( anObject ) == true )
                                        {
                                                aReader = anotherReader;
                                        
                                                break;
                                        }
                                }
                        }
                        
                        return aReader;
                }
                
                return null;
        }
        
        public static Object readObject(final Object anObject, final PLObjectInput anInput)
        {
                PLObjectInputReader     aReader = PLObjectInputReader.readerForObject( anObject, anInput );
                
                if ( aReader != null )
                {
                        return aReader.read( anObject, anInput );
                }
                
                return anObject;
        }

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

        protected abstract Class type();
        
        protected abstract String name();

        protected boolean canHandleObject(final Object anObject)
        {
                if ( anObject != null )
                {
                        Class   aType = this.type();
                        
                        if ( aType.isAssignableFrom( anObject.getClass() ) == true )
                        {
                                return true;
                        }
                }
                
                return false;
        }
        
        protected abstract Object read(final Object anObject, final PLObjectInput anInput);

//      ===========================================================================
//      StringReader method(s)
//      ---------------------------------------------------------------------------

        private final static class StringReader extends PLObjectInputReader
        {
        
                private static final Class      Type = String.class;
                
                private static final Class[]    Classes = 
                                                {
                                                        AliasReader.class,
                                                        AliasPointerReader.class,

                                                        BooleanReader.class,
                                                        ClassReader.class,
                                                        DoubleReader.class,
                                                        FloatReader.class,
                                                        IntegerReader.class,
                                                        LongReader.class,
                                                        ShortReader.class,
                                                        
                                                        BigDecimalReader.class,
                                                        BigIntegerReader.class,
                                                        
                                                        InetAddressReader.class,
                                                        URIReader.class,
                                                        
                                                        CharsetReader.class,
                                                        
                                                        CurrencyReader.class,
                                                        DateReader.class,
                                                        LocaleReader.class,
                                                        TimeZoneReader.class,
                                                };
                
                private final Map               _readers = new HashMap( StringReader.Classes.length );
                private final Map               _customReaders = new HashMap();

                protected StringReader()
                {
                        super();
                        
                        this.init();
                }
                
                private void init()
                {
                        Class[] someClasses = StringReader.Classes;
                        int     count = someClasses.length;
                                
                        for ( int index = 0; index < count; index++ )
                        {
                                Class   aClass = someClasses[ index ];
                                
                                try
                                {
                                        PLObjectInputReader     aReader = (PLObjectInputReader) aClass.newInstance();
                                        String                  aName = aReader.name();
                                        
                                        if ( aName != null )
                                        {
                                                if ( _readers.containsKey( aName ) == false )
                                                {
                                                        _readers.put( aName, aReader );
                                                }
                                                else
                                                {
                                                        throw new IllegalArgumentException( "PLObjectInputReader.StringReader: duplicate name in " + aClass );
                                                }
                                        }
                                        else
                                        {
                                                throw new IllegalArgumentException( "PLObjectInputReader.StringReader: null name in " + aClass );
                                        }
                                }
                                catch (Exception anException)
                                {
                                        throw new RuntimeException( anException.getMessage(), anException );
                                }
                        }
                }
        
                private Map customReaders()
                {
                        return _customReaders;
                }
                
                private void registerCustomReader(final PLObjectInputReader aReader)
                {
                        if ( aReader != null )
                        {
                                String  aName = aReader.name();
                                
                                if ( aName != null )
                                {
                                        Map     someReaders = this.customReaders();

                                        if ( someReaders.containsKey( aName ) == false )
                                        {
                                                someReaders.put( aName, aReader );
                                        }
                                        else
                                        {
                                                throw new IllegalArgumentException( "PLObjectInputReader.StringReader.registerCustomReader: duplicate name in " + aReader );
                                        }
                                }
                                
                                return;
                        }
                        
                        throw new IllegalArgumentException( "PLObjectInputReader.StringReader.registerCustomReader: null reader" );
                }
                
                private Map readers()
                {
                        return _readers;
                }
                
                protected Class type()
                {
                        return StringReader.Type;
                }
                
                protected String name()
                {
                        return null;
                }
                
                private String nameWithValue(final String aValue)
                {
                        if ( aValue.length() > 1 )
                        {
                                int     anIndex = aValue.indexOf( ':' );
                                
                                if ( anIndex > 0 )
                                {
                                        return aValue.substring( 0, anIndex );
                                }
                        }
                        
                        return null;
                }
                
                protected Object read(final Object anObject, final PLObjectInput anInput)
                {
                        String  aValue = (String) anObject;
                        
                        if ( aValue.length() > 0 )
                        {
                                String  aName = this.nameWithValue( aValue );
                                
                                if ( aName != null )
                                {
                                        PLObjectInputReader     aReader = (PLObjectInputReader) this.customReaders().get( aName );
                                        
                                        if ( aReader == null )
                                        {
                                                 aReader = (PLObjectInputReader) this.readers().get( aName );
                                        }
                                        
                                        if ( aReader != null )
                                        {
                                                aValue = aValue.substring( aName.length() + 1, aValue.length() );
                                        
                                                return aReader.read( aValue, anInput );
                                        }
                                }
                                
                                return aValue;
                        }

                        return null;
                }
                
        }

//      ===========================================================================
//      AliasReader method(s)
//      ---------------------------------------------------------------------------

        private final static class AliasReader extends PLObjectInputReader
        {
        
                private static final String     Name = "&";
                
                protected AliasReader()
                {
                        super();
                }
                
                protected Class type()
                {
                        return null;
                }
                
                protected String name()
                {
                        return AliasReader.Name;
                }
                
                protected Object read(final Object anObject, final PLObjectInput anInput)
                {
                        return new Alias( anObject );
                }
        }
        
//      ===========================================================================
//      AliasPointerReader method(s)
//      ---------------------------------------------------------------------------

        private final static class AliasPointerReader extends PLObjectInputReader
        {
        
                private static final String     Name = "*";
                
                protected AliasPointerReader()
                {
                        super();
                }
                
                protected Class type()
                {
                        return null;
                }
                
                protected String name()
                {
                        return AliasPointerReader.Name;
                }
                
                protected Object read(final Object anObject, final PLObjectInput anInput)
                {
                        if ( anInput.aliases().containsKey( anObject ) == true )
                        {
                                return anInput.aliases().get( anObject );
                        }
                        
                        Log.info( "Couldn't alias '" + anObject + "'." );

                        return null;
                }
        }
        
//      ===========================================================================
//      BooleanReader method(s)
//      ---------------------------------------------------------------------------

        private final static class BooleanReader extends PLObjectInputReader
        {
        
                private static final Class      Type = Boolean.class;
                private static final String     Name = Boolean.TYPE.getName();
                
                protected BooleanReader()
                {
                        super();
                }
                
                protected Class type()
                {
                        return BooleanReader.Type;
                }
                
                protected String name()
                {
                        return BooleanReader.Name;
                }
                
                protected Object read(final Object anObject, final PLObjectInput anInput)
                {
                        return Boolean.valueOf( (String) anObject );
                }
                
        }
        
//      ===========================================================================
//      ClassReader method(s)
//      ---------------------------------------------------------------------------

        private final static class ClassReader extends PLObjectInputReader
        {
        
                private static final Class      Type = Class.class;
                private static final String     Name = "x-class";
                
                private static final Class[]    Types = 
                                                {
                                                        Byte.TYPE,
                                                        Boolean.TYPE,
                                                        Character.TYPE,
                                                        Double.TYPE,
                                                        Float.TYPE,
                                                        Integer.TYPE,
                                                        Long.TYPE,
                                                        Short.TYPE,
                                                        Void.TYPE
                                                };
                                                
                private static final Map        TypesMap = new HashMap( Types.length ); 
                private static final Map        CodesMap = new HashMap( Types.length ); 

                protected ClassReader()
                {
                        super();
                }
                
                static
                {
                        int     count = Types.length;
                        
                        for ( int index = 0; index < count; index++ )
                        {
                                Class                   aType = Types[ index ];
                                ObjectStreamField       aField = new ObjectStreamField( aType.getName(), aType );
                                String                  aCode = new String( new char[] { aField.getTypeCode() } );
                                
                                TypesMap.put( aType.getName(), aType );
                                CodesMap.put( aType, aCode );
                        }
                }
                
                protected Class type()
                {
                        return ClassReader.Type;
                }
                
                protected String name()
                {
                        return ClassReader.Name;
                }
                
                private Class classWithValue(final String aValue) throws Exception
                {
                        String  aName = aValue;
                        int     anIndex = aName.lastIndexOf( ']' );
                        Class   aClass = null;
                        
                        if ( anIndex >= 0 )
                        {
                                aName = aName.substring( anIndex + 1, aName.length() );
                        }
                        
                        aClass = (Class) TypesMap.get( aName );
                        
                        if ( aClass == null )
                        {
                                aClass = Class.forName( aName, true, Thread.currentThread().getContextClassLoader() );
                        }
                        
                        return aClass;
                }
                
                protected Object read(final Object anObject, final PLObjectInput anInput)
                {
                        try
                        {
                                String  aValue = (String) anObject;
                                Class   aClass = this.classWithValue( aValue );
                                int     anIndex = aValue.lastIndexOf( ']' );
                                
                                if ( anIndex > 0 )
                                {
                                        String  aCode = (String) CodesMap.get( aClass );
                                        
                                        if ( aCode == null )
                                        {
                                                aCode = "L";
                                        }
                                        
                                        aValue = aValue.replaceAll( "\\[\\]", "[" );
                                        anIndex = aValue.lastIndexOf( '[' );
                                        aValue = aValue.substring( 0, anIndex + 1 );
                                        aValue = aValue + aCode;
                                        
                                        if ( aClass.isPrimitive() == false )
                                        {
                                                aValue = aValue + aClass.getName() + ";";
                                        }

                                        aClass = Class.forName( aValue, true, Thread.currentThread().getContextClassLoader() );
                                }
                                
                                return aClass;
                        }
                        catch (Throwable anException)
                        {
                                Log.log( Level.FINER, anException.getMessage(), anException );
                                Log.info( "Couldn't convert '" + anObject + "'." );
                        }
                        
                        return null;
                }
                
        }
        
//      ===========================================================================
//      DoubleReader method(s)
//      ---------------------------------------------------------------------------

        private final static class DoubleReader extends PLObjectInputReader
        {
        
                private static final Class      Type = Double.class;
                private static final String     Name = Double.TYPE.getName();
                
                protected DoubleReader()
                {
                        super();
                }
                
                protected Class type()
                {
                        return DoubleReader.Type;
                }
                
                protected String name()
                {
                        return DoubleReader.Name;
                }
                
                protected Object read(final Object anObject, final PLObjectInput anInput)
                {
                        try
                        {
                                return Double.valueOf( (String) anObject );
                        }
                        catch (Exception anException)
                        {
                                Log.log( Level.FINER, anException.getMessage(), anException );
                                Log.info( "Couldn't convert '" + anObject + "'." );
                        }

                        return null;
                }
                
        }
        
//      ===========================================================================
//      FloatReader method(s)
//      ---------------------------------------------------------------------------

        private final static class FloatReader extends PLObjectInputReader
        {
        
                private static final Class      Type = Float.class;
                private static final String     Name = Float.TYPE.getName();
                
                protected FloatReader()
                {
                        super();
                }
                
                protected Class type()
                {
                        return FloatReader.Type;
                }
                
                protected String name()
                {
                        return FloatReader.Name;
                }
                
                protected Object read(final Object anObject, final PLObjectInput anInput)
                {
                        try
                        {
                                return Float.valueOf( (String) anObject );
                        }
                        catch (Exception anException)
                        {
                                Log.log( Level.FINER, anException.getMessage(), anException );
                                Log.info( "Couldn't convert '" + anObject + "'." );
                        }

                        return null;
                }
                
        }
        
//      ===========================================================================
//      IntegerReader method(s)
//      ---------------------------------------------------------------------------

        private final static class IntegerReader extends PLObjectInputReader
        {
        
                private static final Class      Type = Integer.class;
                private static final String     Name = Integer.TYPE.getName();
                
                protected IntegerReader()
                {
                        super();
                }
                
                protected Class type()
                {
                        return IntegerReader.Type;
                }
                
                protected String name()
                {
                        return IntegerReader.Name;
                }
                
                protected Object read(final Object anObject, final PLObjectInput anInput)
                {
                        try
                        {
                                return Integer.valueOf( (String) anObject );
                        }
                        catch (Exception anException)
                        {
                                Log.log( Level.FINER, anException.getMessage(), anException );
                                Log.info( "Couldn't convert '" + anObject + "'." );
                        }

                        return null;
                }
                
        }
        
//      ===========================================================================
//      LongReader method(s)
//      ---------------------------------------------------------------------------

        private final static class LongReader extends PLObjectInputReader
        {
        
                private static final Class      Type = Long.class;
                private static final String     Name = Long.TYPE.getName();
                
                protected LongReader()
                {
                        super();
                }
                
                protected Class type()
                {
                        return LongReader.Type;
                }
                
                protected String name()
                {
                        return LongReader.Name;
                }