Index: trunk/psLib/src/collections/psMetadata.c
===================================================================
--- trunk/psLib/src/collections/psMetadata.c	(revision 1406)
+++ trunk/psLib/src/collections/psMetadata.c	(revision 1407)
@@ -1,2 +1,3 @@
+
 /** @file  psMetadata.c
 *
@@ -11,6 +12,6 @@
 *  @author Ross Harman, MHPCC
 *
-*  @version $Revision: 1.14 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2004-08-06 22:34:05 $
+*  @version $Revision: 1.15 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2004-08-07 00:06:06 $
 *
 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -18,5 +19,7 @@
 
 /******************************************************************************/
+
 /*  INCLUDE FILES                                                             */
+
 /******************************************************************************/
 #include<stdio.h>
@@ -34,7 +37,8 @@
 #include "psString.h"
 
-
 /******************************************************************************/
+
 /*  DEFINE STATEMENTS                                                         */
+
 /******************************************************************************/
 
@@ -56,5 +60,7 @@
 
 /******************************************************************************/
+
 /*  TYPE DEFINITIONS                                                          */
+
 /******************************************************************************/
 
@@ -62,5 +68,7 @@
 
 /*****************************************************************************/
+
 /*  GLOBAL VARIABLES                                                         */
+
 /*****************************************************************************/
 
@@ -68,5 +76,7 @@
 
 /*****************************************************************************/
+
 /*  FILE STATIC VARIABLES                                                    */
+
 /*****************************************************************************/
 
@@ -74,7 +84,9 @@
 
 /*****************************************************************************/
+
 /*  FUNCTION IMPLEMENTATION - LOCAL                                          */
-/*****************************************************************************/
-static void metadataItemFree( psMetadataItem *metadataItem )
+
+/*****************************************************************************/
+static void metadataItemFree(psMetadataItem * metadataItem)
 {
     psMetadataType type;
@@ -82,36 +94,35 @@
     type = metadataItem->type;
 
-    if(metadataItem == NULL) {
-        return ;
-    }
-
-    psFree( metadataItem->name );
-    psFree( metadataItem->comment );
-    psFree( metadataItem->items );
-
-    if(type == PS_META_STR ||
+    if (metadataItem == NULL) {
+        return;
+    }
+
+    psFree(metadataItem->name);
+    psFree(metadataItem->comment);
+    psFree(metadataItem->items);
+
+    if (type == PS_META_STR ||
             type == PS_META_IMG ||
-            type == PS_META_JPEG ||
-            type == PS_META_PNG ||
-            type == PS_META_ASTROM ||
-            type == PS_META_UNKNOWN) {
-        psFree( metadataItem->data.V );
-    }
-}
-
-static void metadataFree( psMetadata *metadata )
-{
-    if(metadata == NULL) {
-        return ;
-    }
-    psFree( metadata->list );
-    psFree( metadata->table );
-}
-
-/*****************************************************************************/
+            type == PS_META_JPEG || type == PS_META_PNG || type == PS_META_ASTROM || type == PS_META_UNKNOWN) {
+        psFree(metadataItem->data.V);
+    }
+}
+
+static void metadataFree(psMetadata * metadata)
+{
+    if (metadata == NULL) {
+        return;
+    }
+    psFree(metadata->list);
+    psFree(metadata->table);
+}
+
+/*****************************************************************************/
+
 /* FUNCTION IMPLEMENTATION - PUBLIC                                          */
-/*****************************************************************************/
-
-psMetadataItem *psMetadataItemAlloc( const char *name, psMetadataType type, const char *comment, ... )
+
+/*****************************************************************************/
+
+psMetadataItem *psMetadataItemAlloc(const char *name, psMetadataType type, const char *comment, ...)
 {
     va_list argPtr;
@@ -119,44 +130,43 @@
 
     // Get the variable list parameters to pass to allocation function
-    va_start( argPtr, comment );
+    va_start(argPtr, comment);
 
     // Call metadata item allocation
-    metadataItem = psMetadataItemAllocV( name, type, comment, argPtr );
+    metadataItem = psMetadataItemAllocV(name, type, comment, argPtr);
 
     // Clean up stack after variable arguement has been used
-    va_end( argPtr );
+    va_end(argPtr);
 
     return metadataItem;
 }
 
-psMetadataItem *psMetadataItemAllocV( const char *name, psMetadataType type, const char *comment, va_list argPtr )
-{
-    psMetadataItem * metadataItem = NULL;
-
-    if(name == NULL) {
-        psError( __func__, "Null value for name not allowed" );
-        return NULL;
-    }
-
+psMetadataItem *psMetadataItemAllocV(const char *name, psMetadataType type, const char *comment,
+                                     va_list argPtr)
+{
+    psMetadataItem *metadataItem = NULL;
+
+    if (name == NULL) {
+        psError(__func__, "Null value for name not allowed");
+        return NULL;
+    }
     // Allocate metadata item
-    metadataItem = ( psMetadataItem * ) psAlloc( sizeof( psMetadataItem ) );
-    if(metadataItem == NULL) {
-        psAbort( __func__, "Failed to allocate memory" );
-    }
-
+    metadataItem = (psMetadataItem *) psAlloc(sizeof(psMetadataItem));
+    if (metadataItem == NULL) {
+        psAbort(__func__, "Failed to allocate memory");
+    }
     // Set deallocator
-    p_psMemSetDeallocator( metadataItem, ( psFreeFcn ) metadataItemFree );
+    p_psMemSetDeallocator(metadataItem, (psFreeFcn) metadataItemFree);
 
     // Allocate and set metadata item comment
-    metadataItem->comment = ( char * ) psAlloc( sizeof( char ) * MAX_STRING_LENGTH );
-    if(comment == NULL) {
+    metadataItem->comment = (char *)psAlloc(sizeof(char) * MAX_STRING_LENGTH);
+    if (comment == NULL) {
         // Per SDRS, null isn't allowed, must use "" instead
-        strncpy( metadataItem->comment, "", MAX_STRING_LENGTH );
+        strncpy(metadataItem->comment, "", MAX_STRING_LENGTH);
     } else {
-        strncpy( metadataItem->comment, comment, MAX_STRING_LENGTH );
+        strncpy(metadataItem->comment, comment, MAX_STRING_LENGTH);
     }
 
     // Set metadata item unique id
-    *( int* ) ( &metadataItem->id ) = ++metadataId;
+    *(int *)(&metadataItem->id) = ++metadataId;
 
     // Set metadata item type
@@ -164,19 +174,21 @@
 
     // Set metadata item value
-    switch(type) {
+    switch (type) {
     case PS_META_BOOL:
-        metadataItem->data.B = ( bool ) va_arg( argPtr, int );
+        metadataItem->data.B = (bool) va_arg(argPtr, int);
+
         break;
     case PS_META_S32:
-        metadataItem->data.S32 = va_arg( argPtr, psS32 );
+        metadataItem->data.S32 = va_arg(argPtr, psS32);
         break;
     case PS_META_F32:
-        metadataItem->data.F32 = ( psF32 ) va_arg( argPtr, psF64 );
+        metadataItem->data.F32 = (psF32) va_arg(argPtr, psF64);
         break;
     case PS_META_F64:
-        metadataItem->data.F64 = va_arg( argPtr, psF64 );
+        metadataItem->data.F64 = va_arg(argPtr, psF64);
         break;
     case PS_META_STR:
-        metadataItem->data.V = psStringNCopy( va_arg( argPtr, char* ), MAX_STRING_LENGTH );
+        metadataItem->data.V = psStringNCopy(va_arg(argPtr, char *), MAX_STRING_LENGTH);
+
         break;
     case PS_META_IMG:
@@ -186,41 +198,40 @@
     case PS_META_UNKNOWN:
     default:
-        psError( __func__, "Invalid psMetadataType: %d", type );
+        psError(__func__, "Invalid psMetadataType: %d", type);
     }
 
     // Allocate and set metadata item name
-    metadataItem->name = ( char * ) psAlloc( sizeof( char ) * MAX_STRING_LENGTH );
-    vsprintf( metadataItem->name, name, argPtr );
+    metadataItem->name = (char *)psAlloc(sizeof(char) * MAX_STRING_LENGTH);
+    vsprintf(metadataItem->name, name, argPtr);
 
     // Allocate metadata items with same name.
-    metadataItem->items = psListAlloc( NULL );
+    metadataItem->items = psListAlloc(NULL);
 
     return metadataItem;
 }
 
-psMetadata *psMetadataAlloc( void )
-{
-    psList * list = NULL;
+psMetadata *psMetadataAlloc(void)
+{
+    psList *list = NULL;
     psHash *table = NULL;
     psMetadata *metadata = NULL;
 
     // Allocate metadata
-    metadata = ( psMetadata * ) psAlloc( sizeof( psMetadata ) );
-    if(metadata == NULL) {
-        psAbort( __func__, "Failed to allocate metadata" );
-    }
-
+    metadata = (psMetadata *) psAlloc(sizeof(psMetadata));
+    if (metadata == NULL) {
+        psAbort(__func__, "Failed to allocate metadata");
+    }
     // Set deallocator
-    p_psMemSetDeallocator( metadata, ( psFreeFcn ) metadataFree );
+    p_psMemSetDeallocator(metadata, (psFreeFcn) metadataFree);
 
     // Allocate metadata's internal containers
-    list = ( psList * ) psListAlloc( NULL );
-    if(list == NULL) {
-        psAbort( __func__, "Failed to allocate list" );
-    }
-
-    table = ( psHash * ) psHashAlloc( 10 );
-    if(table == NULL) {
-        psAbort( __func__, "Failed to allocate table" );
+    list = (psList *) psListAlloc(NULL);
+    if (list == NULL) {
+        psAbort(__func__, "Failed to allocate list");
+    }
+
+    table = (psHash *) psHashAlloc(10);
+    if (table == NULL) {
+        psAbort(__func__, "Failed to allocate table");
     }
 
@@ -231,7 +242,7 @@
 }
 
-bool psMetadataAddItem( psMetadata *restrict md, int where, psMetadataItem *restrict metadataItem )
-{
-    char * key = NULL;
+bool psMetadataAddItem(psMetadata * restrict md, int where, psMetadataItem * restrict metadataItem)
+{
+    char *key = NULL;
     psHash *mdTable = NULL;
     psList *mdList = NULL;
@@ -239,11 +250,11 @@
     psMetadataType type = PS_META_ITEM_SET;
 
-    if(md == NULL) {
-        psError( __func__, "Null metadata collection not allowed" );
-        return false;
-    }
-
-    if(metadataItem == NULL) {
-        psError( __func__, "Null metadata item not allowed" );
+    if (md == NULL) {
+        psError(__func__, "Null metadata collection not allowed");
+        return false;
+    }
+
+    if (metadataItem == NULL) {
+        psError(__func__, "Null metadata item not allowed");
         return false;
     }
@@ -252,54 +263,51 @@
 
     mdTable = md->table;
-    if(mdTable == NULL) {
-        psError( __func__, "Null metadata table not allowed" );
-        return false;
-    }
-
-    mdList = md->list;
-    if(mdList == NULL) {
-        psError( __func__, "Null metadata list not allowed" );
+    if (mdTable == NULL) {
+        psError(__func__, "Null metadata table not allowed");
+        return false;
+    }
+
+    mdList = md->list;
+    if (mdList == NULL) {
+        psError(__func__, "Null metadata list not allowed");
         return false;
     }
 
     key = metadataItem->name;
-    if(key == NULL) {
-        psError( __func__, "Null key item not allowed" );
-        return false;
-    }
-
+    if (key == NULL) {
+        psError(__func__, "Null key item not allowed");
+        return false;
+    }
     // Check if key is already in table
-    value = ( psMetadataItem* ) psHashLookup( mdTable, key );
-    if(value != NULL && type != PS_META_ITEM_SET) {
+    value = (psMetadataItem *) psHashLookup(mdTable, key);
+    if (value != NULL && type != PS_META_ITEM_SET) {
 
         // The key was found and the new metadata item is a leaf node (its type isn't PS_META_ITEM_SET), so
         // add the new metadata item to hash as a child of the existing metadata item folder node.
-        if(!psListAdd( value->items, metadataItem, where )) {
-            psError( __func__, "Couldn't add metadata item to items list. Name: %s",
-                     metadataItem->name );
+        if (!psListAdd(value->items, metadataItem, where)) {
+            psError(__func__, "Couldn't add metadata item to items list. Name: %s", metadataItem->name);
             return false;
         }
-    } else
-        if(value != NULL) {
-
-            // The key was found and the new metadata item is a folder node. Don't add new metadata item, since
-            // it will wipe out existing node.
-            psError( __func__, "Metadata already exists in metadata collection. Item not added. Name: %s",
-                     metadataItem->name );
+    } else if (value != NULL) {
+
+        // The key was found and the new metadata item is a folder node. Don't add new metadata item, since
+        // it will wipe out existing node.
+        psError(__func__, "Metadata already exists in metadata collection. Item not added. Name: %s",
+                metadataItem->name);
+        return false;
+    } else {
+
+        // Duplicate key not found. Add new metadata item to metadata collection's hash
+        if (!psHashAdd(mdTable, key, metadataItem)) {
+            psError(__func__, "Couldn't add metadata item to metadata collection table. Name: %s",
+                    metadataItem->name);
             return false;
-        } else {
-
-            // Duplicate key not found. Add new metadata item to metadata collection's hash
-            if(!psHashAdd( mdTable, key, metadataItem )) {
-                psError( __func__, "Couldn't add metadata item to metadata collection table. Name: %s",
-                         metadataItem->name );
-                return false;
-            }
-        }
+        }
+    }
 
     // Add all items to metadata collection's list, even if they have the same metadata item names
-    if(!psListAdd( md->list, metadataItem, where )) {
-        psError( __func__, "Couldn't add metadata item to metadata collection list. Name: %s",
-                 metadataItem->name );
+    if (!psListAdd(md->list, metadataItem, where)) {
+        psError(__func__, "Couldn't add metadata item to metadata collection list. Name: %s",
+                metadataItem->name);
         return false;
     }
@@ -308,28 +316,28 @@
 }
 
-bool psMetadataAdd( psMetadata *restrict md, int where, const char *name, psMetadataType type,
-                    const char *comment, ... )
+bool psMetadataAdd(psMetadata * restrict md, int where, const char *name, psMetadataType type,
+                   const char *comment, ...)
 {
     va_list argPtr;
     psMetadataItem *metadataItem = NULL;
 
-    va_start( argPtr, comment );
-    metadataItem = psMetadataItemAllocV( name, type, comment, argPtr );
-    va_end( argPtr );
-
-    if(!psMetadataAddItem( md, where, metadataItem )) {
-        psError( __func__, "Couldn't add metadata item to metadata collection list. Name: %s",
-                 metadataItem->name );
-        psFree( metadataItem );
-        return false;
-    }
-
-    // Decrement reference count, since the metadata item is now in metadata collection and no longer needed here
-    psMemDecrRefCounter( metadataItem );
+    va_start(argPtr, comment);
+    metadataItem = psMetadataItemAllocV(name, type, comment, argPtr);
+    va_end(argPtr);
+
+    if (!psMetadataAddItem(md, where, metadataItem)) {
+        psError(__func__, "Couldn't add metadata item to metadata collection list. Name: %s",
+                metadataItem->name);
+        psFree(metadataItem);
+        return false;
+    }
+    // Decrement reference count, since the metadata item is now in metadata collection and no longer needed
+    // here
+    psMemDecrRefCounter(metadataItem);
 
     return true;
 }
 
-bool psMetadataRemove( psMetadata *restrict md, int where, const char *restrict key )
+bool psMetadataRemove(psMetadata * restrict md, int where, const char *restrict key)
 {
     int numChildren = 0;
@@ -340,49 +348,46 @@
 
     mdList = md->list;
-    if(mdList == NULL) {
-        psError( __func__, "Null metadata list not allowed" );
+    if (mdList == NULL) {
+        psError(__func__, "Null metadata list not allowed");
         return false;
     }
 
     mdTable = md->table;
-    if(mdTable == NULL) {
-        psError( __func__, "Null metadata table not allowed" );
-        return false;
-    }
-
+    if (mdTable == NULL) {
+        psError(__func__, "Null metadata table not allowed");
+        return false;
+    }
     // Select removal by key or index
-    if(key != NULL) {
+    if (key != NULL) {
 
         // Remove by key name
-        entry = ( psMetadataItem* ) psHashLookup( mdTable, key );
-        if(entry == NULL) {
-            psError( __func__, "Couldn't find metadata item remove. Name: %s", key );
+        entry = (psMetadataItem *) psHashLookup(mdTable, key);
+        if (entry == NULL) {
+            psError(__func__, "Couldn't find metadata item remove. Name: %s", key);
             return false;
         }
 
         numChildren = entry->items->size;
-        if(entry->type == PS_META_ITEM_SET && numChildren > 0) {
+        if (entry->type == PS_META_ITEM_SET && numChildren > 0) {
 
             // Table entry has children. Entry and children must be removed from metadata collection's list
-            psListSetIterator( mdList, PS_LIST_HEAD );
-            entryChild = psListGetCurrent( mdList );
-            while(entryChild != NULL) {
-                if(!psListRemove( entry->items, entryChild, PS_LIST_UNKNOWN )) {
-                    psError( __func__, "Couldn't remove metadata item from list. Name: %s", key );
+            psListSetIterator(mdList, PS_LIST_HEAD);
+            entryChild = psListGetCurrent(mdList);
+            while (entryChild != NULL) {
+                if (!psListRemove(entry->items, entryChild, PS_LIST_UNKNOWN)) {
+                    psError(__func__, "Couldn't remove metadata item from list. Name: %s", key);
                     return false;
                 }
-                entryChild = psListGetNext( entry->items );
+                entryChild = psListGetNext(entry->items);
             }
         }
-
         // Remove entry from metadata collection's list
-        if(!psListRemove( mdList, entry, PS_LIST_UNKNOWN )) {
-            psError( __func__, "Couldn't remove metadata item from list. Name: %s", key );
+        if (!psListRemove(mdList, entry, PS_LIST_UNKNOWN)) {
+            psError(__func__, "Couldn't remove metadata item from list. Name: %s", key);
             return false;
         }
-
         // Remove entry from metadata collection's table
-        if(!psHashRemove( mdTable, key )) {
-            psError( __func__, "Couldn't remove metadata item from table. Name: %s", key );
+        if (!psHashRemove(mdTable, key)) {
+            psError(__func__, "Couldn't remove metadata item from table. Name: %s", key);
             return false;
         }
@@ -390,18 +395,17 @@
 
         // Remove by index
-        entry = psListGet( mdList, where );
-        if(entry == NULL) {
-            psError( __func__, "Couldn't find metadata item from list. Index: %d", where );
+        entry = psListGet(mdList, where);
+        if (entry == NULL) {
+            psError(__func__, "Couldn't find metadata item from list. Index: %d", where);
             return false;
         }
 
         key = entry->name;
-        if(key == NULL) {
-            psError( __func__, "Null key name not allowed. Index: %d", where );
+        if (key == NULL) {
+            psError(__func__, "Null key name not allowed. Index: %d", where);
             return false;
         }
-
         // Use recursive remove, now that key is known
-        psMetadataRemove( md, PS_LIST_UNKNOWN, key );
+        psMetadataRemove(md, PS_LIST_UNKNOWN, key);
     }
 
@@ -409,23 +413,23 @@
 }
 
-psMetadataItem *psMetadataLookup( psMetadata *restrict md, const char *restrict key )
-{
-    psHash * mdTable = NULL;
+psMetadataItem *psMetadataLookup(psMetadata * restrict md, const char *restrict key)
+{
+    psHash *mdTable = NULL;
     psMetadataItem *entry = NULL;
 
     mdTable = md->table;
-    if(mdTable == NULL) {
-        psError( __func__, "Null metadata table not allowed" );
-        return NULL;
-    }
-
-    if(key == NULL) {
-        psError( __func__, "Null key name not allowed" );
-        return NULL;
-    }
-
-    entry = ( psMetadataItem* ) psHashLookup( mdTable, key );
-    if(entry == NULL) {
-        psError( __func__, "Could not find metadata item with given key. Key: %s", key );
+    if (mdTable == NULL) {
+        psError(__func__, "Null metadata table not allowed");
+        return NULL;
+    }
+
+    if (key == NULL) {
+        psError(__func__, "Null key name not allowed");
+        return NULL;
+    }
+
+    entry = (psMetadataItem *) psHashLookup(mdTable, key);
+    if (entry == NULL) {
+        psError(__func__, "Could not find metadata item with given key. Key: %s", key);
         return NULL;
     }
@@ -434,18 +438,18 @@
 }
 
-psMetadataItem *psMetadataGet( psMetadata *restrict md, int where )
-{
-    psList * mdList = NULL;
+psMetadataItem *psMetadataGet(psMetadata * restrict md, int where)
+{
+    psList *mdList = NULL;
     psMetadataItem *entry = NULL;
 
     mdList = md->list;
-    if(mdList == NULL) {
-        psError( __func__, "Null metadata list not allowed" );
-        return NULL;
-    }
-
-    entry = ( psMetadataItem* ) psListGet( mdList, where );
-    if(entry == NULL) {
-        psError( __func__, "Couldn't find metadata item with given index. Index: %d", where );
+    if (mdList == NULL) {
+        psError(__func__, "Null metadata list not allowed");
+        return NULL;
+    }
+
+    entry = (psMetadataItem *) psListGet(mdList, where);
+    if (entry == NULL) {
+        psError(__func__, "Couldn't find metadata item with given index. Index: %d", where);
         return NULL;
     }
@@ -454,50 +458,50 @@
 }
 
-bool psMetadataSetIterator( psMetadata *restrict md, int where )
-{
-    psList * mdList = NULL;
-
-    mdList = md->list;
-    if(mdList == NULL) {
-        psError( __func__, "Null metadata list not allowed" );
-        return false;
-    }
-
-    psListSetIterator( mdList, where );
+bool psMetadataSetIterator(psMetadata * restrict md, int where)
+{
+    psList *mdList = NULL;
+
+    mdList = md->list;
+    if (mdList == NULL) {
+        psError(__func__, "Null metadata list not allowed");
+        return false;
+    }
+
+    psListSetIterator(mdList, where);
 
     return true;
 }
 
-psMetadataItem *psMetadataGetNext( psMetadata *restrict md, const char *restrict match, int which )
-{
-    psList * mdList = NULL;
+psMetadataItem *psMetadataGetNext(psMetadata * restrict md, const char *restrict match, int which)
+{
+    psList *mdList = NULL;
     psMetadataItem *entry = NULL;
 
     mdList = md->list;
-    if(mdList == NULL) {
-        psError( __func__, "Null metadata list not allowed" );
-        return NULL;
-    }
-
-    mdList = md->list;
-    if(mdList == NULL) {
-        psError( __func__, "Null metadata list not allowed" );
-        return NULL;
-    }
-
-    psListSetIterator( mdList, which );
-    entry = psListGetCurrent( mdList );
-    while(entry != NULL) {
-        if(!strncmp( match, entry->name, strlen( match ) )) {
+    if (mdList == NULL) {
+        psError(__func__, "Null metadata list not allowed");
+        return NULL;
+    }
+
+    mdList = md->list;
+    if (mdList == NULL) {
+        psError(__func__, "Null metadata list not allowed");
+        return NULL;
+    }
+
+    psListSetIterator(mdList, which);
+    entry = psListGetCurrent(mdList);
+    while (entry != NULL) {
+        if (!strncmp(match, entry->name, strlen(match))) {
 
             // Match found
             return entry;
         }
-        entry = psListGetNext( mdList );
+        entry = psListGetNext(mdList);
     }
 
     // Match not found
-    if(entry == NULL) {
-        psError( __func__, "Couldn't find metadata item with given match. Match: %s", match );
+    if (entry == NULL) {
+        psError(__func__, "Couldn't find metadata item with given match. Match: %s", match);
     }
 
@@ -505,35 +509,35 @@
 }
 
-psMetadataItem *psMetadataGetPrevious( psMetadata *restrict md, const char *restrict match, int which )
-{
-    psList * mdList = NULL;
+psMetadataItem *psMetadataGetPrevious(psMetadata * restrict md, const char *restrict match, int which)
+{
+    psList *mdList = NULL;
     psMetadataItem *entry = NULL;
 
     mdList = md->list;
-    if(mdList == NULL) {
-        psError( __func__, "Null metadata list not allowed" );
-        return NULL;
-    }
-
-    mdList = md->list;
-    if(mdList == NULL) {
-        psError( __func__, "Null metadata list not allowed" );
-        return NULL;
-    }
-
-    psListSetIterator( mdList, which );
-    entry = psListGetCurrent( mdList );
-    while(entry != NULL) {
-        if(!strncmp( match, entry->name, strlen( match ) )) {
+    if (mdList == NULL) {
+        psError(__func__, "Null metadata list not allowed");
+        return NULL;
+    }
+
+    mdList = md->list;
+    if (mdList == NULL) {
+        psError(__func__, "Null metadata list not allowed");
+        return NULL;
+    }
+
+    psListSetIterator(mdList, which);
+    entry = psListGetCurrent(mdList);
+    while (entry != NULL) {
+        if (!strncmp(match, entry->name, strlen(match))) {
 
             // Match found
             return entry;
         }
-        entry = psListGetPrevious( mdList );
+        entry = psListGetPrevious(mdList);
     }
 
     // Match not found
-    if(entry == NULL) {
-        psError( __func__, "Couldn't find metadata item with given match. Match: %s", match );
+    if (entry == NULL) {
+        psError(__func__, "Couldn't find metadata item with given match. Match: %s", match);
     }
 
@@ -541,40 +545,40 @@
 }
 
-void psMetadataItemPrint( FILE *fd, const char *format, const psMetadataItem *restrict metadataItem )
+void psMetadataItemPrint(FILE * fd, const char *format, const psMetadataItem * restrict metadataItem)
 {
     psMetadataType type;
 
-    if(fd == NULL) {
-        psError( __func__, "Null file descriptor not allowed" );
-        return ;
-    }
-
-    if(format == NULL) {
-        psError( __func__, "Null format not allowed" );
-        return ;
-    }
-
-    if(metadataItem == NULL) {
-        psError( __func__, "Null metadata not allowed" );
-        return ;
+    if (fd == NULL) {
+        psError(__func__, "Null file descriptor not allowed");
+        return;
+    }
+
+    if (format == NULL) {
+        psError(__func__, "Null format not allowed");
+        return;
+    }
+
+    if (metadataItem == NULL) {
+        psError(__func__, "Null metadata not allowed");
+        return;
     }
 
     type = metadataItem->type;
 
-    switch(type) {
+    switch (type) {
     case PS_META_BOOL:
-        fprintf( fd, format, metadataItem->data.B );
+        fprintf(fd, format, metadataItem->data.B);
         break;
     case PS_META_S32:
-        fprintf( fd, format, metadataItem->data.S32 );
+        fprintf(fd, format, metadataItem->data.S32);
         break;
     case PS_META_F32:
-        fprintf( fd, format, metadataItem->data.F32 );
+        fprintf(fd, format, metadataItem->data.F32);
         break;
     case PS_META_F64:
-        fprintf( fd, format, metadataItem->data.F64 );
+        fprintf(fd, format, metadataItem->data.F64);
         break;
     case PS_META_STR:
-        fprintf( fd, format, metadataItem->data.V );
+        fprintf(fd, format, metadataItem->data.V);
         break;
     case PS_META_ITEM_SET:
@@ -585,17 +589,17 @@
     case PS_META_UNKNOWN:
     default:
-        psError( __func__, " Invalid psMetadataType to print: %d", type );
-    }
-}
-
-psMetadata *psMetadataFReadHeader( psMetadata *output, char *extName, int extNum, fitsfile *fd )
+        psError(__func__, " Invalid psMetadataType to print: %d", type);
+    }
+}
+
+psMetadata *psMetadataFReadHeader(psMetadata * output, char *extName, int extNum, fitsfile * fd)
 {
     bool tempBool;
     bool success;
     char keyType;
-    char keyName[ FITS_LINE_SIZE ];
-    char keyValue[ FITS_LINE_SIZE ];
-    char keyComment[ FITS_LINE_SIZE ];
-    char fitsErr[ MAX_STRING_LENGTH ];
+    char keyName[FITS_LINE_SIZE];
+    char keyValue[FITS_LINE_SIZE];
+    char keyComment[FITS_LINE_SIZE];
+    char fitsErr[MAX_STRING_LENGTH];
     int i;
     int hduType = 0;
@@ -605,30 +609,27 @@
     psMetadataType metadataItemType;
 
-    if(fd == NULL) {
-        psError( __func__, "Null FITS file descriptor not allowed" );
-        return NULL;
-    }
-
-    if(extName == NULL && extNum == 0) {
-        psError( __func__, "Null extName and extNum = 0 not allowed" );
-        return NULL;
-    } else
-        if(extName && extNum) {
-            psError( __func__, "Both extName and extNum arguments should not have non zero values." );
-            return NULL;
-        }
-
+    if (fd == NULL) {
+        psError(__func__, "Null FITS file descriptor not allowed");
+        return NULL;
+    }
+
+    if (extName == NULL && extNum == 0) {
+        psError(__func__, "Null extName and extNum = 0 not allowed");
+        return NULL;
+    } else if (extName && extNum) {
+        psError(__func__, "Both extName and extNum arguments should not have non zero values.");
+        return NULL;
+    }
     // Allocate metadata if user didn't
-    if(output == NULL) {
+    if (output == NULL) {
         output = psMetadataAlloc();
     }
-
     // Move to user designated HDU number or HDU name in FITS file. HDU numbers starts at one.
-    if(extName != NULL) {
-        if(fits_movnam_hdu( fd, ANY_HDU, extName, 0, &status ) != 0) {
+    if (extName != NULL) {
+        if (fits_movnam_hdu(fd, ANY_HDU, extName, 0, &status) != 0) {
             FITS_ERROR("FITS error while locating header %s: %s", extName);
         }
     } else {
-        if(fits_movabs_hdu( fd, extNum, &hduType, &status ) != 0) {
+        if (fits_movabs_hdu(fd, extNum, &hduType, &status) != 0) {
             FITS_ERROR("FITS error while locating header %d: %s", extNum);
         }
@@ -636,19 +637,19 @@
 
     // Get number of key names
-    if(fits_get_hdrpos( fd, &numKeys, &keyNum, &status ) != 0) {
+    if (fits_get_hdrpos(fd, &numKeys, &keyNum, &status) != 0) {
         FITS_ERROR("FITS error while reading key %d: %s", keyNum);
     }
-
     // Get each key name. Keywords start at one.
-    for(i = 1; i <= numKeys; i++) {
-        if(fits_read_keyn( fd, i, keyName, keyValue, keyComment, &status ) != 0) {
+    for (i = 1; i <= numKeys; i++) {
+        if (fits_read_keyn(fd, i, keyName, keyValue, keyComment, &status) != 0) {
             FITS_ERROR("FITS error while reading key %d: %s", keyNum);
         }
-        if(fits_get_keytype( keyValue, &keyType, &status ) != 0) {
-            fits_get_errstatus( status, fitsErr );
-            if(status != VALUE_UNDEFINED) {
+        if (fits_get_keytype(keyValue, &keyType, &status) != 0) {
+            fits_get_errstatus(status, fitsErr);
+            if (status != VALUE_UNDEFINED) {
                 FITS_ERROR("FITS error while determining key %d type: %s", keyNum);
             } else {
-                // Some keywords are still valid even though they don't have a type, like COMMENTS and HISTORY
+                // Some keywords are still valid even though they don't have a type, like COMMENTS and
+                // HISTORY
                 keyType = 'C';
                 status = 0;
@@ -656,31 +657,37 @@
         }
 
-        switch(keyType) {
+        switch (keyType) {
         case 'I':
             metadataItemType = PS_META_S32;
-            success = psMetadataAdd( output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, atoi( keyValue ) );
+            success =
+                psMetadataAdd(output, PS_LIST_TAIL, keyName, metadataItemType, keyComment,
+                              atoi(keyValue));
             break;
         case 'F':
             metadataItemType = PS_META_F64;
-            success = psMetadataAdd( output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, atof( keyValue ) );
+            success =
+                psMetadataAdd(output, PS_LIST_TAIL, keyName, metadataItemType, keyComment,
+                              atof(keyValue));
             break;
         case 'C':
             metadataItemType = PS_META_STR;
-            success = psMetadataAdd( output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, keyValue );
+            success =
+                psMetadataAdd(output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, keyValue);
             break;
         case 'L':
             metadataItemType = PS_META_BOOL;
-            tempBool = ( keyValue[ 0 ] == 'T' ) ? 1 : 0;
-            success = psMetadataAdd( output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, tempBool );
+            tempBool = (keyValue[0] == 'T') ? 1 : 0;
+            success =
+                psMetadataAdd(output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, tempBool);
             break;
         case 'U':
         case 'X':
         default:
-            psError( __func__, "Invalid psMetadataType: %c", keyType );
+            psError(__func__, "Invalid psMetadataType: %c", keyType);
             return output;
         }
 
-        if(!success) {
-            psError( __func__, "Failed to add metadata item. Name: %s", keyName );
+        if (!success) {
+            psError(__func__, "Failed to add metadata item. Name: %s", keyName);
             return output;
         }