Index: trunk/psLib/src/collections/psMetadata.c
===================================================================
--- trunk/psLib/src/collections/psMetadata.c	(revision 2521)
+++ trunk/psLib/src/collections/psMetadata.c	(revision 2607)
@@ -12,6 +12,6 @@
 *  @author Ross Harman, MHPCC
 *
-*  @version $Revision: 1.38 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2004-11-30 00:26:53 $
+*  @version $Revision: 1.39 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2004-12-03 23:14:28 $
 *
 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -80,8 +80,5 @@
     psFree(metadataItem->name);
     psFree(metadataItem->comment);
-    psFree(metadataItem->items);
-    if (type == PS_META_STR || type == PS_META_VEC || type == PS_META_IMG || type == PS_META_LOOKUPTABLE ||
-            type == PS_META_JPEG || type == PS_META_PNG || type == PS_META_ASTROM || type == PS_META_UNKNOWN ||
-            type == PS_META_HASH) {
+    if (type != PS_META_PRIMITIVE) {
         psFree(metadataItem->data.V);
     }
@@ -101,5 +98,6 @@
 /*****************************************************************************/
 
-psMetadataItem* psMetadataItemAlloc(const char *name, psMetadataType type, const char *comment, ...)
+psMetadataItem* psMetadataItemAlloc(const char *name, psElemType pType, psMetadataType type,
+                                    const char *comment, ...)
 {
     va_list argPtr;
@@ -110,5 +108,5 @@
 
     // Call metadata item allocation
-    metadataItem = psMetadataItemAllocV(name, type, comment, argPtr);
+    metadataItem = psMetadataItemAllocV(name, pType, type, comment, argPtr);
 
     // Clean up stack after variable arguement has been used
@@ -118,9 +116,7 @@
 }
 
-psMetadataItem* psMetadataItemAllocV(const char *name, psMetadataType type, const char *comment,
-                                     va_list argPtr)
-{
-    psVector *vecIn = NULL;
-    psVector *vecOut = NULL;
+psMetadataItem* psMetadataItemAllocV(const char *name, psElemType pType, psMetadataType type,
+                                     const char *comment, va_list argPtr)
+{
     psMetadataItem* metadataItem = NULL;
 
@@ -129,5 +125,6 @@
 
     // Allocate metadata item
-    metadataItem = (psMetadataItem* ) psAlloc(sizeof(psMetadataItem));
+    metadataItem = (psMetadataItem*) psAlloc(sizeof(psMetadataItem));
+    metadataItem->data.V = NULL;
 
     // Set deallocator
@@ -148,8 +145,5 @@
     // Set metadata item type
     metadataItem->type = type;
-    metadataItem->data.V = NULL;
-
-    // Allocate metadata items with same name.
-    metadataItem->items = psListAlloc(NULL);
+    metadataItem->pType = pType;
 
     // Allocate and set metadata item name
@@ -158,39 +152,40 @@
 
     // Set metadata item value
-    switch (type) {
-    case PS_META_ITEM_SET:
-        break;
-    case PS_META_BOOL:
-        metadataItem->data.B = (psBool)va_arg(argPtr, psS32);
-        break;
-    case PS_META_S32:
-        metadataItem->data.S32 = (psS32)va_arg(argPtr, psS32);
-        break;
-    case PS_META_F32:
-        metadataItem->data.F32 = (psF32)va_arg(argPtr, psF64);
-        break;
-    case PS_META_F64:
-        metadataItem->data.F64 = va_arg(argPtr, psF64);
+    switch(type) {
+    case PS_META_PRIMITIVE:
+        switch(pType) {
+        case PS_TYPE_BOOL:
+            metadataItem->data.B = (psBool)va_arg(argPtr, psS32);
+            break;
+        case PS_TYPE_S32:
+            metadataItem->data.S32 = (psS32)va_arg(argPtr, psS32);
+            break;
+        case PS_TYPE_F32:
+            metadataItem->data.F32 = (psF32)va_arg(argPtr, psF64);
+            break;
+        case PS_TYPE_F64:
+            metadataItem->data.F64 = (psF64)va_arg(argPtr, psF64);
+            break;
+        default:
+            psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psMetadata_METATYPE_INVALID, type);
+            psFree(metadataItem);
+            metadataItem = NULL;
+        }
         break;
     case PS_META_STR:
+        // Perform copy of input strings
         metadataItem->data.V = psStringNCopy(va_arg(argPtr, char *), MAX_STRING_LENGTH);
         break;
+    case PS_META_LIST:
     case PS_META_VEC:
-        vecIn = (psVector*)va_arg(argPtr, psVector*);
-        vecOut = psVectorAlloc(vecIn->nalloc, vecIn->type.type);
-        memcpy(vecOut->data.V, vecIn->data.V, vecIn->nalloc*PSELEMTYPE_SIZEOF(vecIn->type.type));
-        metadataItem->data.V = vecOut;
-        break;
+    case PS_META_HASH:
     case PS_META_LOOKUPTABLE:
-        metadataItem->data.V = va_arg(argPtr, psLookupTable*); // Deep copy of input data not performed
-        break;
-    case PS_META_HASH:
-        metadataItem->data.V = va_arg(argPtr, psHash*); // Deep copy of input data not performed
-        break;
-    case PS_META_IMG:
     case PS_META_JPEG:
     case PS_META_PNG:
     case PS_META_ASTROM:
     case PS_META_UNKNOWN:
+        // Copy of input data not performed due to variability of data types
+        metadataItem->data.V = va_arg(argPtr, psPtr);
+        break;
     default:
         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psMetadata_METATYPE_INVALID, type);
@@ -209,11 +204,11 @@
 
     // Allocate metadata
-    metadata = (psMetadata* ) psAlloc(sizeof(psMetadata));
+    metadata = (psMetadata*) psAlloc(sizeof(psMetadata));
     // Set deallocator
     p_psMemSetDeallocator(metadata, (psFreeFcn) metadataFree);
 
     // Allocate metadata's internal containers
-    list = (psList* ) psListAlloc(NULL);
-    table = (psHash* ) psHashAlloc(10);
+    list = (psList*) psListAlloc(NULL);
+    table = (psHash*) psHashAlloc(10);
 
     metadata->list = list;
@@ -223,5 +218,5 @@
 }
 
-psBool psMetadataAddItem( psMetadata *restrict md, psMetadataItem *restrict metadataItem, psS32 location )
+psBool psMetadataAddItem(psMetadata *restrict md, psMetadataItem *restrict metadataItem, psS32 location)
 {
     char * key = NULL;
@@ -230,5 +225,5 @@
     psMetadataItem *existingEntry = NULL;
     psMetadataItem *newFolderEntry = NULL;
-    psMetadataType newType = PS_META_ITEM_SET;
+    psMetadataType newType;
 
     PS_PTR_CHECK_NULL(md,NULL);
@@ -247,30 +242,29 @@
     if(existingEntry != NULL) {
 
-        if(existingEntry->type == PS_META_ITEM_SET) {
+        if(existingEntry->type == PS_META_LIST) {
+
+            if(existingEntry->data.list == NULL) {
+                existingEntry->data.list = psListAlloc(NULL);
+            }
 
             // Add leaf node to existing folder node
-            if(!psListAdd(existingEntry->items, PS_LIST_TAIL, metadataItem)) {
-                psError(PS_ERR_UNKNOWN,false,
-                        PS_ERRORTEXT_psMetadata_ADD_LIST_FAILED,
-                        metadataItem->name );
-                return false;
-            }
-        } else if(existingEntry->type != PS_META_ITEM_SET && newType!= PS_META_ITEM_SET) {
+            if(!psListAdd(existingEntry->data.list, PS_LIST_TAIL, metadataItem)) {
+                psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psMetadata_ADD_LIST_FAILED, metadataItem->name);
+                return false;
+            }
+        } else if(existingEntry->type != PS_META_LIST && newType!= PS_META_LIST) {
 
             // Leaf node replaces another leaf. Make new folder node and add leaves.
-            newFolderEntry = psMetadataItemAlloc(key, PS_META_ITEM_SET, NULL, NULL);
-
-            if(!psListAdd(newFolderEntry->items, PS_LIST_TAIL, existingEntry)) {
-                psError(PS_ERR_UNKNOWN,false,
-                        PS_ERRORTEXT_psMetadata_ADD_LIST_FAILED,
-                        key);
+            newFolderEntry = psMetadataItemAlloc(key, PS_TYPE_PTR, PS_META_LIST, NULL, NULL);
+            newFolderEntry->data.list = psListAlloc(NULL);
+
+            if(!psListAdd(newFolderEntry->data.list, PS_LIST_TAIL, existingEntry)) {
+                psError(PS_ERR_UNKNOWN,false, PS_ERRORTEXT_psMetadata_ADD_LIST_FAILED,key);
                 psFree(newFolderEntry);
                 return false;
             }
 
-            if(!psListAdd(newFolderEntry->items, PS_LIST_TAIL, metadataItem)) {
-                psError(PS_ERR_UNKNOWN,false,
-                        PS_ERRORTEXT_psMetadata_ADD_LIST_FAILED,
-                        key);
+            if(!psListAdd(newFolderEntry->data.list, PS_LIST_TAIL, metadataItem)) {
+                psError(PS_ERR_UNKNOWN,false, PS_ERRORTEXT_psMetadata_ADD_LIST_FAILED,key);
                 psFree(newFolderEntry);
                 return false;
@@ -278,7 +272,5 @@
 
             if(!psHashRemove(mdTable, key)) {
-                psError(PS_ERR_UNKNOWN,false,
-                        PS_ERRORTEXT_psMetadata_REMOVE_TABLE_FAILED,
-                        key);
+                psError(PS_ERR_UNKNOWN,false,PS_ERRORTEXT_psMetadata_REMOVE_TABLE_FAILED,key);
                 psFree(newFolderEntry);
                 return false;
@@ -286,7 +278,5 @@
 
             if(!psHashAdd(mdTable, key, newFolderEntry)) {
-                psError(PS_ERR_UNKNOWN,false,
-                        PS_ERRORTEXT_psMetadata_ADD_TABLE_FAILED,
-                        key);
+                psError(PS_ERR_UNKNOWN,false,PS_ERRORTEXT_psMetadata_ADD_TABLE_FAILED,key);
                 psFree(newFolderEntry);
                 return false;
@@ -298,22 +288,20 @@
 
             // Folder node replaces leaf or folder node - Put old node into new folder and remove from table
-            if(!psListAdd(metadataItem->items, PS_LIST_TAIL, existingEntry)) {
-                psError(PS_ERR_UNKNOWN,false,
-                        PS_ERRORTEXT_psMetadata_ADD_LIST_FAILED,
-                        key);
+            if(metadataItem->data.list == NULL) {
+                metadataItem->data.list = psListAlloc(NULL);
+            }
+
+            if(!psListAdd(metadataItem->data.list, PS_LIST_TAIL, existingEntry)) {
+                psError(PS_ERR_UNKNOWN,false,PS_ERRORTEXT_psMetadata_ADD_LIST_FAILED,key);
                 return false;
             }
 
             if(!psHashRemove(mdTable, key)) {
-                psError(PS_ERR_UNKNOWN,false,
-                        PS_ERRORTEXT_psMetadata_REMOVE_TABLE_FAILED,
-                        key);
+                psError(PS_ERR_UNKNOWN,false,PS_ERRORTEXT_psMetadata_REMOVE_TABLE_FAILED,key);
                 return false;
             }
 
             if(!psHashAdd(mdTable, key, metadataItem)) {
-                psError(PS_ERR_UNKNOWN,false,
-                        PS_ERRORTEXT_psMetadata_ADD_TABLE_FAILED,
-                        key);
+                psError(PS_ERR_UNKNOWN,false,PS_ERRORTEXT_psMetadata_ADD_TABLE_FAILED,key);
                 return false;
             }
@@ -323,7 +311,5 @@
         // Node doesn't exist - Add new metadata item to metadata collection's hash
         if(!psHashAdd(mdTable, key, metadataItem)) {
-            psError(PS_ERR_UNKNOWN,false,
-                    PS_ERRORTEXT_psMetadata_ADD_TABLE_FAILED,
-                    key);
+            psError(PS_ERR_UNKNOWN,false,PS_ERRORTEXT_psMetadata_ADD_TABLE_FAILED,key);
             return false;
         }
@@ -331,10 +317,8 @@
 
     // Add items to metadata collection's list, even if they have the same metadata item names. Folder nodes
-    // (PS_META_ITEM_SET metadata items) are not added, since the metadata list is flat.
-    if(metadataItem->type != PS_META_ITEM_SET) {
+    // (PS_META_LIST metadata items) are not added, since the metadata list is flat.
+    if(metadataItem->type != PS_META_LIST) {
         if(!psListAdd(mdList, location, metadataItem)) {
-            psError(PS_ERR_UNKNOWN,false,
-                    PS_ERRORTEXT_psMetadata_ADD_COLLECTION_FAILED,
-                    key);
+            psError(PS_ERR_UNKNOWN,false,PS_ERRORTEXT_psMetadata_ADD_COLLECTION_FAILED,key);
             return false;
         }
@@ -344,6 +328,6 @@
 }
 
-psBool psMetadataAdd(psMetadata* restrict md, psS32 where, const char *name, psMetadataType type,
-                     const char *comment, ...)
+psBool psMetadataAdd(psMetadata* restrict md, psS32 where, const char *name, psElemType pType,
+                     psMetadataType type, const char *comment, ...)
 {
     va_list argPtr;
@@ -351,10 +335,9 @@
 
     va_start(argPtr, comment);
-    metadataItem = psMetadataItemAllocV(name, type, comment, argPtr);
+    metadataItem = psMetadataItemAllocV(name, pType, type, comment, argPtr);
     va_end(argPtr);
 
     if (!psMetadataAddItem(md, metadataItem, where)) {
-        psError(PS_ERR_UNKNOWN,false,
-                PS_ERRORTEXT_psMetadata_ADD_FAILED);
+        psError(PS_ERR_UNKNOWN,false,PS_ERRORTEXT_psMetadata_ADD_FAILED);
         psFree(metadataItem);
         return false;
@@ -368,6 +351,6 @@
 psBool psMetadataRemove(psMetadata* restrict md, psS32 where, const char *restrict key)
 {
-    psS32 numChildren = 0;
     psList* mdList = NULL;
+    psList* entryList = NULL;
     psHash* mdTable = NULL;
     psMetadataItem* entry = NULL;
@@ -386,26 +369,21 @@
 
         // Remove by key name
-        entry = (psMetadataItem* ) psHashLookup(mdTable, key);
+        entry = (psMetadataItem*)psHashLookup(mdTable, key);
         if (entry == NULL) {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                    PS_ERRORTEXT_psMetadata_FIND_FAILED,
-                    key);
+            psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psMetadata_FIND_FAILED, key);
             return false;
         }
 
-        numChildren = entry->items->size;
-        if (entry->type == PS_META_ITEM_SET && numChildren > 0) {
+        if (entry->type == PS_META_LIST) {
 
             // Table entry has children. Entry and children must be removed from metadata collection's list
-            psListSetIterator(entry->items, PS_LIST_HEAD);
-            entryChild = psListGetCurrent(entry->items);
-            while (entryChild != NULL) {
+            psListSetIterator(entryList, PS_LIST_HEAD);
+            entryChild = psListGetCurrent(entryList);
+            while(entryChild != NULL) {
                 if (!psListRemove(mdList, PS_LIST_UNKNOWN, entryChild)) {
-                    psError(PS_ERR_UNKNOWN,false,
-                            PS_ERRORTEXT_psMetadata_REMOVE_LIST_FAILED,
-                            key);
+                    psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psMetadata_REMOVE_LIST_FAILED, key);
                     return false;
                 }
-                entryChild = psListGetNext(entry->items);
+                entryChild = psListGetNext(entryList);
             }
         } else {
@@ -413,7 +391,5 @@
             // Table entry has no children. Remove entry from metadata collection's list
             if (!psListRemove(mdList, PS_LIST_UNKNOWN, entry)) {
-                psError(PS_ERR_UNKNOWN,false,
-                        PS_ERRORTEXT_psMetadata_REMOVE_LIST_FAILED,
-                        key);
+                psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psMetadata_REMOVE_LIST_FAILED, key);
                 return false;
             }
@@ -421,7 +397,5 @@
         // Remove entry from metadata collection's table
         if (!psHashRemove(mdTable, key)) {
-            psError(PS_ERR_UNKNOWN,false,
-                    PS_ERRORTEXT_psMetadata_REMOVE_TABLE_FAILED,
-                    key);
+            psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psMetadata_REMOVE_TABLE_FAILED, key);
             return false;
         }
@@ -431,15 +405,11 @@
         entry = psListGet(mdList, where);
         if (entry == NULL) {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                    PS_ERRORTEXT_psMetadata_FIND_INDEX_FAILED,
-                    where);
+            psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psMetadata_FIND_INDEX_FAILED, where);
             return false;
         }
 
         key = entry->name;
-        if (key == NULL) {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                    PS_ERRORTEXT_psMetadata_REMOVE_LIST_INDEX_FAILED,
-                    where);
+        if(key == NULL) {
+            psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psMetadata_REMOVE_LIST_INDEX_FAILED, where);
             return false;
         }
@@ -463,5 +433,5 @@
     mdTable = md->table;
 
-    entry = (psMetadataItem* ) psHashLookup(mdTable, key);
+    entry = (psMetadataItem*)psHashLookup(mdTable, key);
     if (entry == NULL) {
         return NULL;
@@ -478,9 +448,7 @@
     PS_PTR_CHECK_NULL(md->list,NULL);
 
-    entry = (psMetadataItem* ) psListGet(md->list, where);
+    entry = (psMetadataItem*) psListGet(md->list, where);
     if (entry == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psMetadata_FIND_INDEX_FAILED,
-                where);
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psMetadata_FIND_INDEX_FAILED, where);
         return NULL;
     }