IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Aug 6, 2006, 6:03:57 PM (20 years ago)
Author:
jhoblitt
Message:

switch to using [foo]PrintObjects() & ippdbPrint*() functions

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippTools/src/dettool.c

    r8186 r8205  
    105105    }
    106106
    107     psArray *result = p_psDBFetchResult(config->dbh);
    108     if (!result) {
     107    psArray *output = p_psDBFetchResult(config->dbh);
     108    if (!output) {
    109109        // XXX check psError here
    110110        psError(PS_ERR_UNKNOWN, false, "no pending rawDetrendExp rows found");
    … …  
    123123
    124124    // negative simple so the default is true
    125     if (!ippdbPrintMetadatas(stdout, result, "rawDetrendExp", !simple)) {
     125    if (!ippdbPrintMetadatas(stdout, output, "rawDetrendExp", !simple)) {
    126126        psError(PS_ERR_UNKNOWN, false, "failed to print array");
    127         psFree(result);
    128         return false;
    129     }
    130 
    131     psFree(result);
     127        psFree(output);
     128        return false;
     129    }
     130
     131    psFree(output);
    132132
    133133    return true;
    … …  
    275275    }
    276276
     277    // XXX simplify this but just editing the psMetadata in the runs array
    277278    // print imfile list
    278279    psMetadata *output = psMetadataAlloc();
    … …  
    322323    }
    323324
    324     psString str = psMetadataConfigFormat(output);
    325     psFree(output);
    326     fprintf(stdout, "%s\n", str);
    327     psFree(str);
    328 
    329325    psFree(runs);
     326
     327    bool simple = false;
     328    {
     329        bool status = false;
     330        simple = psMetadataLookupBool(&status, config->args, "-simple");
     331        if (!status) {
     332            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
     333            return false;
     334        }
     335    }
     336
     337    // negative simple so the default is true
     338    if (!ippdbPrintMetadata(stdout, output, !simple)) {
     339        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     340        psFree(output);
     341        return false;
     342    }
    330343
    331344    return true;
    … …  
    484497    }
    485498
     499    bool simple = false;
     500    {
     501        bool status = false;
     502        simple = psMetadataLookupBool(&status, config->args, "-simple");
     503        if (!status) {
     504            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
     505            return false;
     506        }
     507    }
     508
    486509    if (psArrayLength(inputExp)) {
    487         // print imfile list
    488         psMetadata *output = psMetadataAlloc();
    489         for (long i = 0; i < psArrayLength(inputExp); i++) {
    490             psMetadata *md = detInputExpMetadataFromObject(inputExp->data[i]);
    491             psMetadataAddMetadata(
    492             output, PS_LIST_TAIL, "detInputExp",  PS_META_DUPLICATE_OK, NULL,
    493                     md);
    494             psFree(md);
    495         }
    496 
    497         psString str = psMetadataConfigFormat(output);
    498         psFree(output);
    499         fprintf(stdout, "%s\n", str);
    500         psFree(str);
     510        // negative simple so the default is true
     511        if (!detInputExpPrintObjects(stdout, inputExp, !simple)) {
     512            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     513            psFree(inputExp);
     514            return false;
     515        }
    501516    }
    502517
    … …  
    541556    }
    542557
     558    bool simple = false;
     559    {
     560        bool status = false;
     561        simple = psMetadataLookupBool(&status, config->args, "-simple");
     562        if (!status) {
     563            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
     564            return false;
     565        }
     566    }
     567
    543568    // did we remove all of the rawImfiles?
    544569    if (rawImfiles->n) {
    545         // print imfile list
    546         psMetadata *output = psMetadataAlloc();
    547         for (long i = 0; i < psArrayLength(rawImfiles); i++) {
    548             psMetadata *md = rawImfileMetadataFromObject(rawImfiles->data[i]);
    549             psMetadataAddMetadata(
    550             output, PS_LIST_TAIL, "rawImfile",  PS_META_DUPLICATE_OK, NULL, md);
    551             psFree(md);
    552         }
    553 
    554         psString str = psMetadataConfigFormat(output);
    555         psFree(output);
    556         fprintf(stdout, "%s\n", str);
    557         psFree(str);
     570        // negative simple so the default is true
     571        if (!rawImfilePrintObjects(stdout, rawImfiles, !simple)) {
     572            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     573            psFree(rawImfiles);
     574            return false;
     575        }
    558576    }
    559577
    … …  
    930948    }
    931949
     950    bool simple = false;
     951    {
     952        bool status = false;
     953        simple = psMetadataLookupBool(&status, config->args, "-simple");
     954        if (!status) {
     955            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
     956            return false;
     957        }
     958    }
     959
    932960    // print imfile list
    933961    if (processedImfiles->n) {
    934         psMetadata *output = psMetadataAlloc();
    935         for (long i = 0; i < psArrayLength(processedImfiles); i++) {
    936             psMetadata *md = detProcessedImfileMetadataFromObject(
    937                     processedImfiles->data[i]);
    938             psMetadataAddMetadata(
    939                 output, PS_LIST_TAIL, "detProcessedImfile", PS_META_DUPLICATE_OK,
    940                 NULL, md
    941             );
    942             psFree(md);
    943         }
    944 
    945         psString str = psMetadataConfigFormat(output);
    946         psFree(output);
    947         fprintf(stdout, "%s\n", str);
    948         psFree(str);
     962        // negative simple so the default is true
     963        if (!detProcessedImfilePrintObjects(stdout, processedImfiles, !simple)) {
     964            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     965            psFree(processedImfiles);
     966            return false;
     967        }
    949968    }
    950969
    … …  
    10951114    }
    10961115
     1116    bool simple = false;
     1117    {
     1118        bool status = false;
     1119        simple = psMetadataLookupBool(&status, config->args, "-simple");
     1120        if (!status) {
     1121            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
     1122            return false;
     1123        }
     1124    }
     1125
     1126    // print imfile list
    10971127    if (stackedImfiles->n) {
    1098         // print imfile list
    1099         psMetadata *output = psMetadataAlloc();
    1100         for (long i = 0; i < psArrayLength(stackedImfiles); i++) {
    1101             psMetadata *md = detStackedImfileMetadataFromObject(
    1102                     stackedImfiles->data[i]);
    1103             psMetadataAddMetadata(
    1104                 output, PS_LIST_TAIL, "detStackedImfile", PS_META_DUPLICATE_OK,
    1105                 NULL, md
    1106             );
    1107             psFree(md);
    1108         }
    1109 
    1110         psString str = psMetadataConfigFormat(output);
    1111         psFree(output);
    1112         fprintf(stdout, "%s\n", str);
    1113         psFree(str);
     1128        // negative simple so the default is true
     1129        if (!detStackedImfilePrintObjects(stdout, stackedImfiles, !simple)) {
     1130            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1131            psFree(stackedImfiles);
     1132            return false;
     1133        }
    11141134    }
    11151135
    … …  
    11861206    psFree(valid_class_ids);
    11871207
    1188     // print detStackedImfile if all class_ids are matched
    1189     psMetadata *output = psMetadataAlloc();
    1190     for (long i = 0; i < psArrayLength(stackedImfiles); i++) {
    1191         psMetadata *md = detStackedImfileMetadataFromObject(
    1192                 stackedImfiles->data[i]);
    1193         psMetadataAddMetadata(
    1194             output, PS_LIST_TAIL, "detStackedImfile", PS_META_DUPLICATE_OK,
    1195             NULL, md
    1196         );
    1197         psFree(md);
    1198     }
     1208    bool simple = false;
     1209    {
     1210        bool status = false;
     1211        simple = psMetadataLookupBool(&status, config->args, "-simple");
     1212        if (!status) {
     1213            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
     1214            return false;
     1215        }
     1216    }
     1217
     1218    // negative simple so the default is true
     1219    if (stackedImfiles->n) {
     1220        if (!detStackedImfilePrintObjects(stdout, stackedImfiles, !simple)) {
     1221            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1222            psFree(stackedImfiles);
     1223            return false;
     1224        }
     1225    }
     1226
    11991227    psFree(stackedImfiles);
    1200 
    1201     psString str = psMetadataConfigFormat(output);
    1202     psFree(output);
    1203     fprintf(stdout, "%s\n", str);
    1204     psFree(str);
    12051228 
    12061229    return true;
    … …  
    14561479    }
    14571480
    1458     // print detNormalizedImfiles
    1459     psMetadata *output = psMetadataAlloc();
    1460     for (long i = 0; i < psArrayLength(normalizedImfiles); i++) {
    1461         psMetadata *md = detStackedImfileMetadataFromObject(
    1462                 normalizedImfiles->data[i]);
    1463         psMetadataAddMetadata(
    1464             output, PS_LIST_TAIL, "detNormalizedImfile", PS_META_DUPLICATE_OK,
    1465             NULL, md
    1466         );
    1467         psFree(md);
    1468     }
     1481    bool simple = false;
     1482    {
     1483        bool status = false;
     1484        simple = psMetadataLookupBool(&status, config->args, "-simple");
     1485        if (!status) {
     1486            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
     1487            return false;
     1488        }
     1489    }
     1490
     1491    // negative simple so the default is true
     1492    if (normalizedImfiles->n) {
     1493        if (!detNormalizedImfilePrintObjects(stdout, normalizedImfiles, !simple)) {
     1494            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1495            psFree(normalizedImfiles);
     1496            return false;
     1497        }
     1498    }
     1499
    14691500    psFree(normalizedImfiles);
    1470 
    1471     psString str = psMetadataConfigFormat(output);
    1472     psFree(output);
    1473     fprintf(stdout, "%s\n", str);
    1474     psFree(str);
    14751501
    14761502    return true;
    … …  
    15361562    // if we nade it this far we must have a complete frame
    15371563
    1538     // print detNormalizedImfiles
    1539     psMetadata *output = psMetadataAlloc();
    1540     for (long i = 0; i < psArrayLength(masterImfiles); i++) {
    1541         psMetadata *md = detStackedImfileMetadataFromObject(
    1542                 masterImfiles->data[i]);
    1543         psMetadataAddMetadata(
    1544             output, PS_LIST_TAIL, "detNormalizedImfile", PS_META_DUPLICATE_OK,
    1545             NULL, md
    1546         );
    1547         psFree(md);
    1548     }
    1549 
    1550     psString str = psMetadataConfigFormat(output);
    1551     psFree(output);
    1552     fprintf(stdout, "%s\n", str);
    1553     psFree(str);
     1564    bool simple = false;
     1565    {
     1566        bool status = false;
     1567        simple = psMetadataLookupBool(&status, config->args, "-simple");
     1568        if (!status) {
     1569            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
     1570            return false;
     1571        }
     1572    }
     1573
     1574    // negative simple so the default is true
     1575    if (masterImfiles->n) {
     1576        if (!detNormalizedImfilePrintObjects(stdout, masterImfiles, !simple)) {
     1577            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1578            psFree(masterImfiles);
     1579            return false;
     1580        }
     1581    }
     1582
     1583    psFree(masterImfiles);
    15541584
    15551585    return true;
    … …  
    17081738    }
    17091739
    1710     if (psArrayLength(residImfiles)) {
    1711         // print imfile list
    1712         psMetadata *output = psMetadataAlloc();
    1713         for (long i = 0; i < psArrayLength(residImfiles); i++) {
    1714             psMetadata *md = detResidImfileAnalysisMetadataFromObject(
    1715                     residImfiles->data[i]);
    1716             psMetadataAddMetadata(
    1717                 output, PS_LIST_TAIL, "detResidImfileAnalysis",
    1718                 PS_META_DUPLICATE_OK, NULL, md
    1719             );
    1720             psFree(md);
    1721         }
    1722 
    1723         psString str = psMetadataConfigFormat(output);
    1724         psFree(output);
    1725         fprintf(stdout, "%s\n", str);
    1726         psFree(str);
     1740    bool simple = false;
     1741    {
     1742        bool status = false;
     1743        simple = psMetadataLookupBool(&status, config->args, "-simple");
     1744        if (!status) {
     1745            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
     1746            return false;
     1747        }
     1748    }
     1749
     1750    // negative simple so the default is true
     1751    if (residImfiles->n) {
     1752        if (!detResidImfileAnalysisPrintObjects(stdout, residImfiles, !simple)) {
     1753            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1754            psFree(residImfiles);
     1755            return false;
     1756        }
    17271757    }
    17281758
    … …  
    18391869    }
    18401870
    1841     if (psArrayLength(residExps)) {
    1842         // print imfile list
    1843         psMetadata *output = psMetadataAlloc();
    1844         for (long i = 0; i < psArrayLength(residExps); i++) {
    1845             psMetadata *md = detResidExpAnalysisMetadataFromObject(
    1846                     residExps->data[i]);
    1847             psMetadataAddMetadata(
    1848                 output, PS_LIST_TAIL, "detResidExpAnalysis",
    1849                 PS_META_DUPLICATE_OK, NULL, md
    1850             );
    1851             psFree(md);
    1852         }
    1853 
    1854         psString str = psMetadataConfigFormat(output);
    1855         psFree(output);
    1856         fprintf(stdout, "%s\n", str);
    1857         psFree(str);
     1871    bool simple = false;
     1872    {
     1873        bool status = false;
     1874        simple = psMetadataLookupBool(&status, config->args, "-simple");
     1875        if (!status) {
     1876            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
     1877            return false;
     1878        }
     1879    }
     1880
     1881    // negative simple so the default is true
     1882    if (residExps->n) {
     1883        if (!detResidExpAnalysisPrintObjects(stdout, residExps, !simple)) {
     1884            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1885            psFree(residExps);
     1886            return false;
     1887        }
    18581888    }
    18591889
    18601890    psFree(residExps);
     1891
    18611892    return true;
    18621893}
    … …  
    19211952    }
    19221953
    1923     if (psArrayLength(masterFrames)) {
    1924         // print imfile list
    1925         psMetadata *output = psMetadataAlloc();
    1926         for (long i = 0; i < psArrayLength(masterFrames); i++) {
    1927             psMetadata *md = detMasterFrameMetadataFromObject(
    1928                     masterFrames->data[i]);
    1929             psMetadataAddMetadata(
    1930                 output, PS_LIST_TAIL, "detMasterFrame",
    1931                 PS_META_DUPLICATE_OK, NULL, md
    1932             );
    1933             psFree(md);
    1934         }
    1935 
    1936         psString str = psMetadataConfigFormat(output);
    1937         psFree(output);
    1938         fprintf(stdout, "%s\n", str);
    1939         psFree(str);
     1954    bool simple = false;
     1955    {
     1956        bool status = false;
     1957        simple = psMetadataLookupBool(&status, config->args, "-simple");
     1958        if (!status) {
     1959            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
     1960            return false;
     1961        }
     1962    }
     1963
     1964    // negative simple so the default is true
     1965    if (masterFrames->n) {
     1966        if (!detMasterFramePrintObjects(stdout, masterFrames, !simple)) {
     1967            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1968            psFree(masterFrames);
     1969            return false;
     1970        }
    19401971    }
    19411972
    … …  
    19581989    }
    19591990
    1960     if (psArrayLength(normalizedImfiles)) {
    1961         // print imfile list
    1962         psMetadata *output = psMetadataAlloc();
    1963         for (long i = 0; i < psArrayLength(normalizedImfiles); i++) {
    1964             psMetadata *md = detNormalizedImfileMetadataFromObject(
    1965                     normalizedImfiles->data[i]);
    1966             psMetadataAddMetadata(
    1967                 output, PS_LIST_TAIL, "detNormalizedImfile",
    1968                 PS_META_DUPLICATE_OK, NULL, md
    1969             );
    1970             psFree(md);
    1971         }
    1972 
    1973         psString str = psMetadataConfigFormat(output);
    1974         psFree(output);
    1975         fprintf(stdout, "%s\n", str);
    1976         psFree(str);
     1991    bool simple = false;
     1992    {
     1993        bool status = false;
     1994        simple = psMetadataLookupBool(&status, config->args, "-simple");
     1995        if (!status) {
     1996            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
     1997            return false;
     1998        }
     1999    }
     2000
     2001    // negative simple so the default is true
     2002    if (normalizedImfiles->n) {
     2003        if (!detNormalizedImfilePrintObjects(stdout, normalizedImfiles, !simple)) {
     2004            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     2005            psFree(normalizedImfiles);
     2006            return false;
     2007        }
    19772008    }
    19782009
Note: See TracChangeset for help on using the changeset viewer.