IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 8156


Ignore:
Timestamp:
Aug 4, 2006, 2:35:59 PM (20 years ago)
Author:
jhoblitt
Message:

VERSION 0.0.15

Location:
trunk/ippdb
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippdb/configure.ac

    r8152 r8156  
    11AC_PREREQ(2.59)
    22
    3 AC_INIT([ippdb], [0.0.14], [pan-starrs.ifa.hawaii.edu])
     3AC_INIT([ippdb], [0.0.15], [pan-starrs.ifa.hawaii.edu])
    44AC_CONFIG_SRCDIR([ippdb.pc.in])
    55

  • trunk/ippdb/src/ippdb.c

    r8152 r8156  
    575575    return deleted;
    576576}
    577 /** Formats and prints an array of weatherRow objects
    578  *
    579  * @return A boolean - false on error
    580  */
    581 
    582 bool weatherPrintObjects(
    583     FILE            *stream,            ///< a stream
    584     psArray         *objects,           ///< An array of weatherRow objects
    585     bool            mdconfigformat      ///< format as mdconfig or simple
    586 );
     577bool weatherPrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     578{
     579    PS_ASSERT_PTR_NON_NULL(objects, false);
     580
     581    psMetadata *output = psMetadataAlloc();
     582    for (long i = 0; i < psArrayLength(objects); i++) {
     583        psMetadata *md = weatherMetadataFromObject(objects->data[i]);
     584        if (!psMetadataAddMetadata(
     585            output,
     586            PS_LIST_TAIL,
     587            WEATHER_TABLE_NAME,
     588            PS_META_DUPLICATE_OK,
     589            NULL,
     590            md
     591        )) {
     592            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     593            psFree(md);
     594            psFree(output);
     595            return false;
     596        }
     597        psFree(md);
     598    }
     599
     600    psString str = psMetadataConfigFormat(output);
     601    if (!str) {
     602        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     603        psFree(output);
     604    }
     605    psFree(output);
     606    fprintf(stream, "%s\n", str);
     607    psFree(str);
     608
     609    return true;
     610}
    587611static void skyp_transparencyRowFree(skyp_transparencyRow *object);
    588612
    … …  
    10841108    return deleted;
    10851109}
    1086 /** Formats and prints an array of skyp_transparencyRow objects
    1087  *
    1088  * @return A boolean - false on error
    1089  */
    1090 
    1091 bool skyp_transparencyPrintObjects(
    1092     FILE            *stream,            ///< a stream
    1093     psArray         *objects,           ///< An array of skyp_transparencyRow objects
    1094     bool            mdconfigformat      ///< format as mdconfig or simple
    1095 );
     1110bool skyp_transparencyPrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     1111{
     1112    PS_ASSERT_PTR_NON_NULL(objects, false);
     1113
     1114    psMetadata *output = psMetadataAlloc();
     1115    for (long i = 0; i < psArrayLength(objects); i++) {
     1116        psMetadata *md = skyp_transparencyMetadataFromObject(objects->data[i]);
     1117        if (!psMetadataAddMetadata(
     1118            output,
     1119            PS_LIST_TAIL,
     1120            SKYP_TRANSPARENCY_TABLE_NAME,
     1121            PS_META_DUPLICATE_OK,
     1122            NULL,
     1123            md
     1124        )) {
     1125            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     1126            psFree(md);
     1127            psFree(output);
     1128            return false;
     1129        }
     1130        psFree(md);
     1131    }
     1132
     1133    psString str = psMetadataConfigFormat(output);
     1134    if (!str) {
     1135        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     1136        psFree(output);
     1137    }
     1138    psFree(output);
     1139    fprintf(stream, "%s\n", str);
     1140    psFree(str);
     1141
     1142    return true;
     1143}
    10961144static void skyp_absorptionRowFree(skyp_absorptionRow *object);
    10971145
    … …  
    16511699    return deleted;
    16521700}
    1653 /** Formats and prints an array of skyp_absorptionRow objects
    1654  *
    1655  * @return A boolean - false on error
    1656  */
    1657 
    1658 bool skyp_absorptionPrintObjects(
    1659     FILE            *stream,            ///< a stream
    1660     psArray         *objects,           ///< An array of skyp_absorptionRow objects
    1661     bool            mdconfigformat      ///< format as mdconfig or simple
    1662 );
     1701bool skyp_absorptionPrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     1702{
     1703    PS_ASSERT_PTR_NON_NULL(objects, false);
     1704
     1705    psMetadata *output = psMetadataAlloc();
     1706    for (long i = 0; i < psArrayLength(objects); i++) {
     1707        psMetadata *md = skyp_absorptionMetadataFromObject(objects->data[i]);
     1708        if (!psMetadataAddMetadata(
     1709            output,
     1710            PS_LIST_TAIL,
     1711            SKYP_ABSORPTION_TABLE_NAME,
     1712            PS_META_DUPLICATE_OK,
     1713            NULL,
     1714            md
     1715        )) {
     1716            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     1717            psFree(md);
     1718            psFree(output);
     1719            return false;
     1720        }
     1721        psFree(md);
     1722    }
     1723
     1724    psString str = psMetadataConfigFormat(output);
     1725    if (!str) {
     1726        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     1727        psFree(output);
     1728    }
     1729    psFree(output);
     1730    fprintf(stream, "%s\n", str);
     1731    psFree(str);
     1732
     1733    return true;
     1734}
    16631735static void skyp_emissionRowFree(skyp_emissionRow *object);
    16641736
    … …  
    21312203    return deleted;
    21322204}
    2133 /** Formats and prints an array of skyp_emissionRow objects
    2134  *
    2135  * @return A boolean - false on error
    2136  */
    2137 
    2138 bool skyp_emissionPrintObjects(
    2139     FILE            *stream,            ///< a stream
    2140     psArray         *objects,           ///< An array of skyp_emissionRow objects
    2141     bool            mdconfigformat      ///< format as mdconfig or simple
    2142 );
     2205bool skyp_emissionPrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     2206{
     2207    PS_ASSERT_PTR_NON_NULL(objects, false);
     2208
     2209    psMetadata *output = psMetadataAlloc();
     2210    for (long i = 0; i < psArrayLength(objects); i++) {
     2211        psMetadata *md = skyp_emissionMetadataFromObject(objects->data[i]);
     2212        if (!psMetadataAddMetadata(
     2213            output,
     2214            PS_LIST_TAIL,
     2215            SKYP_EMISSION_TABLE_NAME,
     2216            PS_META_DUPLICATE_OK,
     2217            NULL,
     2218            md
     2219        )) {
     2220            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     2221            psFree(md);
     2222            psFree(output);
     2223            return false;
     2224        }
     2225        psFree(md);
     2226    }
     2227
     2228    psString str = psMetadataConfigFormat(output);
     2229    if (!str) {
     2230        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     2231        psFree(output);
     2232    }
     2233    psFree(output);
     2234    fprintf(stream, "%s\n", str);
     2235    psFree(str);
     2236
     2237    return true;
     2238}
    21432239static void dimmRowFree(dimmRow *object);
    21442240
    … …  
    26402736    return deleted;
    26412737}
    2642 /** Formats and prints an array of dimmRow objects
    2643  *
    2644  * @return A boolean - false on error
    2645  */
    2646 
    2647 bool dimmPrintObjects(
    2648     FILE            *stream,            ///< a stream
    2649     psArray         *objects,           ///< An array of dimmRow objects
    2650     bool            mdconfigformat      ///< format as mdconfig or simple
    2651 );
     2738bool dimmPrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     2739{
     2740    PS_ASSERT_PTR_NON_NULL(objects, false);
     2741
     2742    psMetadata *output = psMetadataAlloc();
     2743    for (long i = 0; i < psArrayLength(objects); i++) {
     2744        psMetadata *md = dimmMetadataFromObject(objects->data[i]);
     2745        if (!psMetadataAddMetadata(
     2746            output,
     2747            PS_LIST_TAIL,
     2748            DIMM_TABLE_NAME,
     2749            PS_META_DUPLICATE_OK,
     2750            NULL,
     2751            md
     2752        )) {
     2753            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     2754            psFree(md);
     2755            psFree(output);
     2756            return false;
     2757        }
     2758        psFree(md);
     2759    }
     2760
     2761    psString str = psMetadataConfigFormat(output);
     2762    if (!str) {
     2763        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     2764        psFree(output);
     2765    }
     2766    psFree(output);
     2767    fprintf(stream, "%s\n", str);
     2768    psFree(str);
     2769
     2770    return true;
     2771}
    26522772static void skyp_irRowFree(skyp_irRow *object);
    26532773
    … …  
    31193239    return deleted;
    31203240}
    3121 /** Formats and prints an array of skyp_irRow objects
    3122  *
    3123  * @return A boolean - false on error
    3124  */
    3125 
    3126 bool skyp_irPrintObjects(
    3127     FILE            *stream,            ///< a stream
    3128     psArray         *objects,           ///< An array of skyp_irRow objects
    3129     bool            mdconfigformat      ///< format as mdconfig or simple
    3130 );
     3241bool skyp_irPrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     3242{
     3243    PS_ASSERT_PTR_NON_NULL(objects, false);
     3244
     3245    psMetadata *output = psMetadataAlloc();
     3246    for (long i = 0; i < psArrayLength(objects); i++) {
     3247        psMetadata *md = skyp_irMetadataFromObject(objects->data[i]);
     3248        if (!psMetadataAddMetadata(
     3249            output,
     3250            PS_LIST_TAIL,
     3251            SKYP_IR_TABLE_NAME,
     3252            PS_META_DUPLICATE_OK,
     3253            NULL,
     3254            md
     3255        )) {
     3256            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     3257            psFree(md);
     3258            psFree(output);
     3259            return false;
     3260        }
     3261        psFree(md);
     3262    }
     3263
     3264    psString str = psMetadataConfigFormat(output);
     3265    if (!str) {
     3266        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     3267        psFree(output);
     3268    }
     3269    psFree(output);
     3270    fprintf(stream, "%s\n", str);
     3271    psFree(str);
     3272
     3273    return true;
     3274}
    31313275static void domeRowFree(domeRow *object);
    31323276
    … …  
    35403684    return deleted;
    35413685}
    3542 /** Formats and prints an array of domeRow objects
    3543  *
    3544  * @return A boolean - false on error
    3545  */
    3546 
    3547 bool domePrintObjects(
    3548     FILE            *stream,            ///< a stream
    3549     psArray         *objects,           ///< An array of domeRow objects
    3550     bool            mdconfigformat      ///< format as mdconfig or simple
    3551 );
     3686bool domePrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     3687{
     3688    PS_ASSERT_PTR_NON_NULL(objects, false);
     3689
     3690    psMetadata *output = psMetadataAlloc();
     3691    for (long i = 0; i < psArrayLength(objects); i++) {
     3692        psMetadata *md = domeMetadataFromObject(objects->data[i]);
     3693        if (!psMetadataAddMetadata(
     3694            output,
     3695            PS_LIST_TAIL,
     3696            DOME_TABLE_NAME,
     3697            PS_META_DUPLICATE_OK,
     3698            NULL,
     3699            md
     3700        )) {
     3701            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     3702            psFree(md);
     3703            psFree(output);
     3704            return false;
     3705        }
     3706        psFree(md);
     3707    }
     3708
     3709    psString str = psMetadataConfigFormat(output);
     3710    if (!str) {
     3711        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     3712        psFree(output);
     3713    }
     3714    psFree(output);
     3715    fprintf(stream, "%s\n", str);
     3716    psFree(str);
     3717
     3718    return true;
     3719}
    35523720static void telescopeRowFree(telescopeRow *object);
    35533721
    … …  
    39914159    return deleted;
    39924160}
    3993 /** Formats and prints an array of telescopeRow objects
    3994  *
    3995  * @return A boolean - false on error
    3996  */
    3997 
    3998 bool telescopePrintObjects(
    3999     FILE            *stream,            ///< a stream
    4000     psArray         *objects,           ///< An array of telescopeRow objects
    4001     bool            mdconfigformat      ///< format as mdconfig or simple
    4002 );
     4161bool telescopePrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     4162{
     4163    PS_ASSERT_PTR_NON_NULL(objects, false);
     4164
     4165    psMetadata *output = psMetadataAlloc();
     4166    for (long i = 0; i < psArrayLength(objects); i++) {
     4167        psMetadata *md = telescopeMetadataFromObject(objects->data[i]);
     4168        if (!psMetadataAddMetadata(
     4169            output,
     4170            PS_LIST_TAIL,
     4171            TELESCOPE_TABLE_NAME,
     4172            PS_META_DUPLICATE_OK,
     4173            NULL,
     4174            md
     4175        )) {
     4176            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     4177            psFree(md);
     4178            psFree(output);
     4179            return false;
     4180        }
     4181        psFree(md);
     4182    }
     4183
     4184    psString str = psMetadataConfigFormat(output);
     4185    if (!str) {
     4186        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     4187        psFree(output);
     4188    }
     4189    psFree(output);
     4190    fprintf(stream, "%s\n", str);
     4191    psFree(str);
     4192
     4193    return true;
     4194}
    40034195static void summitExpRowFree(summitExpRow *object);
    40044196
    … …  
    44464638    return deleted;
    44474639}
    4448 /** Formats and prints an array of summitExpRow objects
    4449  *
    4450  * @return A boolean - false on error
    4451  */
    4452 
    4453 bool summitExpPrintObjects(
    4454     FILE            *stream,            ///< a stream
    4455     psArray         *objects,           ///< An array of summitExpRow objects
    4456     bool            mdconfigformat      ///< format as mdconfig or simple
    4457 );
     4640bool summitExpPrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     4641{
     4642    PS_ASSERT_PTR_NON_NULL(objects, false);
     4643
     4644    psMetadata *output = psMetadataAlloc();
     4645    for (long i = 0; i < psArrayLength(objects); i++) {
     4646        psMetadata *md = summitExpMetadataFromObject(objects->data[i]);
     4647        if (!psMetadataAddMetadata(
     4648            output,
     4649            PS_LIST_TAIL,
     4650            SUMMITEXP_TABLE_NAME,
     4651            PS_META_DUPLICATE_OK,
     4652            NULL,
     4653            md
     4654        )) {
     4655            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     4656            psFree(md);
     4657            psFree(output);
     4658            return false;
     4659        }
     4660        psFree(md);
     4661    }
     4662
     4663    psString str = psMetadataConfigFormat(output);
     4664    if (!str) {
     4665        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     4666        psFree(output);
     4667    }
     4668    psFree(output);
     4669    fprintf(stream, "%s\n", str);
     4670    psFree(str);
     4671
     4672    return true;
     4673}
    44584674static void pzPendingExpRowFree(pzPendingExpRow *object);
    44594675
    … …  
    49005116    return deleted;
    49015117}
    4902 /** Formats and prints an array of pzPendingExpRow objects
    4903  *
    4904  * @return A boolean - false on error
    4905  */
    4906 
    4907 bool pzPendingExpPrintObjects(
    4908     FILE            *stream,            ///< a stream
    4909     psArray         *objects,           ///< An array of pzPendingExpRow objects
    4910     bool            mdconfigformat      ///< format as mdconfig or simple
    4911 );
     5118bool pzPendingExpPrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     5119{
     5120    PS_ASSERT_PTR_NON_NULL(objects, false);
     5121
     5122    psMetadata *output = psMetadataAlloc();
     5123    for (long i = 0; i < psArrayLength(objects); i++) {
     5124        psMetadata *md = pzPendingExpMetadataFromObject(objects->data[i]);
     5125        if (!psMetadataAddMetadata(
     5126            output,
     5127            PS_LIST_TAIL,
     5128            PZPENDINGEXP_TABLE_NAME,
     5129            PS_META_DUPLICATE_OK,
     5130            NULL,
     5131            md
     5132        )) {
     5133            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     5134            psFree(md);
     5135            psFree(output);
     5136            return false;
     5137        }
     5138        psFree(md);
     5139    }
     5140
     5141    psString str = psMetadataConfigFormat(output);
     5142    if (!str) {
     5143        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     5144        psFree(output);
     5145    }
     5146    psFree(output);
     5147    fprintf(stream, "%s\n", str);
     5148    psFree(str);
     5149
     5150    return true;
     5151}
    49125152static void pzPendingImfileRowFree(pzPendingImfileRow *object);
    49135153
    … …  
    53845624    return deleted;
    53855625}
    5386 /** Formats and prints an array of pzPendingImfileRow objects
    5387  *
    5388  * @return A boolean - false on error
    5389  */
    5390 
    5391 bool pzPendingImfilePrintObjects(
    5392     FILE            *stream,            ///< a stream
    5393     psArray         *objects,           ///< An array of pzPendingImfileRow objects
    5394     bool            mdconfigformat      ///< format as mdconfig or simple
    5395 );
     5626bool pzPendingImfilePrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     5627{
     5628    PS_ASSERT_PTR_NON_NULL(objects, false);
     5629
     5630    psMetadata *output = psMetadataAlloc();
     5631    for (long i = 0; i < psArrayLength(objects); i++) {
     5632        psMetadata *md = pzPendingImfileMetadataFromObject(objects->data[i]);
     5633        if (!psMetadataAddMetadata(
     5634            output,
     5635            PS_LIST_TAIL,
     5636            PZPENDINGIMFILE_TABLE_NAME,
     5637            PS_META_DUPLICATE_OK,
     5638            NULL,
     5639            md
     5640        )) {
     5641            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     5642            psFree(md);
     5643            psFree(output);
     5644            return false;
     5645        }
     5646        psFree(md);
     5647    }
     5648
     5649    psString str = psMetadataConfigFormat(output);
     5650    if (!str) {
     5651        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     5652        psFree(output);
     5653    }
     5654    psFree(output);
     5655    fprintf(stream, "%s\n", str);
     5656    psFree(str);
     5657
     5658    return true;
     5659}
    53965660static void newExpRowFree(newExpRow *object);
    53975661
    … …  
    58386102    return deleted;
    58396103}
    5840 /** Formats and prints an array of newExpRow objects
    5841  *
    5842  * @return A boolean - false on error
    5843  */
    5844 
    5845 bool newExpPrintObjects(
    5846     FILE            *stream,            ///< a stream
    5847     psArray         *objects,           ///< An array of newExpRow objects
    5848     bool            mdconfigformat      ///< format as mdconfig or simple
    5849 );
     6104bool newExpPrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     6105{
     6106    PS_ASSERT_PTR_NON_NULL(objects, false);
     6107
     6108    psMetadata *output = psMetadataAlloc();
     6109    for (long i = 0; i < psArrayLength(objects); i++) {
     6110        psMetadata *md = newExpMetadataFromObject(objects->data[i]);
     6111        if (!psMetadataAddMetadata(
     6112            output,
     6113            PS_LIST_TAIL,
     6114            NEWEXP_TABLE_NAME,
     6115            PS_META_DUPLICATE_OK,
     6116            NULL,
     6117            md
     6118        )) {
     6119            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     6120            psFree(md);
     6121            psFree(output);
     6122            return false;
     6123        }
     6124        psFree(md);
     6125    }
     6126
     6127    psString str = psMetadataConfigFormat(output);
     6128    if (!str) {
     6129        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     6130        psFree(output);
     6131    }
     6132    psFree(output);
     6133    fprintf(stream, "%s\n", str);
     6134    psFree(str);
     6135
     6136    return true;
     6137}
    58506138static void newImfileRowFree(newImfileRow *object);
    58516139
    … …  
    62636551    return deleted;
    62646552}
    6265 /** Formats and prints an array of newImfileRow objects
    6266  *
    6267  * @return A boolean - false on error
    6268  */
    6269 
    6270 bool newImfilePrintObjects(
    6271     FILE            *stream,            ///< a stream
    6272     psArray         *objects,           ///< An array of newImfileRow objects
    6273     bool            mdconfigformat      ///< format as mdconfig or simple
    6274 );
     6553bool newImfilePrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     6554{
     6555    PS_ASSERT_PTR_NON_NULL(objects, false);
     6556
     6557    psMetadata *output = psMetadataAlloc();
     6558    for (long i = 0; i < psArrayLength(objects); i++) {
     6559        psMetadata *md = newImfileMetadataFromObject(objects->data[i]);
     6560        if (!psMetadataAddMetadata(
     6561            output,
     6562            PS_LIST_TAIL,
     6563            NEWIMFILE_TABLE_NAME,
     6564            PS_META_DUPLICATE_OK,
     6565            NULL,
     6566            md
     6567        )) {
     6568            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     6569            psFree(md);
     6570            psFree(output);
     6571            return false;
     6572        }
     6573        psFree(md);
     6574    }
     6575
     6576    psString str = psMetadataConfigFormat(output);
     6577    if (!str) {
     6578        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     6579        psFree(output);
     6580    }
     6581    psFree(output);
     6582    fprintf(stream, "%s\n", str);
     6583    psFree(str);
     6584
     6585    return true;
     6586}
    62756587static void rawDetrendExpRowFree(rawDetrendExpRow *object);
    62766588
    … …  
    68927204    return deleted;
    68937205}
    6894 /** Formats and prints an array of rawDetrendExpRow objects
    6895  *
    6896  * @return A boolean - false on error
    6897  */
    6898 
    6899 bool rawDetrendExpPrintObjects(
    6900     FILE            *stream,            ///< a stream
    6901     psArray         *objects,           ///< An array of rawDetrendExpRow objects
    6902     bool            mdconfigformat      ///< format as mdconfig or simple
    6903 );
     7206bool rawDetrendExpPrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     7207{
     7208    PS_ASSERT_PTR_NON_NULL(objects, false);
     7209
     7210    psMetadata *output = psMetadataAlloc();
     7211    for (long i = 0; i < psArrayLength(objects); i++) {
     7212        psMetadata *md = rawDetrendExpMetadataFromObject(objects->data[i]);
     7213        if (!psMetadataAddMetadata(
     7214            output,
     7215            PS_LIST_TAIL,
     7216            RAWDETRENDEXP_TABLE_NAME,
     7217            PS_META_DUPLICATE_OK,
     7218            NULL,
     7219            md
     7220        )) {
     7221            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     7222            psFree(md);
     7223            psFree(output);
     7224            return false;
     7225        }
     7226        psFree(md);
     7227    }
     7228
     7229    psString str = psMetadataConfigFormat(output);
     7230    if (!str) {
     7231        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     7232        psFree(output);
     7233    }
     7234    psFree(output);
     7235    fprintf(stream, "%s\n", str);
     7236    psFree(str);
     7237
     7238    return true;
     7239}
    69047240static void rawScienceExpRowFree(rawScienceExpRow *object);
    69057241
    … …  
    75217857    return deleted;
    75227858}
    7523 /** Formats and prints an array of rawScienceExpRow objects
    7524  *
    7525  * @return A boolean - false on error
    7526  */
    7527 
    7528 bool rawScienceExpPrintObjects(
    7529     FILE            *stream,            ///< a stream
    7530     psArray         *objects,           ///< An array of rawScienceExpRow objects
    7531     bool            mdconfigformat      ///< format as mdconfig or simple
    7532 );
     7859bool rawScienceExpPrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     7860{
     7861    PS_ASSERT_PTR_NON_NULL(objects, false);
     7862
     7863    psMetadata *output = psMetadataAlloc();
     7864    for (long i = 0; i < psArrayLength(objects); i++) {
     7865        psMetadata *md = rawScienceExpMetadataFromObject(objects->data[i]);
     7866        if (!psMetadataAddMetadata(
     7867            output,
     7868            PS_LIST_TAIL,
     7869            RAWSCIENCEEXP_TABLE_NAME,
     7870            PS_META_DUPLICATE_OK,
     7871            NULL,
     7872            md
     7873        )) {
     7874            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     7875            psFree(md);
     7876            psFree(output);
     7877            return false;
     7878        }
     7879        psFree(md);
     7880    }
     7881
     7882    psString str = psMetadataConfigFormat(output);
     7883    if (!str) {
     7884        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     7885        psFree(output);
     7886    }
     7887    psFree(output);
     7888    fprintf(stream, "%s\n", str);
     7889    psFree(str);
     7890
     7891    return true;
     7892}
    75337893static void rawImfileRowFree(rawImfileRow *object);
    75347894
    … …  
    79468306    return deleted;
    79478307}
    7948 /** Formats and prints an array of rawImfileRow objects
    7949  *
    7950  * @return A boolean - false on error
    7951  */
    7952 
    7953 bool rawImfilePrintObjects(
    7954     FILE            *stream,            ///< a stream
    7955     psArray         *objects,           ///< An array of rawImfileRow objects
    7956     bool            mdconfigformat      ///< format as mdconfig or simple
    7957 );
     8308bool rawImfilePrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     8309{
     8310    PS_ASSERT_PTR_NON_NULL(objects, false);
     8311
     8312    psMetadata *output = psMetadataAlloc();
     8313    for (long i = 0; i < psArrayLength(objects); i++) {
     8314        psMetadata *md = rawImfileMetadataFromObject(objects->data[i]);
     8315        if (!psMetadataAddMetadata(
     8316            output,
     8317            PS_LIST_TAIL,
     8318            RAWIMFILE_TABLE_NAME,
     8319            PS_META_DUPLICATE_OK,
     8320            NULL,
     8321            md
     8322        )) {
     8323            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     8324            psFree(md);
     8325            psFree(output);
     8326            return false;
     8327        }
     8328        psFree(md);
     8329    }
     8330
     8331    psString str = psMetadataConfigFormat(output);
     8332    if (!str) {
     8333        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     8334        psFree(output);
     8335    }
     8336    psFree(output);
     8337    fprintf(stream, "%s\n", str);
     8338    psFree(str);
     8339
     8340    return true;
     8341}
    79588342static void p1PendingExpRowFree(p1PendingExpRow *object);
    79598343
    … …  
    86349018    return deleted;
    86359019}
    8636 /** Formats and prints an array of p1PendingExpRow objects
    8637  *
    8638  * @return A boolean - false on error
    8639  */
    8640 
    8641 bool p1PendingExpPrintObjects(
    8642     FILE            *stream,            ///< a stream
    8643     psArray         *objects,           ///< An array of p1PendingExpRow objects
    8644     bool            mdconfigformat      ///< format as mdconfig or simple
    8645 );
     9020bool p1PendingExpPrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     9021{
     9022    PS_ASSERT_PTR_NON_NULL(objects, false);
     9023
     9024    psMetadata *output = psMetadataAlloc();
     9025    for (long i = 0; i < psArrayLength(objects); i++) {
     9026        psMetadata *md = p1PendingExpMetadataFromObject(objects->data[i]);
     9027        if (!psMetadataAddMetadata(
     9028            output,
     9029            PS_LIST_TAIL,
     9030            P1PENDINGEXP_TABLE_NAME,
     9031            PS_META_DUPLICATE_OK,
     9032            NULL,
     9033            md
     9034        )) {
     9035            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     9036            psFree(md);
     9037            psFree(output);
     9038            return false;
     9039        }
     9040        psFree(md);
     9041    }
     9042
     9043    psString str = psMetadataConfigFormat(output);
     9044    if (!str) {
     9045        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     9046        psFree(output);
     9047    }
     9048    psFree(output);
     9049    fprintf(stream, "%s\n", str);
     9050    psFree(str);
     9051
     9052    return true;
     9053}
    86469054static void p2PendingExpRowFree(p2PendingExpRow *object);
    86479055
    … …  
    93519759    return deleted;
    93529760}
    9353 /** Formats and prints an array of p2PendingExpRow objects
    9354  *
    9355  * @return A boolean - false on error
    9356  */
    9357 
    9358 bool p2PendingExpPrintObjects(
    9359     FILE            *stream,            ///< a stream
    9360     psArray         *objects,           ///< An array of p2PendingExpRow objects
    9361     bool            mdconfigformat      ///< format as mdconfig or simple
    9362 );
     9761bool p2PendingExpPrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     9762{
     9763    PS_ASSERT_PTR_NON_NULL(objects, false);
     9764
     9765    psMetadata *output = psMetadataAlloc();
     9766    for (long i = 0; i < psArrayLength(objects); i++) {
     9767        psMetadata *md = p2PendingExpMetadataFromObject(objects->data[i]);
     9768        if (!psMetadataAddMetadata(
     9769            output,
     9770            PS_LIST_TAIL,
     9771            P2PENDINGEXP_TABLE_NAME,
     9772            PS_META_DUPLICATE_OK,
     9773            NULL,
     9774            md
     9775        )) {
     9776            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     9777            psFree(md);
     9778            psFree(output);
     9779            return false;
     9780        }
     9781        psFree(md);
     9782    }
     9783
     9784    psString str = psMetadataConfigFormat(output);
     9785    if (!str) {
     9786        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     9787        psFree(output);
     9788    }
     9789    psFree(output);
     9790    fprintf(stream, "%s\n", str);
     9791    psFree(str);
     9792
     9793    return true;
     9794}
    93639795static void p2PendingImfileRowFree(p2PendingImfileRow *object);
    93649796
    … …  
    983410266    return deleted;
    983510267}
    9836 /** Formats and prints an array of p2PendingImfileRow objects
    9837  *
    9838  * @return A boolean - false on error
    9839  */
    9840 
    9841 bool p2PendingImfilePrintObjects(
    9842     FILE            *stream,            ///< a stream
    9843     psArray         *objects,           ///< An array of p2PendingImfileRow objects
    9844     bool            mdconfigformat      ///< format as mdconfig or simple
    9845 );
     10268bool p2PendingImfilePrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     10269{
     10270    PS_ASSERT_PTR_NON_NULL(objects, false);
     10271
     10272    psMetadata *output = psMetadataAlloc();
     10273    for (long i = 0; i < psArrayLength(objects); i++) {
     10274        psMetadata *md = p2PendingImfileMetadataFromObject(objects->data[i]);
     10275        if (!psMetadataAddMetadata(
     10276            output,
     10277            PS_LIST_TAIL,
     10278            P2PENDINGIMFILE_TABLE_NAME,
     10279            PS_META_DUPLICATE_OK,
     10280            NULL,
     10281            md
     10282        )) {
     10283            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     10284            psFree(md);
     10285            psFree(output);
     10286            return false;
     10287        }
     10288        psFree(md);
     10289    }
     10290
     10291    psString str = psMetadataConfigFormat(output);
     10292    if (!str) {
     10293        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     10294        psFree(output);
     10295    }
     10296    psFree(output);
     10297    fprintf(stream, "%s\n", str);
     10298    psFree(str);
     10299
     10300    return true;
     10301}
    984610302static void p2DoneExpRowFree(p2DoneExpRow *object);
    984710303
    … …  
    1055111007    return deleted;
    1055211008}
    10553 /** Formats and prints an array of p2DoneExpRow objects
    10554  *
    10555  * @return A boolean - false on error
    10556  */
    10557 
    10558 bool p2DoneExpPrintObjects(
    10559     FILE            *stream,            ///< a stream
    10560     psArray         *objects,           ///< An array of p2DoneExpRow objects
    10561     bool            mdconfigformat      ///< format as mdconfig or simple
    10562 );
     11009bool p2DoneExpPrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     11010{
     11011    PS_ASSERT_PTR_NON_NULL(objects, false);
     11012
     11013    psMetadata *output = psMetadataAlloc();
     11014    for (long i = 0; i < psArrayLength(objects); i++) {
     11015        psMetadata *md = p2DoneExpMetadataFromObject(objects->data[i]);
     11016        if (!psMetadataAddMetadata(
     11017            output,
     11018            PS_LIST_TAIL,
     11019            P2DONEEXP_TABLE_NAME,
     11020            PS_META_DUPLICATE_OK,
     11021            NULL,
     11022            md
     11023        )) {
     11024            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     11025            psFree(md);
     11026            psFree(output);
     11027            return false;
     11028        }
     11029        psFree(md);
     11030    }
     11031
     11032    psString str = psMetadataConfigFormat(output);
     11033    if (!str) {
     11034        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     11035        psFree(output);
     11036    }
     11037    psFree(output);
     11038    fprintf(stream, "%s\n", str);
     11039    psFree(str);
     11040
     11041    return true;
     11042}
    1056311043static void p2DoneImfileRowFree(p2DoneImfileRow *object);
    1056411044
    … …  
    1103411514    return deleted;
    1103511515}
    11036 /** Formats and prints an array of p2DoneImfileRow objects
    11037  *
    11038  * @return A boolean - false on error
    11039  */
    11040 
    11041 bool p2DoneImfilePrintObjects(
    11042     FILE            *stream,            ///< a stream
    11043     psArray         *objects,           ///< An array of p2DoneImfileRow objects
    11044     bool            mdconfigformat      ///< format as mdconfig or simple
    11045 );
     11516bool p2DoneImfilePrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     11517{
     11518    PS_ASSERT_PTR_NON_NULL(objects, false);
     11519
     11520    psMetadata *output = psMetadataAlloc();
     11521    for (long i = 0; i < psArrayLength(objects); i++) {
     11522        psMetadata *md = p2DoneImfileMetadataFromObject(objects->data[i]);
     11523        if (!psMetadataAddMetadata(
     11524            output,
     11525            PS_LIST_TAIL,
     11526            P2DONEIMFILE_TABLE_NAME,
     11527            PS_META_DUPLICATE_OK,
     11528            NULL,
     11529            md
     11530        )) {
     11531            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     11532            psFree(md);
     11533            psFree(output);
     11534            return false;
     11535        }
     11536        psFree(md);
     11537    }
     11538
     11539    psString str = psMetadataConfigFormat(output);
     11540    if (!str) {
     11541        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     11542        psFree(output);
     11543    }
     11544    psFree(output);
     11545    fprintf(stream, "%s\n", str);
     11546    psFree(str);
     11547
     11548    return true;
     11549}
    1104611550static void p3PendingExpRowFree(p3PendingExpRow *object);
    1104711551
    … …  
    1172112225    return deleted;
    1172212226}
    11723 /** Formats and prints an array of p3PendingExpRow objects
    11724  *
    11725  * @return A boolean - false on error
    11726  */
    11727 
    11728 bool p3PendingExpPrintObjects(
    11729     FILE            *stream,            ///< a stream
    11730     psArray         *objects,           ///< An array of p3PendingExpRow objects
    11731     bool            mdconfigformat      ///< format as mdconfig or simple
    11732 );
     12227bool p3PendingExpPrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     12228{
     12229    PS_ASSERT_PTR_NON_NULL(objects, false);
     12230
     12231    psMetadata *output = psMetadataAlloc();
     12232    for (long i = 0; i < psArrayLength(objects); i++) {
     12233        psMetadata *md = p3PendingExpMetadataFromObject(objects->data[i]);
     12234        if (!psMetadataAddMetadata(
     12235            output,
     12236            PS_LIST_TAIL,
     12237            P3PENDINGEXP_TABLE_NAME,
     12238            PS_META_DUPLICATE_OK,
     12239            NULL,
     12240            md
     12241        )) {
     12242            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     12243            psFree(md);
     12244            psFree(output);
     12245            return false;
     12246        }
     12247        psFree(md);
     12248    }
     12249
     12250    psString str = psMetadataConfigFormat(output);
     12251    if (!str) {
     12252        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     12253        psFree(output);
     12254    }
     12255    psFree(output);
     12256    fprintf(stream, "%s\n", str);
     12257    psFree(str);
     12258
     12259    return true;
     12260}
    1173312261static void detRunRowFree(detRunRow *object);
    1173412262
    … …  
    1208512613    return deleted;
    1208612614}
    12087 /** Formats and prints an array of detRunRow objects
    12088  *
    12089  * @return A boolean - false on error
    12090  */
    12091 
    12092 bool detRunPrintObjects(
    12093     FILE            *stream,            ///< a stream
    12094     psArray         *objects,           ///< An array of detRunRow objects
    12095     bool            mdconfigformat      ///< format as mdconfig or simple
    12096 );
     12615bool detRunPrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     12616{
     12617    PS_ASSERT_PTR_NON_NULL(objects, false);
     12618
     12619    psMetadata *output = psMetadataAlloc();
     12620    for (long i = 0; i < psArrayLength(objects); i++) {
     12621        psMetadata *md = detRunMetadataFromObject(objects->data[i]);
     12622        if (!psMetadataAddMetadata(
     12623            output,
     12624            PS_LIST_TAIL,
     12625            DETRUN_TABLE_NAME,
     12626            PS_META_DUPLICATE_OK,
     12627            NULL,
     12628            md
     12629        )) {
     12630            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     12631            psFree(md);
     12632            psFree(output);
     12633            return false;
     12634        }
     12635        psFree(md);
     12636    }
     12637
     12638    psString str = psMetadataConfigFormat(output);
     12639    if (!str) {
     12640        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     12641        psFree(output);
     12642    }
     12643    psFree(output);
     12644    fprintf(stream, "%s\n", str);
     12645    psFree(str);
     12646
     12647    return true;
     12648}
    1209712649static void detInputExpRowFree(detInputExpRow *object);
    1209812650
    … …  
    1277213324    return deleted;
    1277313325}
    12774 /** Formats and prints an array of detInputExpRow objects
    12775  *
    12776  * @return A boolean - false on error
    12777  */
    12778 
    12779 bool detInputExpPrintObjects(
    12780     FILE            *stream,            ///< a stream
    12781     psArray         *objects,           ///< An array of detInputExpRow objects
    12782     bool            mdconfigformat      ///< format as mdconfig or simple
    12783 );
     13326bool detInputExpPrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     13327{
     13328    PS_ASSERT_PTR_NON_NULL(objects, false);
     13329
     13330    psMetadata *output = psMetadataAlloc();
     13331    for (long i = 0; i < psArrayLength(objects); i++) {
     13332        psMetadata *md = detInputExpMetadataFromObject(objects->data[i]);
     13333        if (!psMetadataAddMetadata(
     13334            output,
     13335            PS_LIST_TAIL,
     13336            DETINPUTEXP_TABLE_NAME,
     13337            PS_META_DUPLICATE_OK,
     13338            NULL,
     13339            md
     13340        )) {
     13341            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     13342            psFree(md);
     13343            psFree(output);
     13344            return false;
     13345        }
     13346        psFree(md);
     13347    }
     13348
     13349    psString str = psMetadataConfigFormat(output);
     13350    if (!str) {
     13351        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     13352        psFree(output);
     13353    }
     13354    psFree(output);
     13355    fprintf(stream, "%s\n", str);
     13356    psFree(str);
     13357
     13358    return true;
     13359}
    1278413360static void detProcessedImfileRowFree(detProcessedImfileRow *object);
    1278513361
    … …  
    1322613802    return deleted;
    1322713803}
    13228 /** Formats and prints an array of detProcessedImfileRow objects
    13229  *
    13230  * @return A boolean - false on error
    13231  */
    13232 
    13233 bool detProcessedImfilePrintObjects(
    13234     FILE            *stream,            ///< a stream
    13235     psArray         *objects,           ///< An array of detProcessedImfileRow objects
    13236     bool            mdconfigformat      ///< format as mdconfig or simple
    13237 );
     13804bool detProcessedImfilePrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     13805{
     13806    PS_ASSERT_PTR_NON_NULL(objects, false);
     13807
     13808    psMetadata *output = psMetadataAlloc();
     13809    for (long i = 0; i < psArrayLength(objects); i++) {
     13810        psMetadata *md = detProcessedImfileMetadataFromObject(objects->data[i]);
     13811        if (!psMetadataAddMetadata(
     13812            output,
     13813            PS_LIST_TAIL,
     13814            DETPROCESSEDIMFILE_TABLE_NAME,
     13815            PS_META_DUPLICATE_OK,
     13816            NULL,
     13817            md
     13818        )) {
     13819            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     13820            psFree(md);
     13821            psFree(output);
     13822            return false;
     13823        }
     13824        psFree(md);
     13825    }
     13826
     13827    psString str = psMetadataConfigFormat(output);
     13828    if (!str) {
     13829        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     13830        psFree(output);
     13831    }
     13832    psFree(output);
     13833    fprintf(stream, "%s\n", str);
     13834    psFree(str);
     13835
     13836    return true;
     13837}
    1323813838static void detStackedImfileRowFree(detStackedImfileRow *object);
    1323913839
    … …  
    1367914279    return deleted;
    1368014280}
    13681 /** Formats and prints an array of detStackedImfileRow objects
    13682  *
    13683  * @return A boolean - false on error
    13684  */
    13685 
    13686 bool detStackedImfilePrintObjects(
    13687     FILE            *stream,            ///< a stream
    13688     psArray         *objects,           ///< An array of detStackedImfileRow objects
    13689     bool            mdconfigformat      ///< format as mdconfig or simple
    13690 );
     14281bool detStackedImfilePrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     14282{
     14283    PS_ASSERT_PTR_NON_NULL(objects, false);
     14284
     14285    psMetadata *output = psMetadataAlloc();
     14286    for (long i = 0; i < psArrayLength(objects); i++) {
     14287        psMetadata *md = detStackedImfileMetadataFromObject(objects->data[i]);
     14288        if (!psMetadataAddMetadata(
     14289            output,
     14290            PS_LIST_TAIL,
     14291            DETSTACKEDIMFILE_TABLE_NAME,
     14292            PS_META_DUPLICATE_OK,
     14293            NULL,
     14294            md
     14295        )) {
     14296            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     14297            psFree(md);
     14298            psFree(output);
     14299            return false;
     14300        }
     14301        psFree(md);
     14302    }
     14303
     14304    psString str = psMetadataConfigFormat(output);
     14305    if (!str) {
     14306        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     14307        psFree(output);
     14308    }
     14309    psFree(output);
     14310    fprintf(stream, "%s\n", str);
     14311    psFree(str);
     14312
     14313    return true;
     14314}
    1369114315static void detNormalizedImfileRowFree(detNormalizedImfileRow *object);
    1369214316
    … …  
    1413214756    return deleted;
    1413314757}
    14134 /** Formats and prints an array of detNormalizedImfileRow objects
    14135  *
    14136  * @return A boolean - false on error
    14137  */
    14138 
    14139 bool detNormalizedImfilePrintObjects(
    14140     FILE            *stream,            ///< a stream
    14141     psArray         *objects,           ///< An array of detNormalizedImfileRow objects
    14142     bool            mdconfigformat      ///< format as mdconfig or simple
    14143 );
     14758bool detNormalizedImfilePrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     14759{
     14760    PS_ASSERT_PTR_NON_NULL(objects, false);
     14761
     14762    psMetadata *output = psMetadataAlloc();
     14763    for (long i = 0; i < psArrayLength(objects); i++) {
     14764        psMetadata *md = detNormalizedImfileMetadataFromObject(objects->data[i]);
     14765        if (!psMetadataAddMetadata(
     14766            output,
     14767            PS_LIST_TAIL,
     14768            DETNORMALIZEDIMFILE_TABLE_NAME,
     14769            PS_META_DUPLICATE_OK,
     14770            NULL,
     14771            md
     14772        )) {
     14773            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     14774            psFree(md);
     14775            psFree(output);
     14776            return false;
     14777        }
     14778        psFree(md);
     14779    }
     14780
     14781    psString str = psMetadataConfigFormat(output);
     14782    if (!str) {
     14783        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     14784        psFree(output);
     14785    }
     14786    psFree(output);
     14787    fprintf(stream, "%s\n", str);
     14788    psFree(str);
     14789
     14790    return true;
     14791}
    1414414792static void detMasterFrameRowFree(detMasterFrameRow *object);
    1414514793
    … …  
    1452515173    return deleted;
    1452615174}
    14527 /** Formats and prints an array of detMasterFrameRow objects
    14528  *
    14529  * @return A boolean - false on error
    14530  */
    14531 
    14532 bool detMasterFramePrintObjects(
    14533     FILE            *stream,            ///< a stream
    14534     psArray         *objects,           ///< An array of detMasterFrameRow objects
    14535     bool            mdconfigformat      ///< format as mdconfig or simple
    14536 );
     15175bool detMasterFramePrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     15176{
     15177    PS_ASSERT_PTR_NON_NULL(objects, false);
     15178
     15179    psMetadata *output = psMetadataAlloc();
     15180    for (long i = 0; i < psArrayLength(objects); i++) {
     15181        psMetadata *md = detMasterFrameMetadataFromObject(objects->data[i]);
     15182        if (!psMetadataAddMetadata(
     15183            output,
     15184            PS_LIST_TAIL,
     15185            DETMASTERFRAME_TABLE_NAME,
     15186            PS_META_DUPLICATE_OK,
     15187            NULL,
     15188            md
     15189        )) {
     15190            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     15191            psFree(md);
     15192            psFree(output);
     15193            return false;
     15194        }
     15195        psFree(md);
     15196    }
     15197
     15198    psString str = psMetadataConfigFormat(output);
     15199    if (!str) {
     15200        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     15201        psFree(output);
     15202    }
     15203    psFree(output);
     15204    fprintf(stream, "%s\n", str);
     15205    psFree(str);
     15206
     15207    return true;
     15208}
    1453715209static void detMasterImfileRowFree(detMasterImfileRow *object);
    1453815210
    … …  
    1494915621    return deleted;
    1495015622}
    14951 /** Formats and prints an array of detMasterImfileRow objects
    14952  *
    14953  * @return A boolean - false on error
    14954  */
    14955 
    14956 bool detMasterImfilePrintObjects(
    14957     FILE            *stream,            ///< a stream
    14958     psArray         *objects,           ///< An array of detMasterImfileRow objects
    14959     bool            mdconfigformat      ///< format as mdconfig or simple
    14960 );
     15623bool detMasterImfilePrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     15624{
     15625    PS_ASSERT_PTR_NON_NULL(objects, false);
     15626
     15627    psMetadata *output = psMetadataAlloc();
     15628    for (long i = 0; i < psArrayLength(objects); i++) {
     15629        psMetadata *md = detMasterImfileMetadataFromObject(objects->data[i]);
     15630        if (!psMetadataAddMetadata(
     15631            output,
     15632            PS_LIST_TAIL,
     15633            DETMASTERIMFILE_TABLE_NAME,
     15634            PS_META_DUPLICATE_OK,
     15635            NULL,
     15636            md
     15637        )) {
     15638            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     15639            psFree(md);
     15640            psFree(output);
     15641            return false;
     15642        }
     15643        psFree(md);
     15644    }
     15645
     15646    psString str = psMetadataConfigFormat(output);
     15647    if (!str) {
     15648        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     15649        psFree(output);
     15650    }
     15651    psFree(output);
     15652    fprintf(stream, "%s\n", str);
     15653    psFree(str);
     15654
     15655    return true;
     15656}
    1496115657static void detResidImfileAnalysisRowFree(detResidImfileAnalysisRow *object);
    1496215658
    … …  
    1549216188    return deleted;
    1549316189}
    15494 /** Formats and prints an array of detResidImfileAnalysisRow objects
    15495  *
    15496  * @return A boolean - false on error
    15497  */
    15498 
    15499 bool detResidImfileAnalysisPrintObjects(
    15500     FILE            *stream,            ///< a stream
    15501     psArray         *objects,           ///< An array of detResidImfileAnalysisRow objects
    15502     bool            mdconfigformat      ///< format as mdconfig or simple
    15503 );
     16190bool detResidImfileAnalysisPrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     16191{
     16192    PS_ASSERT_PTR_NON_NULL(objects, false);
     16193
     16194    psMetadata *output = psMetadataAlloc();
     16195    for (long i = 0; i < psArrayLength(objects); i++) {
     16196        psMetadata *md = detResidImfileAnalysisMetadataFromObject(objects->data[i]);
     16197        if (!psMetadataAddMetadata(
     16198            output,
     16199            PS_LIST_TAIL,
     16200            DETRESIDIMFILEANALYSIS_TABLE_NAME,
     16201            PS_META_DUPLICATE_OK,
     16202            NULL,
     16203            md
     16204        )) {
     16205            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     16206            psFree(md);
     16207            psFree(output);
     16208            return false;
     16209        }
     16210        psFree(md);
     16211    }
     16212
     16213    psString str = psMetadataConfigFormat(output);
     16214    if (!str) {
     16215        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     16216        psFree(output);
     16217    }
     16218    psFree(output);
     16219    fprintf(stream, "%s\n", str);
     16220    psFree(str);
     16221
     16222    return true;
     16223}
    1550416224static void detResidExpAnalysisRowFree(detResidExpAnalysisRow *object);
    1550516225
    … …  
    1594416664    return deleted;
    1594516665}
    15946 /** Formats and prints an array of detResidExpAnalysisRow objects
    15947  *
    15948  * @return A boolean - false on error
    15949  */
    15950 
    15951 bool detResidExpAnalysisPrintObjects(
    15952     FILE            *stream,            ///< a stream
    15953     psArray         *objects,           ///< An array of detResidExpAnalysisRow objects
    15954     bool            mdconfigformat      ///< format as mdconfig or simple
    15955 );
     16666bool detResidExpAnalysisPrintObjects(FILE *stream, psArray *objects, bool mdconfigformat)
     16667{
     16668    PS_ASSERT_PTR_NON_NULL(objects, false);
     16669
     16670    psMetadata *output = psMetadataAlloc();
     16671    for (long i = 0; i < psArrayLength(objects); i++) {
     16672        psMetadata *md = detResidExpAnalysisMetadataFromObject(objects->data[i]);
     16673        if (!psMetadataAddMetadata(
     16674            output,
     16675            PS_LIST_TAIL,
     16676            DETRESIDEXPANALYSIS_TABLE_NAME,
     16677            PS_META_DUPLICATE_OK,
     16678            NULL,
     16679            md
     16680        )) {
     16681            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     16682            psFree(md);
     16683            psFree(output);
     16684            return false;
     16685        }
     16686        psFree(md);
     16687    }
     16688
     16689    psString str = psMetadataConfigFormat(output);
     16690    if (!str) {
     16691        psError(PS_ERR_UNKNOWN, false, "failed to format data into a string");
     16692        psFree(output);
     16693    }
     16694    psFree(output);
     16695    fprintf(stream, "%s\n", str);
     16696    psFree(str);
     16697
     16698    return true;
     16699}
Note: See TracChangeset for help on using the changeset viewer.