Index: /trunk/ippdb/Makefile.am =================================================================== --- /trunk/ippdb/Makefile.am (revision 10752) +++ /trunk/ippdb/Makefile.am (revision 10753) @@ -45,10 +45,10 @@ $(top_builddir)/docs/man/man3/p4InputImfileRow.3 \ $(top_builddir)/docs/man/man3/p4WarpedImfileRow.3 \ - $(top_builddir)/docs/man/man3/p4PStackedImfileRow.3 \ - $(top_builddir)/docs/man/man3/p4PDiffImfileRow.3 \ - $(top_builddir)/docs/man/man3/p4PMagicMaskImfileRow.3 + $(top_builddir)/docs/man/man3/p4StackedImfileRow.3 \ + $(top_builddir)/docs/man/man3/p4DiffImfileRow.3 \ + $(top_builddir)/docs/man/man3/p4MagicMaskImfileRow.3 -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: +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/p4StackedImfileRow.3 docs/man/man3/p4DiffImfileRow.3 docs/man/man3/p4MagicMaskImfileRow.3: $(DOXYGEN) Index: /trunk/ippdb/configure.ac =================================================================== --- /trunk/ippdb/configure.ac (revision 10752) +++ /trunk/ippdb/configure.ac (revision 10753) @@ -7,5 +7,5 @@ AC_PREREQ(2.59) -AC_INIT([ippdb], [0.0.67], [pan-starrs.ifa.hawaii.edu]) +AC_INIT([ippdb], [0.0.68], [pan-starrs.ifa.hawaii.edu]) AC_CONFIG_SRCDIR([ippdb.pc.in]) Index: /trunk/ippdb/src/ippdb.c =================================================================== --- /trunk/ippdb/src/ippdb.c (revision 10752) +++ /trunk/ippdb/src/ippdb.c (revision 10753) @@ -66,7 +66,7 @@ #define P4INPUTIMFILE_TABLE_NAME "p4InputImfile" #define P4WARPEDIMFILE_TABLE_NAME "p4WarpedImfile" -#define P4PSTACKEDIMFILE_TABLE_NAME "p4PStackedImfile" -#define P4PDIFFIMFILE_TABLE_NAME "p4PDiffImfile" -#define P4PMAGICMASKIMFILE_TABLE_NAME "p4PMagicMaskImfile" +#define P4STACKEDIMFILE_TABLE_NAME "p4StackedImfile" +#define P4DIFFIMFILE_TABLE_NAME "p4DiffImfile" +#define P4MAGICMASKIMFILE_TABLE_NAME "p4MagicMaskImfile" #define MAX_STRING_LENGTH 1024 @@ -14861,12 +14861,12 @@ return true; } -static void p4PStackedImfileRowFree(p4PStackedImfileRow *object); - -p4PStackedImfileRow *p4PStackedImfileRowAlloc(psS32 p4_id, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri) -{ - p4PStackedImfileRow *_object; - - _object = psAlloc(sizeof(p4PStackedImfileRow)); - psMemSetDeallocator(_object, (psFreeFunc)p4PStackedImfileRowFree); +static void p4StackedImfileRowFree(p4StackedImfileRow *object); + +p4StackedImfileRow *p4StackedImfileRowAlloc(psS32 p4_id, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri) +{ + p4StackedImfileRow *_object; + + _object = psAlloc(sizeof(p4StackedImfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)p4StackedImfileRowFree); _object->p4_id = p4_id; @@ -14879,5 +14879,5 @@ } -static void p4PStackedImfileRowFree(p4PStackedImfileRow *object) +static void p4StackedImfileRowFree(p4StackedImfileRow *object) { psFree(object->class_id); @@ -14887,5 +14887,5 @@ } -bool p4PStackedImfileCreateTable(psDB *dbh) +bool p4StackedImfileCreateTable(psDB *dbh) { psMetadata *md = psMetadataAlloc(); @@ -14916,5 +14916,5 @@ } - bool status = psDBCreateTable(dbh, P4PSTACKEDIMFILE_TABLE_NAME, md); + bool status = psDBCreateTable(dbh, P4STACKEDIMFILE_TABLE_NAME, md); psFree(md); @@ -14923,10 +14923,10 @@ } -bool p4PStackedImfileDropTable(psDB *dbh) -{ - return psDBDropTable(dbh, P4PSTACKEDIMFILE_TABLE_NAME); -} - -bool p4PStackedImfileInsert(psDB * dbh, psS32 p4_id, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri) +bool p4StackedImfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, P4STACKEDIMFILE_TABLE_NAME); +} + +bool p4StackedImfileInsert(psDB * dbh, psS32 p4_id, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri) { psMetadata *md = psMetadataAlloc(); @@ -14957,5 +14957,5 @@ } - bool status = psDBInsertOneRow(dbh, P4PSTACKEDIMFILE_TABLE_NAME, md); + bool status = psDBInsertOneRow(dbh, P4STACKEDIMFILE_TABLE_NAME, md); psFree(md); @@ -14963,11 +14963,11 @@ } -long long p4PStackedImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +long long p4StackedImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) { long long deleted = 0; - long long count = psDBDeleteRows(dbh, P4PSTACKEDIMFILE_TABLE_NAME, where, limit); + long long count = psDBDeleteRows(dbh, P4STACKEDIMFILE_TABLE_NAME, where, limit); if (count < 0) { - psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PStackedImfile"); + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4StackedImfile"); return count; @@ -14977,13 +14977,13 @@ return deleted; } -bool p4PStackedImfileInsertObject(psDB *dbh, p4PStackedImfileRow *object) -{ - return p4PStackedImfileInsert(dbh, object->p4_id, object->class_id, object->uri, object->b1_uri, object->b2_uri); -} - -bool p4PStackedImfileInsertObjects(psDB *dbh, psArray *objects) +bool p4StackedImfileInsertObject(psDB *dbh, p4StackedImfileRow *object) +{ + return p4StackedImfileInsert(dbh, object->p4_id, object->class_id, object->uri, object->b1_uri, object->b2_uri); +} + +bool p4StackedImfileInsertObjects(psDB *dbh, psArray *objects) { for (long i = 0; i < psArrayLength(objects); i++) { - if (!p4PStackedImfileInsertObject(dbh, objects->data[i])) { + if (!p4StackedImfileInsertObject(dbh, objects->data[i])) { return false; } @@ -14993,11 +14993,11 @@ } -bool p4PStackedImfileInsertFits(psDB *dbh, const psFits *fits) +bool p4StackedImfileInsertFits(psDB *dbh, const psFits *fits) { psArray *rowSet; - // move to (the first?) extension named P4PSTACKEDIMFILE_TABLE_NAME - if (!psFitsMoveExtName(fits, P4PSTACKEDIMFILE_TABLE_NAME)) { - psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4PSTACKEDIMFILE_TABLE_NAME); + // move to (the first?) extension named P4STACKEDIMFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, P4STACKEDIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4STACKEDIMFILE_TABLE_NAME); return false; } @@ -15017,5 +15017,5 @@ } - if (!psDBInsertRows(dbh, P4PSTACKEDIMFILE_TABLE_NAME, rowSet)) { + if (!psDBInsertRows(dbh, P4STACKEDIMFILE_TABLE_NAME, rowSet)) { psError(PS_ERR_UNKNOWN, false, "databse insert failed"); psFree(rowSet); @@ -15028,9 +15028,9 @@ } -bool p4PStackedImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +bool p4StackedImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) { psArray *rowSet; - rowSet = psDBSelectRows(dbh, P4PSTACKEDIMFILE_TABLE_NAME, where, limit); + rowSet = psDBSelectRows(dbh, P4STACKEDIMFILE_TABLE_NAME, where, limit); if (!rowSet) { return false; @@ -15038,5 +15038,5 @@ // output to fits - if (!psFitsWriteTable(fits, NULL, rowSet, P4PSTACKEDIMFILE_TABLE_NAME)) { + if (!psFitsWriteTable(fits, NULL, rowSet, P4STACKEDIMFILE_TABLE_NAME)) { psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); psFree(rowSet); @@ -15049,5 +15049,5 @@ } -psMetadata *p4PStackedImfileMetadataFromObject(const p4PStackedImfileRow *object) +psMetadata *p4StackedImfileMetadataFromObject(const p4StackedImfileRow *object) { psMetadata *md = psMetadataAlloc(); @@ -15082,5 +15082,5 @@ } -p4PStackedImfileRow *p4PStackedImfileObjectFromMetadata(psMetadata *md) +p4StackedImfileRow *p4StackedImfileObjectFromMetadata(psMetadata *md) { @@ -15112,7 +15112,7 @@ } - return p4PStackedImfileRowAlloc(p4_id, class_id, uri, b1_uri, b2_uri); -} -psArray *p4PStackedImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) + return p4StackedImfileRowAlloc(p4_id, class_id, uri, b1_uri, b2_uri); +} +psArray *p4StackedImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) { psArray *rowSet; @@ -15120,5 +15120,5 @@ psU64 i; - rowSet = psDBSelectRows(dbh, P4PSTACKEDIMFILE_TABLE_NAME, where, limit); + rowSet = psDBSelectRows(dbh, P4STACKEDIMFILE_TABLE_NAME, where, limit); if (!rowSet) { return NULL; @@ -15130,5 +15130,5 @@ for (i = 0; i < rowSet->n; i++) { - p4PStackedImfileRow *object = p4PStackedImfileObjectFromMetadata(rowSet->data[i]); + p4StackedImfileRow *object = p4StackedImfileObjectFromMetadata(rowSet->data[i]); psArrayAdd(returnSet, 0, object); psFree(object); @@ -15139,11 +15139,11 @@ return returnSet; } -bool p4PStackedImfileDeleteObject(psDB *dbh, const p4PStackedImfileRow *object) -{ - psMetadata *where = p4PStackedImfileMetadataFromObject(object); - long long count = psDBDeleteRows(dbh, P4PSTACKEDIMFILE_TABLE_NAME, where, 0); +bool p4StackedImfileDeleteObject(psDB *dbh, const p4StackedImfileRow *object) +{ + psMetadata *where = p4StackedImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P4STACKEDIMFILE_TABLE_NAME, where, 0); psFree(where) if (count < 0) { - psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PStackedImfile"); + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4StackedImfile"); return false; } @@ -15151,21 +15151,21 @@ // XXX should this be a psAbort() instead? It is possible that // having an object match multiple rows was by design. - psError(PS_ERR_UNKNOWN, true, "p4PStackedImfileRow object matched more then one row. Check your database schema"); - return false; - } - - return true; -} -long long p4PStackedImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) + psError(PS_ERR_UNKNOWN, true, "p4StackedImfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long p4StackedImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) { long long deleted = 0; for (long long i = 0; i < objects->n; i++) { - p4PStackedImfileRow *object = objects->data[i]; - psMetadata *where = p4PStackedImfileMetadataFromObject(object); - long long count = psDBDeleteRows(dbh, P4PSTACKEDIMFILE_TABLE_NAME, where, limit); + p4StackedImfileRow *object = objects->data[i]; + psMetadata *where = p4StackedImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P4STACKEDIMFILE_TABLE_NAME, where, limit); psFree(where) if (count < 0) { - psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PStackedImfile"); + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4StackedImfile"); return count; } @@ -15176,5 +15176,5 @@ return deleted; } -bool p4PStackedImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf) +bool p4StackedImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf) { PS_ASSERT_PTR_NON_NULL(objects, false); @@ -15182,9 +15182,9 @@ psMetadata *output = psMetadataAlloc(); for (long i = 0; i < psArrayLength(objects); i++) { - psMetadata *md = p4PStackedImfileMetadataFromObject(objects->data[i]); + psMetadata *md = p4StackedImfileMetadataFromObject(objects->data[i]); if (!psMetadataAddMetadata( output, PS_LIST_TAIL, - P4PSTACKEDIMFILE_TABLE_NAME, + P4STACKEDIMFILE_TABLE_NAME, PS_META_DUPLICATE_OK, NULL, @@ -15207,9 +15207,9 @@ return true; } -bool p4PStackedImfilePrintObject(FILE *stream, p4PStackedImfileRow *object, bool mdcf) +bool p4StackedImfilePrintObject(FILE *stream, p4StackedImfileRow *object, bool mdcf) { PS_ASSERT_PTR_NON_NULL(object, false); - psMetadata *md = p4PStackedImfileMetadataFromObject(object); + psMetadata *md = p4StackedImfileMetadataFromObject(object); if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { @@ -15222,12 +15222,12 @@ return true; } -static void p4PDiffImfileRowFree(p4PDiffImfileRow *object); - -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) -{ - p4PDiffImfileRow *_object; - - _object = psAlloc(sizeof(p4PDiffImfileRow)); - psMemSetDeallocator(_object, (psFreeFunc)p4PDiffImfileRowFree); +static void p4DiffImfileRowFree(p4DiffImfileRow *object); + +p4DiffImfileRow *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) +{ + p4DiffImfileRow *_object; + + _object = psAlloc(sizeof(p4DiffImfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)p4DiffImfileRowFree); _object->p4_id = p4_id; @@ -15242,5 +15242,5 @@ } -static void p4PDiffImfileRowFree(p4PDiffImfileRow *object) +static void p4DiffImfileRowFree(p4DiffImfileRow *object) { psFree(object->exp_tag); @@ -15251,5 +15251,5 @@ } -bool p4PDiffImfileCreateTable(psDB *dbh) +bool p4DiffImfileCreateTable(psDB *dbh) { psMetadata *md = psMetadataAlloc(); @@ -15290,5 +15290,5 @@ } - bool status = psDBCreateTable(dbh, P4PDIFFIMFILE_TABLE_NAME, md); + bool status = psDBCreateTable(dbh, P4DIFFIMFILE_TABLE_NAME, md); psFree(md); @@ -15297,10 +15297,10 @@ } -bool p4PDiffImfileDropTable(psDB *dbh) -{ - return psDBDropTable(dbh, P4PDIFFIMFILE_TABLE_NAME); -} - -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) +bool p4DiffImfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, P4DIFFIMFILE_TABLE_NAME); +} + +bool 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) { psMetadata *md = psMetadataAlloc(); @@ -15341,5 +15341,5 @@ } - bool status = psDBInsertOneRow(dbh, P4PDIFFIMFILE_TABLE_NAME, md); + bool status = psDBInsertOneRow(dbh, P4DIFFIMFILE_TABLE_NAME, md); psFree(md); @@ -15347,11 +15347,11 @@ } -long long p4PDiffImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +long long p4DiffImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) { long long deleted = 0; - long long count = psDBDeleteRows(dbh, P4PDIFFIMFILE_TABLE_NAME, where, limit); + long long count = psDBDeleteRows(dbh, P4DIFFIMFILE_TABLE_NAME, where, limit); if (count < 0) { - psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PDiffImfile"); + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4DiffImfile"); return count; @@ -15361,13 +15361,13 @@ return deleted; } -bool p4PDiffImfileInsertObject(psDB *dbh, p4PDiffImfileRow *object) -{ - return p4PDiffImfileInsert(dbh, object->p4_id, object->exp_tag, object->p3_version, object->class_id, object->uri, object->b1_uri, object->b2_uri); -} - -bool p4PDiffImfileInsertObjects(psDB *dbh, psArray *objects) +bool p4DiffImfileInsertObject(psDB *dbh, p4DiffImfileRow *object) +{ + return p4DiffImfileInsert(dbh, object->p4_id, object->exp_tag, object->p3_version, object->class_id, object->uri, object->b1_uri, object->b2_uri); +} + +bool p4DiffImfileInsertObjects(psDB *dbh, psArray *objects) { for (long i = 0; i < psArrayLength(objects); i++) { - if (!p4PDiffImfileInsertObject(dbh, objects->data[i])) { + if (!p4DiffImfileInsertObject(dbh, objects->data[i])) { return false; } @@ -15377,11 +15377,11 @@ } -bool p4PDiffImfileInsertFits(psDB *dbh, const psFits *fits) +bool p4DiffImfileInsertFits(psDB *dbh, const psFits *fits) { psArray *rowSet; - // move to (the first?) extension named P4PDIFFIMFILE_TABLE_NAME - if (!psFitsMoveExtName(fits, P4PDIFFIMFILE_TABLE_NAME)) { - psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4PDIFFIMFILE_TABLE_NAME); + // move to (the first?) extension named P4DIFFIMFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, P4DIFFIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4DIFFIMFILE_TABLE_NAME); return false; } @@ -15401,5 +15401,5 @@ } - if (!psDBInsertRows(dbh, P4PDIFFIMFILE_TABLE_NAME, rowSet)) { + if (!psDBInsertRows(dbh, P4DIFFIMFILE_TABLE_NAME, rowSet)) { psError(PS_ERR_UNKNOWN, false, "databse insert failed"); psFree(rowSet); @@ -15412,9 +15412,9 @@ } -bool p4PDiffImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +bool p4DiffImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) { psArray *rowSet; - rowSet = psDBSelectRows(dbh, P4PDIFFIMFILE_TABLE_NAME, where, limit); + rowSet = psDBSelectRows(dbh, P4DIFFIMFILE_TABLE_NAME, where, limit); if (!rowSet) { return false; @@ -15422,5 +15422,5 @@ // output to fits - if (!psFitsWriteTable(fits, NULL, rowSet, P4PDIFFIMFILE_TABLE_NAME)) { + if (!psFitsWriteTable(fits, NULL, rowSet, P4DIFFIMFILE_TABLE_NAME)) { psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); psFree(rowSet); @@ -15433,5 +15433,5 @@ } -psMetadata *p4PDiffImfileMetadataFromObject(const p4PDiffImfileRow *object) +psMetadata *p4DiffImfileMetadataFromObject(const p4DiffImfileRow *object) { psMetadata *md = psMetadataAlloc(); @@ -15476,5 +15476,5 @@ } -p4PDiffImfileRow *p4PDiffImfileObjectFromMetadata(psMetadata *md) +p4DiffImfileRow *p4DiffImfileObjectFromMetadata(psMetadata *md) { @@ -15516,7 +15516,7 @@ } - return p4PDiffImfileRowAlloc(p4_id, exp_tag, p3_version, class_id, uri, b1_uri, b2_uri); -} -psArray *p4PDiffImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) + return p4DiffImfileRowAlloc(p4_id, exp_tag, p3_version, class_id, uri, b1_uri, b2_uri); +} +psArray *p4DiffImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) { psArray *rowSet; @@ -15524,5 +15524,5 @@ psU64 i; - rowSet = psDBSelectRows(dbh, P4PDIFFIMFILE_TABLE_NAME, where, limit); + rowSet = psDBSelectRows(dbh, P4DIFFIMFILE_TABLE_NAME, where, limit); if (!rowSet) { return NULL; @@ -15534,5 +15534,5 @@ for (i = 0; i < rowSet->n; i++) { - p4PDiffImfileRow *object = p4PDiffImfileObjectFromMetadata(rowSet->data[i]); + p4DiffImfileRow *object = p4DiffImfileObjectFromMetadata(rowSet->data[i]); psArrayAdd(returnSet, 0, object); psFree(object); @@ -15543,11 +15543,11 @@ return returnSet; } -bool p4PDiffImfileDeleteObject(psDB *dbh, const p4PDiffImfileRow *object) -{ - psMetadata *where = p4PDiffImfileMetadataFromObject(object); - long long count = psDBDeleteRows(dbh, P4PDIFFIMFILE_TABLE_NAME, where, 0); +bool p4DiffImfileDeleteObject(psDB *dbh, const p4DiffImfileRow *object) +{ + psMetadata *where = p4DiffImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P4DIFFIMFILE_TABLE_NAME, where, 0); psFree(where) if (count < 0) { - psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PDiffImfile"); + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4DiffImfile"); return false; } @@ -15555,21 +15555,21 @@ // XXX should this be a psAbort() instead? It is possible that // having an object match multiple rows was by design. - psError(PS_ERR_UNKNOWN, true, "p4PDiffImfileRow object matched more then one row. Check your database schema"); - return false; - } - - return true; -} -long long p4PDiffImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) + psError(PS_ERR_UNKNOWN, true, "p4DiffImfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long p4DiffImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) { long long deleted = 0; for (long long i = 0; i < objects->n; i++) { - p4PDiffImfileRow *object = objects->data[i]; - psMetadata *where = p4PDiffImfileMetadataFromObject(object); - long long count = psDBDeleteRows(dbh, P4PDIFFIMFILE_TABLE_NAME, where, limit); + p4DiffImfileRow *object = objects->data[i]; + psMetadata *where = p4DiffImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P4DIFFIMFILE_TABLE_NAME, where, limit); psFree(where) if (count < 0) { - psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PDiffImfile"); + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4DiffImfile"); return count; } @@ -15580,5 +15580,5 @@ return deleted; } -bool p4PDiffImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf) +bool p4DiffImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf) { PS_ASSERT_PTR_NON_NULL(objects, false); @@ -15586,9 +15586,9 @@ psMetadata *output = psMetadataAlloc(); for (long i = 0; i < psArrayLength(objects); i++) { - psMetadata *md = p4PDiffImfileMetadataFromObject(objects->data[i]); + psMetadata *md = p4DiffImfileMetadataFromObject(objects->data[i]); if (!psMetadataAddMetadata( output, PS_LIST_TAIL, - P4PDIFFIMFILE_TABLE_NAME, + P4DIFFIMFILE_TABLE_NAME, PS_META_DUPLICATE_OK, NULL, @@ -15611,9 +15611,9 @@ return true; } -bool p4PDiffImfilePrintObject(FILE *stream, p4PDiffImfileRow *object, bool mdcf) +bool p4DiffImfilePrintObject(FILE *stream, p4DiffImfileRow *object, bool mdcf) { PS_ASSERT_PTR_NON_NULL(object, false); - psMetadata *md = p4PDiffImfileMetadataFromObject(object); + psMetadata *md = p4DiffImfileMetadataFromObject(object); if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { @@ -15626,12 +15626,12 @@ return true; } -static void p4PMagicMaskImfileRowFree(p4PMagicMaskImfileRow *object); - -p4PMagicMaskImfileRow *p4PMagicMaskImfileRowAlloc(psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri) -{ - p4PMagicMaskImfileRow *_object; - - _object = psAlloc(sizeof(p4PMagicMaskImfileRow)); - psMemSetDeallocator(_object, (psFreeFunc)p4PMagicMaskImfileRowFree); +static void p4MagicMaskImfileRowFree(p4MagicMaskImfileRow *object); + +p4MagicMaskImfileRow *p4MagicMaskImfileRowAlloc(psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri) +{ + p4MagicMaskImfileRow *_object; + + _object = psAlloc(sizeof(p4MagicMaskImfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)p4MagicMaskImfileRowFree); _object->p4_id = p4_id; @@ -15644,5 +15644,5 @@ } -static void p4PMagicMaskImfileRowFree(p4PMagicMaskImfileRow *object) +static void p4MagicMaskImfileRowFree(p4MagicMaskImfileRow *object) { psFree(object->exp_tag); @@ -15651,5 +15651,5 @@ } -bool p4PMagicMaskImfileCreateTable(psDB *dbh) +bool p4MagicMaskImfileCreateTable(psDB *dbh) { psMetadata *md = psMetadataAlloc(); @@ -15680,5 +15680,5 @@ } - bool status = psDBCreateTable(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, md); + bool status = psDBCreateTable(dbh, P4MAGICMASKIMFILE_TABLE_NAME, md); psFree(md); @@ -15687,10 +15687,10 @@ } -bool p4PMagicMaskImfileDropTable(psDB *dbh) -{ - return psDBDropTable(dbh, P4PMAGICMASKIMFILE_TABLE_NAME); -} - -bool p4PMagicMaskImfileInsert(psDB * dbh, psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri) +bool p4MagicMaskImfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, P4MAGICMASKIMFILE_TABLE_NAME); +} + +bool p4MagicMaskImfileInsert(psDB * dbh, psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri) { psMetadata *md = psMetadataAlloc(); @@ -15721,5 +15721,5 @@ } - bool status = psDBInsertOneRow(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, md); + bool status = psDBInsertOneRow(dbh, P4MAGICMASKIMFILE_TABLE_NAME, md); psFree(md); @@ -15727,11 +15727,11 @@ } -long long p4PMagicMaskImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +long long p4MagicMaskImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) { long long deleted = 0; - long long count = psDBDeleteRows(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, where, limit); + long long count = psDBDeleteRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, where, limit); if (count < 0) { - psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PMagicMaskImfile"); + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4MagicMaskImfile"); return count; @@ -15741,13 +15741,13 @@ return deleted; } -bool p4PMagicMaskImfileInsertObject(psDB *dbh, p4PMagicMaskImfileRow *object) -{ - return p4PMagicMaskImfileInsert(dbh, object->p4_id, object->exp_tag, object->p3_version, object->class_id, object->uri); -} - -bool p4PMagicMaskImfileInsertObjects(psDB *dbh, psArray *objects) +bool p4MagicMaskImfileInsertObject(psDB *dbh, p4MagicMaskImfileRow *object) +{ + return p4MagicMaskImfileInsert(dbh, object->p4_id, object->exp_tag, object->p3_version, object->class_id, object->uri); +} + +bool p4MagicMaskImfileInsertObjects(psDB *dbh, psArray *objects) { for (long i = 0; i < psArrayLength(objects); i++) { - if (!p4PMagicMaskImfileInsertObject(dbh, objects->data[i])) { + if (!p4MagicMaskImfileInsertObject(dbh, objects->data[i])) { return false; } @@ -15757,11 +15757,11 @@ } -bool p4PMagicMaskImfileInsertFits(psDB *dbh, const psFits *fits) +bool p4MagicMaskImfileInsertFits(psDB *dbh, const psFits *fits) { psArray *rowSet; - // move to (the first?) extension named P4PMAGICMASKIMFILE_TABLE_NAME - if (!psFitsMoveExtName(fits, P4PMAGICMASKIMFILE_TABLE_NAME)) { - psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4PMAGICMASKIMFILE_TABLE_NAME); + // move to (the first?) extension named P4MAGICMASKIMFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, P4MAGICMASKIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4MAGICMASKIMFILE_TABLE_NAME); return false; } @@ -15781,5 +15781,5 @@ } - if (!psDBInsertRows(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, rowSet)) { + if (!psDBInsertRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, rowSet)) { psError(PS_ERR_UNKNOWN, false, "databse insert failed"); psFree(rowSet); @@ -15792,9 +15792,9 @@ } -bool p4PMagicMaskImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +bool p4MagicMaskImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) { psArray *rowSet; - rowSet = psDBSelectRows(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, where, limit); + rowSet = psDBSelectRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, where, limit); if (!rowSet) { return false; @@ -15802,5 +15802,5 @@ // output to fits - if (!psFitsWriteTable(fits, NULL, rowSet, P4PMAGICMASKIMFILE_TABLE_NAME)) { + if (!psFitsWriteTable(fits, NULL, rowSet, P4MAGICMASKIMFILE_TABLE_NAME)) { psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); psFree(rowSet); @@ -15813,5 +15813,5 @@ } -psMetadata *p4PMagicMaskImfileMetadataFromObject(const p4PMagicMaskImfileRow *object) +psMetadata *p4MagicMaskImfileMetadataFromObject(const p4MagicMaskImfileRow *object) { psMetadata *md = psMetadataAlloc(); @@ -15846,5 +15846,5 @@ } -p4PMagicMaskImfileRow *p4PMagicMaskImfileObjectFromMetadata(psMetadata *md) +p4MagicMaskImfileRow *p4MagicMaskImfileObjectFromMetadata(psMetadata *md) { @@ -15876,7 +15876,7 @@ } - return p4PMagicMaskImfileRowAlloc(p4_id, exp_tag, p3_version, class_id, uri); -} -psArray *p4PMagicMaskImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) + return p4MagicMaskImfileRowAlloc(p4_id, exp_tag, p3_version, class_id, uri); +} +psArray *p4MagicMaskImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) { psArray *rowSet; @@ -15884,5 +15884,5 @@ psU64 i; - rowSet = psDBSelectRows(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, where, limit); + rowSet = psDBSelectRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, where, limit); if (!rowSet) { return NULL; @@ -15894,5 +15894,5 @@ for (i = 0; i < rowSet->n; i++) { - p4PMagicMaskImfileRow *object = p4PMagicMaskImfileObjectFromMetadata(rowSet->data[i]); + p4MagicMaskImfileRow *object = p4MagicMaskImfileObjectFromMetadata(rowSet->data[i]); psArrayAdd(returnSet, 0, object); psFree(object); @@ -15903,11 +15903,11 @@ return returnSet; } -bool p4PMagicMaskImfileDeleteObject(psDB *dbh, const p4PMagicMaskImfileRow *object) -{ - psMetadata *where = p4PMagicMaskImfileMetadataFromObject(object); - long long count = psDBDeleteRows(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, where, 0); +bool p4MagicMaskImfileDeleteObject(psDB *dbh, const p4MagicMaskImfileRow *object) +{ + psMetadata *where = p4MagicMaskImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, where, 0); psFree(where) if (count < 0) { - psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PMagicMaskImfile"); + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4MagicMaskImfile"); return false; } @@ -15915,21 +15915,21 @@ // XXX should this be a psAbort() instead? It is possible that // having an object match multiple rows was by design. - psError(PS_ERR_UNKNOWN, true, "p4PMagicMaskImfileRow object matched more then one row. Check your database schema"); - return false; - } - - return true; -} -long long p4PMagicMaskImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) + psError(PS_ERR_UNKNOWN, true, "p4MagicMaskImfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long p4MagicMaskImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) { long long deleted = 0; for (long long i = 0; i < objects->n; i++) { - p4PMagicMaskImfileRow *object = objects->data[i]; - psMetadata *where = p4PMagicMaskImfileMetadataFromObject(object); - long long count = psDBDeleteRows(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, where, limit); + p4MagicMaskImfileRow *object = objects->data[i]; + psMetadata *where = p4MagicMaskImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, where, limit); psFree(where) if (count < 0) { - psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PMagicMaskImfile"); + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4MagicMaskImfile"); return count; } @@ -15940,5 +15940,5 @@ return deleted; } -bool p4PMagicMaskImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf) +bool p4MagicMaskImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf) { PS_ASSERT_PTR_NON_NULL(objects, false); @@ -15946,9 +15946,9 @@ psMetadata *output = psMetadataAlloc(); for (long i = 0; i < psArrayLength(objects); i++) { - psMetadata *md = p4PMagicMaskImfileMetadataFromObject(objects->data[i]); + psMetadata *md = p4MagicMaskImfileMetadataFromObject(objects->data[i]); if (!psMetadataAddMetadata( output, PS_LIST_TAIL, - P4PMAGICMASKIMFILE_TABLE_NAME, + P4MAGICMASKIMFILE_TABLE_NAME, PS_META_DUPLICATE_OK, NULL, @@ -15971,9 +15971,9 @@ return true; } -bool p4PMagicMaskImfilePrintObject(FILE *stream, p4PMagicMaskImfileRow *object, bool mdcf) +bool p4MagicMaskImfilePrintObject(FILE *stream, p4MagicMaskImfileRow *object, bool mdcf) { PS_ASSERT_PTR_NON_NULL(object, false); - psMetadata *md = p4PMagicMaskImfileMetadataFromObject(object); + psMetadata *md = p4MagicMaskImfileMetadataFromObject(object); if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { Index: /trunk/ippdb/src/ippdb.h =================================================================== --- /trunk/ippdb/src/ippdb.h (revision 10752) +++ /trunk/ippdb/src/ippdb.h (revision 10753) @@ -7652,7 +7652,7 @@ bool mdcf ///< format as mdconfig or simple ); -/** p4PStackedImfileRow data structure - * - * Structure for representing a single row of p4PStackedImfile table data. +/** p4StackedImfileRow data structure + * + * Structure for representing a single row of p4StackedImfile table data. */ @@ -7663,12 +7663,12 @@ char *b1_uri; char *b2_uri; -} p4PStackedImfileRow; - -/** Creates a new p4PStackedImfileRow object - * - * @return A new p4PStackedImfileRow object or NULL on failure. - */ - -p4PStackedImfileRow *p4PStackedImfileRowAlloc( +} p4StackedImfileRow; + +/** Creates a new p4StackedImfileRow object + * + * @return A new p4StackedImfileRow object or NULL on failure. + */ + +p4StackedImfileRow *p4StackedImfileRowAlloc( psS32 p4_id, const char *class_id, @@ -7678,19 +7678,19 @@ ); -/** Creates a new p4PStackedImfile table - * - * @return true on success - */ - -bool p4PStackedImfileCreateTable( +/** Creates a new p4StackedImfile table + * + * @return true on success + */ + +bool p4StackedImfileCreateTable( psDB *dbh ///< Database handle ); -/** Deletes a p4PStackedImfile table - * - * @return true on success - */ - -bool p4PStackedImfileDropTable( +/** Deletes a p4StackedImfile table + * + * @return true on success + */ + +bool p4StackedImfileDropTable( psDB *dbh ///< Database handle ); @@ -7703,5 +7703,5 @@ */ -bool p4PStackedImfileInsert( +bool p4StackedImfileInsert( psDB *dbh, ///< Database handle psS32 p4_id, @@ -7717,5 +7717,5 @@ */ -long long p4PStackedImfileDelete( +long long p4StackedImfileDelete( psDB *dbh, ///< Database handle const psMetadata *where, ///< Row match criteria @@ -7723,5 +7723,5 @@ ); -/** Insert a single p4PStackedImfileRow object into a table +/** Insert a single p4StackedImfileRow object into a table * * This function constructs and inserts a single row based on it's parameters. @@ -7730,10 +7730,10 @@ */ -bool p4PStackedImfileInsertObject( - psDB *dbh, ///< Database handle - p4PStackedImfileRow *object ///< p4PStackedImfileRow object -); - -/** Insert an array of p4PStackedImfileRow object into a table +bool p4StackedImfileInsertObject( + psDB *dbh, ///< Database handle + p4StackedImfileRow *object ///< p4StackedImfileRow object +); + +/** Insert an array of p4StackedImfileRow object into a table * * This function constructs and inserts multiple rows based on it's parameters. @@ -7742,10 +7742,10 @@ */ -bool p4PStackedImfileInsertObjects( - psDB *dbh, ///< Database handle - psArray *objects ///< array of p4PStackedImfileRow objects -); - -/** Insert data from a binary FITS table p4PStackedImfileRow into the database +bool p4StackedImfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of p4StackedImfileRow objects +); + +/** Insert data from a binary FITS table p4StackedImfileRow into the database * * This function expects a psFits object with a FITS table as the first @@ -7757,5 +7757,5 @@ */ -bool p4PStackedImfileInsertFits( +bool p4StackedImfileInsertFits( psDB *dbh, ///< Database handle const psFits *fits ///< psFits object @@ -7772,5 +7772,5 @@ */ -bool p4PStackedImfileSelectRowsFits( +bool p4StackedImfileSelectRowsFits( psDB *dbh, ///< Database handle psFits *fits, ///< psFits object @@ -7779,22 +7779,22 @@ ); -/** Convert a p4PStackedImfileRow into an equivalent psMetadata +/** Convert a p4StackedImfileRow into an equivalent psMetadata * * @return A psMetadata pointer or NULL on error */ -psMetadata *p4PStackedImfileMetadataFromObject( - const p4PStackedImfileRow *object ///< fooRow to convert into a psMetadata +psMetadata *p4StackedImfileMetadataFromObject( + const p4StackedImfileRow *object ///< fooRow to convert into a psMetadata ); /** Convert a psMetadata into an equivalent fooRow * - * @return A p4PStackedImfileRow pointer or NULL on error - */ - -p4PStackedImfileRow *p4PStackedImfileObjectFromMetadata( + * @return A p4StackedImfileRow pointer or NULL on error + */ + +p4StackedImfileRow *p4StackedImfileObjectFromMetadata( psMetadata *md ///< psMetadata to convert into a fooRow ); -/** Selects up to limit rows from the database and returns as p4PStackedImfileRow objects in a psArray +/** Selects up to limit rows from the database and returns as p4StackedImfileRow objects in a psArray * * See psDBSelectRows() for documentation on the format of where. @@ -7803,10 +7803,10 @@ */ -psArray *p4PStackedImfileSelectRowObjects( +psArray *p4StackedImfileSelectRowObjects( psDB *dbh, ///< Database handle const psMetadata *where, ///< Row match criteria unsigned long long limit ///< Maximum number of elements to return ); -/** Deletes a row from the database coresponding to an p4PStackedImfile +/** Deletes a row from the database coresponding to an p4StackedImfile * * Note that a 'where' search psMetadata is constructed from each object and @@ -7816,7 +7816,7 @@ */ -bool p4PStackedImfileDeleteObject( - psDB *dbh, ///< Database handle - const p4PStackedImfileRow *object ///< Object to delete +bool p4StackedImfileDeleteObject( + psDB *dbh, ///< Database handle + const p4StackedImfileRow *object ///< Object to delete ); /** Deletes up to limit rows from the database and returns the number of rows actually deleted. @@ -7828,10 +7828,10 @@ */ -long long p4PStackedImfileDeleteRowObjects( +long long p4StackedImfileDeleteRowObjects( psDB *dbh, ///< Database handle const psArray *objects, ///< Array of objects to delete unsigned long long limit ///< Maximum number of elements to delete ); -/** Formats and prints an array of p4PStackedImfileRow objects +/** Formats and prints an array of p4StackedImfileRow objects * * When mdcf is set the formated output is in psMetadataConfig @@ -7841,10 +7841,10 @@ */ -bool p4PStackedImfilePrintObjects( +bool p4StackedImfilePrintObjects( FILE *stream, ///< a stream - psArray *objects, ///< An array of p4PStackedImfileRow objects + psArray *objects, ///< An array of p4StackedImfileRow objects bool mdcf ///< format as mdconfig or simple ); -/** Formats and prints an p4PStackedImfileRow object +/** Formats and prints an p4StackedImfileRow object * * When mdcf is set the formated output is in psMetadataConfig @@ -7854,12 +7854,12 @@ */ -bool p4PStackedImfilePrintObject( +bool p4StackedImfilePrintObject( FILE *stream, ///< a stream - p4PStackedImfileRow *object, ///< an p4PStackedImfileRow object + p4StackedImfileRow *object, ///< an p4StackedImfileRow object bool mdcf ///< format as mdconfig or simple ); -/** p4PDiffImfileRow data structure - * - * Structure for representing a single row of p4PDiffImfile table data. +/** p4DiffImfileRow data structure + * + * Structure for representing a single row of p4DiffImfile table data. */ @@ -7872,12 +7872,12 @@ char *b1_uri; char *b2_uri; -} p4PDiffImfileRow; - -/** Creates a new p4PDiffImfileRow object - * - * @return A new p4PDiffImfileRow object or NULL on failure. - */ - -p4PDiffImfileRow *p4PDiffImfileRowAlloc( +} p4DiffImfileRow; + +/** Creates a new p4DiffImfileRow object + * + * @return A new p4DiffImfileRow object or NULL on failure. + */ + +p4DiffImfileRow *p4DiffImfileRowAlloc( psS32 p4_id, const char *exp_tag, @@ -7889,19 +7889,19 @@ ); -/** Creates a new p4PDiffImfile table - * - * @return true on success - */ - -bool p4PDiffImfileCreateTable( +/** Creates a new p4DiffImfile table + * + * @return true on success + */ + +bool p4DiffImfileCreateTable( psDB *dbh ///< Database handle ); -/** Deletes a p4PDiffImfile table - * - * @return true on success - */ - -bool p4PDiffImfileDropTable( +/** Deletes a p4DiffImfile table + * + * @return true on success + */ + +bool p4DiffImfileDropTable( psDB *dbh ///< Database handle ); @@ -7914,5 +7914,5 @@ */ -bool p4PDiffImfileInsert( +bool p4DiffImfileInsert( psDB *dbh, ///< Database handle psS32 p4_id, @@ -7930,5 +7930,5 @@ */ -long long p4PDiffImfileDelete( +long long p4DiffImfileDelete( psDB *dbh, ///< Database handle const psMetadata *where, ///< Row match criteria @@ -7936,5 +7936,5 @@ ); -/** Insert a single p4PDiffImfileRow object into a table +/** Insert a single p4DiffImfileRow object into a table * * This function constructs and inserts a single row based on it's parameters. @@ -7943,10 +7943,10 @@ */ -bool p4PDiffImfileInsertObject( - psDB *dbh, ///< Database handle - p4PDiffImfileRow *object ///< p4PDiffImfileRow object -); - -/** Insert an array of p4PDiffImfileRow object into a table +bool p4DiffImfileInsertObject( + psDB *dbh, ///< Database handle + p4DiffImfileRow *object ///< p4DiffImfileRow object +); + +/** Insert an array of p4DiffImfileRow object into a table * * This function constructs and inserts multiple rows based on it's parameters. @@ -7955,10 +7955,10 @@ */ -bool p4PDiffImfileInsertObjects( - psDB *dbh, ///< Database handle - psArray *objects ///< array of p4PDiffImfileRow objects -); - -/** Insert data from a binary FITS table p4PDiffImfileRow into the database +bool p4DiffImfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of p4DiffImfileRow objects +); + +/** Insert data from a binary FITS table p4DiffImfileRow into the database * * This function expects a psFits object with a FITS table as the first @@ -7970,5 +7970,5 @@ */ -bool p4PDiffImfileInsertFits( +bool p4DiffImfileInsertFits( psDB *dbh, ///< Database handle const psFits *fits ///< psFits object @@ -7985,5 +7985,5 @@ */ -bool p4PDiffImfileSelectRowsFits( +bool p4DiffImfileSelectRowsFits( psDB *dbh, ///< Database handle psFits *fits, ///< psFits object @@ -7992,22 +7992,22 @@ ); -/** Convert a p4PDiffImfileRow into an equivalent psMetadata +/** Convert a p4DiffImfileRow into an equivalent psMetadata * * @return A psMetadata pointer or NULL on error */ -psMetadata *p4PDiffImfileMetadataFromObject( - const p4PDiffImfileRow *object ///< fooRow to convert into a psMetadata +psMetadata *p4DiffImfileMetadataFromObject( + const p4DiffImfileRow *object ///< fooRow to convert into a psMetadata ); /** Convert a psMetadata into an equivalent fooRow * - * @return A p4PDiffImfileRow pointer or NULL on error - */ - -p4PDiffImfileRow *p4PDiffImfileObjectFromMetadata( + * @return A p4DiffImfileRow pointer or NULL on error + */ + +p4DiffImfileRow *p4DiffImfileObjectFromMetadata( psMetadata *md ///< psMetadata to convert into a fooRow ); -/** Selects up to limit rows from the database and returns as p4PDiffImfileRow objects in a psArray +/** Selects up to limit rows from the database and returns as p4DiffImfileRow objects in a psArray * * See psDBSelectRows() for documentation on the format of where. @@ -8016,10 +8016,10 @@ */ -psArray *p4PDiffImfileSelectRowObjects( +psArray *p4DiffImfileSelectRowObjects( psDB *dbh, ///< Database handle const psMetadata *where, ///< Row match criteria unsigned long long limit ///< Maximum number of elements to return ); -/** Deletes a row from the database coresponding to an p4PDiffImfile +/** Deletes a row from the database coresponding to an p4DiffImfile * * Note that a 'where' search psMetadata is constructed from each object and @@ -8029,7 +8029,7 @@ */ -bool p4PDiffImfileDeleteObject( - psDB *dbh, ///< Database handle - const p4PDiffImfileRow *object ///< Object to delete +bool p4DiffImfileDeleteObject( + psDB *dbh, ///< Database handle + const p4DiffImfileRow *object ///< Object to delete ); /** Deletes up to limit rows from the database and returns the number of rows actually deleted. @@ -8041,10 +8041,10 @@ */ -long long p4PDiffImfileDeleteRowObjects( +long long p4DiffImfileDeleteRowObjects( psDB *dbh, ///< Database handle const psArray *objects, ///< Array of objects to delete unsigned long long limit ///< Maximum number of elements to delete ); -/** Formats and prints an array of p4PDiffImfileRow objects +/** Formats and prints an array of p4DiffImfileRow objects * * When mdcf is set the formated output is in psMetadataConfig @@ -8054,10 +8054,10 @@ */ -bool p4PDiffImfilePrintObjects( +bool p4DiffImfilePrintObjects( FILE *stream, ///< a stream - psArray *objects, ///< An array of p4PDiffImfileRow objects + psArray *objects, ///< An array of p4DiffImfileRow objects bool mdcf ///< format as mdconfig or simple ); -/** Formats and prints an p4PDiffImfileRow object +/** Formats and prints an p4DiffImfileRow object * * When mdcf is set the formated output is in psMetadataConfig @@ -8067,12 +8067,12 @@ */ -bool p4PDiffImfilePrintObject( +bool p4DiffImfilePrintObject( FILE *stream, ///< a stream - p4PDiffImfileRow *object, ///< an p4PDiffImfileRow object + p4DiffImfileRow *object, ///< an p4DiffImfileRow object bool mdcf ///< format as mdconfig or simple ); -/** p4PMagicMaskImfileRow data structure - * - * Structure for representing a single row of p4PMagicMaskImfile table data. +/** p4MagicMaskImfileRow data structure + * + * Structure for representing a single row of p4MagicMaskImfile table data. */ @@ -8083,12 +8083,12 @@ char *class_id; char *uri; -} p4PMagicMaskImfileRow; - -/** Creates a new p4PMagicMaskImfileRow object - * - * @return A new p4PMagicMaskImfileRow object or NULL on failure. - */ - -p4PMagicMaskImfileRow *p4PMagicMaskImfileRowAlloc( +} p4MagicMaskImfileRow; + +/** Creates a new p4MagicMaskImfileRow object + * + * @return A new p4MagicMaskImfileRow object or NULL on failure. + */ + +p4MagicMaskImfileRow *p4MagicMaskImfileRowAlloc( psS32 p4_id, const char *exp_tag, @@ -8098,19 +8098,19 @@ ); -/** Creates a new p4PMagicMaskImfile table - * - * @return true on success - */ - -bool p4PMagicMaskImfileCreateTable( +/** Creates a new p4MagicMaskImfile table + * + * @return true on success + */ + +bool p4MagicMaskImfileCreateTable( psDB *dbh ///< Database handle ); -/** Deletes a p4PMagicMaskImfile table - * - * @return true on success - */ - -bool p4PMagicMaskImfileDropTable( +/** Deletes a p4MagicMaskImfile table + * + * @return true on success + */ + +bool p4MagicMaskImfileDropTable( psDB *dbh ///< Database handle ); @@ -8123,5 +8123,5 @@ */ -bool p4PMagicMaskImfileInsert( +bool p4MagicMaskImfileInsert( psDB *dbh, ///< Database handle psS32 p4_id, @@ -8137,5 +8137,5 @@ */ -long long p4PMagicMaskImfileDelete( +long long p4MagicMaskImfileDelete( psDB *dbh, ///< Database handle const psMetadata *where, ///< Row match criteria @@ -8143,5 +8143,5 @@ ); -/** Insert a single p4PMagicMaskImfileRow object into a table +/** Insert a single p4MagicMaskImfileRow object into a table * * This function constructs and inserts a single row based on it's parameters. @@ -8150,10 +8150,10 @@ */ -bool p4PMagicMaskImfileInsertObject( - psDB *dbh, ///< Database handle - p4PMagicMaskImfileRow *object ///< p4PMagicMaskImfileRow object -); - -/** Insert an array of p4PMagicMaskImfileRow object into a table +bool p4MagicMaskImfileInsertObject( + psDB *dbh, ///< Database handle + p4MagicMaskImfileRow *object ///< p4MagicMaskImfileRow object +); + +/** Insert an array of p4MagicMaskImfileRow object into a table * * This function constructs and inserts multiple rows based on it's parameters. @@ -8162,10 +8162,10 @@ */ -bool p4PMagicMaskImfileInsertObjects( - psDB *dbh, ///< Database handle - psArray *objects ///< array of p4PMagicMaskImfileRow objects -); - -/** Insert data from a binary FITS table p4PMagicMaskImfileRow into the database +bool p4MagicMaskImfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of p4MagicMaskImfileRow objects +); + +/** Insert data from a binary FITS table p4MagicMaskImfileRow into the database * * This function expects a psFits object with a FITS table as the first @@ -8177,5 +8177,5 @@ */ -bool p4PMagicMaskImfileInsertFits( +bool p4MagicMaskImfileInsertFits( psDB *dbh, ///< Database handle const psFits *fits ///< psFits object @@ -8192,5 +8192,5 @@ */ -bool p4PMagicMaskImfileSelectRowsFits( +bool p4MagicMaskImfileSelectRowsFits( psDB *dbh, ///< Database handle psFits *fits, ///< psFits object @@ -8199,22 +8199,22 @@ ); -/** Convert a p4PMagicMaskImfileRow into an equivalent psMetadata +/** Convert a p4MagicMaskImfileRow into an equivalent psMetadata * * @return A psMetadata pointer or NULL on error */ -psMetadata *p4PMagicMaskImfileMetadataFromObject( - const p4PMagicMaskImfileRow *object ///< fooRow to convert into a psMetadata +psMetadata *p4MagicMaskImfileMetadataFromObject( + const p4MagicMaskImfileRow *object ///< fooRow to convert into a psMetadata ); /** Convert a psMetadata into an equivalent fooRow * - * @return A p4PMagicMaskImfileRow pointer or NULL on error - */ - -p4PMagicMaskImfileRow *p4PMagicMaskImfileObjectFromMetadata( + * @return A p4MagicMaskImfileRow pointer or NULL on error + */ + +p4MagicMaskImfileRow *p4MagicMaskImfileObjectFromMetadata( psMetadata *md ///< psMetadata to convert into a fooRow ); -/** Selects up to limit rows from the database and returns as p4PMagicMaskImfileRow objects in a psArray +/** Selects up to limit rows from the database and returns as p4MagicMaskImfileRow objects in a psArray * * See psDBSelectRows() for documentation on the format of where. @@ -8223,10 +8223,10 @@ */ -psArray *p4PMagicMaskImfileSelectRowObjects( +psArray *p4MagicMaskImfileSelectRowObjects( psDB *dbh, ///< Database handle const psMetadata *where, ///< Row match criteria unsigned long long limit ///< Maximum number of elements to return ); -/** Deletes a row from the database coresponding to an p4PMagicMaskImfile +/** Deletes a row from the database coresponding to an p4MagicMaskImfile * * Note that a 'where' search psMetadata is constructed from each object and @@ -8236,7 +8236,7 @@ */ -bool p4PMagicMaskImfileDeleteObject( - psDB *dbh, ///< Database handle - const p4PMagicMaskImfileRow *object ///< Object to delete +bool p4MagicMaskImfileDeleteObject( + psDB *dbh, ///< Database handle + const p4MagicMaskImfileRow *object ///< Object to delete ); /** Deletes up to limit rows from the database and returns the number of rows actually deleted. @@ -8248,10 +8248,10 @@ */ -long long p4PMagicMaskImfileDeleteRowObjects( +long long p4MagicMaskImfileDeleteRowObjects( psDB *dbh, ///< Database handle const psArray *objects, ///< Array of objects to delete unsigned long long limit ///< Maximum number of elements to delete ); -/** Formats and prints an array of p4PMagicMaskImfileRow objects +/** Formats and prints an array of p4MagicMaskImfileRow objects * * When mdcf is set the formated output is in psMetadataConfig @@ -8261,10 +8261,10 @@ */ -bool p4PMagicMaskImfilePrintObjects( +bool p4MagicMaskImfilePrintObjects( FILE *stream, ///< a stream - psArray *objects, ///< An array of p4PMagicMaskImfileRow objects + psArray *objects, ///< An array of p4MagicMaskImfileRow objects bool mdcf ///< format as mdconfig or simple ); -/** Formats and prints an p4PMagicMaskImfileRow object +/** Formats and prints an p4MagicMaskImfileRow object * * When mdcf is set the formated output is in psMetadataConfig @@ -8274,7 +8274,7 @@ */ -bool p4PMagicMaskImfilePrintObject( +bool p4MagicMaskImfilePrintObject( FILE *stream, ///< a stream - p4PMagicMaskImfileRow *object, ///< an p4PMagicMaskImfileRow object + p4MagicMaskImfileRow *object, ///< an p4MagicMaskImfileRow object bool mdcf ///< format as mdconfig or simple ); @@ -8286,3 +8286,3 @@ #endif -#endif // P4PMAGICMASKIMFILE_DB_H +#endif // P4MAGICMASKIMFILE_DB_H Index: /trunk/ippdb/tests/alloc.c =================================================================== --- /trunk/ippdb/tests/alloc.c (revision 10752) +++ /trunk/ippdb/tests/alloc.c (revision 10753) @@ -1531,7 +1531,7 @@ { - p4PStackedImfileRow *object; - - object = p4PStackedImfileRowAlloc(-32, "a string", "a string", "a string", "a string" ); + p4StackedImfileRow *object; + + object = p4StackedImfileRowAlloc(-32, "a string", "a string", "a string", "a string" ); if (!object) { @@ -1564,7 +1564,7 @@ { - p4PDiffImfileRow *object; - - object = p4PDiffImfileRowAlloc(-32, "a string", -32, "a string", "a string", "a string", "a string" ); + p4DiffImfileRow *object; + + object = p4DiffImfileRowAlloc(-32, "a string", -32, "a string", "a string", "a string", "a string" ); if (!object) { @@ -1605,7 +1605,7 @@ { - p4PMagicMaskImfileRow *object; - - object = p4PMagicMaskImfileRowAlloc(-32, "a string", -32, "a string", "a string" ); + p4MagicMaskImfileRow *object; + + object = p4MagicMaskImfileRowAlloc(-32, "a string", -32, "a string", "a string" ); if (!object) { Index: /trunk/ippdb/tests/createtable.c =================================================================== --- /trunk/ippdb/tests/createtable.c (revision 10752) +++ /trunk/ippdb/tests/createtable.c (revision 10753) @@ -538,35 +538,35 @@ } - if(!p4PStackedImfileCreateTable(dbh)) { - exit(EXIT_FAILURE); - } - - psDBCleanup(dbh); - } - - { - psDB *dbh; - - dbh = psDBInit("localhost", "test", NULL, "test"); - if (!dbh) { - exit(EXIT_FAILURE); - } - - if(!p4PDiffImfileCreateTable(dbh)) { - exit(EXIT_FAILURE); - } - - psDBCleanup(dbh); - } - - { - psDB *dbh; - - dbh = psDBInit("localhost", "test", NULL, "test"); - if (!dbh) { - exit(EXIT_FAILURE); - } - - if(!p4PMagicMaskImfileCreateTable(dbh)) { + if(!p4StackedImfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!p4DiffImfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!p4MagicMaskImfileCreateTable(dbh)) { exit(EXIT_FAILURE); } Index: /trunk/ippdb/tests/dbcleanup.c =================================================================== --- /trunk/ippdb/tests/dbcleanup.c (revision 10752) +++ /trunk/ippdb/tests/dbcleanup.c (revision 10753) @@ -46,7 +46,7 @@ p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4InputImfile"); p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4WarpedImfile"); - p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4PStackedImfile"); - p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4PDiffImfile"); - p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4PMagicMaskImfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4StackedImfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4DiffImfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4MagicMaskImfile"); psDBCleanup(dbh); Index: /trunk/ippdb/tests/dbsetup.c =================================================================== --- /trunk/ippdb/tests/dbsetup.c (revision 10752) +++ /trunk/ippdb/tests/dbsetup.c (revision 10753) @@ -118,12 +118,12 @@ p4WarpedImfileCreateTable(dbh); - p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4PStackedImfile"); - p4PStackedImfileCreateTable(dbh); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4StackedImfile"); + p4StackedImfileCreateTable(dbh); - p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4PDiffImfile"); - p4PDiffImfileCreateTable(dbh); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4DiffImfile"); + p4DiffImfileCreateTable(dbh); - p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4PMagicMaskImfile"); - p4PMagicMaskImfileCreateTable(dbh); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4MagicMaskImfile"); + p4MagicMaskImfileCreateTable(dbh); psDBCleanup(dbh); Index: /trunk/ippdb/tests/droptable.c =================================================================== --- /trunk/ippdb/tests/droptable.c (revision 10752) +++ /trunk/ippdb/tests/droptable.c (revision 10753) @@ -538,35 +538,35 @@ } - if (!p4PStackedImfileDropTable(dbh)) { - exit(EXIT_FAILURE); - } - - psDBCleanup(dbh); - } - - { - psDB *dbh; - - dbh = psDBInit("localhost", "test", NULL, "test"); - if (!dbh) { - exit(EXIT_FAILURE); - } - - if (!p4PDiffImfileDropTable(dbh)) { - exit(EXIT_FAILURE); - } - - psDBCleanup(dbh); - } - - { - psDB *dbh; - - dbh = psDBInit("localhost", "test", NULL, "test"); - if (!dbh) { - exit(EXIT_FAILURE); - } - - if (!p4PMagicMaskImfileDropTable(dbh)) { + if (!p4StackedImfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p4DiffImfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p4MagicMaskImfileDropTable(dbh)) { exit(EXIT_FAILURE); } Index: /trunk/ippdb/tests/insert.c =================================================================== --- /trunk/ippdb/tests/insert.c (revision 10752) +++ /trunk/ippdb/tests/insert.c (revision 10753) @@ -538,35 +538,35 @@ } - if (!p4PStackedImfileInsert(dbh, -32, "a string", "a string", "a string", "a string")) { - exit(EXIT_FAILURE); - } - - psDBCleanup(dbh); - } - - { - psDB *dbh; - - dbh = psDBInit("localhost", "test", NULL, "test"); - if (!dbh) { - exit(EXIT_FAILURE); - } - - if (!p4PDiffImfileInsert(dbh, -32, "a string", -32, "a string", "a string", "a string", "a string")) { - exit(EXIT_FAILURE); - } - - psDBCleanup(dbh); - } - - { - psDB *dbh; - - dbh = psDBInit("localhost", "test", NULL, "test"); - if (!dbh) { - exit(EXIT_FAILURE); - } - - if (!p4PMagicMaskImfileInsert(dbh, -32, "a string", -32, "a string", "a string")) { + if (!p4StackedImfileInsert(dbh, -32, "a string", "a string", "a string", "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p4DiffImfileInsert(dbh, -32, "a string", -32, "a string", "a string", "a string", "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p4MagicMaskImfileInsert(dbh, -32, "a string", -32, "a string", "a string")) { exit(EXIT_FAILURE); } Index: /trunk/ippdb/tests/insertfits.c =================================================================== --- /trunk/ippdb/tests/insertfits.c (revision 10752) +++ /trunk/ippdb/tests/insertfits.c (revision 10753) @@ -934,57 +934,57 @@ } - if (!p4PStackedImfileInsertFits(dbh, fits)) { - exit(EXIT_FAILURE); - } - - if (!psFitsClose(fits)) { - exit(EXIT_FAILURE); - } - - psDBCleanup(dbh); - } - - { - psDB *dbh; - psFits *fits; - - dbh = psDBInit("localhost", "test", NULL, "test"); - if (!dbh) { - exit(EXIT_FAILURE); - } - - // open a temp - fits = psFitsOpen(TMP_FILENAME, "r"); - if (!fits) { - exit(EXIT_FAILURE); - } - - if (!p4PDiffImfileInsertFits(dbh, fits)) { - exit(EXIT_FAILURE); - } - - if (!psFitsClose(fits)) { - exit(EXIT_FAILURE); - } - - psDBCleanup(dbh); - } - - { - psDB *dbh; - psFits *fits; - - dbh = psDBInit("localhost", "test", NULL, "test"); - if (!dbh) { - exit(EXIT_FAILURE); - } - - // open a temp - fits = psFitsOpen(TMP_FILENAME, "r"); - if (!fits) { - exit(EXIT_FAILURE); - } - - if (!p4PMagicMaskImfileInsertFits(dbh, fits)) { + if (!p4StackedImfileInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!p4DiffImfileInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!p4MagicMaskImfileInsertFits(dbh, fits)) { exit(EXIT_FAILURE); } Index: /trunk/ippdb/tests/insertobject.c =================================================================== --- /trunk/ippdb/tests/insertobject.c (revision 10752) +++ /trunk/ippdb/tests/insertobject.c (revision 10753) @@ -777,61 +777,61 @@ { psDB *dbh; - p4PStackedImfileRow *object; - - dbh = psDBInit("localhost", "test", NULL, "test"); - if (!dbh) { - exit(EXIT_FAILURE); - } - - object = p4PStackedImfileRowAlloc(-32, "a string", "a string", "a string", "a string"); - if (!object) { - exit(EXIT_FAILURE); - } - - if (!p4PStackedImfileInsertObject(dbh, object)) { - exit(EXIT_FAILURE); - } - - psFree(object); - psDBCleanup(dbh); - } - - { - psDB *dbh; - p4PDiffImfileRow *object; - - dbh = psDBInit("localhost", "test", NULL, "test"); - if (!dbh) { - exit(EXIT_FAILURE); - } - - object = p4PDiffImfileRowAlloc(-32, "a string", -32, "a string", "a string", "a string", "a string"); - if (!object) { - exit(EXIT_FAILURE); - } - - if (!p4PDiffImfileInsertObject(dbh, object)) { - exit(EXIT_FAILURE); - } - - psFree(object); - psDBCleanup(dbh); - } - - { - psDB *dbh; - p4PMagicMaskImfileRow *object; - - dbh = psDBInit("localhost", "test", NULL, "test"); - if (!dbh) { - exit(EXIT_FAILURE); - } - - object = p4PMagicMaskImfileRowAlloc(-32, "a string", -32, "a string", "a string"); - if (!object) { - exit(EXIT_FAILURE); - } - - if (!p4PMagicMaskImfileInsertObject(dbh, object)) { + p4StackedImfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = p4StackedImfileRowAlloc(-32, "a string", "a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!p4StackedImfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + p4DiffImfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = p4DiffImfileRowAlloc(-32, "a string", -32, "a string", "a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!p4DiffImfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + p4MagicMaskImfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = p4MagicMaskImfileRowAlloc(-32, "a string", -32, "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!p4MagicMaskImfileInsertObject(dbh, object)) { exit(EXIT_FAILURE); } Index: /trunk/ippdb/tests/metadatafromobject.c =================================================================== --- /trunk/ippdb/tests/metadatafromobject.c (revision 10752) +++ /trunk/ippdb/tests/metadatafromobject.c (revision 10753) @@ -1812,13 +1812,13 @@ { psMetadata *md; - p4PStackedImfileRow *object; - bool status; - - object = p4PStackedImfileRowAlloc(-32, "a string", "a string", "a string", "a string"); - if (!object) { - exit(EXIT_FAILURE); - } - - md = p4PStackedImfileMetadataFromObject(object); + p4StackedImfileRow *object; + bool status; + + object = p4StackedImfileRowAlloc(-32, "a string", "a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = p4StackedImfileMetadataFromObject(object); if (!md) { exit(EXIT_FAILURE); @@ -1853,13 +1853,13 @@ { psMetadata *md; - p4PDiffImfileRow *object; - bool status; - - object = p4PDiffImfileRowAlloc(-32, "a string", -32, "a string", "a string", "a string", "a string"); - if (!object) { - exit(EXIT_FAILURE); - } - - md = p4PDiffImfileMetadataFromObject(object); + p4DiffImfileRow *object; + bool status; + + object = p4DiffImfileRowAlloc(-32, "a string", -32, "a string", "a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = p4DiffImfileMetadataFromObject(object); if (!md) { exit(EXIT_FAILURE); @@ -1902,13 +1902,13 @@ { psMetadata *md; - p4PMagicMaskImfileRow *object; - bool status; - - object = p4PMagicMaskImfileRowAlloc(-32, "a string", -32, "a string", "a string"); - if (!object) { - exit(EXIT_FAILURE); - } - - md = p4PMagicMaskImfileMetadataFromObject(object); + p4MagicMaskImfileRow *object; + bool status; + + object = p4MagicMaskImfileRowAlloc(-32, "a string", -32, "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = p4MagicMaskImfileMetadataFromObject(object); if (!md) { exit(EXIT_FAILURE); Index: /trunk/ippdb/tests/objectfrommetadata.c =================================================================== --- /trunk/ippdb/tests/objectfrommetadata.c (revision 10752) +++ /trunk/ippdb/tests/objectfrommetadata.c (revision 10753) @@ -2774,5 +2774,5 @@ { psMetadata *md; - p4PStackedImfileRow *object; + p4StackedImfileRow *object; md = psMetadataAlloc(); @@ -2798,5 +2798,5 @@ } - object = p4PStackedImfileObjectFromMetadata(md); + object = p4StackedImfileObjectFromMetadata(md); if (!object) { psFree(md); @@ -2832,5 +2832,5 @@ { psMetadata *md; - p4PDiffImfileRow *object; + p4DiffImfileRow *object; md = psMetadataAlloc(); @@ -2864,5 +2864,5 @@ } - object = p4PDiffImfileObjectFromMetadata(md); + object = p4DiffImfileObjectFromMetadata(md); if (!object) { psFree(md); @@ -2906,5 +2906,5 @@ { psMetadata *md; - p4PMagicMaskImfileRow *object; + p4MagicMaskImfileRow *object; md = psMetadataAlloc(); @@ -2930,5 +2930,5 @@ } - object = p4PMagicMaskImfileObjectFromMetadata(md); + object = p4MagicMaskImfileObjectFromMetadata(md); if (!object) { psFree(md); Index: /trunk/ippdb/tests/selectrowsfits.c =================================================================== --- /trunk/ippdb/tests/selectrowsfits.c (revision 10752) +++ /trunk/ippdb/tests/selectrowsfits.c (revision 10753) @@ -791,49 +791,49 @@ } - if (!p4PStackedImfileSelectRowsFits(dbh, fits, NULL, 1)) { - exit(EXIT_FAILURE); - } - - psFree(fits); - psDBCleanup(dbh); - } - - { - psDB *dbh; - psFits *fits; - - dbh = psDBInit("localhost", "test", NULL, "test"); - if (!dbh) { - exit(EXIT_FAILURE); - } - - fits = psFitsOpen(TMP_FILENAME, "w"); - if (!fits) { - exit(EXIT_FAILURE); - } - - if (!p4PDiffImfileSelectRowsFits(dbh, fits, NULL, 1)) { - exit(EXIT_FAILURE); - } - - psFree(fits); - psDBCleanup(dbh); - } - - { - psDB *dbh; - psFits *fits; - - dbh = psDBInit("localhost", "test", NULL, "test"); - if (!dbh) { - exit(EXIT_FAILURE); - } - - fits = psFitsOpen(TMP_FILENAME, "w"); - if (!fits) { - exit(EXIT_FAILURE); - } - - if (!p4PMagicMaskImfileSelectRowsFits(dbh, fits, NULL, 1)) { + if (!p4StackedImfileSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!p4DiffImfileSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!p4MagicMaskImfileSelectRowsFits(dbh, fits, NULL, 1)) { exit(EXIT_FAILURE); }