IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Aug 6, 2004, 2:06:06 PM (22 years ago)
Author:
desonia
Message:

another attempt to get astyle to get it right.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/collections/psMetadata.c

    r1406 r1407  
     1
    12/** @file  psMetadata.c
    23*
    … …  
    1112*  @author Ross Harman, MHPCC
    1213*
    13 *  @version $Revision: 1.14 $ $Name: not supported by cvs2svn $
    14 *  @date $Date: 2004-08-06 22:34:05 $
     14*  @version $Revision: 1.15 $ $Name: not supported by cvs2svn $
     15*  @date $Date: 2004-08-07 00:06:06 $
    1516*
    1617*  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    1819
    1920/******************************************************************************/
     21
    2022/*  INCLUDE FILES                                                             */
     23
    2124/******************************************************************************/
    2225#include<stdio.h>
    … …  
    3437#include "psString.h"
    3538
    36 
    3739/******************************************************************************/
     40
    3841/*  DEFINE STATEMENTS                                                         */
     42
    3943/******************************************************************************/
    4044
    … …  
    5660
    5761/******************************************************************************/
     62
    5863/*  TYPE DEFINITIONS                                                          */
     64
    5965/******************************************************************************/
    6066
    … …  
    6268
    6369/*****************************************************************************/
     70
    6471/*  GLOBAL VARIABLES                                                         */
     72
    6573/*****************************************************************************/
    6674
    … …  
    6876
    6977/*****************************************************************************/
     78
    7079/*  FILE STATIC VARIABLES                                                    */
     80
    7181/*****************************************************************************/
    7282
    … …  
    7484
    7585/*****************************************************************************/
     86
    7687/*  FUNCTION IMPLEMENTATION - LOCAL                                          */
    77 /*****************************************************************************/
    78 static void metadataItemFree( psMetadataItem *metadataItem )
     88
     89/*****************************************************************************/
     90static void metadataItemFree(psMetadataItem * metadataItem)
    7991{
    8092    psMetadataType type;
    … …  
    8294    type = metadataItem->type;
    8395
    84     if(metadataItem == NULL) {
    85         return ;
    86     }
    87 
    88     psFree( metadataItem->name );
    89     psFree( metadataItem->comment );
    90     psFree( metadataItem->items );
    91 
    92     if(type == PS_META_STR ||
     96    if (metadataItem == NULL) {
     97        return;
     98    }
     99
     100    psFree(metadataItem->name);
     101    psFree(metadataItem->comment);
     102    psFree(metadataItem->items);
     103
     104    if (type == PS_META_STR ||
    93105            type == PS_META_IMG ||
    94             type == PS_META_JPEG ||
    95             type == PS_META_PNG ||
    96             type == PS_META_ASTROM ||
    97             type == PS_META_UNKNOWN) {
    98         psFree( metadataItem->data.V );
    99     }
    100 }
    101 
    102 static void metadataFree( psMetadata *metadata )
    103 {
    104     if(metadata == NULL) {
    105         return ;
    106     }
    107     psFree( metadata->list );
    108     psFree( metadata->table );
    109 }
    110 
    111 /*****************************************************************************/
     106            type == PS_META_JPEG || type == PS_META_PNG || type == PS_META_ASTROM || type == PS_META_UNKNOWN) {
     107        psFree(metadataItem->data.V);
     108    }
     109}
     110
     111static void metadataFree(psMetadata * metadata)
     112{
     113    if (metadata == NULL) {
     114        return;
     115    }
     116    psFree(metadata->list);
     117    psFree(metadata->table);
     118}
     119
     120/*****************************************************************************/
     121
    112122/* FUNCTION IMPLEMENTATION - PUBLIC                                          */
    113 /*****************************************************************************/
    114 
    115 psMetadataItem *psMetadataItemAlloc( const char *name, psMetadataType type, const char *comment, ... )
     123
     124/*****************************************************************************/
     125
     126psMetadataItem *psMetadataItemAlloc(const char *name, psMetadataType type, const char *comment, ...)
    116127{
    117128    va_list argPtr;
    … …  
    119130
    120131    // Get the variable list parameters to pass to allocation function
    121     va_start( argPtr, comment );
     132    va_start(argPtr, comment);
    122133
    123134    // Call metadata item allocation
    124     metadataItem = psMetadataItemAllocV( name, type, comment, argPtr );
     135    metadataItem = psMetadataItemAllocV(name, type, comment, argPtr);
    125136
    126137    // Clean up stack after variable arguement has been used
    127     va_end( argPtr );
     138    va_end(argPtr);
    128139
    129140    return metadataItem;
    130141}
    131142
    132 psMetadataItem *psMetadataItemAllocV( const char *name, psMetadataType type, const char *comment, va_list argPtr )
    133 {
    134     psMetadataItem * metadataItem = NULL;
    135 
    136     if(name == NULL) {
    137         psError( __func__, "Null value for name not allowed" );
    138         return NULL;
    139     }
    140 
     143psMetadataItem *psMetadataItemAllocV(const char *name, psMetadataType type, const char *comment,
     144                                     va_list argPtr)
     145{
     146    psMetadataItem *metadataItem = NULL;
     147
     148    if (name == NULL) {
     149        psError(__func__, "Null value for name not allowed");
     150        return NULL;
     151    }
    141152    // Allocate metadata item
    142     metadataItem = ( psMetadataItem * ) psAlloc( sizeof( psMetadataItem ) );
    143     if(metadataItem == NULL) {
    144         psAbort( __func__, "Failed to allocate memory" );
    145     }
    146 
     153    metadataItem = (psMetadataItem *) psAlloc(sizeof(psMetadataItem));
     154    if (metadataItem == NULL) {
     155        psAbort(__func__, "Failed to allocate memory");
     156    }
    147157    // Set deallocator
    148     p_psMemSetDeallocator( metadataItem, ( psFreeFcn ) metadataItemFree );
     158    p_psMemSetDeallocator(metadataItem, (psFreeFcn) metadataItemFree);
    149159
    150160    // Allocate and set metadata item comment
    151     metadataItem->comment = ( char * ) psAlloc( sizeof( char ) * MAX_STRING_LENGTH );
    152     if(comment == NULL) {
     161    metadataItem->comment = (char *)psAlloc(sizeof(char) * MAX_STRING_LENGTH);
     162    if (comment == NULL) {
    153163        // Per SDRS, null isn't allowed, must use "" instead
    154         strncpy( metadataItem->comment, "", MAX_STRING_LENGTH );
     164        strncpy(metadataItem->comment, "", MAX_STRING_LENGTH);
    155165    } else {
    156         strncpy( metadataItem->comment, comment, MAX_STRING_LENGTH );
     166        strncpy(metadataItem->comment, comment, MAX_STRING_LENGTH);
    157167    }
    158168
    159169    // Set metadata item unique id
    160     *( int* ) ( &metadataItem->id ) = ++metadataId;
     170    *(int *)(&metadataItem->id) = ++metadataId;
    161171
    162172    // Set metadata item type
    … …  
    164174
    165175    // Set metadata item value
    166     switch(type) {
     176    switch (type) {
    167177    case PS_META_BOOL:
    168         metadataItem->data.B = ( bool ) va_arg( argPtr, int );
     178        metadataItem->data.B = (bool) va_arg(argPtr, int);
     179
    169180        break;
    170181    case PS_META_S32:
    171         metadataItem->data.S32 = va_arg( argPtr, psS32 );
     182        metadataItem->data.S32 = va_arg(argPtr, psS32);
    172183        break;
    173184    case PS_META_F32:
    174         metadataItem->data.F32 = ( psF32 ) va_arg( argPtr, psF64 );
     185        metadataItem->data.F32 = (psF32) va_arg(argPtr, psF64);
    175186        break;
    176187    case PS_META_F64:
    177         metadataItem->data.F64 = va_arg( argPtr, psF64 );
     188        metadataItem->data.F64 = va_arg(argPtr, psF64);
    178189        break;
    179190    case PS_META_STR:
    180         metadataItem->data.V = psStringNCopy( va_arg( argPtr, char* ), MAX_STRING_LENGTH );
     191        metadataItem->data.V = psStringNCopy(va_arg(argPtr, char *), MAX_STRING_LENGTH);
     192
    181193        break;
    182194    case PS_META_IMG:
    … …  
    186198    case PS_META_UNKNOWN:
    187199    default:
    188         psError( __func__, "Invalid psMetadataType: %d", type );
     200        psError(__func__, "Invalid psMetadataType: %d", type);
    189201    }
    190202
    191203    // Allocate and set metadata item name
    192     metadataItem->name = ( char * ) psAlloc( sizeof( char ) * MAX_STRING_LENGTH );
    193     vsprintf( metadataItem->name, name, argPtr );
     204    metadataItem->name = (char *)psAlloc(sizeof(char) * MAX_STRING_LENGTH);
     205    vsprintf(metadataItem->name, name, argPtr);
    194206
    195207    // Allocate metadata items with same name.
    196     metadataItem->items = psListAlloc( NULL );
     208    metadataItem->items = psListAlloc(NULL);
    197209
    198210    return metadataItem;
    199211}
    200212
    201 psMetadata *psMetadataAlloc( void )
    202 {
    203     psList * list = NULL;
     213psMetadata *psMetadataAlloc(void)
     214{
     215    psList *list = NULL;
    204216    psHash *table = NULL;
    205217    psMetadata *metadata = NULL;
    206218
    207219    // Allocate metadata
    208     metadata = ( psMetadata * ) psAlloc( sizeof( psMetadata ) );
    209     if(metadata == NULL) {
    210         psAbort( __func__, "Failed to allocate metadata" );
    211     }
    212 
     220    metadata = (psMetadata *) psAlloc(sizeof(psMetadata));
     221    if (metadata == NULL) {
     222        psAbort(__func__, "Failed to allocate metadata");
     223    }
    213224    // Set deallocator
    214     p_psMemSetDeallocator( metadata, ( psFreeFcn ) metadataFree );
     225    p_psMemSetDeallocator(metadata, (psFreeFcn) metadataFree);
    215226
    216227    // Allocate metadata's internal containers
    217     list = ( psList * ) psListAlloc( NULL );
    218     if(list == NULL) {
    219         psAbort( __func__, "Failed to allocate list" );
    220     }
    221 
    222     table = ( psHash * ) psHashAlloc( 10 );
    223     if(table == NULL) {
    224         psAbort( __func__, "Failed to allocate table" );
     228    list = (psList *) psListAlloc(NULL);
     229    if (list == NULL) {
     230        psAbort(__func__, "Failed to allocate list");
     231    }
     232
     233    table = (psHash *) psHashAlloc(10);
     234    if (table == NULL) {
     235        psAbort(__func__, "Failed to allocate table");
    225236    }
    226237
    … …  
    231242}
    232243
    233 bool psMetadataAddItem( psMetadata *restrict md, int where, psMetadataItem *restrict metadataItem )
    234 {
    235     char * key = NULL;
     244bool psMetadataAddItem(psMetadata * restrict md, int where, psMetadataItem * restrict metadataItem)
     245{
     246    char *key = NULL;
    236247    psHash *mdTable = NULL;
    237248    psList *mdList = NULL;
    … …  
    239250    psMetadataType type = PS_META_ITEM_SET;
    240251
    241     if(md == NULL) {
    242         psError( __func__, "Null metadata collection not allowed" );
    243         return false;
    244     }
    245 
    246     if(metadataItem == NULL) {
    247         psError( __func__, "Null metadata item not allowed" );
     252    if (md == NULL) {
     253        psError(__func__, "Null metadata collection not allowed");
     254        return false;
     255    }
     256
     257    if (metadataItem == NULL) {
     258        psError(__func__, "Null metadata item not allowed");
    248259        return false;
    249260    }
    … …  
    252263
    253264    mdTable = md->table;
    254     if(mdTable == NULL) {
    255         psError( __func__, "Null metadata table not allowed" );
    256         return false;
    257     }
    258 
    259     mdList = md->list;
    260     if(mdList == NULL) {
    261         psError( __func__, "Null metadata list not allowed" );
     265    if (mdTable == NULL) {
     266        psError(__func__, "Null metadata table not allowed");
     267        return false;
     268    }
     269
     270    mdList = md->list;
     271    if (mdList == NULL) {
     272        psError(__func__, "Null metadata list not allowed");
    262273        return false;
    263274    }
    264275
    265276    key = metadataItem->name;
    266     if(key == NULL) {
    267         psError( __func__, "Null key item not allowed" );
    268         return false;
    269     }
    270 
     277    if (key == NULL) {
     278        psError(__func__, "Null key item not allowed");
     279        return false;
     280    }
    271281    // Check if key is already in table
    272     value = ( psMetadataItem* ) psHashLookup( mdTable, key );
    273     if(value != NULL && type != PS_META_ITEM_SET) {
     282    value = (psMetadataItem *) psHashLookup(mdTable, key);
     283    if (value != NULL && type != PS_META_ITEM_SET) {
    274284
    275285        // The key was found and the new metadata item is a leaf node (its type isn't PS_META_ITEM_SET), so
    276286        // add the new metadata item to hash as a child of the existing metadata item folder node.
    277         if(!psListAdd( value->items, metadataItem, where )) {
    278             psError( __func__, "Couldn't add metadata item to items list. Name: %s",
    279                      metadataItem->name );
     287        if (!psListAdd(value->items, metadataItem, where)) {
     288            psError(__func__, "Couldn't add metadata item to items list. Name: %s", metadataItem->name);
    280289            return false;
    281290        }
    282     } else
    283         if(value != NULL) {
    284 
    285             // The key was found and the new metadata item is a folder node. Don't add new metadata item, since
    286             // it will wipe out existing node.
    287             psError( __func__, "Metadata already exists in metadata collection. Item not added. Name: %s",
    288                      metadataItem->name );
     291    } else if (value != NULL) {
     292
     293        // The key was found and the new metadata item is a folder node. Don't add new metadata item, since
     294        // it will wipe out existing node.
     295        psError(__func__, "Metadata already exists in metadata collection. Item not added. Name: %s",
     296                metadataItem->name);
     297        return false;
     298    } else {
     299
     300        // Duplicate key not found. Add new metadata item to metadata collection's hash
     301        if (!psHashAdd(mdTable, key, metadataItem)) {
     302            psError(__func__, "Couldn't add metadata item to metadata collection table. Name: %s",
     303                    metadataItem->name);
    289304            return false;
    290         } else {
    291 
    292             // Duplicate key not found. Add new metadata item to metadata collection's hash
    293             if(!psHashAdd( mdTable, key, metadataItem )) {
    294                 psError( __func__, "Couldn't add metadata item to metadata collection table. Name: %s",
    295                          metadataItem->name );
    296                 return false;
    297             }
    298         }
     305        }
     306    }
    299307
    300308    // Add all items to metadata collection's list, even if they have the same metadata item names
    301     if(!psListAdd( md->list, metadataItem, where )) {
    302         psError( __func__, "Couldn't add metadata item to metadata collection list. Name: %s",
    303                  metadataItem->name );
     309    if (!psListAdd(md->list, metadataItem, where)) {
     310        psError(__func__, "Couldn't add metadata item to metadata collection list. Name: %s",
     311                metadataItem->name);
    304312        return false;
    305313    }
    … …  
    308316}
    309317
    310 bool psMetadataAdd( psMetadata *restrict md, int where, const char *name, psMetadataType type,
    311                     const char *comment, ... )
     318bool psMetadataAdd(psMetadata * restrict md, int where, const char *name, psMetadataType type,
     319                   const char *comment, ...)
    312320{
    313321    va_list argPtr;
    314322    psMetadataItem *metadataItem = NULL;
    315323
    316     va_start( argPtr, comment );
    317     metadataItem = psMetadataItemAllocV( name, type, comment, argPtr );
    318     va_end( argPtr );
    319 
    320     if(!psMetadataAddItem( md, where, metadataItem )) {
    321         psError( __func__, "Couldn't add metadata item to metadata collection list. Name: %s",
    322                  metadataItem->name );
    323         psFree( metadataItem );
    324         return false;
    325     }
    326 
    327     // Decrement reference count, since the metadata item is now in metadata collection and no longer needed here
    328     psMemDecrRefCounter( metadataItem );
     324    va_start(argPtr, comment);
     325    metadataItem = psMetadataItemAllocV(name, type, comment, argPtr);
     326    va_end(argPtr);
     327
     328    if (!psMetadataAddItem(md, where, metadataItem)) {
     329        psError(__func__, "Couldn't add metadata item to metadata collection list. Name: %s",
     330                metadataItem->name);
     331        psFree(metadataItem);
     332        return false;
     333    }
     334    // Decrement reference count, since the metadata item is now in metadata collection and no longer needed
     335    // here
     336    psMemDecrRefCounter(metadataItem);
    329337
    330338    return true;
    331339}
    332340
    333 bool psMetadataRemove( psMetadata *restrict md, int where, const char *restrict key )
     341bool psMetadataRemove(psMetadata * restrict md, int where, const char *restrict key)
    334342{
    335343    int numChildren = 0;
    … …  
    340348
    341349    mdList = md->list;
    342     if(mdList == NULL) {
    343         psError( __func__, "Null metadata list not allowed" );
     350    if (mdList == NULL) {
     351        psError(__func__, "Null metadata list not allowed");
    344352        return false;
    345353    }
    346354
    347355    mdTable = md->table;
    348     if(mdTable == NULL) {
    349         psError( __func__, "Null metadata table not allowed" );
    350         return false;
    351     }
    352 
     356    if (mdTable == NULL) {
     357        psError(__func__, "Null metadata table not allowed");
     358        return false;
     359    }
    353360    // Select removal by key or index
    354     if(key != NULL) {
     361    if (key != NULL) {
    355362
    356363        // Remove by key name
    357         entry = ( psMetadataItem* ) psHashLookup( mdTable, key );
    358         if(entry == NULL) {
    359             psError( __func__, "Couldn't find metadata item remove. Name: %s", key );
     364        entry = (psMetadataItem *) psHashLookup(mdTable, key);
     365        if (entry == NULL) {
     366            psError(__func__, "Couldn't find metadata item remove. Name: %s", key);
    360367            return false;
    361368        }
    362369
    363370        numChildren = entry->items->size;
    364         if(entry->type == PS_META_ITEM_SET && numChildren > 0) {
     371        if (entry->type == PS_META_ITEM_SET && numChildren > 0) {
    365372
    366373            // Table entry has children. Entry and children must be removed from metadata collection's list
    367             psListSetIterator( mdList, PS_LIST_HEAD );
    368             entryChild = psListGetCurrent( mdList );
    369             while(entryChild != NULL) {
    370                 if(!psListRemove( entry->items, entryChild, PS_LIST_UNKNOWN )) {
    371                     psError( __func__, "Couldn't remove metadata item from list. Name: %s", key );
     374            psListSetIterator(mdList, PS_LIST_HEAD);
     375            entryChild = psListGetCurrent(mdList);
     376            while (entryChild != NULL) {
     377                if (!psListRemove(entry->items, entryChild, PS_LIST_UNKNOWN)) {
     378                    psError(__func__, "Couldn't remove metadata item from list. Name: %s", key);
    372379                    return false;
    373380                }
    374                 entryChild = psListGetNext( entry->items );
     381                entryChild = psListGetNext(entry->items);
    375382            }
    376383        }
    377 
    378384        // Remove entry from metadata collection's list
    379         if(!psListRemove( mdList, entry, PS_LIST_UNKNOWN )) {
    380             psError( __func__, "Couldn't remove metadata item from list. Name: %s", key );
     385        if (!psListRemove(mdList, entry, PS_LIST_UNKNOWN)) {
     386            psError(__func__, "Couldn't remove metadata item from list. Name: %s", key);
    381387            return false;
    382388        }
    383 
    384389        // Remove entry from metadata collection's table
    385         if(!psHashRemove( mdTable, key )) {
    386             psError( __func__, "Couldn't remove metadata item from table. Name: %s", key );
     390        if (!psHashRemove(mdTable, key)) {
     391            psError(__func__, "Couldn't remove metadata item from table. Name: %s", key);
    387392            return false;
    388393        }
    … …  
    390395
    391396        // Remove by index
    392         entry = psListGet( mdList, where );
    393         if(entry == NULL) {
    394             psError( __func__, "Couldn't find metadata item from list. Index: %d", where );
     397        entry = psListGet(mdList, where);
     398        if (entry == NULL) {
     399            psError(__func__, "Couldn't find metadata item from list. Index: %d", where);
    395400            return false;
    396401        }
    397402
    398403        key = entry->name;
    399         if(key == NULL) {
    400             psError( __func__, "Null key name not allowed. Index: %d", where );
     404        if (key == NULL) {
     405            psError(__func__, "Null key name not allowed. Index: %d", where);
    401406            return false;
    402407        }
    403 
    404408        // Use recursive remove, now that key is known
    405         psMetadataRemove( md, PS_LIST_UNKNOWN, key );
     409        psMetadataRemove(md, PS_LIST_UNKNOWN, key);
    406410    }
    407411
    … …  
    409413}
    410414
    411 psMetadataItem *psMetadataLookup( psMetadata *restrict md, const char *restrict key )
    412 {
    413     psHash * mdTable = NULL;
     415psMetadataItem *psMetadataLookup(psMetadata * restrict md, const char *restrict key)
     416{
     417    psHash *mdTable = NULL;
    414418    psMetadataItem *entry = NULL;
    415419
    416420    mdTable = md->table;
    417     if(mdTable == NULL) {
    418         psError( __func__, "Null metadata table not allowed" );
    419         return NULL;
    420     }
    421 
    422     if(key == NULL) {
    423         psError( __func__, "Null key name not allowed" );
    424         return NULL;
    425     }
    426 
    427     entry = ( psMetadataItem* ) psHashLookup( mdTable, key );
    428     if(entry == NULL) {
    429         psError( __func__, "Could not find metadata item with given key. Key: %s", key );
     421    if (mdTable == NULL) {
     422        psError(__func__, "Null metadata table not allowed");
     423        return NULL;
     424    }
     425
     426    if (key == NULL) {
     427        psError(__func__, "Null key name not allowed");
     428        return NULL;
     429    }
     430
     431    entry = (psMetadataItem *) psHashLookup(mdTable, key);
     432    if (entry == NULL) {
     433        psError(__func__, "Could not find metadata item with given key. Key: %s", key);
    430434        return NULL;
    431435    }
    … …  
    434438}
    435439
    436 psMetadataItem *psMetadataGet( psMetadata *restrict md, int where )
    437 {
    438     psList * mdList = NULL;
     440psMetadataItem *psMetadataGet(psMetadata * restrict md, int where)
     441{
     442    psList *mdList = NULL;
    439443    psMetadataItem *entry = NULL;
    440444
    441445    mdList = md->list;
    442     if(mdList == NULL) {
    443         psError( __func__, "Null metadata list not allowed" );
    444         return NULL;
    445     }
    446 
    447     entry = ( psMetadataItem* ) psListGet( mdList, where );
    448     if(entry == NULL) {
    449         psError( __func__, "Couldn't find metadata item with given index. Index: %d", where );
     446    if (mdList == NULL) {
     447        psError(__func__, "Null metadata list not allowed");
     448        return NULL;
     449    }
     450
     451    entry = (psMetadataItem *) psListGet(mdList, where);
     452    if (entry == NULL) {
     453        psError(__func__, "Couldn't find metadata item with given index. Index: %d", where);
    450454        return NULL;
    451455    }
    … …  
    454458}
    455459
    456 bool psMetadataSetIterator( psMetadata *restrict md, int where )
    457 {
    458     psList * mdList = NULL;
    459 
    460     mdList = md->list;
    461     if(mdList == NULL) {
    462         psError( __func__, "Null metadata list not allowed" );
    463         return false;
    464     }
    465 
    466     psListSetIterator( mdList, where );
     460bool psMetadataSetIterator(psMetadata * restrict md, int where)
     461{
     462    psList *mdList = NULL;
     463
     464    mdList = md->list;
     465    if (mdList == NULL) {
     466        psError(__func__, "Null metadata list not allowed");
     467        return false;
     468    }
     469
     470    psListSetIterator(mdList, where);
    467471
    468472    return true;
    469473}
    470474
    471 psMetadataItem *psMetadataGetNext( psMetadata *restrict md, const char *restrict match, int which )
    472 {
    473     psList * mdList = NULL;
     475psMetadataItem *psMetadataGetNext(psMetadata * restrict md, const char *restrict match, int which)
     476{
     477    psList *mdList = NULL;
    474478    psMetadataItem *entry = NULL;
    475479
    476480    mdList = md->list;
    477     if(mdList == NULL) {
    478         psError( __func__, "Null metadata list not allowed" );
    479         return NULL;
    480     }
    481 
    482     mdList = md->list;
    483     if(mdList == NULL) {
    484         psError( __func__, "Null metadata list not allowed" );
    485         return NULL;
    486     }
    487 
    488     psListSetIterator( mdList, which );
    489     entry = psListGetCurrent( mdList );
    490     while(entry != NULL) {
    491         if(!strncmp( match, entry->name, strlen( match ) )) {
     481    if (mdList == NULL) {
     482        psError(__func__, "Null metadata list not allowed");
     483        return NULL;
     484    }
     485
     486    mdList = md->list;
     487    if (mdList == NULL) {
     488        psError(__func__, "Null metadata list not allowed");
     489        return NULL;
     490    }
     491
     492    psListSetIterator(mdList, which);
     493    entry = psListGetCurrent(mdList);
     494    while (entry != NULL) {
     495        if (!strncmp(match, entry->name, strlen(match))) {
    492496
    493497            // Match found
    494498            return entry;
    495499        }
    496         entry = psListGetNext( mdList );
     500        entry = psListGetNext(mdList);
    497501    }
    498502
    499503    // Match not found
    500     if(entry == NULL) {
    501         psError( __func__, "Couldn't find metadata item with given match. Match: %s", match );
     504    if (entry == NULL) {
     505        psError(__func__, "Couldn't find metadata item with given match. Match: %s", match);
    502506    }
    503507
    … …  
    505509}
    506510
    507 psMetadataItem *psMetadataGetPrevious( psMetadata *restrict md, const char *restrict match, int which )
    508 {
    509     psList * mdList = NULL;
     511psMetadataItem *psMetadataGetPrevious(psMetadata * restrict md, const char *restrict match, int which)
     512{
     513    psList *mdList = NULL;
    510514    psMetadataItem *entry = NULL;
    511515
    512516    mdList = md->list;
    513     if(mdList == NULL) {
    514         psError( __func__, "Null metadata list not allowed" );
    515         return NULL;
    516     }
    517 
    518     mdList = md->list;
    519     if(mdList == NULL) {
    520         psError( __func__, "Null metadata list not allowed" );
    521         return NULL;
    522     }
    523 
    524     psListSetIterator( mdList, which );
    525     entry = psListGetCurrent( mdList );
    526     while(entry != NULL) {
    527         if(!strncmp( match, entry->name, strlen( match ) )) {
     517    if (mdList == NULL) {
     518        psError(__func__, "Null metadata list not allowed");
     519        return NULL;
     520    }
     521
     522    mdList = md->list;
     523    if (mdList == NULL) {
     524        psError(__func__, "Null metadata list not allowed");
     525        return NULL;
     526    }
     527
     528    psListSetIterator(mdList, which);
     529    entry = psListGetCurrent(mdList);
     530    while (entry != NULL) {
     531        if (!strncmp(match, entry->name, strlen(match))) {
    528532
    529533            // Match found
    530534            return entry;
    531535        }
    532         entry = psListGetPrevious( mdList );
     536        entry = psListGetPrevious(mdList);
    533537    }
    534538
    535539    // Match not found
    536     if(entry == NULL) {
    537         psError( __func__, "Couldn't find metadata item with given match. Match: %s", match );
     540    if (entry == NULL) {
     541        psError(__func__, "Couldn't find metadata item with given match. Match: %s", match);
    538542    }
    539543
    … …  
    541545}
    542546
    543 void psMetadataItemPrint( FILE *fd, const char *format, const psMetadataItem *restrict metadataItem )
     547void psMetadataItemPrint(FILE * fd, const char *format, const psMetadataItem * restrict metadataItem)
    544548{
    545549    psMetadataType type;
    546550
    547     if(fd == NULL) {
    548         psError( __func__, "Null file descriptor not allowed" );
    549         return ;
    550     }
    551 
    552     if(format == NULL) {
    553         psError( __func__, "Null format not allowed" );
    554         return ;
    555     }
    556 
    557     if(metadataItem == NULL) {
    558         psError( __func__, "Null metadata not allowed" );
    559         return ;
     551    if (fd == NULL) {
     552        psError(__func__, "Null file descriptor not allowed");
     553        return;
     554    }
     555
     556    if (format == NULL) {
     557        psError(__func__, "Null format not allowed");
     558        return;
     559    }
     560
     561    if (metadataItem == NULL) {
     562        psError(__func__, "Null metadata not allowed");
     563        return;
    560564    }
    561565
    562566    type = metadataItem->type;
    563567
    564     switch(type) {
     568    switch (type) {
    565569    case PS_META_BOOL:
    566         fprintf( fd, format, metadataItem->data.B );
     570        fprintf(fd, format, metadataItem->data.B);
    567571        break;
    568572    case PS_META_S32:
    569         fprintf( fd, format, metadataItem->data.S32 );
     573        fprintf(fd, format, metadataItem->data.S32);
    570574        break;
    571575    case PS_META_F32:
    572         fprintf( fd, format, metadataItem->data.F32 );
     576        fprintf(fd, format, metadataItem->data.F32);
    573577        break;
    574578    case PS_META_F64:
    575         fprintf( fd, format, metadataItem->data.F64 );
     579        fprintf(fd, format, metadataItem->data.F64);
    576580        break;
    577581    case PS_META_STR:
    578         fprintf( fd, format, metadataItem->data.V );
     582        fprintf(fd, format, metadataItem->data.V);
    579583        break;
    580584    case PS_META_ITEM_SET:
    … …  
    585589    case PS_META_UNKNOWN:
    586590    default:
    587         psError( __func__, " Invalid psMetadataType to print: %d", type );
    588     }
    589 }
    590 
    591 psMetadata *psMetadataFReadHeader( psMetadata *output, char *extName, int extNum, fitsfile *fd )
     591        psError(__func__, " Invalid psMetadataType to print: %d", type);
     592    }
     593}
     594
     595psMetadata *psMetadataFReadHeader(psMetadata * output, char *extName, int extNum, fitsfile * fd)
    592596{
    593597    bool tempBool;
    594598    bool success;
    595599    char keyType;
    596     char keyName[ FITS_LINE_SIZE ];
    597     char keyValue[ FITS_LINE_SIZE ];
    598     char keyComment[ FITS_LINE_SIZE ];
    599     char fitsErr[ MAX_STRING_LENGTH ];
     600    char keyName[FITS_LINE_SIZE];
     601    char keyValue[FITS_LINE_SIZE];
     602    char keyComment[FITS_LINE_SIZE];
     603    char fitsErr[MAX_STRING_LENGTH];
    600604    int i;
    601605    int hduType = 0;
    … …  
    605609    psMetadataType metadataItemType;
    606610
    607     if(fd == NULL) {
    608         psError( __func__, "Null FITS file descriptor not allowed" );
    609         return NULL;
    610     }
    611 
    612     if(extName == NULL && extNum == 0) {
    613         psError( __func__, "Null extName and extNum = 0 not allowed" );
    614         return NULL;
    615     } else
    616         if(extName && extNum) {
    617             psError( __func__, "Both extName and extNum arguments should not have non zero values." );
    618             return NULL;
    619         }
    620 
     611    if (fd == NULL) {
     612        psError(__func__, "Null FITS file descriptor not allowed");
     613        return NULL;
     614    }
     615
     616    if (extName == NULL && extNum == 0) {
     617        psError(__func__, "Null extName and extNum = 0 not allowed");
     618        return NULL;
     619    } else if (extName && extNum) {
     620        psError(__func__, "Both extName and extNum arguments should not have non zero values.");
     621        return NULL;
     622    }
    621623    // Allocate metadata if user didn't
    622     if(output == NULL) {
     624    if (output == NULL) {
    623625        output = psMetadataAlloc();
    624626    }
    625 
    626627    // Move to user designated HDU number or HDU name in FITS file. HDU numbers starts at one.
    627     if(extName != NULL) {
    628         if(fits_movnam_hdu( fd, ANY_HDU, extName, 0, &status ) != 0) {
     628    if (extName != NULL) {
     629        if (fits_movnam_hdu(fd, ANY_HDU, extName, 0, &status) != 0) {
    629630            FITS_ERROR("FITS error while locating header %s: %s", extName);
    630631        }
    631632    } else {
    632         if(fits_movabs_hdu( fd, extNum, &hduType, &status ) != 0) {
     633        if (fits_movabs_hdu(fd, extNum, &hduType, &status) != 0) {
    633634            FITS_ERROR("FITS error while locating header %d: %s", extNum);
    634635        }
    … …  
    636637
    637638    // Get number of key names
    638     if(fits_get_hdrpos( fd, &numKeys, &keyNum, &status ) != 0) {
     639    if (fits_get_hdrpos(fd, &numKeys, &keyNum, &status) != 0) {
    639640        FITS_ERROR("FITS error while reading key %d: %s", keyNum);
    640641    }
    641 
    642642    // Get each key name. Keywords start at one.
    643     for(i = 1; i <= numKeys; i++) {
    644         if(fits_read_keyn( fd, i, keyName, keyValue, keyComment, &status ) != 0) {
     643    for (i = 1; i <= numKeys; i++) {
     644        if (fits_read_keyn(fd, i, keyName, keyValue, keyComment, &status) != 0) {
    645645            FITS_ERROR("FITS error while reading key %d: %s", keyNum);
    646646        }
    647         if(fits_get_keytype( keyValue, &keyType, &status ) != 0) {
    648             fits_get_errstatus( status, fitsErr );
    649             if(status != VALUE_UNDEFINED) {
     647        if (fits_get_keytype(keyValue, &keyType, &status) != 0) {
     648            fits_get_errstatus(status, fitsErr);
     649            if (status != VALUE_UNDEFINED) {
    650650                FITS_ERROR("FITS error while determining key %d type: %s", keyNum);
    651651            } else {
    652                 // Some keywords are still valid even though they don't have a type, like COMMENTS and HISTORY
     652                // Some keywords are still valid even though they don't have a type, like COMMENTS and
     653                // HISTORY
    653654                keyType = 'C';
    654655                status = 0;
    … …  
    656657        }
    657658
    658         switch(keyType) {
     659        switch (keyType) {
    659660        case 'I':
    660661            metadataItemType = PS_META_S32;
    661             success = psMetadataAdd( output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, atoi( keyValue ) );
     662            success =
     663                psMetadataAdd(output, PS_LIST_TAIL, keyName, metadataItemType, keyComment,
     664                              atoi(keyValue));
    662665            break;
    663666        case 'F':
    664667            metadataItemType = PS_META_F64;
    665             success = psMetadataAdd( output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, atof( keyValue ) );
     668            success =
     669                psMetadataAdd(output, PS_LIST_TAIL, keyName, metadataItemType, keyComment,
     670                              atof(keyValue));
    666671            break;
    667672        case 'C':
    668673            metadataItemType = PS_META_STR;
    669             success = psMetadataAdd( output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, keyValue );
     674            success =
     675                psMetadataAdd(output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, keyValue);
    670676            break;
    671677        case 'L':
    672678            metadataItemType = PS_META_BOOL;
    673             tempBool = ( keyValue[ 0 ] == 'T' ) ? 1 : 0;
    674             success = psMetadataAdd( output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, tempBool );
     679            tempBool = (keyValue[0] == 'T') ? 1 : 0;
     680            success =
     681                psMetadataAdd(output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, tempBool);
    675682            break;
    676683        case 'U':
    677684        case 'X':
    678685        default:
    679             psError( __func__, "Invalid psMetadataType: %c", keyType );
     686            psError(__func__, "Invalid psMetadataType: %c", keyType);
    680687            return output;
    681688        }
    682689
    683         if(!success) {
    684             psError( __func__, "Failed to add metadata item. Name: %s", keyName );
     690        if (!success) {
     691            psError(__func__, "Failed to add metadata item. Name: %s", keyName);
    685692            return output;
    686693        }
Note: See TracChangeset for help on using the changeset viewer.