IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 18336


Ignore:
Timestamp:
Jun 26, 2008, 3:39:54 PM (18 years ago)
Author:
jhoblitt
Message:

consitently handle *_id fields as numeric values instead of converting back of forth between ints and strings

Location:
trunk/ippTools
Files:
2 deleted
26 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippTools/scripts/regtest.sh

    r18157 r18336  
    99
    1010exp_id1=`$inject -newExp -tmp_exp_name t10 -tmp_inst gpc -tmp_telescope ps1 -workdir file::///some/path -reduction batman -simple` || exit 1
     11
     12echo $exp_id1
    1113
    1214for ID in `seq 0 3`; do

  • trunk/ippTools/src/Makefile.am

    r18029 r18336  
    3030        pxdata.h \
    3131        pxfake.h \
    32         pxio.h \
    3332        pxregister.h \
    3433        pxtag.h \
    … …  
    7069        pxfake.c \
    7170        pxfault.c \
    72         pxio.c \
    7371        pxregister.c \
    7472        pxtag.c \

  • trunk/ippTools/src/caltool.c

    r16170 r18336  
    152152
    153153    if (psArrayLength(output)) {
    154         if (!convertIdToStr(output)) {
    155             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    156             psFree(output);
    157             return false;
    158         }
    159 
    160154        // negative simple so the default is true
    161155        if (!ippdbPrintMetadatas(stdout, output, "calDB", !simple)) {
    … …  
    247241
    248242    if (psArrayLength(output)) {
    249         if (!convertIdToStr(output)) {
    250             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    251             psFree(output);
    252             return false;
    253         }
    254 
    255243        // negative simple so the default is true
    256244        if (!ippdbPrintMetadatas(stdout, output, "calRun", !simple)) {

  • trunk/ippTools/src/camtool.c

    r18093 r18336  
    9797    PS_ASSERT_PTR_NON_NULL(config, NULL);
    9898
    99     PXOPT_LOOKUP_STR(chip_id, config->args, "-chip_id", false, false);
    100     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    101 
    10299    psMetadata *where = psMetadataAlloc();
    103     // convert chip_id into a psS64
    104     if (chip_id) {
    105         if (!psMetadataAddS64(where, PS_LIST_TAIL, "chip_id", 0, "==", (psS64)atoll(chip_id))) {
    106             psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    107             psFree(where);
    108             return false;
    109         }
    110     }
    111 
    112     // convert exp_id into a psS64
    113     if (exp_id) {
    114         if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", 0, "==", (psS64)atoll(exp_id))) {
    115             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    116             psFree(where);
    117             return false;
    118         }
    119     }
    120 
     100    PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
     101    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    121102    PXOPT_COPY_STR(config->args, where, "-exp_name", "exp_name", "==");
    122103    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
    … …  
    268249    PS_ASSERT_PTR_NON_NULL(config, false);
    269250
    270     PXOPT_LOOKUP_STR(cam_id, config->args, "-cam_id", false, false);
    271     PXOPT_LOOKUP_STR(chip_id, config->args, "-chip_id", false, false);
    272     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    273 
    274251    psMetadata *where = psMetadataAlloc();
    275     // convert cam_id into a psS64
    276     if (cam_id) {
    277         if (!psMetadataAddS64(where, PS_LIST_TAIL, "cam_id", 0, "==", (psS64)atoll(cam_id))) {
    278             psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
    279             psFree(where);
    280             return false;
    281         }
    282     }
    283 
    284     // convert chip_id into a psS64
    285     if (chip_id) {
    286         if (!psMetadataAddS64(where, PS_LIST_TAIL, "chip_id", 0, "==", (psS64)atoll(chip_id))) {
    287             psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    288             psFree(where);
    289             return false;
    290         }
    291     }
    292 
    293     // convert exp_id into a psS64
    294     if (exp_id) {
    295         if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", 0, "==", (psS64)atoll(exp_id))) {
    296             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    297             psFree(where);
    298             return false;
    299         }
    300     }
    301 
     252    PXOPT_COPY_S64(config->args, where, "-cam_id", "cam_id", "==");
     253    PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
     254    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    302255    PXOPT_COPY_STR(config->args, where, "-exp_name", "exp_name", "==");
    303256    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
    … …  
    421374    }
    422375
    423     if (!convertIdToStr(output)) {
    424         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    425         psFree(output);
    426         return false;
    427     }
    428 
    429376    // negate simple so the default is true
    430377    if (!ippdbPrintMetadatas(stdout, output, "camPendingExp", !simple)) {
    … …  
    475422    }
    476423
    477     if (!convertIdToStr(output)) {
    478         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    479         psFree(output);
    480         return false;
    481     }
    482 
    483424    // negate simple so the default is true
    484425    if (!ippdbPrintMetadatas(stdout, output, "chipProcessedImfile", !simple)) {
    … …  
    498439
    499440    // required
    500     PXOPT_LOOKUP_STR(cam_id, config->args, "-cam_id", true, false);
     441    PXOPT_LOOKUP_S64(cam_id, config->args, "-cam_id", true, false);
    501442    PXOPT_LOOKUP_STR(uri, config->args, "-uri", true, false);
    502443
    … …  
    554495        psMetadata *where = psMetadataAlloc();
    555496        if (cam_id) {
    556             if (!psMetadataAddS64(where, PS_LIST_TAIL, "cam_id", 0, "==", (psS64)atoll(cam_id))) {
     497            if (!psMetadataAddS64(where, PS_LIST_TAIL, "cam_id", 0, "==", cam_id)) {
    557498                psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
    558499                psFree(where);
    … …  
    746687    }
    747688
    748     if (!convertIdToStr(output)) {
    749         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    750         psFree(output);
    751         return false;
    752     }
    753 
    754689    // negate simple so the default is true
    755690    if (!ippdbPrintMetadatas(stdout, output, "camProcessedExp", !simple)) {
    … …  
    769704    PS_ASSERT_PTR_NON_NULL(config, false);
    770705
    771     PXOPT_LOOKUP_STR(cam_id, config->args, "-cam_id", false, false);
    772     PXOPT_LOOKUP_STR(chip_id, config->args, "-chip_id", false, false);
    773     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    774 
    775706    psMetadata *where = psMetadataAlloc();
    776     // convert cam_id into a psS64
    777     if (cam_id) {
    778         if (!psMetadataAddS64(where, PS_LIST_TAIL, "cam_id", 0, "==", (psS64)atoll(cam_id))) {
    779             psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
    780             psFree(where);
    781             return false;
    782         }
    783     }
    784 
    785     // convert chip_id into a psS64
    786     if (chip_id) {
    787         if (!psMetadataAddS64(where, PS_LIST_TAIL, "chip_id", 0, "==", (psS64)atoll(chip_id))) {
    788             psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    789             psFree(where);
    790             return false;
    791         }
    792     }
    793 
    794     // convert exp_id into a psS64
    795     if (exp_id) {
    796         if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", 0, "==", (psS64)atoll(exp_id))) {
    797             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    798             psFree(where);
    799             return false;
    800         }
    801     }
    802 
     707    PXOPT_COPY_S64(config->args, where, "-cam_id", "cam_id", "==");
     708    PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
     709    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    803710    PXOPT_COPY_STR(config->args, where, "-exp_name", "exp_name", "==");
    804711    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
    … …  
    977884    }
    978885
    979     if (!convertIdToStr(output)) {
    980         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    981         psFree(output);
    982         return false;
    983     }
    984 
    985886    // negative simple so the default is true
    986887    if (!ippdbPrintMetadatas(stdout, output, "camMask", !simple)) {

  • trunk/ippTools/src/camtoolConfig.c

    r18172 r18336  
    4949    psMetadata *definebydefinebyqueryArgs = psMetadataAlloc();
    5050    // XXX need to allow multiple chip_ids
    51     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-chip_id",  0,
    52             "search by chip_id", NULL);
     51    psMetadataAddS64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-chip_id",  0,
     52            "search by chip_id", 0);
    5353    // XXX need to allow multiple exp_ids
    54     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_id",  0,
    55             "search by exp_id", NULL);
     54    psMetadataAddS64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_id",  0,
     55            "search by exp_id", 0);
    5656    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_name",  0,
    5757            "search by exp_name", NULL);
    … …  
    148148    psMetadata *updaterunArgs = psMetadataAlloc();
    149149    // XXX need to allow multiple cam_ids
    150     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-cam_id",  0,
    151             "search by cam_id", NULL);
     150    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-cam_id",  0,
     151            "search by cam_id", 0);
    152152    // XXX need to allow multiple chip_ids
    153     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-chip_id",  0,
    154             "search by chip_id", NULL);
     153    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-chip_id",  0,
     154            "search by chip_id", 0);
    155155    // XXX need to allow multiple exp_ids
    156     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_id",  0,
    157             "search by exp_id", NULL);
     156    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-exp_id",  0,
     157            "search by exp_id", 0);
    158158    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_name",  0,
    159159            "search by exp_name", NULL);
    … …  
    241241    // -pendingexp
    242242    psMetadata *pendingexpArgs = psMetadataAlloc();
    243     psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-cam_id", 0,
    244             "search by camtool ID", NULL);
    245     psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-chip_id", 0,
    246             "search by chiptool ID", NULL);
     243    psMetadataAddS64(pendingexpArgs, PS_LIST_TAIL, "-cam_id", 0,
     244            "search by camtool ID", 0);
     245    psMetadataAddS64(pendingexpArgs, PS_LIST_TAIL, "-chip_id", 0,
     246            "search by chiptool ID", 0);
    247247    psMetadataAddU64(pendingexpArgs, PS_LIST_TAIL, "-limit",  0,
    248248            "limit result set to N items", 0);
    … …  
    253253    // -pendingimfile
    254254    psMetadata *pendingimfileArgs = psMetadataAlloc();
    255     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-cam_id", 0,
    256             "search by camtool ID", NULL);
    257     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-chip_id", 0,
    258             "search by chiptool ID", NULL);
     255    psMetadataAddS64(pendingimfileArgs, PS_LIST_TAIL, "-cam_id", 0,
     256            "search by camtool ID", 0);
     257    psMetadataAddS64(pendingimfileArgs, PS_LIST_TAIL, "-chip_id", 0,
     258            "search by chiptool ID", 0);
    259259    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-class", 0,
    260260            "search by class", NULL);
    … …  
    267267    // -addprocessedexp
    268268    psMetadata *addprocessedexpArgs = psMetadataAlloc();
    269     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-cam_id", 0,
    270             "define camtool ID (required)", NULL);
     269    psMetadataAddS64(addprocessedexpArgs, PS_LIST_TAIL, "-cam_id", 0,
     270            "define camtool ID (required)", 0);
    271271    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-uri", 0,
    272272            "define URI (required)", NULL);
    … …  
    328328    // -processedexp
    329329    psMetadata *processedexpArgs = psMetadataAlloc();
    330     psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-cam_id", 0,
    331             "search by camtool ID", NULL);
    332     psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-chip_id", 0,
    333             "search by chiptool ID", NULL);
     330    psMetadataAddS64(processedexpArgs, PS_LIST_TAIL, "-cam_id", 0,
     331            "search by camtool ID", 0);
     332    psMetadataAddS64(processedexpArgs, PS_LIST_TAIL, "-chip_id", 0,
     333            "search by chiptool ID", 0);
    334334    psMetadataAddU64(processedexpArgs, PS_LIST_TAIL, "-limit",  0,
    335335            "limit result set to N items", 0);
    … …  
    342342    psMetadata *revertprocessedexpArgs = psMetadataAlloc();
    343343    // XXX need to allow multiple cam_ids
    344     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-cam_id",  0,
    345             "search by cam_id", NULL);
     344    psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-cam_id",  0,
     345            "search by cam_id", 0);
    346346    // XXX need to allow multiple chip_ids
    347     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-chip_id",  0,
    348             "search by chip_id", NULL);
     347    psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-chip_id",  0,
     348            "search by chip_id", 0);
    349349    // XXX need to allow multiple exp_ids
    350     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_id",  0,
    351             "search by exp_id", NULL);
     350    psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_id",  0,
     351            "search by exp_id", 0);
    352352    psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_name",  0,
    353353            "search by exp_name", NULL);
    … …  
    433433    // -updateprocessedexp
    434434    psMetadata *updateprocessedexpArgs = psMetadataAlloc();
    435     psMetadataAddStr(updateprocessedexpArgs, PS_LIST_TAIL, "-cam_id", 0,
    436             "search by camtool ID", NULL);
    437     psMetadataAddStr(updateprocessedexpArgs, PS_LIST_TAIL, "-chip_id",  0,
    438             "search by chiptool ID", NULL);
     435    psMetadataAddS64(updateprocessedexpArgs, PS_LIST_TAIL, "-cam_id", 0,
     436            "search by camtool ID", 0);
     437    psMetadataAddS64(updateprocessedexpArgs, PS_LIST_TAIL, "-chip_id",  0,
     438            "search by chiptool ID", 0);
    439439    psMetadataAddStr(updateprocessedexpArgs, PS_LIST_TAIL, "-class",  0,
    440440            "search by class", NULL);

  • trunk/ippTools/src/chiptool.c

    r18321 r18336  
    106106    PS_ASSERT_PTR_NON_NULL(config, NULL);
    107107
    108     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
     108    PXOPT_LOOKUP_S64(exp_id, config->args, "-exp_id", false, false);
    109109
    110110    psMetadata *where = psMetadataAlloc();
    111     // convert exp_id into a psS64
    112     if (exp_id) {
    113         if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", 0, "==", (psS64)atoll(exp_id))) {
    114             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    115             psFree(where);
    116             return false;
    117         }
    118     }
    119 
     111    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    120112    PXOPT_COPY_STR(config->args, where, "-exp_name", "exp_name", "==");
    121113    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
    … …  
    263255
    264256    psMetadata *where = psMetadataAlloc();
    265     PXOPT_LOOKUP_STR(chip_id, config->args, "-chip_id", false, false);
    266     // convert chip_id into a psS64
    267     if (chip_id) {
    268         if (!psMetadataAddS64(where, PS_LIST_TAIL, "chip_id", 0, "==", (psS64)atoll(chip_id))) {
    269             psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    270             psFree(where);
    271             return false;
    272         }
    273     }
    274 
    275     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    276     // convert exp_id into a psS64
    277     if (exp_id) {
    278         if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", 0, "==", (psS64)atoll(exp_id))) {
    279             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    280             psFree(where);
    281             return false;
    282         }
    283     }
    284 
    285     PXOPT_COPY_STR(config->args,  where, "-chip_id", "chip_id", "==");
    286     PXOPT_COPY_STR(config->args,  where, "-exp_id", "exp_id", "==");
     257    PXOPT_COPY_S64(config->args,  where, "-chip_id", "chip_id", "==");
     258    PXOPT_COPY_S64(config->args,  where, "-exp_id", "exp_id", "==");
    287259    PXOPT_COPY_STR(config->args,  where, "-exp_name", "exp_name", "==");
    288260    PXOPT_COPY_STR(config->args,  where, "-inst", "camera", "==");
    … …  
    371343
    372344    psMetadata *where = psMetadataAlloc();
    373     PXOPT_LOOKUP_STR(chip_id, config->args, "-chip_id", false, false);
    374     // convert chip_id into a psS64
    375     if (chip_id) {
    376         if (!psMetadataAddS64(where, PS_LIST_TAIL, "chipRun.chip_id", 0, "==", (psS64)atoll(chip_id))) {
    377             psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    378             psFree(where);
    379             return false;
    380         }
    381     }
    382 
    383     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    384     // convert exp_id into a psS64
    385     if (exp_id) {
    386         if (!psMetadataAddS64(where, PS_LIST_TAIL, "rawExp.exp_id", 0, "==", (psS64)atoll(exp_id))) {
    387             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    388             psFree(where);
    389             return false;
    390         }
    391     }
    392 
     345    PXOPT_COPY_S64(config->args, where, "-chip_id", "chipRun.chip_id", "==");
     346    PXOPT_COPY_S64(config->args, where, "-exp_id", "rawExp.exp_id", "==");
    393347    PXOPT_COPY_STR(config->args, where, "-class_id", "rawImfile.class_id", "==");
    394348    PXOPT_COPY_STR(config->args, where, "-inst", "rawExp.telescope", "==");
    … …  
    433387    }
    434388
    435     if (!convertIdToStr(output)) {
    436         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    437         psFree(output);
    438         return false;
    439     }
    440 
    441389    // negative simple so the default is true
    442390    if (!ippdbPrintMetadatas(stdout, output, "chipPendingImfile", !simple)) {
    … …  
    457405
    458406    // chip_id, ext_tag, class_id are required
    459     PXOPT_LOOKUP_STR(chip_id, config->args, "-chip_id", true, false);
    460     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", true, false);
     407    PXOPT_LOOKUP_S64(chip_id, config->args, "-chip_id", true, false);
     408    PXOPT_LOOKUP_S64(exp_id, config->args, "-exp_id", true, false);
    461409    PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false);
    462410
    … …  
    498446
    499447    if (!chipProcessedImfileInsert(config->dbh,
    500                                    (psS64)atoll(chip_id),
    501                                    (psS64)atoll(exp_id),
     448                                   chip_id,
     449                                   exp_id,
    502450                                   class_id,
    503451                                   uri,
    … …  
    569517
    570518    psMetadata *where = psMetadataAlloc();
    571     PXOPT_LOOKUP_STR(chip_id, config->args, "-chip_id", false, false);
    572     // convert chip_id into a psS64
    573     if (chip_id) {
    574         if (!psMetadataAddS64(where, PS_LIST_TAIL, "chipRun.chip_id", 0, "==", (psS64)atoll(chip_id))) {
    575             psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    576             psFree(where);
    577             return false;
    578         }
    579     }
    580 
    581     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    582     // convert exp_id into a psS64
    583     if (exp_id) {
    584         if (!psMetadataAddS64(where, PS_LIST_TAIL, "rawExp.exp_id", 0, "==", (psS64)atoll(exp_id))) {
    585             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    586             psFree(where);
    587             return false;
    588         }
    589     }
    590 
     519    PXOPT_COPY_S64(config->args, where, "-chip_id", "chipRun.chip_id", "==");
     520    PXOPT_COPY_S64(config->args, where, "-exp_id", "rawExp.chip_id", "==");
    591521    PXOPT_COPY_STR(config->args, where, "-class_id", "rawImfile.class_id", "==");
    592522    PXOPT_COPY_STR(config->args, where, "-inst", "rawExp.telescope", "==");
    … …  
    639569    }
    640570
    641     if (!convertIdToStr(output)) {
    642         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    643         psFree(output);
    644         return false;
    645     }
    646 
    647571    // negative simple so the default is true
    648572    if (!ippdbPrintMetadatas(stdout, output, "chipProcessedImfile", !simple)) {
    … …  
    662586
    663587    psMetadata *where = psMetadataAlloc();
    664     PXOPT_LOOKUP_STR(chip_id, config->args, "-chip_id", false, false);
    665     // convert chip_id into a psS64
    666     if (chip_id) {
    667         if (!psMetadataAddS64(where, PS_LIST_TAIL, "chip_id", 0, "==", (psS64)atoll(chip_id))) {
    668             psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    669             psFree(where);
    670             return false;
    671         }
    672     }
    673 
    674     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    675     // convert exp_id into a psS64
    676     if (exp_id) {
    677         if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", 0, "==", (psS64)atoll(exp_id))) {
    678             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    679             psFree(where);
    680             return false;
    681         }
    682     }
    683 
     588    PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
     589    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    684590    PXOPT_COPY_STR(config->args, where, "-exp_name", "exp_name", "==");
    685591    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
    … …  
    832738    }
    833739
    834     if (!convertIdToStr(output)) {
    835         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    836         psFree(output);
    837         return false;
    838     }
    839 
    840740    // negative simple so the default is true
    841741    if (!ippdbPrintMetadatas(stdout, output, "chipMask", !simple)) {
    … …  
    905805    }
    906806
    907     if (!convertIdToStr(output)) {
    908         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    909         psFree(output);
    910         return false;
    911     }
    912 
    913807    // negative simple so the default is true
    914808    if (!ippdbPrintMetadatas(stdout, output, "chipUnmask", !simple)) {
    … …  
    989883    }
    990884
    991     if (!convertIdToStr(output)) {
    992         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    993         psFree(output);
    994         return false;
    995     }
    996 
    997885    // negative simple so the default is true
    998886    if (!ippdbPrintMetadatas(stdout, output, "chipPendingCleanup", !simple)) {
    … …  
    1054942        psFree(output);
    1055943        return true;
    1056     }
    1057 
    1058     if (!convertIdToStr(output)) {
    1059         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    1060         psFree(output);
    1061         return false;
    1062944    }
    1063945

  • trunk/ippTools/src/chiptoolConfig.c

    r18321 r18336  
    22 * chiptoolConfig.c
    33 *
    4  * Copyright (C) 2006  Joshua Hoblitt
     4 * Copyright (C) 2006-2008  Joshua Hoblitt
    55 *
    66 * This program is free software; you can redistribute it and/or modify it
    … …  
    4747    psMetadata *queueArgs = psMetadataAlloc();
    4848    // XXX need to allow multiple exp_ids
    49     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exp_id", NULL);
     49    psMetadataAddS64(queueArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exp_id", 0);
    5050    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-exp_name",  0,            "search by exp_name", NULL);
    5151    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-inst",  0,            "search for camera", NULL);
    … …  
    100100    // -updaterun
    101101    psMetadata *updaterunArgs = psMetadataAlloc();
    102     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-chip_id",              0,            "search by chip ID", NULL);
    103     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_id",                 0,            "search by exp_id", NULL);
     102    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-chip_id",              0,            "search by chip ID", 0);
     103    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-exp_id",                 0,            "search by exp_id", 0);
    104104    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_name",             0,            "search by exp_name", NULL);
    105105    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-inst",                 0,            "search for camera", NULL);
    … …  
    148148    // -pendingimfile
    149149    psMetadata *pendingimfileArgs = psMetadataAlloc();
    150     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-chip_id",  0,            "search by chip ID", NULL);
    151     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", NULL);
     150    psMetadataAddS64(pendingimfileArgs, PS_LIST_TAIL, "-chip_id",  0,            "search by chip ID", 0);
     151    psMetadataAddS64(pendingimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", 0);
    152152    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    153153    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-inst",  0,            "search by camera of interest", NULL);
    … …  
    158158    // -addprocessedimfile
    159159    psMetadata *addprocessedimfileArgs = psMetadataAlloc();
    160     psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-chip_id",  0,            "define chip ID (required)", NULL);
    161     psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "define exposure ID (required)", NULL);
     160    psMetadataAddS64(addprocessedimfileArgs, PS_LIST_TAIL, "-chip_id",  0,            "define chip ID (required)", 0);
     161    psMetadataAddS64(addprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "define exposure ID (required)", 0);
    162162    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "define class ID (required)", NULL);
    163163    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-uri",  0,            "define URL", NULL);
    … …  
    192192    // -processedimfile
    193193    psMetadata *processedimfileArgs = psMetadataAlloc();
    194     psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-chip_id",  0,            "define chip ID", NULL);
    195     psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "define exposure ID", NULL);
     194    psMetadataAddS64(processedimfileArgs, PS_LIST_TAIL, "-chip_id",  0,            "define chip ID", 0);
     195    psMetadataAddS64(processedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "define exposure ID", 0);
    196196    psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "define class ID", NULL);
    197197    psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-inst",  0,            "define camera of interest", NULL);
    … …  
    203203    // -updateprocessedimfile
    204204    psMetadata *updateprocessedimfileArgs = psMetadataAlloc();
    205     psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-chip_id",  0,            "search by chip ID", NULL);
    206     psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", NULL);
     205    psMetadataAddS64(updateprocessedimfileArgs, PS_LIST_TAIL, "-chip_id",  0,            "search by chip ID", 0);
     206    psMetadataAddS64(updateprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", 0);
    207207    psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    208208    psMetadataAddS16(updateprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,            "set fault code (required)", 0);
    … …  
    210210    // -revertprocessedimfile
    211211    psMetadata *revertprocessedimfileArgs = psMetadataAlloc();
    212     psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-chip_id", 0,            "search by chip ID", NULL);
    213     psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exp_id", NULL);
     212    psMetadataAddS64(revertprocessedimfileArgs, PS_LIST_TAIL, "-chip_id", 0,            "search by chip ID", 0);
     213    psMetadataAddS64(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exp_id", 0);
    214214    psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_name",  0,            "search by exp_name", NULL);
    215215    psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-inst",  0,            "search for camera", NULL);

  • trunk/ippTools/src/dettool.c

    r18157 r18336  
    459459    }
    460460
    461     if (!convertIdToStr(detRuns)) {
    462         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    463         psFree(detRuns);
    464         return false;
    465     }
    466 
    467461    // negative simple so the default is true
    468462    if (!ippdbPrintMetadatas(stdout, detRuns, "detRun", !simple)) {
    … …  
    722716    }
    723717
    724     // convert det_id to a string externaly
    725     if (!convertIdToStr(detRuns)) {
    726         psError(PS_ERR_UNKNOWN, false, "failed to convert det_id to a string");
    727         psFree(detRuns);
    728         return false;
    729     }
    730 
    731718    // negative simple so the default is true
    732719    if (!ippdbPrintMetadatas(stdout, detRuns, "detRun", !simple)) {
    … …  
    10151002    }
    10161003
    1017     // convert det_id to a string externaly
    1018     if (!convertIdToStr(detRuns)) {
    1019         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    1020         psFree(detRuns);
    1021         return false;
    1022     }
    1023 
    10241004    // negative simple so the default is true
    10251005    if (!ippdbPrintMetadatas(stdout, newDetRuns, "detRun", !simple)) {
    … …  
    11141094        psFree(runs);
    11151095        return true;
    1116     }
    1117 
    1118     // convert det_id to a string externaly
    1119     if (!convertIdToStr(runs)) {
    1120         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    1121         psFree(runs);
    1122         return false;
    11231096    }
    11241097
    … …  
    11831156        psFree(output);
    11841157        return true;
    1185     }
    1186 
    1187     // convert det_id to a string externaly
    1188     if (!convertIdToStr(output)) {
    1189         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    1190         psFree(output);
    1191         return false;
    11921158    }
    11931159
    … …  
    42854251    }
    42864252
    4287     if (!convertIdToStr(detRuns)) {
    4288         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    4289         psFree(detRuns);
    4290         return false;
    4291     }
    4292 
    42934253    // negative simple so the default is true
    42944254    if (!ippdbPrintMetadatas(stdout, detRuns, "detRun", !simple)) {

  • trunk/ippTools/src/dettool_correction.c

    r15830 r18336  
    120120    }
    121121
    122     if (!convertIdToStr(detRuns)) {
    123         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    124         psFree(detRuns);
    125         return false;
    126     }
    127 
    128122    bool simple = false;
    129123    {

  • trunk/ippTools/src/difftool.c

    r18093 r18336  
    4242static bool definebyqueryMode(pxConfig *config);
    4343
    44 static bool setdiffRunState(pxConfig *config, const char *diff_id, const char *state);
     44static bool setdiffRunState(pxConfig *config, psS64 diff_id, const char *state);
    4545
    4646# define MODECASE(caseName, func) \
    … …  
    146146
    147147    // required options
    148     PXOPT_LOOKUP_STR(diff_id, config->args, "-diff_id", true, false);
     148    PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", true, false);
    149149    PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
    150150
    … …  
    163163
    164164    // required options
    165     PXOPT_LOOKUP_STR(diff_id, config->args, "-diff_id", true, false);
     165    PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", true, false);
    166166
    167167    // optional
    168     PXOPT_LOOKUP_STR(stack_id, config->args, "-stack_id", false, false);
    169     PXOPT_LOOKUP_STR(warp_id, config->args, "-warp_id", false, false);
     168    PXOPT_LOOKUP_S64(stack_id, config->args, "-stack_id", false, false);
     169    PXOPT_LOOKUP_S64(warp_id, config->args, "-warp_id", false, false);
    170170    PXOPT_LOOKUP_STR(kind, config->args, "-kind", false, false);
    171171
    … …  
    188188    psString tess_id = NULL;
    189189    if (warp_id) {
    190         if (!p_psDBRunQuery(config->dbh, "SELECT * from diffRun WHERE diff_id = %" PRId64, (psS64)atoll(diff_id))) {
     190        if (!p_psDBRunQuery(config->dbh, "SELECT * from diffRun WHERE diff_id = %" PRId64, diff_id)) {
    191191            psError(PS_ERR_UNKNOWN, false, "database error");
    192192            return false;
    … …  
    199199        }
    200200        if (!psArrayLength(output)) {
    201             psError(PS_ERR_UNKNOWN, false, "diff_id %" PRId64 " not found", (psS64)atoll(diff_id));
     201            psError(PS_ERR_UNKNOWN, false, "diff_id %" PRId64 " not found", diff_id);
    202202            psFree(output);
    203203            return false;
    … …  
    215215
    216216    if (!diffInputSkyfileInsert(config->dbh,
    217             (psS64)atoll(diff_id),
     217            diff_id,
    218218            template,
    219             stack_id ? (psS64)atoll(stack_id) : PS_MAX_S64, // defined or NULL
    220             warp_id ? (psS64)atoll(warp_id) : PS_MAX_S64, // defined or NULL
     219            stack_id ? stack_id : PS_MAX_S64, // defined or NULL
     220            warp_id ? warp_id : PS_MAX_S64, // defined or NULL
    221221            skycell_id,
    222222            tess_id,
    … …  
    230230    }
    231231
    232     if (!p_psDBRunQuery(config->dbh, "SELECT count(diff_id) FROM diffRun JOIN diffInputSkyfile USING(diff_id) WHERE diff_id = %" PRId64, (psS64)atoll(diff_id))) {
     232    if (!p_psDBRunQuery(config->dbh, "SELECT count(diff_id) FROM diffRun JOIN diffInputSkyfile USING(diff_id) WHERE diff_id = %" PRId64, diff_id)) {
    233233        if (!psDBRollback(config->dbh)) {
    234234            psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    250250            psError(PS_ERR_UNKNOWN, false, "database error");
    251251        }
    252         psError(PS_ERR_UNKNOWN, false, "diff_id %" PRId64 " not found", (psS64)atoll(diff_id));
     252        psError(PS_ERR_UNKNOWN, false, "diff_id %" PRId64 " not found", diff_id);
    253253        psFree(output);
    254254        return false;
    … …  
    333333
    334334    if (psArrayLength(output)) {
    335         if (!convertIdToStr(output)) {
    336             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    337             psFree(output);
    338             return false;
    339         }
    340 
    341335        // negative simple so the default is true
    342336        if (!ippdbPrintMetadatas(stdout, output, "diffInputSkyfile", !simple)) {
    … …  
    407401
    408402    if (psArrayLength(output)) {
    409         if (!convertIdToStr(output)) {
    410             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    411             psFree(output);
    412             return false;
    413         }
    414 
    415403        // negative simple so the default is true
    416404        if (!ippdbPrintMetadatas(stdout, output, "diffSkyfile", !simple)) {
    … …  
    432420
    433421    // required
    434     PXOPT_LOOKUP_STR(diff_id, config->args, "-diff_id", true, false);
     422    PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", true, false);
    435423
    436424    // default to 0
    … …  
    465453
    466454    if (!diffSkyfileInsert(config->dbh,
    467                            (psS64)atoll(diff_id),
     455                           diff_id,
    468456                           uri,
    469457                           path_base,
    … …  
    557545
    558546    if (psArrayLength(output)) {
    559         if (!convertIdToStr(output)) {
    560             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    561             psFree(output);
    562             return false;
    563         }
    564 
    565547        // negative simple so the default is true
    566548        if (!ippdbPrintMetadatas(stdout, output, "diffSkyfile", !simple)) {
    … …  
    609591
    610592
    611 static bool setdiffRunState(pxConfig *config, const char *diff_id, const char *state)
    612 {
    613     PS_ASSERT_PTR_NON_NULL(diff_id, false);
     593static bool setdiffRunState(pxConfig *config, psS64 diff_id, const char *state)
     594{
    614595    PS_ASSERT_PTR_NON_NULL(state, false);
    615596
    … …  
    626607    }
    627608
    628     char *query = "UPDATE diffRun SET state = '%s' WHERE diff_id = '%s'";
     609    char *query = "UPDATE diffRun SET state = '%s' WHERE diff_id = %"PRId64;
    629610    if (!p_psDBRunQuery(config->dbh, query, state, diff_id)) {
    630611        psError(PS_ERR_UNKNOWN, false,
    631                 "failed to change state for diff_id %s", diff_id);
     612                "failed to change state for diff_id %"PRId64, diff_id);
    632613        return false;
    633614    }
    … …  
    766747
    767748    // optional
    768     PXOPT_LOOKUP_STR(template_stack_id, config->args, "-template_stack_id", false, false);
    769     PXOPT_LOOKUP_STR(template_warp_id, config->args, "-template_warp_id", false, false);
     749    PXOPT_LOOKUP_S64(template_stack_id, config->args, "-template_stack_id", false, false);
     750    PXOPT_LOOKUP_S64(template_warp_id, config->args, "-template_warp_id", false, false);
    770751
    771752    if (template_stack_id && template_warp_id) {
    … …  
    779760    }
    780761
    781     PXOPT_LOOKUP_STR(input_stack_id, config->args, "-input_stack_id", false, false);
    782     PXOPT_LOOKUP_STR(input_warp_id, config->args, "-input_warp_id", false, false);
     762    PXOPT_LOOKUP_S64(input_stack_id, config->args, "-input_stack_id", false, false);
     763    PXOPT_LOOKUP_S64(input_warp_id, config->args, "-input_warp_id", false, false);
    783764    if (input_stack_id && input_warp_id) {
    784765        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Only one input can be defined.");
    … …  
    792773
    793774    return populatedrun(workdir, skycell_id, tess_id,
    794                         input_warp_id ? (psS64)atoll(input_warp_id) : PS_MAX_S64,
    795                         input_stack_id ? (psS64)atoll(input_stack_id) : PS_MAX_S64,
    796                         template_warp_id ? (psS64)atoll(template_warp_id) : PS_MAX_S64,
    797                         template_stack_id ? (psS64)atoll(template_stack_id) : PS_MAX_S64,
     775                        input_warp_id ? input_warp_id : PS_MAX_S64,
     776                        input_stack_id ? input_stack_id : PS_MAX_S64,
     777                        template_warp_id ? template_warp_id : PS_MAX_S64,
     778                        template_stack_id ? template_stack_id : PS_MAX_S64,
    798779                        config);
    799780

  • trunk/ippTools/src/difftoolConfig.c

    r18172 r18336  
    6060    // -updaterun
    6161    psMetadata *updaterunArgs = psMetadataAlloc();
    62     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-diff_id", 0,
    63             "define diff ID (required)", NULL);
     62    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-diff_id", 0,
     63            "define diff ID (required)", 0);
    6464    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,
    6565            "set state (required)", NULL);
    … …  
    7373    // -addinputskyfile
    7474    psMetadata *addinputskyfileArgs = psMetadataAlloc();
    75     psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
    76             "define diff ID (required)", NULL);
    77     psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,
    78             "define warp ID", NULL);
    79     psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
    80             "define stack ID", NULL);
     75    psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
     76            "define diff ID (required)", 0);
     77    psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,
     78            "define warp ID", 0);
     79    psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
     80            "define stack ID", 0);
    8181    psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-kind", 0,
    8282            "define kind", NULL);
    … …  
    8686    // -inputskyfile
    8787    psMetadata *inputskyfileArgs = psMetadataAlloc();
    88     psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
    89             "search by diff ID", NULL);
    90     psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,
    91             "search by warp ID", NULL);
     88    psMetadataAddS64(inputskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
     89            "search by diff ID", 0);
     90    psMetadataAddS64(inputskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,
     91            "search by warp ID", 0);
    9292    psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0,
    9393            "search by skycell ID", NULL);
    … …  
    105105    // -todiffskyfile
    106106    psMetadata *todiffskyfileArgs = psMetadataAlloc();
    107     psMetadataAddStr(todiffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
    108             "search by diff ID", NULL);
     107    psMetadataAddS64(todiffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
     108            "search by diff ID", 0);
    109109    psMetadataAddU64(todiffskyfileArgs, PS_LIST_TAIL, "-limit",  0,
    110110            "limit result set to N items", 0);
    … …  
    114114    // -adddiffskyfile
    115115    psMetadata *adddiffskyfileArgs = psMetadataAlloc();
    116     psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
    117             "define warp ID (required)", NULL);
     116    psMetadataAddS64(adddiffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
     117            "define warp ID (required)", 0);
    118118    psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-uri", 0,
    119119            "define URI of file", 0);
    … …  
    141141    // -diffskyfile
    142142    psMetadata *diffskyfileArgs = psMetadataAlloc();
    143     psMetadataAddStr(diffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
    144             "search by warp ID", NULL);
     143    psMetadataAddS64(diffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
     144            "search by warp ID", 0);
    145145    psMetadataAddStr(diffskyfileArgs , PS_LIST_TAIL, "-skycell_id",  0,
    146146            "define skycell ID", NULL);
    … …  
    154154    // -revertdiffskyfile
    155155    psMetadata *revertdiffskyfileArgs = psMetadataAlloc();
    156     psMetadataAddStr(revertdiffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
    157             "define warp ID (required)", NULL);
     156    psMetadataAddS64(revertdiffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
     157            "define warp ID (required)", 0);
    158158    psMetadataAddS16(revertdiffskyfileArgs, PS_LIST_TAIL, "-code",  0,
    159159            "search by fault code", 0);
    … …  
    171171    psMetadataAddBool(definepoprunArgs, PS_LIST_TAIL, "-simple",  0,
    172172            "use the simple output format", false);
    173     psMetadataAddStr(definepoprunArgs, PS_LIST_TAIL, "-template_warp_id", 0,
    174             "define warp ID for template", NULL);
    175     psMetadataAddStr(definepoprunArgs, PS_LIST_TAIL, "-template_stack_id", 0,
    176             "define stack ID for template", NULL);
    177     psMetadataAddStr(definepoprunArgs, PS_LIST_TAIL, "-input_warp_id", 0,
    178             "define warp ID for input", NULL);
    179     psMetadataAddStr(definepoprunArgs, PS_LIST_TAIL, "-input_stack_id", 0,
    180             "define stack ID for input", NULL);
     173    psMetadataAddS64(definepoprunArgs, PS_LIST_TAIL, "-template_warp_id", 0,
     174            "define warp ID for template", 0);
     175    psMetadataAddS64(definepoprunArgs, PS_LIST_TAIL, "-template_stack_id", 0,
     176            "define stack ID for template", 0);
     177    psMetadataAddS64(definepoprunArgs, PS_LIST_TAIL, "-input_warp_id", 0,
     178            "define warp ID for input", 0);
     179    psMetadataAddS64(definepoprunArgs, PS_LIST_TAIL, "-input_stack_id", 0,
     180            "define stack ID for input", 0);
    181181
    182182    // -definebyquery

  • trunk/ippTools/src/faketool.c

    r18093 r18336  
    103103    PS_ASSERT_PTR_NON_NULL(config, NULL);
    104104
    105     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    106 
    107105    psMetadata *where = psMetadataAlloc();
    108     // convert exp_id into a psS64
    109     if (exp_id) {
    110         if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", 0, "==", (psS64)atoll(exp_id))) {
    111             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    112             psFree(where);
    113             return false;
    114         }
    115     }
    116 
     106    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    117107    PXOPT_COPY_STR(config->args, where, "-exp_name", "exp_name", "==");
    118108    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
    … …  
    259249
    260250    psMetadata *where = psMetadataAlloc();
    261     PXOPT_LOOKUP_STR(fake_id, config->args, "-fake_id", false, false);
    262     // convert fake_id into a psS64
    263     if (fake_id) {
    264         if (!psMetadataAddS64(where, PS_LIST_TAIL, "fake_id", 0, "==", (psS64)atoll(fake_id))) {
    265             psError(PS_ERR_UNKNOWN, false, "failed to add item fake_id");
    266             psFree(where);
    267             return false;
    268         }
    269     }
    270 
    271     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    272     // convert exp_id into a psS64
    273     if (exp_id) {
    274         if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", 0, "==", (psS64)atoll(exp_id))) {
    275             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    276             psFree(where);
    277             return false;
    278         }
    279     }
    280 
     251    PXOPT_COPY_S64(config->args, where, "-fake_id", "fake_id", "==");
     252    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    281253    PXOPT_COPY_STR(config->args, where, "-exp_name", "exp_name", "==");
    282254    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
    … …  
    406378    }
    407379
    408     if (!convertIdToStr(output)) {
    409         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    410         psFree(output);
    411         return false;
    412     }
    413 
    414380    // negate simple so the default is true
    415381    if (!ippdbPrintMetadatas(stdout, output, "fakePendingExp", !simple)) {
    … …  
    433399
    434400    psMetadata *where = psMetadataAlloc();
    435     PXOPT_LOOKUP_STR(fake_id, config->args, "-fake_id", false, false);
    436     // convert fake_id into a psS64
    437     if (fake_id) {
    438         if (!psMetadataAddS64(where, PS_LIST_TAIL, "fakeRun.fake_id", 0, "==", (psS64)atoll(fake_id))) {
    439             psError(PS_ERR_UNKNOWN, false, "failed to add item fake_id");
    440             psFree(where);
    441             return false;
    442         }
    443     }
    444 
    445     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    446     // convert exp_id into a psS64
    447     if (exp_id) {
    448         if (!psMetadataAddS64(where, PS_LIST_TAIL, "rawExp.exp_id", 0, "==", (psS64)atoll(exp_id))) {
    449             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    450             psFree(where);
    451             return false;
    452         }
    453     }
    454 
     401    PXOPT_COPY_S64(config->args, where, "-fake_id", "fake_id", "==");
     402    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    455403    PXOPT_COPY_STR(config->args, where, "-class_id", "rawImfile.class_id", "==");
    456404    PXOPT_COPY_STR(config->args, where, "-inst", "rawExp.telescope", "==");
    … …  
    495443    }
    496444
    497     if (!convertIdToStr(output)) {
    498         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    499         psFree(output);
    500         return false;
    501     }
    502 
    503445    // negative simple so the default is true
    504446    if (!ippdbPrintMetadatas(stdout, output, "fakePendingImfile", !simple)) {
    … …  
    519461
    520462    // fake_id, ext_tag, class_id are required
    521     PXOPT_LOOKUP_STR(fake_id, config->args,     "-fake_id", true, false);
    522     PXOPT_LOOKUP_STR(exp_id, config->args,      "-exp_id", true, false);
     463    PXOPT_LOOKUP_S64(fake_id, config->args,     "-fake_id", true, false);
     464    PXOPT_LOOKUP_S64(exp_id, config->args,      "-exp_id", true, false);
    523465    PXOPT_LOOKUP_STR(class_id, config->args,    "-class_id", true, false);
    524466
    … …  
    539481
    540482    if (!fakeProcessedImfileInsert(config->dbh,
    541                                    (psS64)atoll(fake_id),
    542                                    (psS64)atoll(exp_id),
     483                                   fake_id,
     484                                   exp_id,
    543485                                   class_id,
    544486                                   uri,
    … …  
    589531
    590532    psMetadata *where = psMetadataAlloc();
    591     PXOPT_LOOKUP_STR(fake_id, config->args, "-fake_id", false, false);
    592     // convert fake_id into a psS64
    593     if (fake_id) {
    594         if (!psMetadataAddS64(where, PS_LIST_TAIL, "fakeRun.fake_id", 0, "==", (psS64)atoll(fake_id))) {
    595             psError(PS_ERR_UNKNOWN, false, "failed to add item fake_id");
    596             psFree(where);
    597             return false;
    598         }
    599     }
    600 
    601     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    602     // convert exp_id into a psS64
    603     if (exp_id) {
    604         if (!psMetadataAddS64(where, PS_LIST_TAIL, "rawExp.exp_id", 0, "==", (psS64)atoll(exp_id))) {
    605             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    606             psFree(where);
    607             return false;
    608         }
    609     }
    610 
     533    PXOPT_COPY_S64(config->args, where, "-fake_id", "fakeRun.fake_id", "==");
     534    PXOPT_COPY_S64(config->args, where, "-exp_id", "rawExp.exp_id", "==");
    611535    PXOPT_COPY_STR(config->args, where, "-class_id", "rawImfile.class_id", "==");
    612536    PXOPT_COPY_STR(config->args, where, "-inst", "rawExp.telescope", "==");
    … …  
    659583    }
    660584
    661     if (!convertIdToStr(output)) {
    662         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    663         psFree(output);
    664         return false;
    665     }
    666 
    667585    // negative simple so the default is true
    668586    if (!ippdbPrintMetadatas(stdout, output, "fakeProcessedImfile", !simple)) {
    … …  
    682600
    683601    psMetadata *where = psMetadataAlloc();
    684     PXOPT_LOOKUP_STR(fake_id, config->args, "-fake_id", false, false);
    685     // convert fake_id into a psS64
    686     if (fake_id) {
    687         if (!psMetadataAddS64(where, PS_LIST_TAIL, "fake_id", 0, "==", (psS64)atoll(fake_id))) {
    688             psError(PS_ERR_UNKNOWN, false, "failed to add item fake_id");
    689             psFree(where);
    690             return false;
    691         }
    692     }
    693 
    694     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    695     // convert exp_id into a psS64
    696     if (exp_id) {
    697         if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", 0, "==", (psS64)atoll(exp_id))) {
    698             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    699             psFree(where);
    700             return false;
    701         }
    702     }
    703 
     602    PXOPT_COPY_S64(config->args, where, "-fake_id", "fake_id", "==");
     603    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    704604    PXOPT_COPY_STR(config->args, where, "-exp_name", "exp_name", "==");
    705605    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
    … …  
    778678
    779679    psMetadata *where = psMetadataAlloc();
    780     PXOPT_LOOKUP_STR(fake_id, config->args, "-fake_id", false, false);
    781     // convert fake_id into a psS64
    782     if (fake_id) {
    783         if (!psMetadataAddS64(where, PS_LIST_TAIL, "fake_id", 0, "==", (psS64)atoll(fake_id))) {
    784             psError(PS_ERR_UNKNOWN, false, "failed to add item fake_id");
    785             psFree(where);
    786             return false;
    787         }
    788     }
     680    PXOPT_COPY_S64(config->args, where, "-fake_id", "fake_id", "==");
    789681    PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
    790682
    … …  
    866758    }
    867759
    868     if (!convertIdToStr(output)) {
    869         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    870         psFree(output);
    871         return false;
    872     }
    873 
    874760    // negative simple so the default is true
    875761    if (!ippdbPrintMetadatas(stdout, output, "fakeMask", !simple)) {
    … …  
    937823        psFree(output);
    938824        return true;
    939     }
    940 
    941     if (!convertIdToStr(output)) {
    942         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    943         psFree(output);
    944         return false;
    945825    }
    946826

  • trunk/ippTools/src/faketoolConfig.c

    r18172 r18336  
    4747    psMetadata *queueArgs = psMetadataAlloc();
    4848    // XXX need to allow multiple exp_ids
    49     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-exp_id",  0,
    50             "search by exp_id", NULL);
     49    psMetadataAddS64(queueArgs, PS_LIST_TAIL, "-exp_id",  0,
     50            "search by exp_id", 0);
    5151    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-exp_name",  0,
    5252            "search by exp_name", NULL);
    … …  
    145145    // -updaterun
    146146    psMetadata *updaterunArgs = psMetadataAlloc();
    147     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-fake_id", 0,
    148             "search by fake ID", NULL);
    149     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_id",  0,
    150             "search by exp_id", NULL);
     147    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-fake_id", 0,
     148            "search by fake ID", 0);
     149    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-exp_id",  0,
     150            "search by exp_id", 0);
    151151    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_name",  0,
    152152            "search by exp_name", NULL);
    … …  
    234234    // -pendingexp
    235235    psMetadata *pendingexpArgs = psMetadataAlloc();
    236     psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-cam_id", 0,
    237             "search by camtool ID", NULL);
    238     psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-chip_id", 0,
    239             "search by chiptool ID", NULL);
     236    psMetadataAddS64(pendingexpArgs, PS_LIST_TAIL, "-cam_id", 0,
     237            "search by camtool ID", 0);
     238    psMetadataAddS64(pendingexpArgs, PS_LIST_TAIL, "-chip_id", 0,
     239            "search by chiptool ID", 0);
    240240    psMetadataAddU64(pendingexpArgs, PS_LIST_TAIL, "-limit",  0,
    241241            "limit result set to N items", 0);
    … …  
    245245    // -pendingimfile
    246246    psMetadata *pendingimfileArgs = psMetadataAlloc();
    247     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-fake_id",  0,
    248             "search by fake ID", NULL);
    249     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    250             "search by exposure ID", NULL);
     247    psMetadataAddS64(pendingimfileArgs, PS_LIST_TAIL, "-fake_id",  0,
     248            "search by fake ID", 0);
     249    psMetadataAddS64(pendingimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
     250            "search by exposure ID", 0);
    251251    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    252252            "search by class ID", NULL);
    … …  
    262262    // -addprocessedimfile
    263263    psMetadata *addprocessedimfileArgs = psMetadataAlloc();
    264     psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-fake_id",  0,
    265             "define fake ID (required)", NULL);
    266     psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    267             "define exposure ID (required)", NULL);
     264    psMetadataAddS64(addprocessedimfileArgs, PS_LIST_TAIL, "-fake_id",  0,
     265            "define fake ID (required)", 0);
     266    psMetadataAddS64(addprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
     267            "define exposure ID (required)", 0);
    268268    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    269269            "define class ID (required)", NULL);
    … …  
    281281    // -processedimfile
    282282    psMetadata *processedimfileArgs = psMetadataAlloc();
    283     psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-fake_id",  0,
    284             "define fake ID", NULL);
    285     psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    286             "define exposure ID", NULL);
     283    psMetadataAddS64(processedimfileArgs, PS_LIST_TAIL, "-fake_id",  0,
     284            "define fake ID", 0);
     285    psMetadataAddS64(processedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
     286            "define exposure ID", 0);
    287287    psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    288288            "define class ID", NULL);
    … …  
    300300    // -updateprocessedimfile
    301301    psMetadata *updateprocessedimfileArgs = psMetadataAlloc();
    302     psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-fake_id",  0,
    303             "search by fake ID", NULL);
    304     psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    305             "search by exposure ID", NULL);
     302    psMetadataAddS64(updateprocessedimfileArgs, PS_LIST_TAIL, "-fake_id",  0,
     303            "search by fake ID", 0);
     304    psMetadataAddS64(updateprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
     305            "search by exposure ID", 0);
    306306    psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    307307            "search by class ID", NULL);
    … …  
    311311    // -revertprocessedimfile
    312312    psMetadata *revertprocessedimfileArgs = psMetadataAlloc();
    313     psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-fake_id", 0,
    314             "search by fake ID", NULL);
    315     psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    316             "search by exp_id", NULL);
     313    psMetadataAddS64(revertprocessedimfileArgs, PS_LIST_TAIL, "-fake_id", 0,
     314            "search by fake ID", 0);
     315    psMetadataAddS64(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
     316            "search by exp_id", 0);
    317317    psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_name",  0,
    318318            "search by exp_name", NULL);

  • trunk/ippTools/src/flatcorr.c

    r17611 r18336  
    463463
    464464    if (psArrayLength(output)) {
    465         if (!convertIdToStr(output)) {
    466             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    467             psFree(output);
    468             return false;
    469         }
    470 
    471465        // negative simple so the default is true
    472466        if (!ippdbPrintMetadatas(stdout, output, "chipProcessedImfile", !simple)) {

  • trunk/ippTools/src/magictool.c

    r18093 r18336  
    399399
    400400    if (psArrayLength(output)) {
    401         if (!convertIdToStr(output)) {
    402             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    403             psFree(output);
    404             return false;
    405         }
    406 
    407401        // negative simple so the default is true
    408402        if (!ippdbPrintMetadatas(stdout, output, "magicInputSkyfile", !simple)) {
    … …  
    627621
    628622    if (psArrayLength(output)) {
    629         if (!convertIdToStr(output)) {
    630             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    631             psFree(output);
    632             return false;
    633         }
    634 
    635623        // negative simple so the default is true
    636624        if (!ippdbPrintMetadatas(stdout, output, "magicMe", !simple)) {
    … …  
    718706
    719707    if (psArrayLength(output)) {
    720         if (!convertIdToStr(output)) {
    721             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    722             psFree(output);
    723             return false;
    724         }
    725 
    726708        // negative simple so the default is true
    727709        if (!ippdbPrintMetadatas(stdout, output, "toprocess", !simple)) {
    … …  
    806788
    807789    if (psArrayLength(output)) {
    808         if (!convertIdToStr(output)) {
    809             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    810             psFree(output);
    811             return false;
    812         }
    813 
    814790        // negative simple so the default is true
    815791        if (!ippdbPrintMetadatas(stdout, output, "toskyfilemask", !simple)) {

  • trunk/ippTools/src/pxinject.c

    r17872 r18336  
    9191
    9292    if (!newExpInsert(config->dbh,
    93                 0x0,    // exp_id
     93                0,    // exp_id
    9494                tmp_exp_name,
    9595                tmp_camera,
    … …  
    110110    }
    111111
    112     psS64 lastInsertID = psDBLastInsertID(config->dbh);
    113     psString exp_id = psDBIntToString(lastInsertID);
     112    psS64 exp_id = psDBLastInsertID(config->dbh);
    114113
    115114    psMetadata *md = psMetadataAlloc();
    116     if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_id", 0, NULL, exp_id)) {
     115    if (!psMetadataAddS64(md, PS_LIST_TAIL, "exp_id", 0, NULL, exp_id)) {
    117116        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    118117        psFree(md);
    119         psFree(exp_id);
    120118    }
    121     psFree(exp_id);
    122119
    123120    // negate simple so the default is true
    … …  
    137134    PS_ASSERT_PTR_NON_NULL(config, false);
    138135
    139     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", true, false);
     136    PXOPT_LOOKUP_S64(exp_id, config->args, "-exp_id", true, false);
    140137    PXOPT_LOOKUP_STR(tmp_class_id, config->args, "-tmp_class_id", true, false);
    141138    PXOPT_LOOKUP_STR(uri, config->args, "-uri", true, false);
    142139
    143140    // insert with error flag state set to 0 (no errors)
    144     if (!newImfileInsert(config->dbh, (psS64)atoll(exp_id), tmp_class_id, uri, NULL)) {
     141    if (!newImfileInsert(config->dbh, exp_id, tmp_class_id, uri, NULL)) {
    145142        psError(PS_ERR_UNKNOWN, false, "database error");
    146143        return false;
    … …  
    155152    PS_ASSERT_PTR_NON_NULL(config, false);
    156153
    157     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", true, false);
     154    PXOPT_LOOKUP_S64(exp_id, config->args, "-exp_id", true, false);
    158155    PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
    159156

  • trunk/ippTools/src/pxinjectConfig.c

    r18172 r18336  
    6868    // -newImfile
    6969    psMetadata *newImfileArgs = psMetadataAlloc();
    70     psMetadataAddStr(newImfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    71             "define the exp_id (required)", NULL);
     70    psMetadataAddS64(newImfileArgs, PS_LIST_TAIL, "-exp_id",  0,
     71            "define the exp_id (required)", 0);
    7272    psMetadataAddStr(newImfileArgs, PS_LIST_TAIL, "-tmp_class_id",  0,
    7373            "define the class ID (required)", NULL);
    … …  
    7777    // -updatenewExp
    7878    psMetadata *updatenewExpArgs = psMetadataAlloc();
    79     psMetadataAddStr(updatenewExpArgs, PS_LIST_TAIL, "-exp_id",  0,
    80             "define the exp_id (required)", NULL);
     79    psMetadataAddS64(updatenewExpArgs, PS_LIST_TAIL, "-exp_id",  0,
     80            "define the exp_id (required)", 0);
    8181    psMetadataAddStr(updatenewExpArgs, PS_LIST_TAIL, "-state", 0,
    8282            "set state (required)", NULL);

  • trunk/ippTools/src/pxregister.c

    r14023 r18336  
    2929#include "pxregister.h"
    3030
    31 bool pxnewExpSetState(pxConfig *config, const char *exp_id, const char *state)
     31bool pxnewExpSetState(pxConfig *config, psS64 exp_id, const char *state)
    3232{
    33     PS_ASSERT_PTR_NON_NULL(exp_id, false);
     33    if (!exp_id) {
     34        psError(PS_ERR_UNKNOWN, true, "0 is not a valid exp_id");
     35        return false;
     36    }
    3437    PS_ASSERT_PTR_NON_NULL(state, false);
    3538
    … …  
    4649    }
    4750
    48     char *query = "UPDATE newExp SET state = '%s' WHERE exp_id = '%s'";
     51    char *query = "UPDATE newExp SET state = '%s' WHERE exp_id = %"PRId64;
    4952    if (!p_psDBRunQuery(config->dbh, query, state, exp_id)) {
    5053        psError(PS_ERR_UNKNOWN, false,
    51                 "failed to change state for exp_id %s", exp_id);
     54                "failed to change state for exp_id %"PRId64, exp_id);
    5255        return false;
    5356    }

  • trunk/ippTools/src/pxregister.h

    r14023 r18336  
    2525#include "pxtools.h"
    2626
    27 bool pxnewExpSetState(pxConfig *config, const char *exp_id, const char *state);
     27bool pxnewExpSetState(pxConfig *config, psS64 exp_id, const char *state);
    2828
    2929#endif // PXREGISTER_H

  • trunk/ippTools/src/pxtools.h

    r18029 r18336  
    3636#include "pxfake.h"
    3737#include "pxwarp.h"
    38 #include "pxio.h"
    3938#include "pxregister.h"
    4039#include "pxtag.h"
    … …  
    109108type var; \
    110109{ \
    111     bool status; \
    112  \
    113     var = psMetadataLookup##suffix(&status, md, key); \
    114     if (!status) { \
    115         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for %s", key); \
    116         return ret; \
    117     } \
    118  \
    119     if (required && (var == max)) { \
    120         psError(PS_ERR_UNKNOWN, true, "%s is required", key); \
    121         return ret; \
    122     } \
     110    psMetadataItem *item = psMetadataLookup(md, key); \
     111    if (!item) { \
     112        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for %s", key); \
     113        return ret; \
     114    } \
     115    psAssert(item->comment, "metadata item comment should be defined"); \
     116    if (required && (!psStrcasestr(item->comment, "(found)"))) { \
     117        psError(PS_ERR_UNKNOWN, true, "%s is required", key); \
     118        return ret; \
     119    } \
     120 \
     121    var = item->data.suffix; \
     122 \
    123123}
    124124
    … …  
    172172// XXX the PXOPT_COPY_* macros free 'to' on error
    173173
    174 #define PXOPT_COPY_PRIMITIVE(from, to, type, suffix, oldname, newname, comment) \
    175 { \
    176     bool status = false; \
    177     type var = psMetadataLookup##suffix(&status, from, oldname); \
    178     if (!status) { \
    179         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for " oldname); \
     174#define PXOPT_COPY_PRIMITIVE(from, to, type, suffix, oldname, newname, newcomment) \
     175{ \
     176    psMetadataItem *item = psMetadataLookup(from, oldname); \
     177    if (!item) { \
     178        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for %s", oldname); \
    180179        return false; \
    181180    } \
    182     if (!psMetadataAdd##suffix(to, PS_LIST_TAIL, newname, PS_META_DUPLICATE_OK, comment, var)) { \
    183         psError(PS_ERR_UNKNOWN, false, "failed to add item " newname); \
    184         psFree(to); \
    185         return false; \
     181    psAssert(item->comment, "metadata item comment should be defined"); \
     182\
     183    if (psStrcasestr(item->comment, "(found)")) { \
     184        if (!psMetadataAdd##suffix(to, PS_LIST_TAIL, newname, PS_META_DUPLICATE_OK, newcomment, item->data.suffix)) { \
     185            psError(PS_ERR_UNKNOWN, false, "failed to add item " newname); \
     186            psFree(to); \
     187            return false; \
     188        } \
    186189    } \
    187190}

  • trunk/ippTools/src/regtool.c

    r18328 r18336  
    170170
    171171    // required
    172     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", true, false);
     172    PXOPT_LOOKUP_S64(exp_id, config->args, "-exp_id", true, false);
    173173    PXOPT_LOOKUP_STR(exp_name, config->args, "-exp_name", true, false);
    174174    PXOPT_LOOKUP_STR(camera, config->args, "-inst", true, false);
    … …  
    230230    if (!rawImfileInsert(
    231231        config->dbh,
    232         (psS64)atoll(exp_id),
     232        exp_id,
    233233        exp_name,
    234234        camera,
    … …  
    496496
    497497    // required
    498     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", true, false);
     498    PXOPT_LOOKUP_S64(exp_id, config->args, "-exp_id", true, false);
    499499    PXOPT_LOOKUP_STR(exp_name, config->args, "-exp_name", true, false);
    500500    PXOPT_LOOKUP_STR(camera, config->args, "-inst", true, false);
    … …  
    569569        // build a query to search by exp_id
    570570        psMetadata *where = psMetadataAlloc();
    571         if (!psMetadataAddStr(where, PS_LIST_TAIL, "newExp.exp_id", 0, "==", exp_id)) {
     571        if (!psMetadataAddS64(where, PS_LIST_TAIL, "newExp.exp_id", 0, "==", exp_id)) {
    572572            psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    573573            psFree(where);
    … …  
    652652
    653653    if (!rawExpInsert(config->dbh,
    654         (psS64)atoll(exp_id),
     654        exp_id,
    655655        exp_name,
    656656        camera,
    … …  
    726726            psError(PS_ERR_UNKNOWN, false, "database error");
    727727        }
    728         psError(PS_ERR_UNKNOWN, false, "failed to change newExp.state for exp_id: %s", exp_id);
     728        psError(PS_ERR_UNKNOWN, false, "failed to change newExp.state for exp_id: %"PRId64, exp_id);
    729729    psFree(newExp);
    730730        return false;
    … …  
    749749    // this can only be run as the newExp's state has been set to stop
    750750    if (!pxchipQueueByExpTag(config,
    751                 (psS64)atoll(exp_id),
     751                exp_id,
    752752                workdir,
    753753            label,
    … …  
    797797
    798798    // XX test this out; need to make this consistent with the list in regtoolConfig.c
    799     PXOPT_COPY_STR(config->args, config->where,  "-exp_id", "exp_id", "==");
     799    PXOPT_COPY_S64(config->args, config->where,  "-exp_id", "exp_id", "==");
    800800    PXOPT_COPY_STR(config->args, config->where,  "-exp_name", "exp_name", "==");
    801801    PXOPT_COPY_STR(config->args, config->where,  "-inst", "camera", "==");

  • trunk/ippTools/src/regtoolConfig.c

    r18328 r18336  
    6161    // -addprocessedimfile
    6262    psMetadata *addprocessedimfileArgs = psMetadataAlloc();
    63     ADD_OPT(Str,  addprocessedimfileArgs, "-exp_id",         "define exposure ID (required)",        NULL);
     63    ADD_OPT(S64,  addprocessedimfileArgs, "-exp_id",         "define exposure ID (required)",        0);
    6464    ADD_OPT(Str,  addprocessedimfileArgs, "-exp_name",       "define the exp_name (required)",         NULL);
    6565    ADD_OPT(Str,  addprocessedimfileArgs, "-inst",           "define the camera name (required)",     NULL);
    … …  
    117117    // -processedimfile
    118118    psMetadata *processedimfileArgs = psMetadataAlloc();
    119    ADD_OPT(Str,  processedimfileArgs, "-exp_id",    "search by exposure ID",                 NULL);
     119   ADD_OPT(S64,  processedimfileArgs, "-exp_id",    "search by exposure ID",                 0);
    120120   ADD_OPT(Str,  processedimfileArgs, "-exp_name",  "search by exposure name",               NULL);
    121121   ADD_OPT(Str,  processedimfileArgs, "-class_id",  "search by class ID",                    NULL);
    … …  
    126126    // -revertprocessedimfile
    127127    psMetadata *revertprocessedimfileArgs = psMetadataAlloc();
    128     ADD_OPT(Str, revertprocessedimfileArgs, "-exp_id",        "search by exposure ID (required)", NULL);
     128    ADD_OPT(S64, revertprocessedimfileArgs, "-exp_id",        "search by exposure ID (required)", 0);
    129129    ADD_OPT(Str, revertprocessedimfileArgs, "-tmp_class_id",  "searcy by temp. class ID", NULL);
    130130    ADD_OPT(Str, revertprocessedimfileArgs, "-class_id",      "search by class ID", NULL);
    … …  
    133133    // -updateprocessedimfile
    134134    psMetadata *updateprocessedimfileArgs = psMetadataAlloc();
    135     ADD_OPT(Str, updateprocessedimfileArgs, "-exp_id",        "search by exposure ID", NULL);
     135    ADD_OPT(S64, updateprocessedimfileArgs, "-exp_id",        "search by exposure ID", 0);
    136136    ADD_OPT(Str, updateprocessedimfileArgs, "-class_id",      "search by class ID", NULL);
    137137    ADD_OPT(S16, updateprocessedimfileArgs, "-code",          "set fault code (required)", INT16_MAX);
    … …  
    151151    // -addprocessedexp
    152152    psMetadata *addprocessedexpArgs = psMetadataAlloc();
    153     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-exp_id",           0,        "exp_id to operate on (required)", NULL);
     153    psMetadataAddS64(addprocessedexpArgs, PS_LIST_TAIL, "-exp_id",           0,        "exp_id to operate on (required)", 0);
    154154    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-exp_name",         0,        "define the exp_name (required)", NULL);
    155155    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-inst",             0,        "define the camera name (required)", NULL);
    … …  
    215215    // -processedexp
    216216    psMetadata *processedexpArgs = psMetadataAlloc();
    217     psMetadataAddStr(processedexpArgs,  PS_LIST_TAIL, "-exp_id",        0,            "search by exposure ID", NULL);
     217    psMetadataAddS64(processedexpArgs,  PS_LIST_TAIL, "-exp_id",        0,            "search by exposure ID", 0);
    218218    psMetadataAddStr(processedexpArgs,  PS_LIST_TAIL, "-exp_name",      0,            "search by exp_name", NULL);
    219219    psMetadataAddStr(processedexpArgs,  PS_LIST_TAIL, "-inst",          0,            "search for camera", NULL);
    … …  
    260260    // -revertprocessedexp
    261261    psMetadata *revertprocessedexpArgs = psMetadataAlloc();
    262     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_id",   0,            "search by exposure ID (required)", NULL);
     262    psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_id",   0,            "search by exposure ID (required)", 0);
    263263    psMetadataAddS16(revertprocessedexpArgs, PS_LIST_TAIL, "-code",     0,            "search by fault code", 0);
    264264
    265265    // -updatedprocessedexp
    266266    psMetadata *updatedprocessedexpArgs = psMetadataAlloc();
    267     psMetadataAddStr(updatedprocessedexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", NULL);
     267    psMetadataAddS64(updatedprocessedexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", 0);
    268268    psMetadataAddS16(updatedprocessedexpArgs, PS_LIST_TAIL, "-code",    0,            "set fault code (required)", INT16_MAX);
    269269

  • trunk/ippTools/src/stacktool.c

    r18152 r18336  
    4141static bool revertsumskyfileMode(pxConfig *config);
    4242
    43 static bool setstackRunState(pxConfig *config, const char *stack_id, const char *state);
     43static bool setstackRunState(pxConfig *config, psS64 stack_id, const char *state);
    4444
    4545# define MODECASE(caseName, func) \
    … …  
    486486    PS_ASSERT_PTR_NON_NULL(config, false);
    487487
    488     PXOPT_LOOKUP_STR(stack_id, config->args, "-stack_id", true, false);
     488    PXOPT_LOOKUP_S64(stack_id, config->args, "-stack_id", true, false);
    489489    PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
    490490
    … …  
    502502    PS_ASSERT_PTR_NON_NULL(config, false);
    503503
    504     PXOPT_LOOKUP_STR(stack_id, config->args, "-stack_id", true, false);
    505     PXOPT_LOOKUP_STR(warp_id, config->args, "-warp_id", true, false);
     504    PXOPT_LOOKUP_S64(stack_id, config->args, "-stack_id", true, false);
     505    PXOPT_LOOKUP_S64(warp_id, config->args, "-warp_id", true, false);
    506506
    507507    // XXX need to validate the warp_id here
    … …  
    509509    // constrants
    510510    if (!stackInputSkyfileInsert(config->dbh,
    511             (psS64)atoll(stack_id),
    512             (psS64)atoll(warp_id)
     511            stack_id,
     512            warp_id
    513513        )) {
    514514        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    574574
    575575    if (psArrayLength(output)) {
    576         if (!convertIdToStr(output)) {
    577             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    578             psFree(output);
    579             return false;
    580         }
    581 
    582576        // negative simple so the default is true
    583577        if (!ippdbPrintMetadatas(stdout, output, "stackInputSkyfile", !simple)) {
    … …  
    648642
    649643    if (psArrayLength(output)) {
    650         if (!convertIdToStr(output)) {
    651             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    652             psFree(output);
    653             return false;
    654         }
    655 
    656644        // negative simple so the default is true
    657645        if (!ippdbPrintMetadatas(stdout, output, "stackSumSkyfile", !simple)) {
    … …  
    673661
    674662    // required
    675     PXOPT_LOOKUP_STR(stack_id, config->args, "-stack_id", true, false);
     663    PXOPT_LOOKUP_S64(stack_id, config->args, "-stack_id", true, false);
    676664
    677665    // optional
    … …  
    696684    // constrants
    697685    if (!stackSumSkyfileInsert(config->dbh,
    698                                (psS64)atoll(stack_id),
     686                               stack_id,
    699687                               uri,
    700688                               path_base,
    … …  
    785773
    786774    if (psArrayLength(output)) {
    787         if (!convertIdToStr(output)) {
    788             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    789             psFree(output);
    790             return false;
    791         }
    792 
    793775        if (!ippdbPrintMetadatas(stdout, output, "stackSumSkyfile", !simple)) {
    794776            psError(PS_ERR_UNKNOWN, false, "failed to print array");
    … …  
    836818
    837819
    838 static bool setstackRunState(pxConfig *config, const char *stack_id, const char *state)
    839 {
    840     PS_ASSERT_PTR_NON_NULL(stack_id, false);
     820static bool setstackRunState(pxConfig *config, psS64 stack_id, const char *state)
     821{
    841822    PS_ASSERT_PTR_NON_NULL(state, false);
    842823
    … …  
    853834    }
    854835
    855     char *query = "UPDATE stackRun SET state = '%s' WHERE stack_id = '%s'";
     836    char *query = "UPDATE stackRun SET state = '%s' WHERE stack_id = %"PRId64;
    856837    if (!p_psDBRunQuery(config->dbh, query, state, stack_id)) {
    857838        psError(PS_ERR_UNKNOWN, false,
    858                 "failed to change state for stack_id %s", stack_id);
    859         return false;
    860     }
    861 
    862     return true;
    863 }
     839                "failed to change state for stack_id %"PRId64, stack_id);
     840        return false;
     841    }
     842
     843    return true;
     844}

  • trunk/ippTools/src/stacktoolConfig.c

    r18172 r18336  
    111111    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-tess_id",  0,
    112112            "define tessellation ID (required)", NULL);
    113     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-warp_id",
     113    psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-warp_id",
    114114             PS_META_DUPLICATE_OK,
    115              "include this warp ID (multiple OK, required)", NULL);
     115             "include this warp ID (multiple OK, required)", 0);
    116116
    117117    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple",  0,
    … …  
    120120    // -updaterun
    121121    psMetadata *updaterunArgs = psMetadataAlloc();
    122     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-stack_id", 0,
    123             "define stack ID (required)", NULL);
     122    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-stack_id", 0,
     123            "define stack ID (required)", 0);
    124124    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,
    125125            "set state (required)", NULL);
    … …  
    133133    // -addinputskyfile
    134134    psMetadata *addinputskyfileArgs = psMetadataAlloc();
    135     psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
    136             "define stack ID (required)", NULL);
    137     psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,
    138             "define warp ID (required)", NULL);
     135    psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
     136            "define stack ID (required)", 0);
     137    psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,
     138            "define warp ID (required)", 0);
    139139
    140140    // -inputskyfile
    141141    psMetadata *inputskyfileArgs = psMetadataAlloc();
    142     psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
    143             "search by stack ID", NULL);
    144     psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,
    145             "search by warp ID", NULL);
     142    psMetadataAddS64(inputskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
     143            "search by stack ID", 0);
     144    psMetadataAddS64(inputskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,
     145            "search by warp ID", 0);
    146146    psMetadataAddU64(inputskyfileArgs, PS_LIST_TAIL, "-limit",  0,
    147147            "limit result set to N items", 0);
    … …  
    151151    // -tosum
    152152    psMetadata *tosumArgs = psMetadataAlloc();
    153     psMetadataAddStr(tosumArgs, PS_LIST_TAIL, "-stack_id", 0,
    154             "search by stack ID", NULL);
    155     psMetadataAddStr(tosumArgs, PS_LIST_TAIL, "-warp_id", 0,
    156             "search by warp ID", NULL);
     153    psMetadataAddS64(tosumArgs, PS_LIST_TAIL, "-stack_id", 0,
     154            "search by stack ID", 0);
     155    psMetadataAddS64(tosumArgs, PS_LIST_TAIL, "-warp_id", 0,
     156            "search by warp ID", 0);
    157157    psMetadataAddU64(tosumArgs, PS_LIST_TAIL, "-limit",  0,
    158158            "limit result set to N items", 0);
    … …  
    162162    // -addsumskyfile
    163163    psMetadata *addsumskyfileArgs = psMetadataAlloc();
    164     psMetadataAddStr(addsumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
    165             "define stack ID (required)", NULL);
     164    psMetadataAddS64(addsumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
     165            "define stack ID (required)", 0);
    166166    psMetadataAddStr(addsumskyfileArgs, PS_LIST_TAIL, "-uri", 0,
    167167            "define URI of file", 0);
    … …  
    183183    // -sumskyfile
    184184    psMetadata *sumskyfileArgs= psMetadataAlloc();
    185     psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
    186             "search by stack ID", NULL);
    187     psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,
    188             "search by warp ID", NULL);
     185    psMetadataAddS64(sumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
     186            "search by stack ID", 0);
     187    psMetadataAddS64(sumskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,
     188            "search by warp ID", 0);
    189189    psMetadataAddU64(sumskyfileArgs, PS_LIST_TAIL, "-limit",  0,
    190190            "limit result set to N items", 0);
    … …  
    194194    // -revertsumskyfile
    195195    psMetadata *revertsumskyfileArgs= psMetadataAlloc();
    196     psMetadataAddStr(revertsumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
    197             "search by stack ID (required)", NULL);
     196    psMetadataAddS64(revertsumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
     197            "search by stack ID (required)", 0);
    198198    psMetadataAddS16(revertsumskyfileArgs, PS_LIST_TAIL, "-code",  0,
    199199            "search by fault code", 0);

  • trunk/ippTools/src/warptool.c

    r18029 r18336  
    111111
    112112    // required options
    113     PXOPT_LOOKUP_STR(fake_id, config->args, "-fake_id", true, false);
     113    PXOPT_LOOKUP_S64(fake_id, config->args, "-fake_id", true, false);
    114114    PXOPT_LOOKUP_STR(mode, config->args, "-mode", true, false);
    115115    // check mode
    … …  
    133133    warpRunRow *warpRun = warpRunRowAlloc(
    134134            0,          // ID
    135             (psS64)atoll(fake_id),
     135            fake_id,
    136136            mode,
    137137            "run",      // state
    … …  
    175175    PS_ASSERT_PTR_NON_NULL(config, false);
    176176
    177     PXOPT_LOOKUP_STR(warp_id, config->args, "-warp_id", false, false);
    178     PXOPT_LOOKUP_STR(fake_id, config->args, "-fake_id", false, false);
    179     PXOPT_LOOKUP_STR(chip_id, config->args, "-chip_id", false, false);
    180     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    181 
    182177    psMetadata *where = psMetadataAlloc();
    183     // convert warp_id into a psS64
    184     if (warp_id) {
    185         if (!psMetadataAddS64(where, PS_LIST_TAIL, "warp_id", 0, "==", (psS64)atoll(warp_id))) {
    186             psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    187             psFree(where);
    188             return false;
    189         }
    190     }
    191 
    192     // convert fake_id into a psS64
    193     if (fake_id) {
    194         if (!psMetadataAddS64(where, PS_LIST_TAIL, "fake_id", 0, "==", (psS64)atoll(fake_id))) {
    195             psError(PS_ERR_UNKNOWN, false, "failed to add item fake_id");
    196             psFree(where);
    197             return false;
    198         }
    199     }
    200 
    201     // convert chip_id into a psS64
    202     if (chip_id) {
    203         if (!psMetadataAddS64(where, PS_LIST_TAIL, "chip_id", 0, "==", (psS64)atoll(chip_id))) {
    204             psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    205             psFree(where);
    206             return false;
    207         }
    208     }
    209 
    210     // convert exp_id into a psS64
    211     if (exp_id) {
    212         if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", 0, "==", (psS64)atoll(exp_id))) {
    213             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    214             psFree(where);
    215             return false;
    216         }
    217     }
    218 
     178    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
     179    PXOPT_COPY_S64(config->args, where, "-fake_id", "fake_id", "==");
     180    PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
     181    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    219182    PXOPT_COPY_STR(config->args, where, "-exp_name", "exp_name", "==");
    220183    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
    … …  
    350313
    351314    if (psArrayLength(output)) {
    352         if (!convertIdToStr(output)) {
    353             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    354             psFree(output);
    355             return false;
    356         }
    357 
    358315        // negative simple so the default is true
    359316        if (!ippdbPrintMetadatas(stdout, output, "warpRun", !simple)) {
    … …  
    425382
    426383    if (psArrayLength(output)) {
    427         if (!convertIdToStr(output)) {
    428             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    429             psFree(output);
    430             return false;
    431         }
    432 
    433384        // negative simple so the default is true
    434385        if (!ippdbPrintMetadatas(stdout, output, "warpInputImfile", !simple)) {
    … …  
    500451
    501452    if (psArrayLength(output)) {
    502         if (!convertIdToStr(output)) {
    503             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    504             psFree(output);
    505             return false;
    506         }
    507 
    508453        // negative simple so the default is true
    509454        if (!ippdbPrintMetadatas(stdout, output, "warpRun", !simple)) {
    … …  
    525470
    526471    PXOPT_LOOKUP_STR(mapfile, config->args, "-mapfile", false, false);
    527     PXOPT_LOOKUP_STR(warp_id, config->args, "-warp_id", false, false);
     472    PXOPT_LOOKUP_S64(warp_id, config->args, "-warp_id", false, false);
    528473    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    529474
    … …  
    544489    } else {
    545490        warpSkyCellMapInsert(config->dbh,
    546             (psS64)atoll(warp_id),
     491            warp_id,
    547492            NULL,   // skycell_id
    548493            NULL,   // tess_id
    … …  
    677622
    678623    if (psArrayLength(output)) {
    679         if (!convertIdToStr(output)) {
    680             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    681             psFree(output);
    682             return false;
    683         }
    684 
    685624        // negative simple so the default is true
    686625        if (!ippdbPrintMetadatas(stdout, output, "warpSkyCellMap", !simple)) {
    … …  
    752691
    753692    if (psArrayLength(output)) {
    754         if (!convertIdToStr(output)) {
    755             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    756             psFree(output);
    757             return false;
    758         }
    759 
    760693        // negative simple so the default is true
    761694        if (!ippdbPrintMetadatas(stdout, output, "warpPendingSkyCell", !simple)) {
    … …  
    776709    PS_ASSERT_PTR_NON_NULL(config, false);
    777710
    778     PXOPT_LOOKUP_STR(warp_id, config->args, "-warp_id", true, false);
     711    PXOPT_LOOKUP_S64(warp_id, config->args, "-warp_id", true, false);
    779712    PXOPT_LOOKUP_STR(skycell_id, config->args, "-skycell_id", true, false);
    780713    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", true, false);
    … …  
    806739    // XXX need to validate that this coresponds to an warpInputImfile
    807740    if (!warpSkyfileInsert(config->dbh,
    808                            (psS64)atoll(warp_id),
     741                           warp_id,
    809742                           skycell_id,
    810743                           tess_id,
    … …  
    1009942
    1010943    if (psArrayLength(output)) {
    1011         if (!convertIdToStr(output)) {
    1012             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    1013             psFree(output);
    1014             return false;
    1015         }
    1016 
    1017944        // negative simple so the default is true
    1018945        if (!ippdbPrintMetadatas(stdout, output, "warpSkyfile", !simple)) {
    … …  
    1033960    PS_ASSERT_PTR_NON_NULL(config, false);
    1034961
    1035     PXOPT_LOOKUP_STR(warp_id, config->args, "-warp_id", false, false);
    1036     PXOPT_LOOKUP_STR(fake_id, config->args, "-fake_id", false, false);
    1037     PXOPT_LOOKUP_STR(chip_id, config->args, "-chip_id", false, false);
    1038     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    1039 
    1040962    psMetadata *where = psMetadataAlloc();
    1041     // convert warp_id into a psS64
    1042     if (warp_id) {
    1043         if (!psMetadataAddS64(where, PS_LIST_TAIL, "warpRun.warp_id", 0, "==", (psS64)atoll(warp_id))) {
    1044             psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1045             psFree(where);
    1046             return false;
    1047         }
    1048     }
    1049 
     963    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
     964    PXOPT_COPY_S64(config->args, where, "-fake_id", "fake_id", "==");
     965    PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
     966    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    1050967    PXOPT_COPY_STR(config->args, where, "-skycell_id", "skycell_id", "==");
    1051968    PXOPT_COPY_STR(config->args, where, "-tess_id", "tess_id", "==");
    1052 
    1053     // convert fake_id into a psS64
    1054     if (fake_id) {
    1055         if (!psMetadataAddS64(where, PS_LIST_TAIL, "fakeRun.fake_id", 0, "==", (psS64)atoll(fake_id))) {
    1056             psError(PS_ERR_UNKNOWN, false, "failed to add item fake_id");
    1057             psFree(where);
    1058             return false;
    1059         }
    1060     }
    1061 
    1062     // convert chip_id into a psS64
    1063     if (chip_id) {
    1064         if (!psMetadataAddS64(where, PS_LIST_TAIL, "chipRun.chip_id", 0, "==", (psS64)atoll(chip_id))) {
    1065             psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    1066             psFree(where);
    1067             return false;
    1068         }
    1069     }
    1070 
    1071     // convert exp_id into a psS64
    1072     if (exp_id) {
    1073         if (!psMetadataAddS64(where, PS_LIST_TAIL, "rawExp.exp_id", 0, "==", (psS64)atoll(exp_id))) {
    1074             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    1075             psFree(where);
    1076             return false;
    1077         }
    1078     }
    1079969
    1080970    // XXX These may need to be updated with the table name?
    … …  
    11931083    }
    11941084
    1195     if (!convertIdToStr(output)) {
    1196         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    1197         psFree(output);
    1198         return false;
    1199     }
    1200 
    12011085    // negative simple so the default is true
    12021086    if (!ippdbPrintMetadatas(stdout, output, "warpMask", !simple)) {

  • trunk/ippTools/src/warptoolConfig.c

    r18172 r18336  
    4949    // -definerun
    5050    psMetadata *definerunArgs = psMetadataAlloc();
    51     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-fake_id", 0,
    52             "define camtool ID (required)", NULL);
     51    psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-fake_id", 0,
     52            "define camtool ID (required)", 0);
    5353    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-mode", 0,
    5454            "define mode (required)", NULL);
    … …  
    7373    psMetadata *updaterunArgs = psMetadataAlloc();
    7474    // XXX need to allow multiple fake_ids
    75     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-warp_id", 0,
    76             "search by warptool ID", NULL);
     75    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-warp_id", 0,
     76            "search by warptool ID", 0);
    7777    // XXX need to allow multiple fake_ids
    78     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-fake_id",  0,
    79             "search by fake_id", NULL);
     78    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-fake_id",  0,
     79            "search by fake_id", 0);
    8080    // XXX need to allow multiple chip_ids
    81     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-chip_id",  0,
    82             "search by chip_id", NULL);
     81    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-chip_id",  0,
     82            "search by chip_id", 0);
    8383    // XXX need to allow multiple exp_ids
    84     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_id",  0,
    85             "search by exp_id", NULL);
     84    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-exp_id",  0,
     85            "search by exp_id", 0);
    8686    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_name",  0,
    8787            "search by exp_name", NULL);
    … …  
    174174    // -exp
    175175    psMetadata *expArgs = psMetadataAlloc();
    176     psMetadataAddStr(expArgs, PS_LIST_TAIL, "-warp_id", 0,
    177             "search by warptool ID", NULL);
    178     psMetadataAddStr(expArgs, PS_LIST_TAIL, "-fake_id", 0,
    179             "search by camtool ID", NULL);
     176    psMetadataAddS64(expArgs, PS_LIST_TAIL, "-warp_id", 0,
     177            "search by warptool ID", 0);
     178    psMetadataAddS64(expArgs, PS_LIST_TAIL, "-fake_id", 0,
     179            "search by camtool ID", 0);
    180180    psMetadataAddU64(expArgs, PS_LIST_TAIL, "-limit",  0,
    181181            "limit result set to N items", 0);
    … …  
    185185    // -imfile
    186186    psMetadata *imfileArgs = psMetadataAlloc();
    187     psMetadataAddStr(imfileArgs, PS_LIST_TAIL, "-warp_id", 0,
    188             "search by warptool ID", NULL);
    189     psMetadataAddStr(imfileArgs, PS_LIST_TAIL, "-fake_id", 0,
    190             "search by camtool ID", NULL);
     187    psMetadataAddS64(imfileArgs, PS_LIST_TAIL, "-warp_id", 0,
     188            "search by warptool ID", 0);
     189    psMetadataAddS64(imfileArgs, PS_LIST_TAIL, "-fake_id", 0,
     190            "search by camtool ID", 0);
    191191    psMetadataAddU64(imfileArgs, PS_LIST_TAIL, "-limit",  0,
    192192            "limit result set to N items", 0);
    … …  
    196196    // -tooverlap
    197197    psMetadata *tooverlapArgs = psMetadataAlloc();
    198     psMetadataAddStr(tooverlapArgs, PS_LIST_TAIL, "-warp_id", 0,
    199             "search by warp ID", NULL);
     198    psMetadataAddS64(tooverlapArgs, PS_LIST_TAIL, "-warp_id", 0,
     199            "search by warp ID", 0);
    200200    psMetadataAddU64(tooverlapArgs, PS_LIST_TAIL, "-limit",  0,
    201201            "limit result set to N items", 0);
    … …  
    207207    psMetadataAddStr(addoverlapArgs, PS_LIST_TAIL, "-mapfile", 0,
    208208            "path to skycell <-> imfile mapping file", NULL);
    209     psMetadataAddStr(addoverlapArgs, PS_LIST_TAIL, "-warp_id",  0,
    210             "set warp ID", NULL);
     209    psMetadataAddS64(addoverlapArgs, PS_LIST_TAIL, "-warp_id",  0,
     210            "set warp ID", 0);
    211211    psMetadataAddS16(addoverlapArgs, PS_LIST_TAIL, "-code",  0,
    212212            "set fault code", 0);
    … …  
    214214    // -scmap
    215215    psMetadata *scmapArgs = psMetadataAlloc();
    216     psMetadataAddStr(scmapArgs, PS_LIST_TAIL, "-warp_id", 0,
    217             "search by warptool ID", NULL);
     216    psMetadataAddS64(scmapArgs, PS_LIST_TAIL, "-warp_id", 0,
     217            "search by warptool ID", 0);
    218218    psMetadataAddStr(scmapArgs, PS_LIST_TAIL, "-skycell_id", 0,
    219219            "search by skycell ID", NULL);
    … …  
    227227    // -towarped
    228228    psMetadata *towarpedArgs = psMetadataAlloc();
    229     psMetadataAddStr(towarpedArgs, PS_LIST_TAIL, "-warp_id", 0,
    230             "search by warptool ID", NULL);
     229    psMetadataAddS64(towarpedArgs, PS_LIST_TAIL, "-warp_id", 0,
     230            "search by warptool ID", 0);
    231231    psMetadataAddU64(towarpedArgs, PS_LIST_TAIL, "-limit",  0,
    232232            "limit result set to N items", 0);
    … …  
    236236    // -addwarped
    237237    psMetadata *addwarpedArgs = psMetadataAlloc();
    238     psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-warp_id", 0,
    239             "define warptool ID (required)", NULL);
     238    psMetadataAddS64(addwarpedArgs, PS_LIST_TAIL, "-warp_id", 0,
     239            "define warptool ID (required)", 0);
    240240    psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-skycell_id",  0,
    241241            "define skycell ID (required)", NULL);
    … …  
    271271    // -warped
    272272    psMetadata *warpedArgs = psMetadataAlloc();
    273     psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-warp_id", 0,
    274             "search by warptool ID", NULL);
     273    psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-warp_id", 0,
     274            "search by warptool ID", 0);
    275275    psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-skycell_id",  0,
    276276            "define skycell ID", NULL);
    277277    psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-tess_id",  0,
    278278            "define tessellation ID", NULL);
    279     psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-exp_id", 0,
    280             "define exposure tag", NULL);
    281     psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-fake_id", 0,
    282             "define phase 3 version of exposure tag", NULL);
     279    psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-exp_id", 0,
     280            "define exposure tag", 0);
     281    psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-fake_id", 0,
     282            "define phase 3 version of exposure tag", 0);
    283283    psMetadataAddU64(warpedArgs, PS_LIST_TAIL, "-limit",  0,
    284284            "limit result set to N items", 0);
    … …  
    289289    psMetadata *revertwarpedArgs = psMetadataAlloc();
    290290    // XXX need to allow multiple fake_ids
    291     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-warp_id", 0,
    292             "search by warptool ID", NULL);
     291    psMetadataAddS64(revertwarpedArgs, PS_LIST_TAIL, "-warp_id", 0,
     292            "search by warptool ID", 0);
    293293    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-skycell_id",  0,
    294294            "search by skycell ID", NULL);
    … …  
    296296            "searcy by tessellation ID", NULL);
    297297    // XXX need to allow multiple fake_ids
    298     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-fake_id",  0,
    299             "search by fake_id", NULL);
     298    psMetadataAddS64(revertwarpedArgs, PS_LIST_TAIL, "-fake_id",  0,
     299            "search by fake_id", 0);
    300300    // XXX need to allow multiple chip_ids
    301     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-chip_id",  0,
    302             "search by chip_id", NULL);
     301    psMetadataAddS64(revertwarpedArgs, PS_LIST_TAIL, "-chip_id",  0,
     302            "search by chip_id", 0);
    303303    // XXX need to allow multiple exp_ids
    304     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-exp_id",  0,
    305             "search by exp_id", NULL);
     304    psMetadataAddS64(revertwarpedArgs, PS_LIST_TAIL, "-exp_id",  0,
     305            "search by exp_id", 0);
    306306    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-exp_name",  0,
    307307            "search by exp_name", NULL);
Note: See TracChangeset for help on using the changeset viewer.