IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 10753


Ignore:
Timestamp:
Dec 15, 2006, 12:38:13 PM (20 years ago)
Author:
jhoblitt
Message:

VERSION to 0.0.68

Location:
trunk/ippdb
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippdb/Makefile.am

    r10748 r10753  
    4545    $(top_builddir)/docs/man/man3/p4InputImfileRow.3 \
    4646    $(top_builddir)/docs/man/man3/p4WarpedImfileRow.3 \
    47     $(top_builddir)/docs/man/man3/p4PStackedImfileRow.3 \
    48     $(top_builddir)/docs/man/man3/p4PDiffImfileRow.3 \
    49     $(top_builddir)/docs/man/man3/p4PMagicMaskImfileRow.3
     47    $(top_builddir)/docs/man/man3/p4StackedImfileRow.3 \
     48    $(top_builddir)/docs/man/man3/p4DiffImfileRow.3 \
     49    $(top_builddir)/docs/man/man3/p4MagicMaskImfileRow.3
    5050
    5151
    52 docs/man/man3/ippdb.3 docs/man/man3/expTagCounterRow.3 docs/man/man3/summitExpRow.3 docs/man/man3/summitImfileRow.3 docs/man/man3/pzPendingExpRow.3 docs/man/man3/pzPendingImfileRow.3 docs/man/man3/pzDoneExpRow.3 docs/man/man3/pzDoneImfileRow.3 docs/man/man3/newExpRow.3 docs/man/man3/newImfileRow.3 docs/man/man3/rawDetrendExpRow.3 docs/man/man3/rawScienceExpRow.3 docs/man/man3/rawImfileRow.3 docs/man/man3/p1PendingExpRow.3 docs/man/man3/p2PendingExpRow.3 docs/man/man3/p2PendingImfileRow.3 docs/man/man3/p2ProcessedExpRow.3 docs/man/man3/p2MaskRow.3 docs/man/man3/p2ProcessedImfileRow.3 docs/man/man3/p3PendingExpRow.3 docs/man/man3/p3ProcessedExpRow.3 docs/man/man3/p3MaskRow.3 docs/man/man3/detRunRow.3 docs/man/man3/detInputExpRow.3 docs/man/man3/detProcessedImfileRow.3 docs/man/man3/detProcessedExpRow.3 docs/man/man3/detStackedImfileRow.3 docs/man/man3/detNormalizedStatImfileRow.3 docs/man/man3/detNormalizedImfileRow.3 docs/man/man3/detNormalizedExpRow.3 docs/man/man3/detResidImfileRow.3 docs/man/man3/detResidExpRow.3 docs/man/man3/detRunSummaryRow.3 docs/man/man3/p4RunRow.3 docs/man/man3/p4InputImfileRow.3 docs/man/man3/p4WarpedImfileRow.3 docs/man/man3/p4PStackedImfileRow.3 docs/man/man3/p4PDiffImfileRow.3 docs/man/man3/p4PMagicMaskImfileRow.3:
     52docs/man/man3/ippdb.3 docs/man/man3/expTagCounterRow.3 docs/man/man3/summitExpRow.3 docs/man/man3/summitImfileRow.3 docs/man/man3/pzPendingExpRow.3 docs/man/man3/pzPendingImfileRow.3 docs/man/man3/pzDoneExpRow.3 docs/man/man3/pzDoneImfileRow.3 docs/man/man3/newExpRow.3 docs/man/man3/newImfileRow.3 docs/man/man3/rawDetrendExpRow.3 docs/man/man3/rawScienceExpRow.3 docs/man/man3/rawImfileRow.3 docs/man/man3/p1PendingExpRow.3 docs/man/man3/p2PendingExpRow.3 docs/man/man3/p2PendingImfileRow.3 docs/man/man3/p2ProcessedExpRow.3 docs/man/man3/p2MaskRow.3 docs/man/man3/p2ProcessedImfileRow.3 docs/man/man3/p3PendingExpRow.3 docs/man/man3/p3ProcessedExpRow.3 docs/man/man3/p3MaskRow.3 docs/man/man3/detRunRow.3 docs/man/man3/detInputExpRow.3 docs/man/man3/detProcessedImfileRow.3 docs/man/man3/detProcessedExpRow.3 docs/man/man3/detStackedImfileRow.3 docs/man/man3/detNormalizedStatImfileRow.3 docs/man/man3/detNormalizedImfileRow.3 docs/man/man3/detNormalizedExpRow.3 docs/man/man3/detResidImfileRow.3 docs/man/man3/detResidExpRow.3 docs/man/man3/detRunSummaryRow.3 docs/man/man3/p4RunRow.3 docs/man/man3/p4InputImfileRow.3 docs/man/man3/p4WarpedImfileRow.3 docs/man/man3/p4StackedImfileRow.3 docs/man/man3/p4DiffImfileRow.3 docs/man/man3/p4MagicMaskImfileRow.3:
    5353        $(DOXYGEN)
    5454

  • trunk/ippdb/configure.ac

    r10748 r10753  
    77AC_PREREQ(2.59)
    88
    9 AC_INIT([ippdb], [0.0.67], [pan-starrs.ifa.hawaii.edu])
     9AC_INIT([ippdb], [0.0.68], [pan-starrs.ifa.hawaii.edu])
    1010AC_CONFIG_SRCDIR([ippdb.pc.in])
    1111

  • trunk/ippdb/src/ippdb.c

    r10748 r10753  
    6666#define P4INPUTIMFILE_TABLE_NAME "p4InputImfile"
    6767#define P4WARPEDIMFILE_TABLE_NAME "p4WarpedImfile"
    68 #define P4PSTACKEDIMFILE_TABLE_NAME "p4PStackedImfile"
    69 #define P4PDIFFIMFILE_TABLE_NAME "p4PDiffImfile"
    70 #define P4PMAGICMASKIMFILE_TABLE_NAME "p4PMagicMaskImfile"
     68#define P4STACKEDIMFILE_TABLE_NAME "p4StackedImfile"
     69#define P4DIFFIMFILE_TABLE_NAME "p4DiffImfile"
     70#define P4MAGICMASKIMFILE_TABLE_NAME "p4MagicMaskImfile"
    7171#define MAX_STRING_LENGTH 1024
    7272
    … …  
    1486114861    return true;
    1486214862}
    14863 static void p4PStackedImfileRowFree(p4PStackedImfileRow *object);
    14864 
    14865 p4PStackedImfileRow *p4PStackedImfileRowAlloc(psS32 p4_id, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri)
    14866 {
    14867     p4PStackedImfileRow *_object;
    14868 
    14869     _object = psAlloc(sizeof(p4PStackedImfileRow));
    14870     psMemSetDeallocator(_object, (psFreeFunc)p4PStackedImfileRowFree);
     14863static void p4StackedImfileRowFree(p4StackedImfileRow *object);
     14864
     14865p4StackedImfileRow *p4StackedImfileRowAlloc(psS32 p4_id, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri)
     14866{
     14867    p4StackedImfileRow *_object;
     14868
     14869    _object = psAlloc(sizeof(p4StackedImfileRow));
     14870    psMemSetDeallocator(_object, (psFreeFunc)p4StackedImfileRowFree);
    1487114871
    1487214872    _object->p4_id = p4_id;
    … …  
    1487914879}
    1488014880
    14881 static void p4PStackedImfileRowFree(p4PStackedImfileRow *object)
     14881static void p4StackedImfileRowFree(p4StackedImfileRow *object)
    1488214882{
    1488314883    psFree(object->class_id);
    … …  
    1488714887}
    1488814888
    14889 bool p4PStackedImfileCreateTable(psDB *dbh)
     14889bool p4StackedImfileCreateTable(psDB *dbh)
    1489014890{
    1489114891    psMetadata *md = psMetadataAlloc();
    … …  
    1491614916    }
    1491714917
    14918     bool status = psDBCreateTable(dbh, P4PSTACKEDIMFILE_TABLE_NAME, md);
     14918    bool status = psDBCreateTable(dbh, P4STACKEDIMFILE_TABLE_NAME, md);
    1491914919
    1492014920    psFree(md);
    … …  
    1492314923}
    1492414924
    14925 bool p4PStackedImfileDropTable(psDB *dbh)
    14926 {
    14927     return psDBDropTable(dbh, P4PSTACKEDIMFILE_TABLE_NAME);
    14928 }
    14929 
    14930 bool p4PStackedImfileInsert(psDB * dbh, psS32 p4_id, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri)
     14925bool p4StackedImfileDropTable(psDB *dbh)
     14926{
     14927    return psDBDropTable(dbh, P4STACKEDIMFILE_TABLE_NAME);
     14928}
     14929
     14930bool p4StackedImfileInsert(psDB * dbh, psS32 p4_id, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri)
    1493114931{
    1493214932    psMetadata *md = psMetadataAlloc();
    … …  
    1495714957    }
    1495814958
    14959     bool status = psDBInsertOneRow(dbh, P4PSTACKEDIMFILE_TABLE_NAME, md);
     14959    bool status = psDBInsertOneRow(dbh, P4STACKEDIMFILE_TABLE_NAME, md);
    1496014960    psFree(md);
    1496114961
    … …  
    1496314963}
    1496414964
    14965 long long p4PStackedImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     14965long long p4StackedImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1496614966{
    1496714967    long long       deleted = 0;
    1496814968
    14969     long long count = psDBDeleteRows(dbh, P4PSTACKEDIMFILE_TABLE_NAME, where, limit);
     14969    long long count = psDBDeleteRows(dbh, P4STACKEDIMFILE_TABLE_NAME, where, limit);
    1497014970    if (count < 0) {
    14971         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PStackedImfile");
     14971        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4StackedImfile");
    1497214972        return count;
    1497314973
    … …  
    1497714977    return deleted;
    1497814978}
    14979 bool p4PStackedImfileInsertObject(psDB *dbh, p4PStackedImfileRow *object)
    14980 {
    14981     return p4PStackedImfileInsert(dbh, object->p4_id, object->class_id, object->uri, object->b1_uri, object->b2_uri);
    14982 }
    14983 
    14984 bool p4PStackedImfileInsertObjects(psDB *dbh, psArray *objects)
     14979bool p4StackedImfileInsertObject(psDB *dbh, p4StackedImfileRow *object)
     14980{
     14981    return p4StackedImfileInsert(dbh, object->p4_id, object->class_id, object->uri, object->b1_uri, object->b2_uri);
     14982}
     14983
     14984bool p4StackedImfileInsertObjects(psDB *dbh, psArray *objects)
    1498514985{
    1498614986    for (long i = 0; i < psArrayLength(objects); i++) {
    14987         if (!p4PStackedImfileInsertObject(dbh, objects->data[i])) {
     14987        if (!p4StackedImfileInsertObject(dbh, objects->data[i])) {
    1498814988            return false;
    1498914989        }
    … …  
    1499314993}
    1499414994
    14995 bool p4PStackedImfileInsertFits(psDB *dbh, const psFits *fits)
     14995bool p4StackedImfileInsertFits(psDB *dbh, const psFits *fits)
    1499614996{
    1499714997    psArray         *rowSet;
    1499814998
    14999     // move to (the first?) extension named  P4PSTACKEDIMFILE_TABLE_NAME
    15000     if (!psFitsMoveExtName(fits, P4PSTACKEDIMFILE_TABLE_NAME)) {
    15001         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4PSTACKEDIMFILE_TABLE_NAME);
     14999    // move to (the first?) extension named  P4STACKEDIMFILE_TABLE_NAME
     15000    if (!psFitsMoveExtName(fits, P4STACKEDIMFILE_TABLE_NAME)) {
     15001        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4STACKEDIMFILE_TABLE_NAME);
    1500215002        return false;
    1500315003    }
    … …  
    1501715017    }
    1501815018
    15019     if (!psDBInsertRows(dbh, P4PSTACKEDIMFILE_TABLE_NAME, rowSet)) {
     15019    if (!psDBInsertRows(dbh, P4STACKEDIMFILE_TABLE_NAME, rowSet)) {
    1502015020        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    1502115021        psFree(rowSet);
    … …  
    1502815028}
    1502915029
    15030 bool p4PStackedImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     15030bool p4StackedImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1503115031{
    1503215032    psArray         *rowSet;
    1503315033
    15034     rowSet = psDBSelectRows(dbh, P4PSTACKEDIMFILE_TABLE_NAME, where, limit);
     15034    rowSet = psDBSelectRows(dbh, P4STACKEDIMFILE_TABLE_NAME, where, limit);
    1503515035    if (!rowSet) {
    1503615036        return false;
    … …  
    1503815038
    1503915039    // output to fits
    15040     if (!psFitsWriteTable(fits, NULL, rowSet, P4PSTACKEDIMFILE_TABLE_NAME)) {
     15040    if (!psFitsWriteTable(fits, NULL, rowSet, P4STACKEDIMFILE_TABLE_NAME)) {
    1504115041        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    1504215042        psFree(rowSet);
    … …  
    1504915049}
    1505015050
    15051 psMetadata *p4PStackedImfileMetadataFromObject(const p4PStackedImfileRow *object)
     15051psMetadata *p4StackedImfileMetadataFromObject(const p4StackedImfileRow *object)
    1505215052{
    1505315053    psMetadata *md = psMetadataAlloc();
    … …  
    1508215082}
    1508315083
    15084 p4PStackedImfileRow *p4PStackedImfileObjectFromMetadata(psMetadata *md)
     15084p4StackedImfileRow *p4StackedImfileObjectFromMetadata(psMetadata *md)
    1508515085{
    1508615086
    … …  
    1511215112    }
    1511315113
    15114     return p4PStackedImfileRowAlloc(p4_id, class_id, uri, b1_uri, b2_uri);
    15115 }
    15116 psArray *p4PStackedImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     15114    return p4StackedImfileRowAlloc(p4_id, class_id, uri, b1_uri, b2_uri);
     15115}
     15116psArray *p4StackedImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1511715117{
    1511815118    psArray         *rowSet;
    … …  
    1512015120    psU64           i;
    1512115121
    15122     rowSet = psDBSelectRows(dbh, P4PSTACKEDIMFILE_TABLE_NAME, where, limit);
     15122    rowSet = psDBSelectRows(dbh, P4STACKEDIMFILE_TABLE_NAME, where, limit);
    1512315123    if (!rowSet) {
    1512415124        return NULL;
    … …  
    1513015130
    1513115131    for (i = 0; i < rowSet->n; i++) {
    15132         p4PStackedImfileRow *object = p4PStackedImfileObjectFromMetadata(rowSet->data[i]);
     15132        p4StackedImfileRow *object = p4StackedImfileObjectFromMetadata(rowSet->data[i]);
    1513315133        psArrayAdd(returnSet, 0, object);
    1513415134        psFree(object);
    … …  
    1513915139    return returnSet;
    1514015140}
    15141 bool p4PStackedImfileDeleteObject(psDB *dbh, const p4PStackedImfileRow *object)
    15142 {
    15143     psMetadata *where = p4PStackedImfileMetadataFromObject(object);
    15144     long long count = psDBDeleteRows(dbh, P4PSTACKEDIMFILE_TABLE_NAME, where, 0);
     15141bool p4StackedImfileDeleteObject(psDB *dbh, const p4StackedImfileRow *object)
     15142{
     15143    psMetadata *where = p4StackedImfileMetadataFromObject(object);
     15144    long long count = psDBDeleteRows(dbh, P4STACKEDIMFILE_TABLE_NAME, where, 0);
    1514515145    psFree(where)
    1514615146    if (count < 0) {
    15147         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PStackedImfile");
     15147        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4StackedImfile");
    1514815148        return false;
    1514915149    }
    … …  
    1515115151        // XXX should this be a psAbort() instead?  It is possible that
    1515215152        // having an object match multiple rows was by design.
    15153         psError(PS_ERR_UNKNOWN, true, "p4PStackedImfileRow object matched more then one row.  Check your database schema");
    15154         return false;
    15155     }
    15156 
    15157     return true;
    15158 }
    15159 long long p4PStackedImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     15153        psError(PS_ERR_UNKNOWN, true, "p4StackedImfileRow object matched more then one row.  Check your database schema");
     15154        return false;
     15155    }
     15156
     15157    return true;
     15158}
     15159long long p4StackedImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    1516015160{
    1516115161    long long       deleted = 0;
    1516215162
    1516315163    for (long long i = 0; i < objects->n; i++) {
    15164         p4PStackedImfileRow *object = objects->data[i];
    15165         psMetadata *where = p4PStackedImfileMetadataFromObject(object);
    15166         long long count = psDBDeleteRows(dbh, P4PSTACKEDIMFILE_TABLE_NAME, where, limit);
     15164        p4StackedImfileRow *object = objects->data[i];
     15165        psMetadata *where = p4StackedImfileMetadataFromObject(object);
     15166        long long count = psDBDeleteRows(dbh, P4STACKEDIMFILE_TABLE_NAME, where, limit);
    1516715167        psFree(where)
    1516815168        if (count < 0) {
    15169             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PStackedImfile");
     15169            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4StackedImfile");
    1517015170            return count;
    1517115171        }
    … …  
    1517615176    return deleted;
    1517715177}
    15178 bool p4PStackedImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
     15178bool p4StackedImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
    1517915179{
    1518015180    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    1518215182    psMetadata *output = psMetadataAlloc();
    1518315183    for (long i = 0; i < psArrayLength(objects); i++) {
    15184         psMetadata *md = p4PStackedImfileMetadataFromObject(objects->data[i]);
     15184        psMetadata *md = p4StackedImfileMetadataFromObject(objects->data[i]);
    1518515185        if (!psMetadataAddMetadata(
    1518615186            output,
    1518715187            PS_LIST_TAIL,
    15188             P4PSTACKEDIMFILE_TABLE_NAME,
     15188            P4STACKEDIMFILE_TABLE_NAME,
    1518915189            PS_META_DUPLICATE_OK,
    1519015190            NULL,
    … …  
    1520715207    return true;
    1520815208}
    15209 bool p4PStackedImfilePrintObject(FILE *stream, p4PStackedImfileRow *object, bool mdcf)
     15209bool p4StackedImfilePrintObject(FILE *stream, p4StackedImfileRow *object, bool mdcf)
    1521015210{
    1521115211    PS_ASSERT_PTR_NON_NULL(object, false);
    1521215212
    15213     psMetadata *md = p4PStackedImfileMetadataFromObject(object);
     15213    psMetadata *md = p4StackedImfileMetadataFromObject(object);
    1521415214
    1521515215    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    1522215222    return true;
    1522315223}
    15224 static void p4PDiffImfileRowFree(p4PDiffImfileRow *object);
    15225 
    15226 p4PDiffImfileRow *p4PDiffImfileRowAlloc(psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri)
    15227 {
    15228     p4PDiffImfileRow *_object;
    15229 
    15230     _object = psAlloc(sizeof(p4PDiffImfileRow));
    15231     psMemSetDeallocator(_object, (psFreeFunc)p4PDiffImfileRowFree);
     15224static void p4DiffImfileRowFree(p4DiffImfileRow *object);
     15225
     15226p4DiffImfileRow *p4DiffImfileRowAlloc(psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri)
     15227{
     15228    p4DiffImfileRow *_object;
     15229
     15230    _object = psAlloc(sizeof(p4DiffImfileRow));
     15231    psMemSetDeallocator(_object, (psFreeFunc)p4DiffImfileRowFree);
    1523215232
    1523315233    _object->p4_id = p4_id;
    … …  
    1524215242}
    1524315243
    15244 static void p4PDiffImfileRowFree(p4PDiffImfileRow *object)
     15244static void p4DiffImfileRowFree(p4DiffImfileRow *object)
    1524515245{
    1524615246    psFree(object->exp_tag);
    … …  
    1525115251}
    1525215252
    15253 bool p4PDiffImfileCreateTable(psDB *dbh)
     15253bool p4DiffImfileCreateTable(psDB *dbh)
    1525415254{
    1525515255    psMetadata *md = psMetadataAlloc();
    … …  
    1529015290    }
    1529115291
    15292     bool status = psDBCreateTable(dbh, P4PDIFFIMFILE_TABLE_NAME, md);
     15292    bool status = psDBCreateTable(dbh, P4DIFFIMFILE_TABLE_NAME, md);
    1529315293
    1529415294    psFree(md);
    … …  
    1529715297}
    1529815298
    15299 bool p4PDiffImfileDropTable(psDB *dbh)
    15300 {
    15301     return psDBDropTable(dbh, P4PDIFFIMFILE_TABLE_NAME);
    15302 }
    15303 
    15304 bool p4PDiffImfileInsert(psDB * dbh, psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri)
     15299bool p4DiffImfileDropTable(psDB *dbh)
     15300{
     15301    return psDBDropTable(dbh, P4DIFFIMFILE_TABLE_NAME);
     15302}
     15303
     15304bool p4DiffImfileInsert(psDB * dbh, psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri)
    1530515305{
    1530615306    psMetadata *md = psMetadataAlloc();
    … …  
    1534115341    }
    1534215342
    15343     bool status = psDBInsertOneRow(dbh, P4PDIFFIMFILE_TABLE_NAME, md);
     15343    bool status = psDBInsertOneRow(dbh, P4DIFFIMFILE_TABLE_NAME, md);
    1534415344    psFree(md);
    1534515345
    … …  
    1534715347}
    1534815348
    15349 long long p4PDiffImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     15349long long p4DiffImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1535015350{
    1535115351    long long       deleted = 0;
    1535215352
    15353     long long count = psDBDeleteRows(dbh, P4PDIFFIMFILE_TABLE_NAME, where, limit);
     15353    long long count = psDBDeleteRows(dbh, P4DIFFIMFILE_TABLE_NAME, where, limit);
    1535415354    if (count < 0) {
    15355         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PDiffImfile");
     15355        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4DiffImfile");
    1535615356        return count;
    1535715357
    … …  
    1536115361    return deleted;
    1536215362}
    15363 bool p4PDiffImfileInsertObject(psDB *dbh, p4PDiffImfileRow *object)
    15364 {
    15365     return p4PDiffImfileInsert(dbh, object->p4_id, object->exp_tag, object->p3_version, object->class_id, object->uri, object->b1_uri, object->b2_uri);
    15366 }
    15367 
    15368 bool p4PDiffImfileInsertObjects(psDB *dbh, psArray *objects)
     15363bool p4DiffImfileInsertObject(psDB *dbh, p4DiffImfileRow *object)
     15364{
     15365    return p4DiffImfileInsert(dbh, object->p4_id, object->exp_tag, object->p3_version, object->class_id, object->uri, object->b1_uri, object->b2_uri);
     15366}
     15367
     15368bool p4DiffImfileInsertObjects(psDB *dbh, psArray *objects)
    1536915369{
    1537015370    for (long i = 0; i < psArrayLength(objects); i++) {
    15371         if (!p4PDiffImfileInsertObject(dbh, objects->data[i])) {
     15371        if (!p4DiffImfileInsertObject(dbh, objects->data[i])) {
    1537215372            return false;
    1537315373        }
    … …  
    1537715377}
    1537815378
    15379 bool p4PDiffImfileInsertFits(psDB *dbh, const psFits *fits)
     15379bool p4DiffImfileInsertFits(psDB *dbh, const psFits *fits)
    1538015380{
    1538115381    psArray         *rowSet;
    1538215382
    15383     // move to (the first?) extension named  P4PDIFFIMFILE_TABLE_NAME
    15384     if (!psFitsMoveExtName(fits, P4PDIFFIMFILE_TABLE_NAME)) {
    15385         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4PDIFFIMFILE_TABLE_NAME);
     15383    // move to (the first?) extension named  P4DIFFIMFILE_TABLE_NAME
     15384    if (!psFitsMoveExtName(fits, P4DIFFIMFILE_TABLE_NAME)) {
     15385        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4DIFFIMFILE_TABLE_NAME);
    1538615386        return false;
    1538715387    }
    … …  
    1540115401    }
    1540215402
    15403     if (!psDBInsertRows(dbh, P4PDIFFIMFILE_TABLE_NAME, rowSet)) {
     15403    if (!psDBInsertRows(dbh, P4DIFFIMFILE_TABLE_NAME, rowSet)) {
    1540415404        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    1540515405        psFree(rowSet);
    … …  
    1541215412}
    1541315413
    15414 bool p4PDiffImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     15414bool p4DiffImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1541515415{
    1541615416    psArray         *rowSet;
    1541715417
    15418     rowSet = psDBSelectRows(dbh, P4PDIFFIMFILE_TABLE_NAME, where, limit);
     15418    rowSet = psDBSelectRows(dbh, P4DIFFIMFILE_TABLE_NAME, where, limit);
    1541915419    if (!rowSet) {
    1542015420        return false;
    … …  
    1542215422
    1542315423    // output to fits
    15424     if (!psFitsWriteTable(fits, NULL, rowSet, P4PDIFFIMFILE_TABLE_NAME)) {
     15424    if (!psFitsWriteTable(fits, NULL, rowSet, P4DIFFIMFILE_TABLE_NAME)) {
    1542515425        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    1542615426        psFree(rowSet);
    … …  
    1543315433}
    1543415434
    15435 psMetadata *p4PDiffImfileMetadataFromObject(const p4PDiffImfileRow *object)
     15435psMetadata *p4DiffImfileMetadataFromObject(const p4DiffImfileRow *object)
    1543615436{
    1543715437    psMetadata *md = psMetadataAlloc();
    … …  
    1547615476}
    1547715477
    15478 p4PDiffImfileRow *p4PDiffImfileObjectFromMetadata(psMetadata *md)
     15478p4DiffImfileRow *p4DiffImfileObjectFromMetadata(psMetadata *md)
    1547915479{
    1548015480
    … …  
    1551615516    }
    1551715517
    15518     return p4PDiffImfileRowAlloc(p4_id, exp_tag, p3_version, class_id, uri, b1_uri, b2_uri);
    15519 }
    15520 psArray *p4PDiffImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     15518    return p4DiffImfileRowAlloc(p4_id, exp_tag, p3_version, class_id, uri, b1_uri, b2_uri);
     15519}
     15520psArray *p4DiffImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1552115521{
    1552215522    psArray         *rowSet;
    … …  
    1552415524    psU64           i;
    1552515525
    15526     rowSet = psDBSelectRows(dbh, P4PDIFFIMFILE_TABLE_NAME, where, limit);
     15526    rowSet = psDBSelectRows(dbh, P4DIFFIMFILE_TABLE_NAME, where, limit);
    1552715527    if (!rowSet) {
    1552815528        return NULL;
    … …  
    1553415534
    1553515535    for (i = 0; i < rowSet->n; i++) {
    15536         p4PDiffImfileRow *object = p4PDiffImfileObjectFromMetadata(rowSet->data[i]);
     15536        p4DiffImfileRow *object = p4DiffImfileObjectFromMetadata(rowSet->data[i]);
    1553715537        psArrayAdd(returnSet, 0, object);
    1553815538        psFree(object);
    … …  
    1554315543    return returnSet;
    1554415544}
    15545 bool p4PDiffImfileDeleteObject(psDB *dbh, const p4PDiffImfileRow *object)
    15546 {
    15547     psMetadata *where = p4PDiffImfileMetadataFromObject(object);
    15548     long long count = psDBDeleteRows(dbh, P4PDIFFIMFILE_TABLE_NAME, where, 0);
     15545bool p4DiffImfileDeleteObject(psDB *dbh, const p4DiffImfileRow *object)
     15546{
     15547    psMetadata *where = p4DiffImfileMetadataFromObject(object);
     15548    long long count = psDBDeleteRows(dbh, P4DIFFIMFILE_TABLE_NAME, where, 0);
    1554915549    psFree(where)
    1555015550    if (count < 0) {
    15551         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PDiffImfile");
     15551        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4DiffImfile");
    1555215552        return false;
    1555315553    }
    … …  
    1555515555        // XXX should this be a psAbort() instead?  It is possible that
    1555615556        // having an object match multiple rows was by design.
    15557         psError(PS_ERR_UNKNOWN, true, "p4PDiffImfileRow object matched more then one row.  Check your database schema");
    15558         return false;
    15559     }
    15560 
    15561     return true;
    15562 }
    15563 long long p4PDiffImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     15557        psError(PS_ERR_UNKNOWN, true, "p4DiffImfileRow object matched more then one row.  Check your database schema");
     15558        return false;
     15559    }
     15560
     15561    return true;
     15562}
     15563long long p4DiffImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    1556415564{
    1556515565    long long       deleted = 0;
    1556615566
    1556715567    for (long long i = 0; i < objects->n; i++) {
    15568         p4PDiffImfileRow *object = objects->data[i];
    15569         psMetadata *where = p4PDiffImfileMetadataFromObject(object);
    15570         long long count = psDBDeleteRows(dbh, P4PDIFFIMFILE_TABLE_NAME, where, limit);
     15568        p4DiffImfileRow *object = objects->data[i];
     15569        psMetadata *where = p4DiffImfileMetadataFromObject(object);
     15570        long long count = psDBDeleteRows(dbh, P4DIFFIMFILE_TABLE_NAME, where, limit);
    1557115571        psFree(where)
    1557215572        if (count < 0) {
    15573             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PDiffImfile");
     15573            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4DiffImfile");
    1557415574            return count;
    1557515575        }
    … …  
    1558015580    return deleted;
    1558115581}
    15582 bool p4PDiffImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
     15582bool p4DiffImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
    1558315583{
    1558415584    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    1558615586    psMetadata *output = psMetadataAlloc();
    1558715587    for (long i = 0; i < psArrayLength(objects); i++) {
    15588         psMetadata *md = p4PDiffImfileMetadataFromObject(objects->data[i]);
     15588        psMetadata *md = p4DiffImfileMetadataFromObject(objects->data[i]);
    1558915589        if (!psMetadataAddMetadata(
    1559015590            output,
    1559115591            PS_LIST_TAIL,
    15592             P4PDIFFIMFILE_TABLE_NAME,
     15592            P4DIFFIMFILE_TABLE_NAME,
    1559315593            PS_META_DUPLICATE_OK,
    1559415594            NULL,
    … …  
    1561115611    return true;
    1561215612}
    15613 bool p4PDiffImfilePrintObject(FILE *stream, p4PDiffImfileRow *object, bool mdcf)
     15613bool p4DiffImfilePrintObject(FILE *stream, p4DiffImfileRow *object, bool mdcf)
    1561415614{
    1561515615    PS_ASSERT_PTR_NON_NULL(object, false);
    1561615616
    15617     psMetadata *md = p4PDiffImfileMetadataFromObject(object);
     15617    psMetadata *md = p4DiffImfileMetadataFromObject(object);
    1561815618
    1561915619    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    1562615626    return true;
    1562715627}
    15628 static void p4PMagicMaskImfileRowFree(p4PMagicMaskImfileRow *object);
    15629 
    15630 p4PMagicMaskImfileRow *p4PMagicMaskImfileRowAlloc(psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri)
    15631 {
    15632     p4PMagicMaskImfileRow *_object;
    15633 
    15634     _object = psAlloc(sizeof(p4PMagicMaskImfileRow));
    15635     psMemSetDeallocator(_object, (psFreeFunc)p4PMagicMaskImfileRowFree);
     15628static void p4MagicMaskImfileRowFree(p4MagicMaskImfileRow *object);
     15629
     15630p4MagicMaskImfileRow *p4MagicMaskImfileRowAlloc(psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri)
     15631{
     15632    p4MagicMaskImfileRow *_object;
     15633
     15634    _object = psAlloc(sizeof(p4MagicMaskImfileRow));
     15635    psMemSetDeallocator(_object, (psFreeFunc)p4MagicMaskImfileRowFree);
    1563615636
    1563715637    _object->p4_id = p4_id;
    … …  
    1564415644}
    1564515645
    15646 static void p4PMagicMaskImfileRowFree(p4PMagicMaskImfileRow *object)
     15646static void p4MagicMaskImfileRowFree(p4MagicMaskImfileRow *object)
    1564715647{
    1564815648    psFree(object->exp_tag);
    … …  
    1565115651}
    1565215652
    15653 bool p4PMagicMaskImfileCreateTable(psDB *dbh)
     15653bool p4MagicMaskImfileCreateTable(psDB *dbh)
    1565415654{
    1565515655    psMetadata *md = psMetadataAlloc();
    … …  
    1568015680    }
    1568115681
    15682     bool status = psDBCreateTable(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, md);
     15682    bool status = psDBCreateTable(dbh, P4MAGICMASKIMFILE_TABLE_NAME, md);
    1568315683
    1568415684    psFree(md);
    … …  
    1568715687}
    1568815688
    15689 bool p4PMagicMaskImfileDropTable(psDB *dbh)
    15690 {
    15691     return psDBDropTable(dbh, P4PMAGICMASKIMFILE_TABLE_NAME);
    15692 }
    15693 
    15694 bool p4PMagicMaskImfileInsert(psDB * dbh, psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri)
     15689bool p4MagicMaskImfileDropTable(psDB *dbh)
     15690{
     15691    return psDBDropTable(dbh, P4MAGICMASKIMFILE_TABLE_NAME);
     15692}
     15693
     15694bool p4MagicMaskImfileInsert(psDB * dbh, psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri)
    1569515695{
    1569615696    psMetadata *md = psMetadataAlloc();
    … …  
    1572115721    }
    1572215722
    15723     bool status = psDBInsertOneRow(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, md);
     15723    bool status = psDBInsertOneRow(dbh, P4MAGICMASKIMFILE_TABLE_NAME, md);
    1572415724    psFree(md);
    1572515725
    … …  
    1572715727}
    1572815728
    15729 long long p4PMagicMaskImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     15729long long p4MagicMaskImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1573015730{
    1573115731    long long       deleted = 0;
    1573215732
    15733     long long count = psDBDeleteRows(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, where, limit);
     15733    long long count = psDBDeleteRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, where, limit);
    1573415734    if (count < 0) {
    15735         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PMagicMaskImfile");
     15735        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4MagicMaskImfile");
    1573615736        return count;
    1573715737
    … …  
    1574115741    return deleted;
    1574215742}
    15743 bool p4PMagicMaskImfileInsertObject(psDB *dbh, p4PMagicMaskImfileRow *object)
    15744 {
    15745     return p4PMagicMaskImfileInsert(dbh, object->p4_id, object->exp_tag, object->p3_version, object->class_id, object->uri);
    15746 }
    15747 
    15748 bool p4PMagicMaskImfileInsertObjects(psDB *dbh, psArray *objects)
     15743bool p4MagicMaskImfileInsertObject(psDB *dbh, p4MagicMaskImfileRow *object)
     15744{
     15745    return p4MagicMaskImfileInsert(dbh, object->p4_id, object->exp_tag, object->p3_version, object->class_id, object->uri);
     15746}
     15747
     15748bool p4MagicMaskImfileInsertObjects(psDB *dbh, psArray *objects)
    1574915749{
    1575015750    for (long i = 0; i < psArrayLength(objects); i++) {
    15751         if (!p4PMagicMaskImfileInsertObject(dbh, objects->data[i])) {
     15751        if (!p4MagicMaskImfileInsertObject(dbh, objects->data[i])) {
    1575215752            return false;
    1575315753        }
    … …  
    1575715757}
    1575815758
    15759 bool p4PMagicMaskImfileInsertFits(psDB *dbh, const psFits *fits)
     15759bool p4MagicMaskImfileInsertFits(psDB *dbh, const psFits *fits)
    1576015760{
    1576115761    psArray         *rowSet;
    1576215762
    15763     // move to (the first?) extension named  P4PMAGICMASKIMFILE_TABLE_NAME
    15764     if (!psFitsMoveExtName(fits, P4PMAGICMASKIMFILE_TABLE_NAME)) {
    15765         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4PMAGICMASKIMFILE_TABLE_NAME);
     15763    // move to (the first?) extension named  P4MAGICMASKIMFILE_TABLE_NAME
     15764    if (!psFitsMoveExtName(fits, P4MAGICMASKIMFILE_TABLE_NAME)) {
     15765        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4MAGICMASKIMFILE_TABLE_NAME);
    1576615766        return false;
    1576715767    }
    … …  
    1578115781    }
    1578215782
    15783     if (!psDBInsertRows(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, rowSet)) {
     15783    if (!psDBInsertRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, rowSet)) {
    1578415784        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    1578515785        psFree(rowSet);
    … …  
    1579215792}
    1579315793
    15794 bool p4PMagicMaskImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     15794bool p4MagicMaskImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1579515795{
    1579615796    psArray         *rowSet;
    1579715797
    15798     rowSet = psDBSelectRows(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, where, limit);
     15798    rowSet = psDBSelectRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, where, limit);
    1579915799    if (!rowSet) {
    1580015800        return false;
    … …  
    1580215802
    1580315803    // output to fits
    15804     if (!psFitsWriteTable(fits, NULL, rowSet, P4PMAGICMASKIMFILE_TABLE_NAME)) {
     15804    if (!psFitsWriteTable(fits, NULL, rowSet, P4MAGICMASKIMFILE_TABLE_NAME)) {
    1580515805        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    1580615806        psFree(rowSet);
    … …  
    1581315813}
    1581415814
    15815 psMetadata *p4PMagicMaskImfileMetadataFromObject(const p4PMagicMaskImfileRow *object)
     15815psMetadata *p4MagicMaskImfileMetadataFromObject(const p4MagicMaskImfileRow *object)
    1581615816{
    1581715817    psMetadata *md = psMetadataAlloc();
    … …  
    1584615846}
    1584715847
    15848 p4PMagicMaskImfileRow *p4PMagicMaskImfileObjectFromMetadata(psMetadata *md)
     15848p4MagicMaskImfileRow *p4MagicMaskImfileObjectFromMetadata(psMetadata *md)
    1584915849{
    1585015850
    … …  
    1587615876    }
    1587715877
    15878     return p4PMagicMaskImfileRowAlloc(p4_id, exp_tag, p3_version, class_id, uri);
    15879 }
    15880 psArray *p4PMagicMaskImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     15878    return p4MagicMaskImfileRowAlloc(p4_id, exp_tag, p3_version, class_id, uri);
     15879}
     15880psArray *p4MagicMaskImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1588115881{
    1588215882    psArray         *rowSet;
    … …  
    1588415884    psU64           i;
    1588515885
    15886     rowSet = psDBSelectRows(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, where, limit);
     15886    rowSet = psDBSelectRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, where, limit);
    1588715887    if (!rowSet) {
    1588815888        return NULL;
    … …  
    1589415894
    1589515895    for (i = 0; i < rowSet->n; i++) {
    15896         p4PMagicMaskImfileRow *object = p4PMagicMaskImfileObjectFromMetadata(rowSet->data[i]);
     15896        p4MagicMaskImfileRow *object = p4MagicMaskImfileObjectFromMetadata(rowSet->data[i]);
    1589715897        psArrayAdd(returnSet, 0, object);
    1589815898        psFree(object);
    … …  
    1590315903    return returnSet;
    1590415904}
    15905 bool p4PMagicMaskImfileDeleteObject(psDB *dbh, const p4PMagicMaskImfileRow *object)
    15906 {
    15907     psMetadata *where = p4PMagicMaskImfileMetadataFromObject(object);
    15908     long long count = psDBDeleteRows(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, where, 0);
     15905bool p4MagicMaskImfileDeleteObject(psDB *dbh, const p4MagicMaskImfileRow *object)
     15906{
     15907    psMetadata *where = p4MagicMaskImfileMetadataFromObject(object);
     15908    long long count = psDBDeleteRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, where, 0);
    1590915909    psFree(where)
    1591015910    if (count < 0) {
    15911         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PMagicMaskImfile");
     15911        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4MagicMaskImfile");
    1591215912        return false;
    1591315913    }
    … …  
    1591515915        // XXX should this be a psAbort() instead?  It is possible that
    1591615916        // having an object match multiple rows was by design.
    15917         psError(PS_ERR_UNKNOWN, true, "p4PMagicMaskImfileRow object matched more then one row.  Check your database schema");
    15918         return false;
    15919     }
    15920 
    15921     return true;
    15922 }
    15923 long long p4PMagicMaskImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     15917        psError(PS_ERR_UNKNOWN, true, "p4MagicMaskImfileRow object matched more then one row.  Check your database schema");
     15918        return false;
     15919    }
     15920
     15921    return true;
     15922}
     15923long long p4MagicMaskImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    1592415924{
    1592515925    long long       deleted = 0;
    1592615926
    1592715927    for (long long i = 0; i < objects->n; i++) {
    15928         p4PMagicMaskImfileRow *object = objects->data[i];
    15929         psMetadata *where = p4PMagicMaskImfileMetadataFromObject(object);
    15930         long long count = psDBDeleteRows(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, where, limit);
     15928        p4MagicMaskImfileRow *object = objects->data[i];
     15929        psMetadata *where = p4MagicMaskImfileMetadataFromObject(object);
     15930        long long count = psDBDeleteRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, where, limit);
    1593115931        psFree(where)
    1593215932        if (count < 0) {
    15933             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PMagicMaskImfile");
     15933            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4MagicMaskImfile");
    1593415934            return count;
    1593515935        }
    … …  
    1594015940    return deleted;
    1594115941}
    15942 bool p4PMagicMaskImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
     15942bool p4MagicMaskImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
    1594315943{
    1594415944    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    1594615946    psMetadata *output = psMetadataAlloc();
    1594715947    for (long i = 0; i < psArrayLength(objects); i++) {
    15948         psMetadata *md = p4PMagicMaskImfileMetadataFromObject(objects->data[i]);
     15948        psMetadata *md = p4MagicMaskImfileMetadataFromObject(objects->data[i]);
    1594915949        if (!psMetadataAddMetadata(
    1595015950            output,
    1595115951            PS_LIST_TAIL,
    15952             P4PMAGICMASKIMFILE_TABLE_NAME,
     15952            P4MAGICMASKIMFILE_TABLE_NAME,
    1595315953            PS_META_DUPLICATE_OK,
    1595415954            NULL,
    … …  
    1597115971    return true;
    1597215972}
    15973 bool p4PMagicMaskImfilePrintObject(FILE *stream, p4PMagicMaskImfileRow *object, bool mdcf)
     15973bool p4MagicMaskImfilePrintObject(FILE *stream, p4MagicMaskImfileRow *object, bool mdcf)
    1597415974{
    1597515975    PS_ASSERT_PTR_NON_NULL(object, false);
    1597615976
    15977     psMetadata *md = p4PMagicMaskImfileMetadataFromObject(object);
     15977    psMetadata *md = p4MagicMaskImfileMetadataFromObject(object);
    1597815978
    1597915979    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {

  • trunk/ippdb/src/ippdb.h

    r10748 r10753  
    76527652    bool            mdcf                ///< format as mdconfig or simple
    76537653);
    7654 /** p4PStackedImfileRow data structure
    7655  *
    7656  * Structure for representing a single row of p4PStackedImfile table data.
     7654/** p4StackedImfileRow data structure
     7655 *
     7656 * Structure for representing a single row of p4StackedImfile table data.
    76577657 */
    76587658
    … …  
    76637663    char            *b1_uri;
    76647664    char            *b2_uri;
    7665 } p4PStackedImfileRow;
    7666 
    7667 /** Creates a new p4PStackedImfileRow object
    7668  *
    7669  *  @return A new p4PStackedImfileRow object or NULL on failure.
    7670  */
    7671 
    7672 p4PStackedImfileRow *p4PStackedImfileRowAlloc(
     7665} p4StackedImfileRow;
     7666
     7667/** Creates a new p4StackedImfileRow object
     7668 *
     7669 *  @return A new p4StackedImfileRow object or NULL on failure.
     7670 */
     7671
     7672p4StackedImfileRow *p4StackedImfileRowAlloc(
    76737673    psS32           p4_id,
    76747674    const char      *class_id,
    … …  
    76787678);
    76797679
    7680 /** Creates a new p4PStackedImfile table
    7681  *
    7682  * @return true on success
    7683  */
    7684 
    7685 bool p4PStackedImfileCreateTable(
     7680/** Creates a new p4StackedImfile table
     7681 *
     7682 * @return true on success
     7683 */
     7684
     7685bool p4StackedImfileCreateTable(
    76867686    psDB            *dbh                ///< Database handle
    76877687);
    76887688
    7689 /** Deletes a p4PStackedImfile table
    7690  *
    7691  * @return true on success
    7692  */
    7693 
    7694 bool p4PStackedImfileDropTable(
     7689/** Deletes a p4StackedImfile table
     7690 *
     7691 * @return true on success
     7692 */
     7693
     7694bool p4StackedImfileDropTable(
    76957695    psDB            *dbh                ///< Database handle
    76967696);
    … …  
    77037703 */
    77047704
    7705 bool p4PStackedImfileInsert(
     7705bool p4StackedImfileInsert(
    77067706    psDB            *dbh,               ///< Database handle
    77077707    psS32           p4_id,
    … …  
    77177717 */
    77187718
    7719 long long p4PStackedImfileDelete(
     7719long long p4StackedImfileDelete(
    77207720    psDB            *dbh,               ///< Database handle
    77217721    const psMetadata *where,            ///< Row match criteria
    … …  
    77237723);
    77247724
    7725 /** Insert a single p4PStackedImfileRow object into a table
     7725/** Insert a single p4StackedImfileRow object into a table
    77267726 *
    77277727 * This function constructs and inserts a single row based on it's parameters.
    … …  
    77307730 */
    77317731
    7732 bool p4PStackedImfileInsertObject(
    7733     psDB            *dbh,               ///< Database handle
    7734     p4PStackedImfileRow *object             ///< p4PStackedImfileRow object
    7735 );
    7736 
    7737 /** Insert an array of p4PStackedImfileRow object into a table
     7732bool p4StackedImfileInsertObject(
     7733    psDB            *dbh,               ///< Database handle
     7734    p4StackedImfileRow *object             ///< p4StackedImfileRow object
     7735);
     7736
     7737/** Insert an array of p4StackedImfileRow object into a table
    77387738 *
    77397739 * This function constructs and inserts multiple rows based on it's parameters.
    … …  
    77427742 */
    77437743
    7744 bool p4PStackedImfileInsertObjects(
    7745     psDB            *dbh,               ///< Database handle
    7746     psArray         *objects            ///< array of p4PStackedImfileRow objects
    7747 );
    7748 
    7749 /** Insert data from a binary FITS table p4PStackedImfileRow into the database
     7744bool p4StackedImfileInsertObjects(
     7745    psDB            *dbh,               ///< Database handle
     7746    psArray         *objects            ///< array of p4StackedImfileRow objects
     7747);
     7748
     7749/** Insert data from a binary FITS table p4StackedImfileRow into the database
    77507750 *
    77517751 * This function expects a psFits object with a FITS table as the first
    … …  
    77577757 */
    77587758
    7759 bool p4PStackedImfileInsertFits(
     7759bool p4StackedImfileInsertFits(
    77607760    psDB            *dbh,               ///< Database handle
    77617761    const psFits    *fits               ///< psFits object
    … …  
    77727772 */
    77737773
    7774 bool p4PStackedImfileSelectRowsFits(
     7774bool p4StackedImfileSelectRowsFits(
    77757775    psDB            *dbh,               ///< Database handle
    77767776    psFits          *fits,              ///< psFits object
    … …  
    77797779);
    77807780
    7781 /** Convert a p4PStackedImfileRow into an equivalent psMetadata
     7781/** Convert a p4StackedImfileRow into an equivalent psMetadata
    77827782 *
    77837783 * @return A psMetadata pointer or NULL on error
    77847784 */
    77857785
    7786 psMetadata *p4PStackedImfileMetadataFromObject(
    7787     const p4PStackedImfileRow *object             ///< fooRow to convert into a psMetadata
     7786psMetadata *p4StackedImfileMetadataFromObject(
     7787    const p4StackedImfileRow *object             ///< fooRow to convert into a psMetadata
    77887788);
    77897789
    77907790/** Convert a psMetadata into an equivalent fooRow
    77917791 *
    7792  * @return A p4PStackedImfileRow pointer or NULL on error
    7793  */
    7794 
    7795 p4PStackedImfileRow *p4PStackedImfileObjectFromMetadata(
     7792 * @return A p4StackedImfileRow pointer or NULL on error
     7793 */
     7794
     7795p4StackedImfileRow *p4StackedImfileObjectFromMetadata(
    77967796    psMetadata      *md                 ///< psMetadata to convert into a fooRow
    77977797);
    7798 /** Selects up to limit rows from the database and returns as p4PStackedImfileRow objects in a psArray
     7798/** Selects up to limit rows from the database and returns as p4StackedImfileRow objects in a psArray
    77997799 *
    78007800 *  See psDBSelectRows() for documentation on the format of where.
    … …  
    78037803 */
    78047804
    7805 psArray *p4PStackedImfileSelectRowObjects(
     7805psArray *p4StackedImfileSelectRowObjects(
    78067806    psDB            *dbh,               ///< Database handle
    78077807    const psMetadata *where,            ///< Row match criteria
    78087808    unsigned long long limit            ///< Maximum number of elements to return
    78097809);
    7810 /** Deletes a row from the database coresponding to an p4PStackedImfile
     7810/** Deletes a row from the database coresponding to an p4StackedImfile
    78117811 *
    78127812 *  Note that a 'where' search psMetadata is constructed from each object and
    … …  
    78167816 */
    78177817
    7818 bool p4PStackedImfileDeleteObject(
    7819     psDB            *dbh,               ///< Database handle
    7820     const p4PStackedImfileRow *object    ///< Object to delete
     7818bool p4StackedImfileDeleteObject(
     7819    psDB            *dbh,               ///< Database handle
     7820    const p4StackedImfileRow *object    ///< Object to delete
    78217821);
    78227822/** Deletes up to limit rows from the database and returns the number of rows actually deleted.
    … …  
    78287828 */
    78297829
    7830 long long p4PStackedImfileDeleteRowObjects(
     7830long long p4StackedImfileDeleteRowObjects(
    78317831    psDB            *dbh,               ///< Database handle
    78327832    const psArray   *objects,           ///< Array of objects to delete
    78337833    unsigned long long limit            ///< Maximum number of elements to delete
    78347834);
    7835 /** Formats and prints an array of p4PStackedImfileRow objects
     7835/** Formats and prints an array of p4StackedImfileRow objects
    78367836 *
    78377837 * When mdcf is set the formated output is in psMetadataConfig
    … …  
    78417841 */
    78427842
    7843 bool p4PStackedImfilePrintObjects(
     7843bool p4StackedImfilePrintObjects(
    78447844    FILE            *stream,            ///< a stream
    7845     psArray         *objects,           ///< An array of p4PStackedImfileRow objects
     7845    psArray         *objects,           ///< An array of p4StackedImfileRow objects
    78467846    bool            mdcf                ///< format as mdconfig or simple
    78477847);
    7848 /** Formats and prints an p4PStackedImfileRow object
     7848/** Formats and prints an p4StackedImfileRow object
    78497849 *
    78507850 * When mdcf is set the formated output is in psMetadataConfig
    … …  
    78547854 */
    78557855
    7856 bool p4PStackedImfilePrintObject(
     7856bool p4StackedImfilePrintObject(
    78577857    FILE            *stream,            ///< a stream
    7858     p4PStackedImfileRow *object,    ///< an p4PStackedImfileRow object
     7858    p4StackedImfileRow *object,    ///< an p4StackedImfileRow object
    78597859    bool            mdcf                ///< format as mdconfig or simple
    78607860);
    7861 /** p4PDiffImfileRow data structure
    7862  *
    7863  * Structure for representing a single row of p4PDiffImfile table data.
     7861/** p4DiffImfileRow data structure
     7862 *
     7863 * Structure for representing a single row of p4DiffImfile table data.
    78647864 */
    78657865
    … …  
    78727872    char            *b1_uri;
    78737873    char            *b2_uri;
    7874 } p4PDiffImfileRow;
    7875 
    7876 /** Creates a new p4PDiffImfileRow object
    7877  *
    7878  *  @return A new p4PDiffImfileRow object or NULL on failure.
    7879  */
    7880 
    7881 p4PDiffImfileRow *p4PDiffImfileRowAlloc(
     7874} p4DiffImfileRow;
     7875
     7876/** Creates a new p4DiffImfileRow object
     7877 *
     7878 *  @return A new p4DiffImfileRow object or NULL on failure.
     7879 */
     7880
     7881p4DiffImfileRow *p4DiffImfileRowAlloc(
    78827882    psS32           p4_id,
    78837883    const char      *exp_tag,
    … …  
    78897889);
    78907890
    7891 /** Creates a new p4PDiffImfile table
    7892  *
    7893  * @return true on success
    7894  */
    7895 
    7896 bool p4PDiffImfileCreateTable(
     7891/** Creates a new p4DiffImfile table
     7892 *
     7893 * @return true on success
     7894 */
     7895
     7896bool p4DiffImfileCreateTable(
    78977897    psDB            *dbh                ///< Database handle
    78987898);
    78997899
    7900 /** Deletes a p4PDiffImfile table
    7901  *
    7902  * @return true on success
    7903  */
    7904 
    7905 bool p4PDiffImfileDropTable(
     7900/** Deletes a p4DiffImfile table
     7901 *
     7902 * @return true on success
     7903 */
     7904
     7905bool p4DiffImfileDropTable(
    79067906    psDB            *dbh                ///< Database handle
    79077907);
    … …  
    79147914 */
    79157915
    7916 bool p4PDiffImfileInsert(
     7916bool p4DiffImfileInsert(
    79177917    psDB            *dbh,               ///< Database handle
    79187918    psS32           p4_id,
    … …  
    79307930 */
    79317931
    7932 long long p4PDiffImfileDelete(
     7932long long p4DiffImfileDelete(
    79337933    psDB            *dbh,               ///< Database handle
    79347934    const psMetadata *where,            ///< Row match criteria
    … …  
    79367936);
    79377937
    7938 /** Insert a single p4PDiffImfileRow object into a table
     7938/** Insert a single p4DiffImfileRow object into a table
    79397939 *
    79407940 * This function constructs and inserts a single row based on it's parameters.
    … …  
    79437943 */
    79447944
    7945 bool p4PDiffImfileInsertObject(
    7946     psDB            *dbh,               ///< Database handle
    7947     p4PDiffImfileRow *object             ///< p4PDiffImfileRow object
    7948 );
    7949 
    7950 /** Insert an array of p4PDiffImfileRow object into a table
     7945bool p4DiffImfileInsertObject(
     7946    psDB            *dbh,               ///< Database handle
     7947    p4DiffImfileRow *object             ///< p4DiffImfileRow object
     7948);
     7949
     7950/** Insert an array of p4DiffImfileRow object into a table
    79517951 *
    79527952 * This function constructs and inserts multiple rows based on it's parameters.
    … …  
    79557955 */
    79567956
    7957 bool p4PDiffImfileInsertObjects(
    7958     psDB            *dbh,               ///< Database handle
    7959     psArray         *objects            ///< array of p4PDiffImfileRow objects
    7960 );
    7961 
    7962 /** Insert data from a binary FITS table p4PDiffImfileRow into the database
     7957bool p4DiffImfileInsertObjects(
     7958    psDB            *dbh,               ///< Database handle
     7959    psArray         *objects            ///< array of p4DiffImfileRow objects
     7960);
     7961
     7962/** Insert data from a binary FITS table p4DiffImfileRow into the database
    79637963 *
    79647964 * This function expects a psFits object with a FITS table as the first
    … …  
    79707970 */
    79717971
    7972 bool p4PDiffImfileInsertFits(
     7972bool p4DiffImfileInsertFits(
    79737973    psDB            *dbh,               ///< Database handle
    79747974    const psFits    *fits               ///< psFits object
    … …  
    79857985 */
    79867986
    7987 bool p4PDiffImfileSelectRowsFits(
     7987bool p4DiffImfileSelectRowsFits(
    79887988    psDB            *dbh,               ///< Database handle
    79897989    psFits          *fits,              ///< psFits object
    … …  
    79927992);
    79937993
    7994 /** Convert a p4PDiffImfileRow into an equivalent psMetadata
     7994/** Convert a p4DiffImfileRow into an equivalent psMetadata
    79957995 *
    79967996 * @return A psMetadata pointer or NULL on error
    79977997 */
    79987998
    7999 psMetadata *p4PDiffImfileMetadataFromObject(
    8000     const p4PDiffImfileRow *object             ///< fooRow to convert into a psMetadata
     7999psMetadata *p4DiffImfileMetadataFromObject(
     8000    const p4DiffImfileRow *object             ///< fooRow to convert into a psMetadata
    80018001);
    80028002
    80038003/** Convert a psMetadata into an equivalent fooRow
    80048004 *
    8005  * @return A p4PDiffImfileRow pointer or NULL on error
    8006  */
    8007 
    8008 p4PDiffImfileRow *p4PDiffImfileObjectFromMetadata(
     8005 * @return A p4DiffImfileRow pointer or NULL on error
     8006 */
     8007
     8008p4DiffImfileRow *p4DiffImfileObjectFromMetadata(
    80098009    psMetadata      *md                 ///< psMetadata to convert into a fooRow
    80108010);
    8011 /** Selects up to limit rows from the database and returns as p4PDiffImfileRow objects in a psArray
     8011/** Selects up to limit rows from the database and returns as p4DiffImfileRow objects in a psArray
    80128012 *
    80138013 *  See psDBSelectRows() for documentation on the format of where.
    … …  
    80168016 */
    80178017
    8018 psArray *p4PDiffImfileSelectRowObjects(
     8018psArray *p4DiffImfileSelectRowObjects(
    80198019    psDB            *dbh,               ///< Database handle
    80208020    const psMetadata *where,            ///< Row match criteria
    80218021    unsigned long long limit            ///< Maximum number of elements to return
    80228022);
    8023 /** Deletes a row from the database coresponding to an p4PDiffImfile
     8023/** Deletes a row from the database coresponding to an p4DiffImfile
    80248024 *
    80258025 *  Note that a 'where' search psMetadata is constructed from each object and
    … …  
    80298029 */
    80308030
    8031 bool p4PDiffImfileDeleteObject(
    8032     psDB            *dbh,               ///< Database handle
    8033     const p4PDiffImfileRow *object    ///< Object to delete
     8031bool p4DiffImfileDeleteObject(
     8032    psDB            *dbh,               ///< Database handle
     8033    const p4DiffImfileRow *object    ///< Object to delete
    80348034);
    80358035/** Deletes up to limit rows from the database and returns the number of rows actually deleted.
    … …  
    80418041 */
    80428042
    8043 long long p4PDiffImfileDeleteRowObjects(
     8043long long p4DiffImfileDeleteRowObjects(
    80448044    psDB            *dbh,               ///< Database handle
    80458045    const psArray   *objects,           ///< Array of objects to delete
    80468046    unsigned long long limit            ///< Maximum number of elements to delete
    80478047);
    8048 /** Formats and prints an array of p4PDiffImfileRow objects
     8048/** Formats and prints an array of p4DiffImfileRow objects
    80498049 *
    80508050 * When mdcf is set the formated output is in psMetadataConfig
    … …  
    80548054 */
    80558055
    8056 bool p4PDiffImfilePrintObjects(
     8056bool p4DiffImfilePrintObjects(
    80578057    FILE            *stream,            ///< a stream
    8058     psArray         *objects,           ///< An array of p4PDiffImfileRow objects
     8058    psArray         *objects,           ///< An array of p4DiffImfileRow objects
    80598059    bool            mdcf                ///< format as mdconfig or simple
    80608060);
    8061 /** Formats and prints an p4PDiffImfileRow object
     8061/** Formats and prints an p4DiffImfileRow object
    80628062 *
    80638063 * When mdcf is set the formated output is in psMetadataConfig
    … …  
    80678067 */
    80688068
    8069 bool p4PDiffImfilePrintObject(
     8069bool p4DiffImfilePrintObject(
    80708070    FILE            *stream,            ///< a stream
    8071     p4PDiffImfileRow *object,    ///< an p4PDiffImfileRow object
     8071    p4DiffImfileRow *object,    ///< an p4DiffImfileRow object
    80728072    bool            mdcf                ///< format as mdconfig or simple
    80738073);
    8074 /** p4PMagicMaskImfileRow data structure
    8075  *
    8076  * Structure for representing a single row of p4PMagicMaskImfile table data.
     8074/** p4MagicMaskImfileRow data structure
     8075 *
     8076 * Structure for representing a single row of p4MagicMaskImfile table data.
    80778077 */
    80788078
    … …  
    80838083    char            *class_id;
    80848084    char            *uri;
    8085 } p4PMagicMaskImfileRow;
    8086 
    8087 /** Creates a new p4PMagicMaskImfileRow object
    8088  *
    8089  *  @return A new p4PMagicMaskImfileRow object or NULL on failure.
    8090  */
    8091 
    8092 p4PMagicMaskImfileRow *p4PMagicMaskImfileRowAlloc(
     8085} p4MagicMaskImfileRow;
     8086
     8087/** Creates a new p4MagicMaskImfileRow object
     8088 *
     8089 *  @return A new p4MagicMaskImfileRow object or NULL on failure.
     8090 */
     8091
     8092p4MagicMaskImfileRow *p4MagicMaskImfileRowAlloc(
    80938093    psS32           p4_id,
    80948094    const char      *exp_tag,
    … …  
    80988098);
    80998099
    8100 /** Creates a new p4PMagicMaskImfile table
    8101  *
    8102  * @return true on success
    8103  */
    8104 
    8105 bool p4PMagicMaskImfileCreateTable(
     8100/** Creates a new p4MagicMaskImfile table
     8101 *
     8102 * @return true on success
     8103 */
     8104
     8105bool p4MagicMaskImfileCreateTable(
    81068106    psDB            *dbh                ///< Database handle
    81078107);
    81088108
    8109 /** Deletes a p4PMagicMaskImfile table
    8110  *
    8111  * @return true on success
    8112  */
    8113 
    8114 bool p4PMagicMaskImfileDropTable(
     8109/** Deletes a p4MagicMaskImfile table
     8110 *
     8111 * @return true on success
     8112 */
     8113
     8114bool p4MagicMaskImfileDropTable(
    81158115    psDB            *dbh                ///< Database handle
    81168116);
    … …  
    81238123 */
    81248124
    8125 bool p4PMagicMaskImfileInsert(
     8125bool p4MagicMaskImfileInsert(
    81268126    psDB            *dbh,               ///< Database handle
    81278127    psS32           p4_id,
    … …  
    81378137 */
    81388138
    8139 long long p4PMagicMaskImfileDelete(
     8139long long p4MagicMaskImfileDelete(
    81408140    psDB            *dbh,               ///< Database handle
    81418141    const psMetadata *where,            ///< Row match criteria
    … …  
    81438143);
    81448144
    8145 /** Insert a single p4PMagicMaskImfileRow object into a table
     8145/** Insert a single p4MagicMaskImfileRow object into a table
    81468146 *
    81478147 * This function constructs and inserts a single row based on it's parameters.
    … …  
    81508150 */
    81518151
    8152 bool p4PMagicMaskImfileInsertObject(
    8153     psDB            *dbh,               ///< Database handle
    8154     p4PMagicMaskImfileRow *object             ///< p4PMagicMaskImfileRow object
    8155 );
    8156 
    8157 /** Insert an array of p4PMagicMaskImfileRow object into a table
     8152bool p4MagicMaskImfileInsertObject(
     8153    psDB            *dbh,               ///< Database handle
     8154    p4MagicMaskImfileRow *object             ///< p4MagicMaskImfileRow object
     8155);
     8156
     8157/** Insert an array of p4MagicMaskImfileRow object into a table
    81588158 *
    81598159 * This function constructs and inserts multiple rows based on it's parameters.
    … …  
    81628162 */
    81638163
    8164 bool p4PMagicMaskImfileInsertObjects(
    8165     psDB            *dbh,               ///< Database handle
    8166     psArray         *objects            ///< array of p4PMagicMaskImfileRow objects
    8167 );
    8168 
    8169 /** Insert data from a binary FITS table p4PMagicMaskImfileRow into the database
     8164bool p4MagicMaskImfileInsertObjects(
     8165    psDB            *dbh,               ///< Database handle
     8166    psArray         *objects            ///< array of p4MagicMaskImfileRow objects
     8167);
     8168
     8169/** Insert data from a binary FITS table p4MagicMaskImfileRow into the database
    81708170 *
    81718171 * This function expects a psFits object with a FITS table as the first
    … …  
    81778177 */
    81788178
    8179 bool p4PMagicMaskImfileInsertFits(
     8179bool p4MagicMaskImfileInsertFits(
    81808180    psDB            *dbh,               ///< Database handle
    81818181    const psFits    *fits               ///< psFits object
    … …  
    81928192 */
    81938193
    8194 bool p4PMagicMaskImfileSelectRowsFits(
     8194bool p4MagicMaskImfileSelectRowsFits(
    81958195    psDB            *dbh,               ///< Database handle
    81968196    psFits          *fits,              ///< psFits object
    … …  
    81998199);
    82008200
    8201 /** Convert a p4PMagicMaskImfileRow into an equivalent psMetadata
     8201/** Convert a p4MagicMaskImfileRow into an equivalent psMetadata
    82028202 *
    82038203 * @return A psMetadata pointer or NULL on error
    82048204 */
    82058205
    8206 psMetadata *p4PMagicMaskImfileMetadataFromObject(
    8207     const p4PMagicMaskImfileRow *object             ///< fooRow to convert into a psMetadata
     8206psMetadata *p4MagicMaskImfileMetadataFromObject(
     8207    const p4MagicMaskImfileRow *object             ///< fooRow to convert into a psMetadata
    82088208);
    82098209
    82108210/** Convert a psMetadata into an equivalent fooRow
    82118211 *
    8212  * @return A p4PMagicMaskImfileRow pointer or NULL on error
    8213  */
    8214 
    8215 p4PMagicMaskImfileRow *p4PMagicMaskImfileObjectFromMetadata(
     8212 * @return A p4MagicMaskImfileRow pointer or NULL on error
     8213 */
     8214
     8215p4MagicMaskImfileRow *p4MagicMaskImfileObjectFromMetadata(
    82168216    psMetadata      *md                 ///< psMetadata to convert into a fooRow
    82178217);
    8218 /** Selects up to limit rows from the database and returns as p4PMagicMaskImfileRow objects in a psArray
     8218/** Selects up to limit rows from the database and returns as p4MagicMaskImfileRow objects in a psArray
    82198219 *
    82208220 *  See psDBSelectRows() for documentation on the format of where.
    … …  
    82238223 */
    82248224
    8225 psArray *p4PMagicMaskImfileSelectRowObjects(
     8225psArray *p4MagicMaskImfileSelectRowObjects(
    82268226    psDB            *dbh,               ///< Database handle
    82278227    const psMetadata *where,            ///< Row match criteria
    82288228    unsigned long long limit            ///< Maximum number of elements to return
    82298229);
    8230 /** Deletes a row from the database coresponding to an p4PMagicMaskImfile
     8230/** Deletes a row from the database coresponding to an p4MagicMaskImfile
    82318231 *
    82328232 *  Note that a 'where' search psMetadata is constructed from each object and
    … …  
    82368236 */
    82378237
    8238 bool p4PMagicMaskImfileDeleteObject(
    8239     psDB            *dbh,               ///< Database handle
    8240     const p4PMagicMaskImfileRow *object    ///< Object to delete
     8238bool p4MagicMaskImfileDeleteObject(
     8239    psDB            *dbh,               ///< Database handle
     8240    const p4MagicMaskImfileRow *object    ///< Object to delete
    82418241);
    82428242/** Deletes up to limit rows from the database and returns the number of rows actually deleted.
    … …  
    82488248 */
    82498249
    8250 long long p4PMagicMaskImfileDeleteRowObjects(
     8250long long p4MagicMaskImfileDeleteRowObjects(
    82518251    psDB            *dbh,               ///< Database handle
    82528252    const psArray   *objects,           ///< Array of objects to delete
    82538253    unsigned long long limit            ///< Maximum number of elements to delete
    82548254);
    8255 /** Formats and prints an array of p4PMagicMaskImfileRow objects
     8255/** Formats and prints an array of p4MagicMaskImfileRow objects
    82568256 *
    82578257 * When mdcf is set the formated output is in psMetadataConfig
    … …  
    82618261 */
    82628262
    8263 bool p4PMagicMaskImfilePrintObjects(
     8263bool p4MagicMaskImfilePrintObjects(
    82648264    FILE            *stream,            ///< a stream
    8265     psArray         *objects,           ///< An array of p4PMagicMaskImfileRow objects
     8265    psArray         *objects,           ///< An array of p4MagicMaskImfileRow objects
    82668266    bool            mdcf                ///< format as mdconfig or simple
    82678267);
    8268 /** Formats and prints an p4PMagicMaskImfileRow object
     8268/** Formats and prints an p4MagicMaskImfileRow object
    82698269 *
    82708270 * When mdcf is set the formated output is in psMetadataConfig
    … …  
    82748274 */
    82758275
    8276 bool p4PMagicMaskImfilePrintObject(
     8276bool p4MagicMaskImfilePrintObject(
    82778277    FILE            *stream,            ///< a stream
    8278     p4PMagicMaskImfileRow *object,    ///< an p4PMagicMaskImfileRow object
     8278    p4MagicMaskImfileRow *object,    ///< an p4MagicMaskImfileRow object
    82798279    bool            mdcf                ///< format as mdconfig or simple
    82808280);
    … …  
    82868286#endif
    82878287
    8288 #endif // P4PMAGICMASKIMFILE_DB_H
     8288#endif // P4MAGICMASKIMFILE_DB_H

  • trunk/ippdb/tests/alloc.c

    r10748 r10753  
    15311531
    15321532    {
    1533         p4PStackedImfileRow *object;
    1534 
    1535         object = p4PStackedImfileRowAlloc(-32, "a string", "a string", "a string", "a string"    );
     1533        p4StackedImfileRow *object;
     1534
     1535        object = p4StackedImfileRowAlloc(-32, "a string", "a string", "a string", "a string"    );
    15361536
    15371537        if (!object) {
    … …  
    15641564
    15651565    {
    1566         p4PDiffImfileRow *object;
    1567 
    1568         object = p4PDiffImfileRowAlloc(-32, "a string", -32, "a string", "a string", "a string", "a string"    );
     1566        p4DiffImfileRow *object;
     1567
     1568        object = p4DiffImfileRowAlloc(-32, "a string", -32, "a string", "a string", "a string", "a string"    );
    15691569
    15701570        if (!object) {
    … …  
    16051605
    16061606    {
    1607         p4PMagicMaskImfileRow *object;
    1608 
    1609         object = p4PMagicMaskImfileRowAlloc(-32, "a string", -32, "a string", "a string"    );
     1607        p4MagicMaskImfileRow *object;
     1608
     1609        object = p4MagicMaskImfileRowAlloc(-32, "a string", -32, "a string", "a string"    );
    16101610
    16111611        if (!object) {

  • trunk/ippdb/tests/createtable.c

    r10748 r10753  
    538538        }
    539539
    540         if(!p4PStackedImfileCreateTable(dbh)) {
    541             exit(EXIT_FAILURE);
    542         }
    543 
    544         psDBCleanup(dbh);
    545     }
    546 
    547     {
    548         psDB            *dbh;
    549 
    550         dbh = psDBInit("localhost", "test", NULL, "test");
    551         if (!dbh) {
    552             exit(EXIT_FAILURE);
    553         }
    554 
    555         if(!p4PDiffImfileCreateTable(dbh)) {
    556             exit(EXIT_FAILURE);
    557         }
    558 
    559         psDBCleanup(dbh);
    560     }
    561 
    562     {
    563         psDB            *dbh;
    564 
    565         dbh = psDBInit("localhost", "test", NULL, "test");
    566         if (!dbh) {
    567             exit(EXIT_FAILURE);
    568         }
    569 
    570         if(!p4PMagicMaskImfileCreateTable(dbh)) {
     540        if(!p4StackedImfileCreateTable(dbh)) {
     541            exit(EXIT_FAILURE);
     542        }
     543
     544        psDBCleanup(dbh);
     545    }
     546
     547    {
     548        psDB            *dbh;
     549
     550        dbh = psDBInit("localhost", "test", NULL, "test");
     551        if (!dbh) {
     552            exit(EXIT_FAILURE);
     553        }
     554
     555        if(!p4DiffImfileCreateTable(dbh)) {
     556            exit(EXIT_FAILURE);
     557        }
     558
     559        psDBCleanup(dbh);
     560    }
     561
     562    {
     563        psDB            *dbh;
     564
     565        dbh = psDBInit("localhost", "test", NULL, "test");
     566        if (!dbh) {
     567            exit(EXIT_FAILURE);
     568        }
     569
     570        if(!p4MagicMaskImfileCreateTable(dbh)) {
    571571            exit(EXIT_FAILURE);
    572572        }

  • trunk/ippdb/tests/dbcleanup.c

    r10748 r10753  
    4646    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4InputImfile");
    4747    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4WarpedImfile");
    48     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4PStackedImfile");
    49     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4PDiffImfile");
    50     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4PMagicMaskImfile");
     48    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4StackedImfile");
     49    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4DiffImfile");
     50    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4MagicMaskImfile");
    5151
    5252    psDBCleanup(dbh);

  • trunk/ippdb/tests/dbsetup.c

    r10748 r10753  
    118118    p4WarpedImfileCreateTable(dbh);
    119119
    120     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4PStackedImfile");
    121     p4PStackedImfileCreateTable(dbh);
     120    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4StackedImfile");
     121    p4StackedImfileCreateTable(dbh);
    122122
    123     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4PDiffImfile");
    124     p4PDiffImfileCreateTable(dbh);
     123    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4DiffImfile");
     124    p4DiffImfileCreateTable(dbh);
    125125
    126     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4PMagicMaskImfile");
    127     p4PMagicMaskImfileCreateTable(dbh);
     126    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4MagicMaskImfile");
     127    p4MagicMaskImfileCreateTable(dbh);
    128128
    129129    psDBCleanup(dbh);

  • trunk/ippdb/tests/droptable.c

    r10748 r10753  
    538538        }
    539539
    540         if (!p4PStackedImfileDropTable(dbh)) {
    541             exit(EXIT_FAILURE);
    542         }
    543 
    544         psDBCleanup(dbh);
    545     }
    546 
    547     {
    548         psDB            *dbh;
    549 
    550         dbh = psDBInit("localhost", "test", NULL, "test");
    551         if (!dbh) {
    552             exit(EXIT_FAILURE);
    553         }
    554 
    555         if (!p4PDiffImfileDropTable(dbh)) {
    556             exit(EXIT_FAILURE);
    557         }
    558 
    559         psDBCleanup(dbh);
    560     }
    561 
    562     {
    563         psDB            *dbh;
    564 
    565         dbh = psDBInit("localhost", "test", NULL, "test");
    566         if (!dbh) {
    567             exit(EXIT_FAILURE);
    568         }
    569 
    570         if (!p4PMagicMaskImfileDropTable(dbh)) {
     540        if (!p4StackedImfileDropTable(dbh)) {
     541            exit(EXIT_FAILURE);
     542        }
     543
     544        psDBCleanup(dbh);
     545    }
     546
     547    {
     548        psDB            *dbh;
     549
     550        dbh = psDBInit("localhost", "test", NULL, "test");
     551        if (!dbh) {
     552            exit(EXIT_FAILURE);
     553        }
     554
     555        if (!p4DiffImfileDropTable(dbh)) {
     556            exit(EXIT_FAILURE);
     557        }
     558
     559        psDBCleanup(dbh);
     560    }
     561
     562    {
     563        psDB            *dbh;
     564
     565        dbh = psDBInit("localhost", "test", NULL, "test");
     566        if (!dbh) {
     567            exit(EXIT_FAILURE);
     568        }
     569
     570        if (!p4MagicMaskImfileDropTable(dbh)) {
    571571            exit(EXIT_FAILURE);
    572572        }

  • trunk/ippdb/tests/insert.c

    r10748 r10753  
    538538        }
    539539
    540         if (!p4PStackedImfileInsert(dbh, -32, "a string", "a string", "a string", "a string")) {
    541             exit(EXIT_FAILURE);
    542         }
    543 
    544         psDBCleanup(dbh);
    545     }
    546 
    547     {
    548         psDB            *dbh;
    549 
    550         dbh = psDBInit("localhost", "test", NULL, "test");
    551         if (!dbh) {
    552             exit(EXIT_FAILURE);
    553         }
    554 
    555         if (!p4PDiffImfileInsert(dbh, -32, "a string", -32, "a string", "a string", "a string", "a string")) {
    556             exit(EXIT_FAILURE);
    557         }
    558 
    559         psDBCleanup(dbh);
    560     }
    561 
    562     {
    563         psDB            *dbh;
    564 
    565         dbh = psDBInit("localhost", "test", NULL, "test");
    566         if (!dbh) {
    567             exit(EXIT_FAILURE);
    568         }
    569 
    570         if (!p4PMagicMaskImfileInsert(dbh, -32, "a string", -32, "a string", "a string")) {
     540        if (!p4StackedImfileInsert(dbh, -32, "a string", "a string", "a string", "a string")) {
     541            exit(EXIT_FAILURE);
     542        }
     543
     544        psDBCleanup(dbh);
     545    }
     546
     547    {
     548        psDB            *dbh;
     549
     550        dbh = psDBInit("localhost", "test", NULL, "test");
     551        if (!dbh) {
     552            exit(EXIT_FAILURE);
     553        }
     554
     555        if (!p4DiffImfileInsert(dbh, -32, "a string", -32, "a string", "a string", "a string", "a string")) {
     556            exit(EXIT_FAILURE);
     557        }
     558
     559        psDBCleanup(dbh);
     560    }
     561
     562    {
     563        psDB            *dbh;
     564
     565        dbh = psDBInit("localhost", "test", NULL, "test");
     566        if (!dbh) {
     567            exit(EXIT_FAILURE);
     568        }
     569
     570        if (!p4MagicMaskImfileInsert(dbh, -32, "a string", -32, "a string", "a string")) {
    571571            exit(EXIT_FAILURE);
    572572        }

  • trunk/ippdb/tests/insertfits.c

    r10748 r10753  
    934934        }
    935935
    936         if (!p4PStackedImfileInsertFits(dbh, fits)) {
    937             exit(EXIT_FAILURE);
    938         }
    939 
    940         if (!psFitsClose(fits)) {
    941             exit(EXIT_FAILURE);
    942         }
    943 
    944         psDBCleanup(dbh);
    945     }
    946 
    947     {
    948         psDB            *dbh;
    949         psFits          *fits;
    950 
    951         dbh = psDBInit("localhost", "test", NULL, "test");
    952         if (!dbh) {
    953             exit(EXIT_FAILURE);
    954         }
    955 
    956         // open a temp
    957         fits = psFitsOpen(TMP_FILENAME, "r");
    958         if (!fits) {
    959             exit(EXIT_FAILURE);
    960         }
    961 
    962         if (!p4PDiffImfileInsertFits(dbh, fits)) {
    963             exit(EXIT_FAILURE);
    964         }
    965 
    966         if (!psFitsClose(fits)) {
    967             exit(EXIT_FAILURE);
    968         }
    969 
    970         psDBCleanup(dbh);
    971     }
    972 
    973     {
    974         psDB            *dbh;
    975         psFits          *fits;
    976 
    977         dbh = psDBInit("localhost", "test", NULL, "test");
    978         if (!dbh) {
    979             exit(EXIT_FAILURE);
    980         }
    981 
    982         // open a temp
    983         fits = psFitsOpen(TMP_FILENAME, "r");
    984         if (!fits) {
    985             exit(EXIT_FAILURE);
    986         }
    987 
    988         if (!p4PMagicMaskImfileInsertFits(dbh, fits)) {
     936        if (!p4StackedImfileInsertFits(dbh, fits)) {
     937            exit(EXIT_FAILURE);
     938        }
     939
     940        if (!psFitsClose(fits)) {
     941            exit(EXIT_FAILURE);
     942        }
     943
     944        psDBCleanup(dbh);
     945    }
     946
     947    {
     948        psDB            *dbh;
     949        psFits          *fits;
     950
     951        dbh = psDBInit("localhost", "test", NULL, "test");
     952        if (!dbh) {
     953            exit(EXIT_FAILURE);
     954        }
     955
     956        // open a temp
     957        fits = psFitsOpen(TMP_FILENAME, "r");
     958        if (!fits) {
     959            exit(EXIT_FAILURE);
     960        }
     961
     962        if (!p4DiffImfileInsertFits(dbh, fits)) {
     963            exit(EXIT_FAILURE);
     964        }
     965
     966        if (!psFitsClose(fits)) {
     967            exit(EXIT_FAILURE);
     968        }
     969
     970        psDBCleanup(dbh);
     971    }
     972
     973    {
     974        psDB            *dbh;
     975        psFits          *fits;
     976
     977        dbh = psDBInit("localhost", "test", NULL, "test");
     978        if (!dbh) {
     979            exit(EXIT_FAILURE);
     980        }
     981
     982        // open a temp
     983        fits = psFitsOpen(TMP_FILENAME, "r");
     984        if (!fits) {
     985            exit(EXIT_FAILURE);
     986        }
     987
     988        if (!p4MagicMaskImfileInsertFits(dbh, fits)) {
    989989            exit(EXIT_FAILURE);
    990990        }

  • trunk/ippdb/tests/insertobject.c

    r10748 r10753  
    777777    {
    778778        psDB            *dbh;
    779         p4PStackedImfileRow *object;
    780 
    781         dbh = psDBInit("localhost", "test", NULL, "test");
    782         if (!dbh) {
    783             exit(EXIT_FAILURE);
    784         }
    785 
    786         object = p4PStackedImfileRowAlloc(-32, "a string", "a string", "a string", "a string");
    787         if (!object) {
    788             exit(EXIT_FAILURE);
    789         }
    790 
    791         if (!p4PStackedImfileInsertObject(dbh, object)) {
    792             exit(EXIT_FAILURE);
    793         }
    794 
    795         psFree(object);
    796         psDBCleanup(dbh);
    797     }
    798 
    799     {
    800         psDB            *dbh;
    801         p4PDiffImfileRow *object;
    802 
    803         dbh = psDBInit("localhost", "test", NULL, "test");
    804         if (!dbh) {
    805             exit(EXIT_FAILURE);
    806         }
    807 
    808         object = p4PDiffImfileRowAlloc(-32, "a string", -32, "a string", "a string", "a string", "a string");
    809         if (!object) {
    810             exit(EXIT_FAILURE);
    811         }
    812 
    813         if (!p4PDiffImfileInsertObject(dbh, object)) {
    814             exit(EXIT_FAILURE);
    815         }
    816 
    817         psFree(object);
    818         psDBCleanup(dbh);
    819     }
    820 
    821     {
    822         psDB            *dbh;
    823         p4PMagicMaskImfileRow *object;
    824 
    825         dbh = psDBInit("localhost", "test", NULL, "test");
    826         if (!dbh) {
    827             exit(EXIT_FAILURE);
    828         }
    829 
    830         object = p4PMagicMaskImfileRowAlloc(-32, "a string", -32, "a string", "a string");
    831         if (!object) {
    832             exit(EXIT_FAILURE);
    833         }
    834 
    835         if (!p4PMagicMaskImfileInsertObject(dbh, object)) {
     779        p4StackedImfileRow *object;
     780
     781        dbh = psDBInit("localhost", "test", NULL, "test");
     782        if (!dbh) {
     783            exit(EXIT_FAILURE);
     784        }
     785
     786        object = p4StackedImfileRowAlloc(-32, "a string", "a string", "a string", "a string");
     787        if (!object) {
     788            exit(EXIT_FAILURE);
     789        }
     790
     791        if (!p4StackedImfileInsertObject(dbh, object)) {
     792            exit(EXIT_FAILURE);
     793        }
     794
     795        psFree(object);
     796        psDBCleanup(dbh);
     797    }
     798
     799    {
     800        psDB            *dbh;
     801        p4DiffImfileRow *object;
     802
     803        dbh = psDBInit("localhost", "test", NULL, "test");
     804        if (!dbh) {
     805            exit(EXIT_FAILURE);
     806        }
     807
     808        object = p4DiffImfileRowAlloc(-32, "a string", -32, "a string", "a string", "a string", "a string");
     809        if (!object) {
     810            exit(EXIT_FAILURE);
     811        }
     812
     813        if (!p4DiffImfileInsertObject(dbh, object)) {
     814            exit(EXIT_FAILURE);
     815        }
     816
     817        psFree(object);
     818        psDBCleanup(dbh);
     819    }
     820
     821    {
     822        psDB            *dbh;
     823        p4MagicMaskImfileRow *object;
     824
     825        dbh = psDBInit("localhost", "test", NULL, "test");
     826        if (!dbh) {
     827            exit(EXIT_FAILURE);
     828        }
     829
     830        object = p4MagicMaskImfileRowAlloc(-32, "a string", -32, "a string", "a string");
     831        if (!object) {
     832            exit(EXIT_FAILURE);
     833        }
     834
     835        if (!p4MagicMaskImfileInsertObject(dbh, object)) {
    836836            exit(EXIT_FAILURE);
    837837        }

  • trunk/ippdb/tests/metadatafromobject.c

    r10748 r10753  
    18121812    {
    18131813        psMetadata      *md;
    1814         p4PStackedImfileRow *object;
    1815         bool            status;
    1816 
    1817         object = p4PStackedImfileRowAlloc(-32, "a string", "a string", "a string", "a string");
    1818         if (!object) {
    1819             exit(EXIT_FAILURE);
    1820         }
    1821 
    1822         md = p4PStackedImfileMetadataFromObject(object);
     1814        p4StackedImfileRow *object;
     1815        bool            status;
     1816
     1817        object = p4StackedImfileRowAlloc(-32, "a string", "a string", "a string", "a string");
     1818        if (!object) {
     1819            exit(EXIT_FAILURE);
     1820        }
     1821
     1822        md = p4StackedImfileMetadataFromObject(object);
    18231823        if (!md) {
    18241824            exit(EXIT_FAILURE);
    … …  
    18531853    {
    18541854        psMetadata      *md;
    1855         p4PDiffImfileRow *object;
    1856         bool            status;
    1857 
    1858         object = p4PDiffImfileRowAlloc(-32, "a string", -32, "a string", "a string", "a string", "a string");
    1859         if (!object) {
    1860             exit(EXIT_FAILURE);
    1861         }
    1862 
    1863         md = p4PDiffImfileMetadataFromObject(object);
     1855        p4DiffImfileRow *object;
     1856        bool            status;
     1857
     1858        object = p4DiffImfileRowAlloc(-32, "a string", -32, "a string", "a string", "a string", "a string");
     1859        if (!object) {
     1860            exit(EXIT_FAILURE);
     1861        }
     1862
     1863        md = p4DiffImfileMetadataFromObject(object);
    18641864        if (!md) {
    18651865            exit(EXIT_FAILURE);
    … …  
    19021902    {
    19031903        psMetadata      *md;
    1904         p4PMagicMaskImfileRow *object;
    1905         bool            status;
    1906 
    1907         object = p4PMagicMaskImfileRowAlloc(-32, "a string", -32, "a string", "a string");
    1908         if (!object) {
    1909             exit(EXIT_FAILURE);
    1910         }
    1911 
    1912         md = p4PMagicMaskImfileMetadataFromObject(object);
     1904        p4MagicMaskImfileRow *object;
     1905        bool            status;
     1906
     1907        object = p4MagicMaskImfileRowAlloc(-32, "a string", -32, "a string", "a string");
     1908        if (!object) {
     1909            exit(EXIT_FAILURE);
     1910        }
     1911
     1912        md = p4MagicMaskImfileMetadataFromObject(object);
    19131913        if (!md) {
    19141914            exit(EXIT_FAILURE);

  • trunk/ippdb/tests/objectfrommetadata.c

    r10748 r10753  
    27742774    {
    27752775        psMetadata      *md;
    2776         p4PStackedImfileRow *object;
     2776        p4StackedImfileRow *object;
    27772777
    27782778        md = psMetadataAlloc();
    … …  
    27982798        }
    27992799
    2800         object = p4PStackedImfileObjectFromMetadata(md);
     2800        object = p4StackedImfileObjectFromMetadata(md);
    28012801        if (!object) {
    28022802            psFree(md);
    … …  
    28322832    {
    28332833        psMetadata      *md;
    2834         p4PDiffImfileRow *object;
     2834        p4DiffImfileRow *object;
    28352835
    28362836        md = psMetadataAlloc();
    … …  
    28642864        }
    28652865
    2866         object = p4PDiffImfileObjectFromMetadata(md);
     2866        object = p4DiffImfileObjectFromMetadata(md);
    28672867        if (!object) {
    28682868            psFree(md);
    … …  
    29062906    {
    29072907        psMetadata      *md;
    2908         p4PMagicMaskImfileRow *object;
     2908        p4MagicMaskImfileRow *object;
    29092909
    29102910        md = psMetadataAlloc();
    … …  
    29302930        }
    29312931
    2932         object = p4PMagicMaskImfileObjectFromMetadata(md);
     2932        object = p4MagicMaskImfileObjectFromMetadata(md);
    29332933        if (!object) {
    29342934            psFree(md);

  • trunk/ippdb/tests/selectrowsfits.c

    r10748 r10753  
    791791        }
    792792
    793         if (!p4PStackedImfileSelectRowsFits(dbh, fits, NULL, 1)) {
    794             exit(EXIT_FAILURE);
    795         }
    796 
    797         psFree(fits);
    798         psDBCleanup(dbh);
    799     }
    800 
    801     {
    802         psDB            *dbh;
    803         psFits          *fits;
    804 
    805         dbh = psDBInit("localhost", "test", NULL, "test");
    806         if (!dbh) {
    807             exit(EXIT_FAILURE);
    808         }
    809 
    810         fits = psFitsOpen(TMP_FILENAME, "w");
    811         if (!fits) {
    812             exit(EXIT_FAILURE);
    813         }
    814 
    815         if (!p4PDiffImfileSelectRowsFits(dbh, fits, NULL, 1)) {
    816             exit(EXIT_FAILURE);
    817         }
    818 
    819         psFree(fits);
    820         psDBCleanup(dbh);
    821     }
    822 
    823     {
    824         psDB            *dbh;
    825         psFits          *fits;
    826 
    827         dbh = psDBInit("localhost", "test", NULL, "test");
    828         if (!dbh) {
    829             exit(EXIT_FAILURE);
    830         }
    831 
    832         fits = psFitsOpen(TMP_FILENAME, "w");
    833         if (!fits) {
    834             exit(EXIT_FAILURE);
    835         }
    836 
    837         if (!p4PMagicMaskImfileSelectRowsFits(dbh, fits, NULL, 1)) {
     793        if (!p4StackedImfileSelectRowsFits(dbh, fits, NULL, 1)) {
     794            exit(EXIT_FAILURE);
     795        }
     796
     797        psFree(fits);
     798        psDBCleanup(dbh);
     799    }
     800
     801    {
     802        psDB            *dbh;
     803        psFits          *fits;
     804
     805        dbh = psDBInit("localhost", "test", NULL, "test");
     806        if (!dbh) {
     807            exit(EXIT_FAILURE);
     808        }
     809
     810        fits = psFitsOpen(TMP_FILENAME, "w");
     811        if (!fits) {
     812            exit(EXIT_FAILURE);
     813        }
     814
     815        if (!p4DiffImfileSelectRowsFits(dbh, fits, NULL, 1)) {
     816            exit(EXIT_FAILURE);
     817        }
     818
     819        psFree(fits);
     820        psDBCleanup(dbh);
     821    }
     822
     823    {
     824        psDB            *dbh;
     825        psFits          *fits;
     826
     827        dbh = psDBInit("localhost", "test", NULL, "test");
     828        if (!dbh) {
     829            exit(EXIT_FAILURE);
     830        }
     831
     832        fits = psFitsOpen(TMP_FILENAME, "w");
     833        if (!fits) {
     834            exit(EXIT_FAILURE);
     835        }
     836
     837        if (!p4MagicMaskImfileSelectRowsFits(dbh, fits, NULL, 1)) {
    838838            exit(EXIT_FAILURE);
    839839        }
Note: See TracChangeset for help on using the changeset viewer.