Index: trunk/psLib/src/types/psMetadataConfig.c
===================================================================
--- trunk/psLib/src/types/psMetadataConfig.c	(revision 12449)
+++ trunk/psLib/src/types/psMetadataConfig.c	(revision 12453)
@@ -9,7 +9,8 @@
 *  @author Ross Harman, MHPCC
 *  @author Eric Van Alst, MHPCC
+*  @author Joshua Hoblitt, University of Hawaii 2006-2007
 *
-*  @version $Revision: 1.131 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2007-03-15 02:19:09 $
+*  @version $Revision: 1.132 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2007-03-16 00:07:35 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -64,6 +65,6 @@
 /*****************************************************************************/
 
-static psMetadata* getMetadataType(char *linePtr);
-static psMetadata* setMetadataItem(psMetadata* template, char* linePtr)
+static psMetadata* genTypeTemplate(char *linePtr);
+static psMetadata* parseTypeValues(psMetadata* template, char* linePtr)
 ;
 static bool parseLine(psArray* levelArray,
@@ -93,8 +94,7 @@
 typedef struct
 {
-    psArray*    nonUniqueKeyArray;     ///< non-unique key names
-    psArray*    typeArray;             ///< array of user defined types
-    psArray*    templateArray;         ///< array of user type templates
-    psMetadata* metadata;              ///< metadata container
+    psArray*    nonUniqueKeyArray;      ///< non-unique key names
+    psHash*     typeTemplates;          ///< hash of user type templates
+    psMetadata* metadata;               ///< metadata container
 }
 p_psParseLevelInfo;
@@ -103,6 +103,5 @@
 {
     psFree(info->nonUniqueKeyArray);
-    psFree(info->typeArray);
-    psFree(info->templateArray);
+    psFree(info->typeTemplates);
     psFree(info->metadata);
 }
@@ -115,6 +114,5 @@
 
     info->nonUniqueKeyArray = psArrayAllocEmpty(INITIAL_LENGTH);
-    info->typeArray = psArrayAllocEmpty(INITIAL_LENGTH);
-    info->templateArray = psArrayAllocEmpty(INITIAL_LENGTH);
+    info->typeTemplates = psHashAlloc(10);
     info->metadata = NULL;
 
@@ -553,5 +551,5 @@
 }
 
-static psMetadata* getMetadataType(char* linePtr)
+static psMetadata* genTypeTemplate(char* linePtr)
 {
     psMetadata*     metadataTemplate = NULL;
@@ -561,5 +559,5 @@
 
     // Loop through line and generate metadata items for each token found
-    while((token = getToken(&linePtr, " ", &status, false)) != NULL) {
+    while ((token = getToken(&linePtr, " ", &status, false)) != NULL) {
 
         // If not allocated then allocate new metadata
@@ -570,4 +568,5 @@
         // Look for comment indicator #
         if (strstr(token, "#") != 0) {
+            psFree(metadataTemplate);
             psFree(token);
             return NULL;
@@ -581,4 +580,5 @@
             return NULL;
         }
+        psFree(token);
 
         // Add item to template
@@ -586,10 +586,7 @@
             psFree(metadataTemplate);
             psFree(tempItem);
-            psFree(token);
             return NULL;
         }
-
         psFree(tempItem);
-        psFree(token);
     }
 
@@ -597,9 +594,9 @@
 }
 
-static psMetadata* setMetadataItem(psMetadata* template,
+
+static psMetadata* parseTypeValues(psMetadata* template,
                                    char* linePtr)
 {
     psMetadata*      md           = NULL;
-    psS32            items        = 0;
     char*            token        = NULL;
     psS32            status       = 0;
@@ -608,21 +605,18 @@
     psListIterator*  iter         = NULL;
 
+    // Allocate metadata to return
+    md = psMetadataAlloc();
+
     // Determine the number of items in template
-    items = template->list->n;
-    if(items > 0 ) {
-        // Allocate metadata
-        md = psMetadataAlloc()
-             ;
+    long items = psListLength(template->list);
+
+    if (items > 0 ) {
         // Point to first item in template
-        iter = psListIteratorAlloc(template->
-                                   list, PS_LIST_HEAD, true);
+        iter = psListIteratorAlloc(template->list, PS_LIST_HEAD, true);
         // For each item in template parse line string for values
-        for(psS32 i = 0;
-                i < items;
-                i++) {
+        for (long i = 0; i < items; i++) {
             // Get template item
-            templateItem = psListGetAndIncrement(iter)
-                           ;
-            if(templateItem == NULL) {
+            templateItem = psListGetAndIncrement(iter);
+            if (templateItem == NULL) {
                 psFree(md);
                 psFree(iter);
@@ -630,11 +624,12 @@
                 break;
             }
+
             // Get the next token on the line
             token = getToken(&linePtr, " ", &status, false);
-            if(token != NULL) {
+            if (token != NULL) {
                 // Allocate metadata item
                 mdItem = psMetadataItemAllocStr(templateItem->name,
                                                 templateItem->comment, token);
-                if(mdItem == NULL) {
+                if (mdItem == NULL) {
                     psFree(md);
                     md = NULL;
@@ -643,11 +638,11 @@
                     break;
                 }
+                psFree(token);
 
                 // Add item to metadata
-                if(!psMetadataAddItem(md, mdItem, PS_LIST_TAIL, PS_META_DEFAULT)) {
+                if (!psMetadataAddItem(md, mdItem, PS_LIST_TAIL, PS_META_DEFAULT)) {
                     psFree(md);
                     md = NULL;
                     psFree(mdItem);
-                    psFree(token);
                     psFree(iter);
                     break;
@@ -661,8 +656,7 @@
                 break;
             }
-
-            psFree(token);
-        }
-    }
+        }
+    }
+
     return md;
 }
@@ -688,7 +682,4 @@
     char*                tempStr       = NULL;
     psArray*             nonUniqueKeys = NULL;
-    bool               typeFound     = false;
-    psArray*             typeArray     = NULL;
-    psArray*             templateArray = NULL;
     psMetadata*          tempMeta      = NULL;
     p_psParseLevelInfo*  nextLevelInfo = NULL;
@@ -773,44 +764,40 @@
     } else {
         // Search through user types
-        typeArray = ((p_psParseLevelInfo*)(levelArray->data[level]))->typeArray;
-        templateArray = ((p_psParseLevelInfo*)(levelArray->data[level]))->templateArray;
-        for(psS32 k = 0; k < typeArray->n; k++) {
-            if(strcmp(strType,(char*)typeArray->data[k]) == 0) {
-                tempMeta = setMetadataItem((psMetadata*)templateArray->data[k],linePtr);
-                if(tempMeta != NULL) {
-                    // Add metadata item
-                    md = ((p_psParseLevelInfo*)(levelArray->data[level]))->metadata;
-                    addStatus = psMetadataAdd(md,PS_LIST_TAIL,keyName,
-                                              PS_DATA_METADATA | flags,"",tempMeta);
-                    // Check for add failure
-                    if (! addStatus) {
-                        psError(PS_ERR_IO, true,
-                                _("Duplicate Metadata item, %s, found.  "
-                                  "Overwrite not allowed."),
-                                keyName);
-                        psFree(strType);
-                        psFree(tempMeta);
-                        return false;
-                    }
-                    psFree(tempMeta);
-                } else {
-                    // Metadata type read error
-                    psError(PS_ERR_IO,true,
-                            _("Failed to read a metadata %s."), keyName);
-                    psFree(strType);
-                    return false;
-                }
-                typeFound = true;
-                break;
-            }
-        }
-        if(!typeFound) {
+        // Check if type already exists in typeTempaltes
+        psHash *typeTemplates = ((p_psParseLevelInfo*)(levelArray->data[level]))->typeTemplates;
+
+        psMetadata *template = psHashLookup(typeTemplates, strType);
+        if (!template) {
             psError(PS_ERR_IO, true,
-                    _("Metadata type '%s' is invalid."), strType);
+                    _("Metadata TYPE '%s' is invalid."), strType);
             psFree(strType);
             return false;
-        } else {
+        }
+        
+        // covert the template, and the rest of the line, into a metadata
+        tempMeta = parseTypeValues(template, linePtr);
+        if (!tempMeta) {
+            // Metadata type read error
+            psError(PS_ERR_IO,true,
+                    _("Failed to read Metadata TYPE %s."), keyName);
             psFree(strType);
-            return true;
+            return false;
+        }
+
+        // get the current level's metadata
+        md = ((p_psParseLevelInfo*)(levelArray->data[level]))->metadata;
+
+        // add the parsed TYPE to it
+        addStatus = psMetadataAdd(md,PS_LIST_TAIL,keyName,
+                PS_DATA_METADATA | flags,"",tempMeta);
+        psFree(tempMeta);
+
+        // Check for add failure
+        if (! addStatus) {
+            psError(PS_ERR_IO, true,
+                    _("Duplicate Metadata item, %s, found.  "
+                     "Overwrite not allowed."), keyName);
+            psFree(strType);
+            return false;
         }
     }
@@ -845,4 +832,5 @@
             psFree(strValue);
             psFree(strComment);
+            return false;
         }
     }
@@ -1211,35 +1199,34 @@
     }
 
+    // Access typeTypes for this level/scope
+    psHash *typeTemplates = ((p_psParseLevelInfo*)(levelArray->data[level]))->typeTemplates;
+
+    // Check if type already exists in typeTempaltes
+    if (psHashLookup(typeTemplates, strType)) {
+        psError(PS_ERR_IO, true,
+            _("Specified type %s is already defined."), strType);
+        psFree(strType);
+        return false;
+    }
+
     // attempt to parse the TYPE line into a template metadata
-    psMetadata *tempTemplate = getMetadataType(linePtr);
+    psMetadata *tempTemplate = genTypeTemplate(linePtr);
     if (!tempTemplate) {
-        psError(PS_ERR_IO,true, _("Metadata type '%s' is invalid."), strType);
+        psError(PS_ERR_IO, true, _("Metadata type '%s' is invalid."), strType);
         psFree(strType);
         return false;
     }
 
-    // Access type array
-    psArray *typeArray = ((p_psParseLevelInfo*)(levelArray->data[level]))->typeArray;
-
-    // Check if type already exists in array
-    for (psS32 k = 0; k < psArrayLength(typeArray); k++) {
-        // Compare type name with the list of current types
-        if (strcmp(strType, (char*)typeArray->data[k]) == 0) {
-            psError(PS_ERR_IO,true,
-                    _("Specified type %s is already defined."), strType);
-            psFree(tempTemplate);
-            psFree(strType);
-            return false;
-        }
-    }
-
     // Add key name to array of type
-    typeArray = psArrayAdd(typeArray, 0, strType);
+    // Add template to hash of templates
+    if (!psHashAdd(typeTemplates, strType, tempTemplate)) {
+        psError(PS_ERR_UNKNOWN, false, _("failed to add template for '%s' to hash"), strType);
+        psFree(tempTemplate);
+        psFree(strType);
+        return false;
+    }
+
+    psFree(tempTemplate);
     psFree(strType);
-
-    // Add template to array of templates
-    psArray *templateArray = ((p_psParseLevelInfo*)(levelArray->data[level]))->templateArray;
-    psArrayAdd(templateArray, 0, tempTemplate);
-    psFree(tempTemplate);
 
     return true;