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() );
   }
}