Re: Generics

On Mar 6, 6:15 pm, Lew <l...@lewscanon.com> wrote:


All,

Here is the source that I came up with to do this. Please critique
it. I would like to have concrete comments as to how it could be
improved For example, I read a TechTip that said it would be better
to use a scanner or at least String.split() in lieu of the
StringTokenizer.

Todd

//=========================================

import java.util.StringTokenizer;
import java.util.Vector;

/**
 *
 * @author heidenthal
 */
public class DataRecord
{
    public DataRecord( String value, String description )
    {
        // Fill the data record with the passed information
        this.value = new String( value );
        this.description = new String( description );

        // The record value needs to have its data type defined
        // for the typed return of the value
        dataType = determineType( value );
    }

    public String getDescription()
    {
        return description;
    }

    public <T> T getValue()
    {
        @SuppressWarnings( "unchecked" ) // TODO check cast and don't
suppress
        Class <T> type = dataType.getClassType();

        return type.cast( dataType.castValue( value ) );
    }

    public Class getClassType()
    {
        return dataType.getClassType();
    }

    private DataType determineType( String value )
    {
        dataType = DataType.STRING;

        // boolean type
        if( isBoolean( value ) )
        {
            dataType = DataType.BOOLEAN;
        }
        else if( isInteger( value ) ) // int type
        {
            dataType = DataType.INTEGER;
        }
        else if( isDouble( value ) ) // double type
        {
            dataType = DataType.DOUBLE;
        }
        else if( isDoubleArray( value ) ) // double[] type
        {
            dataType = DataType.DOUBLE_ARRAY;
        }

        return dataType;
    }

    private boolean isBoolean( String value )
    {
        if( value.equalsIgnoreCase( "true" ) ||
            value.equalsIgnoreCase( "false" ) )
        {
            return true;
        }

        return false;
    }

    private boolean isInteger( String value )
    {
        try
        {
            Integer.parseInt( value );
            return true;
        }
        catch( Exception exception )
        {
            return false;
        }
    }

    private boolean isDouble( String value )
    {
        try
        {
            Double.parseDouble( value );
            return true;
        }
        catch( Exception exception )
        {
            return false;
        }
    }

    private boolean isDoubleArray( String value )
    {
        if( value.contains( "{" ) && value.contains( "}" ) )
        {
            return true;
        }

        return false;
    }

    private String value;
    private String description;
    private DataType dataType;

    @SuppressWarnings( "unchecked" ) // TODO check cast and don't
suppress
    private enum DataType
    {
        STRING( String.class )
        {
            String castValue( String value )
            {
                return value;
            }
        },

        BOOLEAN( Boolean.class )
        {
            Boolean castValue( String value )
            {
                return Boolean.parseBoolean( value );
            }
        },

        INTEGER( Integer.class )
        {
            Integer castValue( String value )
            {
                return Integer.parseInt( value );
            }
        },

        DOUBLE( Double.class )
        {
            Double castValue( String value )
            {
                return Double.parseDouble( value );
            }
        },

        DOUBLE_ARRAY( Double[].class )
        {
            Double[] castValue( String value )
            {
                Vector<Double> values = new Vector<Double>();

                StringTokenizer tokenizer =
                        new StringTokenizer( value.substring( 1 ),
" }" );
                while( tokenizer.hasMoreTokens() )
                {
 
values.add( Double.parseDouble( tokenizer.nextToken() ) );
                }

                Double[] valuesArray = new Double[values.size()];
                valuesArray = values.toArray( valuesArray );

                return valuesArray;
            }
        };

        DataType( Class clazz )
        {
            this.clazz = clazz;
        }

        abstract <T> T castValue( String value );

        Class getClassType()
        {
            return clazz;
        }

        private Class clazz;
    }
}

//========================================

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Locale;
import java.util.StringTokenizer;

/**
 *
 * @author heidenthal
 */
public class DataCollection extends HashMap<String, DataRecord>
{
    public DataCollection( String filename )
    {
        buildDefaultMap( filename );
    }

    public void buildDefaultMap( String filename )
    {
        String line = null;
        InputStream reader =
Class.class.getResourceAsStream( filename );
        try
        {
            BufferedReader bufferedReader =
                    new BufferedReader( new
InputStreamReader( reader ) );
            while( (line = bufferedReader.readLine()) != null )
            {
                // Break the line into the key and data record
                StringTokenizer str = new StringTokenizer( line,"=" );

                // Get the key for the data
                String key =
str.nextToken().trim().toUpperCase(Locale.ENGLISH);

                // Get the record value
                String value = str.nextToken( "=," ).trim();

                // Get the description (if it exists)
                String description = str.nextToken( "\n" ).trim();

                // Create a new data record and add it to the
collection
                DataRecord dataRecord = new DataRecord( value,
description );

                this.put( key, dataRecord );
            }
        }
        catch( IOException ioException )
        {
            System.err.println( "Unable to open " + filename );
            System.err.println( ioException );
        }
    }

    public <T> T get( String key ) throws NullPointerException
    {
        DataRecord dataRecord =
                super.get( key.trim().toUpperCase(Locale.ENGLISH) );

        @SuppressWarnings( "unchecked" ) // TODO check cast and don't
suppress
        Class<T> type = dataRecord.getClassType();

        return type.cast( dataRecord.getValue() );
    }
}