00001
00002
00003
00004 #include "reVariableMap.gen.h"
00005
00006 #include "reVariableMap.h"
00007
00008
00009
00010 int getValFromRescInfo(char *varMap, rescInfo_t *rei, Res **varValue, Region *r)
00011 {
00012 char varName[NAME_LEN];
00013 char *varMapCPtr;
00014 int i;
00015
00016 if (varMap == NULL) {
00017 i = getPtrLeafValue(varValue, (void *) rei, NULL, RescInfo_MS_T, r);
00018 return(i);
00019 }
00020 if (rei == NULL)
00021 return(NULL_VALUE_ERR);
00022
00023 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
00024 if (i != 0)
00025 return(i);
00026
00027
00028
00029 if (strcmp(varName, "rescName") == 0) {
00030
00031 i = getStrLeafValue(varValue, rei->rescName, r);
00032
00033 return i;
00034 }
00035
00036
00037 if (strcmp(varName, "rescId") == 0) {
00038
00039 i = getLongLeafValue(varValue, rei->rescId, r);
00040
00041 return i;
00042 }
00043
00044
00045 if (strcmp(varName, "zoneName") == 0) {
00046
00047 i = getStrLeafValue(varValue, rei->zoneName, r);
00048
00049 return i;
00050 }
00051
00052
00053 if (strcmp(varName, "rescLoc") == 0) {
00054
00055 i = getStrLeafValue(varValue, rei->rescLoc, r);
00056
00057 return i;
00058 }
00059
00060
00061 if (strcmp(varName, "rescType") == 0) {
00062
00063 i = getStrLeafValue(varValue, rei->rescType, r);
00064
00065 return i;
00066 }
00067
00068
00069 if (strcmp(varName, "rescTypeInx") == 0) {
00070
00071 i = getIntLeafValue(varValue, rei->rescTypeInx, r);
00072
00073 return i;
00074 }
00075
00076
00077 if (strcmp(varName, "rescClassInx") == 0) {
00078
00079 i = getIntLeafValue(varValue, rei->rescClassInx, r);
00080
00081 return i;
00082 }
00083
00084
00085 if (strcmp(varName, "rescStatus") == 0) {
00086
00087 i = getIntLeafValue(varValue, rei->rescStatus, r);
00088
00089 return i;
00090 }
00091
00092
00093 if (strcmp(varName, "paraOpr") == 0) {
00094
00095 i = getIntLeafValue(varValue, rei->paraOpr, r);
00096
00097 return i;
00098 }
00099
00100
00101 if (strcmp(varName, "rescClass") == 0) {
00102
00103 i = getStrLeafValue(varValue, rei->rescClass, r);
00104
00105 return i;
00106 }
00107
00108
00109 if (strcmp(varName, "rescVaultPath") == 0) {
00110
00111 i = getStrLeafValue(varValue, rei->rescVaultPath, r);
00112
00113 return i;
00114 }
00115
00116
00117 if (strcmp(varName, "rescInfo") == 0) {
00118
00119 i = getStrLeafValue(varValue, rei->rescInfo, r);
00120
00121 return i;
00122 }
00123
00124
00125 if (strcmp(varName, "rescComments") == 0) {
00126
00127 i = getStrLeafValue(varValue, rei->rescComments, r);
00128
00129 return i;
00130 }
00131
00132
00133 if (strcmp(varName, "gateWayAddr") == 0) {
00134
00135 i = getStrLeafValue(varValue, rei->gateWayAddr, r);
00136
00137 return i;
00138 }
00139
00140
00141 if (strcmp(varName, "rescMaxObjSize") == 0) {
00142
00143 i = getLongLeafValue(varValue, rei->rescMaxObjSize, r);
00144
00145 return i;
00146 }
00147
00148
00149 if (strcmp(varName, "freeSpace") == 0) {
00150
00151 i = getLongLeafValue(varValue, rei->freeSpace, r);
00152
00153 return i;
00154 }
00155
00156
00157 if (strcmp(varName, "freeSpaceTimeStamp") == 0) {
00158
00159 i = getStrLeafValue(varValue, rei->freeSpaceTimeStamp, r);
00160
00161 return i;
00162 }
00163
00164
00165 if (strcmp(varName, "freeSpaceTime") == 0) {
00166
00167 i = UNDEFINED_VARIABLE_MAP_ERR;
00168
00169 return i;
00170 }
00171
00172
00173 if (strcmp(varName, "rescCreate") == 0) {
00174
00175 i = getStrLeafValue(varValue, rei->rescCreate, r);
00176
00177 return i;
00178 }
00179
00180
00181 if (strcmp(varName, "rescModify") == 0) {
00182
00183 i = getStrLeafValue(varValue, rei->rescModify, r);
00184
00185 return i;
00186 }
00187
00188
00189 if (strcmp(varName, "rodsServerHost") == 0) {
00190
00191 i = UNDEFINED_VARIABLE_MAP_ERR;
00192
00193 return i;
00194 }
00195
00196
00197 if (strcmp(varName, "quotaLimit") == 0) {
00198
00199 i = getLongLeafValue(varValue, rei->quotaLimit, r);
00200
00201 return i;
00202 }
00203
00204
00205 if (strcmp(varName, "quotaOverrun") == 0) {
00206
00207 i = getLongLeafValue(varValue, rei->quotaOverrun, r);
00208
00209 return i;
00210 }
00211
00212
00213 return(UNDEFINED_VARIABLE_MAP_ERR);
00214 }
00215 int setValFromRescInfo(char *varMap, rescInfo_t **inrei, Res *newVarValue)
00216 {
00217 char varName[NAME_LEN];
00218 char *varMapCPtr;
00219 int i;
00220 rescInfo_t *rei;
00221
00222 rei = *inrei;
00223
00224 if (varMap == NULL) {
00225 i = setStructPtrLeafValue((void**)inrei, newVarValue);
00226 return(i);
00227 }
00228 if (rei == NULL)
00229 return(NULL_VALUE_ERR);
00230
00231 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
00232 if (i != 0)
00233 return(i);
00234
00235
00236 if (strcmp(varName, "rescName") == 0) {
00237
00238 i = setStrLeafValue(rei->rescName, NAME_LEN, newVarValue);
00239
00240 return i;
00241 }
00242
00243 if (strcmp(varName, "rescId") == 0) {
00244
00245 i = setLongLeafValue(&(rei->rescId), newVarValue);
00246
00247 return i;
00248 }
00249
00250 if (strcmp(varName, "zoneName") == 0) {
00251
00252 i = setStrLeafValue(rei->zoneName, NAME_LEN, newVarValue);
00253
00254 return i;
00255 }
00256
00257 if (strcmp(varName, "rescLoc") == 0) {
00258
00259 i = setStrLeafValue(rei->rescLoc, NAME_LEN, newVarValue);
00260
00261 return i;
00262 }
00263
00264 if (strcmp(varName, "rescType") == 0) {
00265
00266 i = setStrLeafValue(rei->rescType, NAME_LEN, newVarValue);
00267
00268 return i;
00269 }
00270
00271 if (strcmp(varName, "rescTypeInx") == 0) {
00272
00273 i = setIntLeafValue(&(rei->rescTypeInx), newVarValue);
00274
00275 return i;
00276 }
00277
00278 if (strcmp(varName, "rescClassInx") == 0) {
00279
00280 i = setIntLeafValue(&(rei->rescClassInx), newVarValue);
00281
00282 return i;
00283 }
00284
00285 if (strcmp(varName, "rescStatus") == 0) {
00286
00287 i = setIntLeafValue(&(rei->rescStatus), newVarValue);
00288
00289 return i;
00290 }
00291
00292 if (strcmp(varName, "paraOpr") == 0) {
00293
00294 i = setIntLeafValue(&(rei->paraOpr), newVarValue);
00295
00296 return i;
00297 }
00298
00299 if (strcmp(varName, "rescClass") == 0) {
00300
00301 i = setStrLeafValue(rei->rescClass, NAME_LEN, newVarValue);
00302
00303 return i;
00304 }
00305
00306 if (strcmp(varName, "rescVaultPath") == 0) {
00307
00308 i = setStrLeafValue(rei->rescVaultPath, MAX_NAME_LEN, newVarValue);
00309
00310 return i;
00311 }
00312
00313 if (strcmp(varName, "rescInfo") == 0) {
00314
00315 i = setStrLeafValue(rei->rescInfo, LONG_NAME_LEN, newVarValue);
00316
00317 return i;
00318 }
00319
00320 if (strcmp(varName, "rescComments") == 0) {
00321
00322 i = setStrLeafValue(rei->rescComments, LONG_NAME_LEN, newVarValue);
00323
00324 return i;
00325 }
00326
00327 if (strcmp(varName, "gateWayAddr") == 0) {
00328
00329 i = setStrLeafValue(rei->gateWayAddr, NAME_LEN, newVarValue);
00330
00331 return i;
00332 }
00333
00334 if (strcmp(varName, "rescMaxObjSize") == 0) {
00335
00336 i = setLongLeafValue(&(rei->rescMaxObjSize), newVarValue);
00337
00338 return i;
00339 }
00340
00341 if (strcmp(varName, "freeSpace") == 0) {
00342
00343 i = setLongLeafValue(&(rei->freeSpace), newVarValue);
00344
00345 return i;
00346 }
00347
00348 if (strcmp(varName, "freeSpaceTimeStamp") == 0) {
00349
00350 i = setStrLeafValue(rei->freeSpaceTimeStamp, TIME_LEN, newVarValue);
00351
00352 return i;
00353 }
00354
00355 if (strcmp(varName, "freeSpaceTime") == 0) {
00356
00357 i = UNDEFINED_VARIABLE_MAP_ERR;
00358
00359 return i;
00360 }
00361
00362 if (strcmp(varName, "rescCreate") == 0) {
00363
00364 i = setStrLeafValue(rei->rescCreate, TIME_LEN, newVarValue);
00365
00366 return i;
00367 }
00368
00369 if (strcmp(varName, "rescModify") == 0) {
00370
00371 i = setStrLeafValue(rei->rescModify, TIME_LEN, newVarValue);
00372
00373 return i;
00374 }
00375
00376 if (strcmp(varName, "rodsServerHost") == 0) {
00377
00378 i = UNDEFINED_VARIABLE_MAP_ERR;
00379
00380 return i;
00381 }
00382
00383 if (strcmp(varName, "quotaLimit") == 0) {
00384
00385 i = setLongLeafValue(&(rei->quotaLimit), newVarValue);
00386
00387 return i;
00388 }
00389
00390 if (strcmp(varName, "quotaOverrun") == 0) {
00391
00392 i = setLongLeafValue(&(rei->quotaOverrun), newVarValue);
00393
00394 return i;
00395 }
00396
00397
00398 return(UNDEFINED_VARIABLE_MAP_ERR);
00399 }
00400 ExprType *getVarTypeFromRescInfo(char *varMap, Region *r)
00401 {
00402 char varName[NAME_LEN];
00403 char *varMapCPtr;
00404 int i;
00405
00406 if (varMap == NULL) {
00407 return newIRODSType(RescInfo_MS_T, r);
00408 }
00409
00410 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
00411 if (i != 0)
00412 return newErrorType(i, r);
00413
00414
00415
00416 if (strcmp(varName, "rescName") == 0) {
00417
00418 return newSimpType(T_STRING, r);
00419
00420 }
00421
00422
00423 if (strcmp(varName, "rescId") == 0) {
00424
00425 return newSimpType(T_DOUBLE, r);
00426
00427 }
00428
00429
00430 if (strcmp(varName, "zoneName") == 0) {
00431
00432 return newSimpType(T_STRING, r);
00433
00434 }
00435
00436
00437 if (strcmp(varName, "rescLoc") == 0) {
00438
00439 return newSimpType(T_STRING, r);
00440
00441 }
00442
00443
00444 if (strcmp(varName, "rescType") == 0) {
00445
00446 return newSimpType(T_STRING, r);
00447
00448 }
00449
00450
00451 if (strcmp(varName, "rescTypeInx") == 0) {
00452
00453 return newSimpType(T_INT, r);
00454
00455 }
00456
00457
00458 if (strcmp(varName, "rescClassInx") == 0) {
00459
00460 return newSimpType(T_INT, r);
00461
00462 }
00463
00464
00465 if (strcmp(varName, "rescStatus") == 0) {
00466
00467 return newSimpType(T_INT, r);
00468
00469 }
00470
00471
00472 if (strcmp(varName, "paraOpr") == 0) {
00473
00474 return newSimpType(T_INT, r);
00475
00476 }
00477
00478
00479 if (strcmp(varName, "rescClass") == 0) {
00480
00481 return newSimpType(T_STRING, r);
00482
00483 }
00484
00485
00486 if (strcmp(varName, "rescVaultPath") == 0) {
00487
00488 return newSimpType(T_STRING, r);
00489
00490 }
00491
00492
00493 if (strcmp(varName, "rescInfo") == 0) {
00494
00495 return newSimpType(T_STRING, r);
00496
00497 }
00498
00499
00500 if (strcmp(varName, "rescComments") == 0) {
00501
00502 return newSimpType(T_STRING, r);
00503
00504 }
00505
00506
00507 if (strcmp(varName, "gateWayAddr") == 0) {
00508
00509 return newSimpType(T_STRING, r);
00510
00511 }
00512
00513
00514 if (strcmp(varName, "rescMaxObjSize") == 0) {
00515
00516 return newSimpType(T_DOUBLE, r);
00517
00518 }
00519
00520
00521 if (strcmp(varName, "freeSpace") == 0) {
00522
00523 return newSimpType(T_DOUBLE, r);
00524
00525 }
00526
00527
00528 if (strcmp(varName, "freeSpaceTimeStamp") == 0) {
00529
00530 return newSimpType(T_STRING, r);
00531
00532 }
00533
00534
00535 if (strcmp(varName, "freeSpaceTime") == 0) {
00536
00537 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
00538
00539 }
00540
00541
00542 if (strcmp(varName, "rescCreate") == 0) {
00543
00544 return newSimpType(T_STRING, r);
00545
00546 }
00547
00548
00549 if (strcmp(varName, "rescModify") == 0) {
00550
00551 return newSimpType(T_STRING, r);
00552
00553 }
00554
00555
00556 if (strcmp(varName, "rodsServerHost") == 0) {
00557
00558 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
00559
00560 }
00561
00562
00563 if (strcmp(varName, "quotaLimit") == 0) {
00564
00565 return newSimpType(T_DOUBLE, r);
00566
00567 }
00568
00569
00570 if (strcmp(varName, "quotaOverrun") == 0) {
00571
00572 return newSimpType(T_DOUBLE, r);
00573
00574 }
00575
00576
00577 return newErrorType(UNDEFINED_VARIABLE_MAP_ERR, r);
00578 }
00579
00580
00581 int getValFromRescGrpInfo(char *varMap, rescGrpInfo_t *rei, Res **varValue, Region *r)
00582 {
00583 char varName[NAME_LEN];
00584 char *varMapCPtr;
00585 int i;
00586
00587 if (varMap == NULL) {
00588 i = getPtrLeafValue(varValue, (void *) rei, NULL, RescGrpInfo_MS_T, r);
00589 return(i);
00590 }
00591 if (rei == NULL)
00592 return(NULL_VALUE_ERR);
00593
00594 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
00595 if (i != 0)
00596 return(i);
00597
00598
00599
00600 if (strcmp(varName, "rescGroupName") == 0) {
00601
00602 i = getStrLeafValue(varValue, rei->rescGroupName, r);
00603
00604 return i;
00605 }
00606
00607
00608 if (strcmp(varName, "rescInfo") == 0) {
00609
00610 i = getValFromRescInfo(varMapCPtr, rei->rescInfo, varValue, r);
00611
00612 return i;
00613 }
00614
00615
00616 if (strcmp(varName, "status") == 0) {
00617
00618 i = getIntLeafValue(varValue, rei->status, r);
00619
00620 return i;
00621 }
00622
00623
00624 if (strcmp(varName, "dummy") == 0) {
00625
00626 i = getIntLeafValue(varValue, rei->dummy, r);
00627
00628 return i;
00629 }
00630
00631
00632 if (strcmp(varName, "cacheNext") == 0) {
00633
00634 i = getValFromRescGrpInfo(varMapCPtr, rei->cacheNext, varValue, r);
00635
00636 return i;
00637 }
00638
00639
00640 if (strcmp(varName, "next") == 0) {
00641
00642 i = getValFromRescGrpInfo(varMapCPtr, rei->next, varValue, r);
00643
00644 return i;
00645 }
00646
00647
00648 return(UNDEFINED_VARIABLE_MAP_ERR);
00649 }
00650 int setValFromRescGrpInfo(char *varMap, rescGrpInfo_t **inrei, Res *newVarValue)
00651 {
00652 char varName[NAME_LEN];
00653 char *varMapCPtr;
00654 int i;
00655 rescGrpInfo_t *rei;
00656
00657 rei = *inrei;
00658
00659 if (varMap == NULL) {
00660 i = setStructPtrLeafValue((void**)inrei, newVarValue);
00661 return(i);
00662 }
00663 if (rei == NULL)
00664 return(NULL_VALUE_ERR);
00665
00666 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
00667 if (i != 0)
00668 return(i);
00669
00670
00671 if (strcmp(varName, "rescGroupName") == 0) {
00672
00673 i = setStrLeafValue(rei->rescGroupName, NAME_LEN, newVarValue);
00674
00675 return i;
00676 }
00677
00678 if (strcmp(varName, "rescInfo") == 0) {
00679
00680 i = setValFromRescInfo(varMapCPtr, &(rei->rescInfo), newVarValue);
00681
00682 return i;
00683 }
00684
00685 if (strcmp(varName, "status") == 0) {
00686
00687 i = setIntLeafValue(&(rei->status), newVarValue);
00688
00689 return i;
00690 }
00691
00692 if (strcmp(varName, "dummy") == 0) {
00693
00694 i = setIntLeafValue(&(rei->dummy), newVarValue);
00695
00696 return i;
00697 }
00698
00699 if (strcmp(varName, "cacheNext") == 0) {
00700
00701 i = setValFromRescGrpInfo(varMapCPtr, &(rei->cacheNext), newVarValue);
00702
00703 return i;
00704 }
00705
00706 if (strcmp(varName, "next") == 0) {
00707
00708 i = setValFromRescGrpInfo(varMapCPtr, &(rei->next), newVarValue);
00709
00710 return i;
00711 }
00712
00713
00714 return(UNDEFINED_VARIABLE_MAP_ERR);
00715 }
00716 ExprType *getVarTypeFromRescGrpInfo(char *varMap, Region *r)
00717 {
00718 char varName[NAME_LEN];
00719 char *varMapCPtr;
00720 int i;
00721
00722 if (varMap == NULL) {
00723 return newIRODSType(RescGrpInfo_MS_T, r);
00724 }
00725
00726 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
00727 if (i != 0)
00728 return newErrorType(i, r);
00729
00730
00731
00732 if (strcmp(varName, "rescGroupName") == 0) {
00733
00734 return newSimpType(T_STRING, r);
00735
00736 }
00737
00738
00739 if (strcmp(varName, "rescInfo") == 0) {
00740
00741 return getVarTypeFromRescInfo(varMapCPtr, r);
00742
00743 }
00744
00745
00746 if (strcmp(varName, "status") == 0) {
00747
00748 return newSimpType(T_INT, r);
00749
00750 }
00751
00752
00753 if (strcmp(varName, "dummy") == 0) {
00754
00755 return newSimpType(T_INT, r);
00756
00757 }
00758
00759
00760 if (strcmp(varName, "cacheNext") == 0) {
00761
00762 return getVarTypeFromRescGrpInfo(varMapCPtr, r);
00763
00764 }
00765
00766
00767 if (strcmp(varName, "next") == 0) {
00768
00769 return getVarTypeFromRescGrpInfo(varMapCPtr, r);
00770
00771 }
00772
00773
00774 return newErrorType(UNDEFINED_VARIABLE_MAP_ERR, r);
00775 }
00776
00777
00778 int getValFromKeyValPair(char *varMap, keyValPair_t *rei, Res **varValue, Region *r)
00779 {
00780 char varName[NAME_LEN];
00781 char *varMapCPtr;
00782 int i;
00783
00784 if (varMap == NULL) {
00785 i = getPtrLeafValue(varValue, (void *) rei, NULL, KeyValPair_MS_T, r);
00786 return(i);
00787 }
00788 if (rei == NULL)
00789 return(NULL_VALUE_ERR);
00790
00791 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
00792 if (i != 0)
00793 return(i);
00794
00795
00796
00797 if (strcmp(varName, "len") == 0) {
00798
00799 i = getIntLeafValue(varValue, rei->len, r);
00800
00801 return i;
00802 }
00803
00804
00805 if (strcmp(varName, "keyWord") == 0) {
00806
00807 i = UNDEFINED_VARIABLE_MAP_ERR;
00808
00809 return i;
00810 }
00811
00812
00813 if (strcmp(varName, "value") == 0) {
00814
00815 i = UNDEFINED_VARIABLE_MAP_ERR;
00816
00817 return i;
00818 }
00819
00820
00821 return(UNDEFINED_VARIABLE_MAP_ERR);
00822 }
00823 int setValFromKeyValPair(char *varMap, keyValPair_t **inrei, Res *newVarValue)
00824 {
00825 char varName[NAME_LEN];
00826 char *varMapCPtr;
00827 int i;
00828 keyValPair_t *rei;
00829
00830 rei = *inrei;
00831
00832 if (varMap == NULL) {
00833 i = setStructPtrLeafValue((void**)inrei, newVarValue);
00834 return(i);
00835 }
00836 if (rei == NULL)
00837 return(NULL_VALUE_ERR);
00838
00839 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
00840 if (i != 0)
00841 return(i);
00842
00843
00844 if (strcmp(varName, "len") == 0) {
00845
00846 i = setIntLeafValue(&(rei->len), newVarValue);
00847
00848 return i;
00849 }
00850
00851 if (strcmp(varName, "keyWord") == 0) {
00852
00853 i = UNDEFINED_VARIABLE_MAP_ERR;
00854
00855 return i;
00856 }
00857
00858 if (strcmp(varName, "value") == 0) {
00859
00860 i = UNDEFINED_VARIABLE_MAP_ERR;
00861
00862 return i;
00863 }
00864
00865
00866 return(UNDEFINED_VARIABLE_MAP_ERR);
00867 }
00868 ExprType *getVarTypeFromKeyValPair(char *varMap, Region *r)
00869 {
00870 char varName[NAME_LEN];
00871 char *varMapCPtr;
00872 int i;
00873
00874 if (varMap == NULL) {
00875 return newIRODSType(KeyValPair_MS_T, r);
00876 }
00877
00878 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
00879 if (i != 0)
00880 return newErrorType(i, r);
00881
00882
00883
00884 if (strcmp(varName, "len") == 0) {
00885
00886 return newSimpType(T_INT, r);
00887
00888 }
00889
00890
00891 if (strcmp(varName, "keyWord") == 0) {
00892
00893 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
00894
00895 }
00896
00897
00898 if (strcmp(varName, "value") == 0) {
00899
00900 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
00901
00902 }
00903
00904
00905 return newErrorType(UNDEFINED_VARIABLE_MAP_ERR, r);
00906 }
00907
00908
00909 int getValFromDataObjInfo(char *varMap, dataObjInfo_t *rei, Res **varValue, Region *r)
00910 {
00911 char varName[NAME_LEN];
00912 char *varMapCPtr;
00913 int i;
00914
00915 if (varMap == NULL) {
00916 i = getPtrLeafValue(varValue, (void *) rei, NULL, DataObjInfo_MS_T, r);
00917 return(i);
00918 }
00919 if (rei == NULL)
00920 return(NULL_VALUE_ERR);
00921
00922 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
00923 if (i != 0)
00924 return(i);
00925
00926
00927
00928 if (strcmp(varName, "objPath") == 0) {
00929
00930 i = getStrLeafValue(varValue, rei->objPath, r);
00931
00932 return i;
00933 }
00934
00935
00936 if (strcmp(varName, "rescName") == 0) {
00937
00938 i = getStrLeafValue(varValue, rei->rescName, r);
00939
00940 return i;
00941 }
00942
00943
00944 if (strcmp(varName, "rescGroupName") == 0) {
00945
00946 i = getStrLeafValue(varValue, rei->rescGroupName, r);
00947
00948 return i;
00949 }
00950
00951
00952 if (strcmp(varName, "dataType") == 0) {
00953
00954 i = getStrLeafValue(varValue, rei->dataType, r);
00955
00956 return i;
00957 }
00958
00959
00960 if (strcmp(varName, "dataSize") == 0) {
00961
00962 i = getLongLeafValue(varValue, rei->dataSize, r);
00963
00964 return i;
00965 }
00966
00967
00968 if (strcmp(varName, "chksum") == 0) {
00969
00970 i = getStrLeafValue(varValue, rei->chksum, r);
00971
00972 return i;
00973 }
00974
00975
00976 if (strcmp(varName, "version") == 0) {
00977
00978 i = getStrLeafValue(varValue, rei->version, r);
00979
00980 return i;
00981 }
00982
00983
00984 if (strcmp(varName, "filePath") == 0) {
00985
00986 i = getStrLeafValue(varValue, rei->filePath, r);
00987
00988 return i;
00989 }
00990
00991
00992 if (strcmp(varName, "rescInfo") == 0) {
00993
00994 i = getValFromRescInfo(varMapCPtr, rei->rescInfo, varValue, r);
00995
00996 return i;
00997 }
00998
00999
01000 if (strcmp(varName, "dataOwnerName") == 0) {
01001
01002 i = getStrLeafValue(varValue, rei->dataOwnerName, r);
01003
01004 return i;
01005 }
01006
01007
01008 if (strcmp(varName, "dataOwnerZone") == 0) {
01009
01010 i = getStrLeafValue(varValue, rei->dataOwnerZone, r);
01011
01012 return i;
01013 }
01014
01015
01016 if (strcmp(varName, "replNum") == 0) {
01017
01018 i = getIntLeafValue(varValue, rei->replNum, r);
01019
01020 return i;
01021 }
01022
01023
01024 if (strcmp(varName, "replStatus") == 0) {
01025
01026 i = getIntLeafValue(varValue, rei->replStatus, r);
01027
01028 return i;
01029 }
01030
01031
01032 if (strcmp(varName, "statusString") == 0) {
01033
01034 i = getStrLeafValue(varValue, rei->statusString, r);
01035
01036 return i;
01037 }
01038
01039
01040 if (strcmp(varName, "dataId") == 0) {
01041
01042 i = getLongLeafValue(varValue, rei->dataId, r);
01043
01044 return i;
01045 }
01046
01047
01048 if (strcmp(varName, "collId") == 0) {
01049
01050 i = getLongLeafValue(varValue, rei->collId, r);
01051
01052 return i;
01053 }
01054
01055
01056 if (strcmp(varName, "dataMapId") == 0) {
01057
01058 i = getIntLeafValue(varValue, rei->dataMapId, r);
01059
01060 return i;
01061 }
01062
01063
01064 if (strcmp(varName, "flags") == 0) {
01065
01066 i = getIntLeafValue(varValue, rei->flags, r);
01067
01068 return i;
01069 }
01070
01071
01072 if (strcmp(varName, "dataComments") == 0) {
01073
01074 i = getStrLeafValue(varValue, rei->dataComments, r);
01075
01076 return i;
01077 }
01078
01079
01080 if (strcmp(varName, "dataMode") == 0) {
01081
01082 i = getStrLeafValue(varValue, rei->dataMode, r);
01083
01084 return i;
01085 }
01086
01087
01088 if (strcmp(varName, "dataExpiry") == 0) {
01089
01090 i = getStrLeafValue(varValue, rei->dataExpiry, r);
01091
01092 return i;
01093 }
01094
01095
01096 if (strcmp(varName, "dataCreate") == 0) {
01097
01098 i = getStrLeafValue(varValue, rei->dataCreate, r);
01099
01100 return i;
01101 }
01102
01103
01104 if (strcmp(varName, "dataModify") == 0) {
01105
01106 i = getStrLeafValue(varValue, rei->dataModify, r);
01107
01108 return i;
01109 }
01110
01111
01112 if (strcmp(varName, "dataAccess") == 0) {
01113
01114 i = getStrLeafValue(varValue, rei->dataAccess, r);
01115
01116 return i;
01117 }
01118
01119
01120 if (strcmp(varName, "dataAccessInx") == 0) {
01121
01122 i = getIntLeafValue(varValue, rei->dataAccessInx, r);
01123
01124 return i;
01125 }
01126
01127
01128 if (strcmp(varName, "writeFlag") == 0) {
01129
01130 i = getIntLeafValue(varValue, rei->writeFlag, r);
01131
01132 return i;
01133 }
01134
01135
01136 if (strcmp(varName, "destRescName") == 0) {
01137
01138 i = getStrLeafValue(varValue, rei->destRescName, r);
01139
01140 return i;
01141 }
01142
01143
01144 if (strcmp(varName, "backupRescName") == 0) {
01145
01146 i = getStrLeafValue(varValue, rei->backupRescName, r);
01147
01148 return i;
01149 }
01150
01151
01152 if (strcmp(varName, "subPath") == 0) {
01153
01154 i = getStrLeafValue(varValue, rei->subPath, r);
01155
01156 return i;
01157 }
01158
01159
01160 if (strcmp(varName, "specColl") == 0) {
01161
01162 i = UNDEFINED_VARIABLE_MAP_ERR;
01163
01164 return i;
01165 }
01166
01167
01168 if (strcmp(varName, "regUid") == 0) {
01169
01170 i = getIntLeafValue(varValue, rei->regUid, r);
01171
01172 return i;
01173 }
01174
01175
01176 if (strcmp(varName, "otherFlags") == 0) {
01177
01178 i = getIntLeafValue(varValue, rei->otherFlags, r);
01179
01180 return i;
01181 }
01182
01183
01184 if (strcmp(varName, "condInput") == 0) {
01185
01186 i = UNDEFINED_VARIABLE_MAP_ERR;
01187
01188 return i;
01189 }
01190
01191
01192 if (strcmp(varName, "next") == 0) {
01193
01194 i = getValFromDataObjInfo(varMapCPtr, rei->next, varValue, r);
01195
01196 return i;
01197 }
01198
01199
01200 return(UNDEFINED_VARIABLE_MAP_ERR);
01201 }
01202 int setValFromDataObjInfo(char *varMap, dataObjInfo_t **inrei, Res *newVarValue)
01203 {
01204 char varName[NAME_LEN];
01205 char *varMapCPtr;
01206 int i;
01207 dataObjInfo_t *rei;
01208
01209 rei = *inrei;
01210
01211 if (varMap == NULL) {
01212 i = setStructPtrLeafValue((void**)inrei, newVarValue);
01213 return(i);
01214 }
01215 if (rei == NULL)
01216 return(NULL_VALUE_ERR);
01217
01218 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
01219 if (i != 0)
01220 return(i);
01221
01222
01223 if (strcmp(varName, "objPath") == 0) {
01224
01225 i = setStrLeafValue(rei->objPath, MAX_NAME_LEN, newVarValue);
01226
01227 return i;
01228 }
01229
01230 if (strcmp(varName, "rescName") == 0) {
01231
01232 i = setStrLeafValue(rei->rescName, NAME_LEN, newVarValue);
01233
01234 return i;
01235 }
01236
01237 if (strcmp(varName, "rescGroupName") == 0) {
01238
01239 i = setStrLeafValue(rei->rescGroupName, NAME_LEN, newVarValue);
01240
01241 return i;
01242 }
01243
01244 if (strcmp(varName, "dataType") == 0) {
01245
01246 i = setStrLeafValue(rei->dataType, NAME_LEN, newVarValue);
01247
01248 return i;
01249 }
01250
01251 if (strcmp(varName, "dataSize") == 0) {
01252
01253 i = setLongLeafValue(&(rei->dataSize), newVarValue);
01254
01255 return i;
01256 }
01257
01258 if (strcmp(varName, "chksum") == 0) {
01259
01260 i = setStrLeafValue(rei->chksum, NAME_LEN, newVarValue);
01261
01262 return i;
01263 }
01264
01265 if (strcmp(varName, "version") == 0) {
01266
01267 i = setStrLeafValue(rei->version, NAME_LEN, newVarValue);
01268
01269 return i;
01270 }
01271
01272 if (strcmp(varName, "filePath") == 0) {
01273
01274 i = setStrLeafValue(rei->filePath, MAX_NAME_LEN, newVarValue);
01275
01276 return i;
01277 }
01278
01279 if (strcmp(varName, "rescInfo") == 0) {
01280
01281 i = setValFromRescInfo(varMapCPtr, &(rei->rescInfo), newVarValue);
01282
01283 return i;
01284 }
01285
01286 if (strcmp(varName, "dataOwnerName") == 0) {
01287
01288 i = setStrLeafValue(rei->dataOwnerName, NAME_LEN, newVarValue);
01289
01290 return i;
01291 }
01292
01293 if (strcmp(varName, "dataOwnerZone") == 0) {
01294
01295 i = setStrLeafValue(rei->dataOwnerZone, NAME_LEN, newVarValue);
01296
01297 return i;
01298 }
01299
01300 if (strcmp(varName, "replNum") == 0) {
01301
01302 i = setIntLeafValue(&(rei->replNum), newVarValue);
01303
01304 return i;
01305 }
01306
01307 if (strcmp(varName, "replStatus") == 0) {
01308
01309 i = setIntLeafValue(&(rei->replStatus), newVarValue);
01310
01311 return i;
01312 }
01313
01314 if (strcmp(varName, "statusString") == 0) {
01315
01316 i = setStrLeafValue(rei->statusString, NAME_LEN, newVarValue);
01317
01318 return i;
01319 }
01320
01321 if (strcmp(varName, "dataId") == 0) {
01322
01323 i = setLongLeafValue(&(rei->dataId), newVarValue);
01324
01325 return i;
01326 }
01327
01328 if (strcmp(varName, "collId") == 0) {
01329
01330 i = setLongLeafValue(&(rei->collId), newVarValue);
01331
01332 return i;
01333 }
01334
01335 if (strcmp(varName, "dataMapId") == 0) {
01336
01337 i = setIntLeafValue(&(rei->dataMapId), newVarValue);
01338
01339 return i;
01340 }
01341
01342 if (strcmp(varName, "flags") == 0) {
01343
01344 i = setIntLeafValue(&(rei->flags), newVarValue);
01345
01346 return i;
01347 }
01348
01349 if (strcmp(varName, "dataComments") == 0) {
01350
01351 i = setStrLeafValue(rei->dataComments, LONG_NAME_LEN, newVarValue);
01352
01353 return i;
01354 }
01355
01356 if (strcmp(varName, "dataMode") == 0) {
01357
01358 i = setStrLeafValue(rei->dataMode, SHORT_STR_LEN, newVarValue);
01359
01360 return i;
01361 }
01362
01363 if (strcmp(varName, "dataExpiry") == 0) {
01364
01365 i = setStrLeafValue(rei->dataExpiry, TIME_LEN, newVarValue);
01366
01367 return i;
01368 }
01369
01370 if (strcmp(varName, "dataCreate") == 0) {
01371
01372 i = setStrLeafValue(rei->dataCreate, TIME_LEN, newVarValue);
01373
01374 return i;
01375 }
01376
01377 if (strcmp(varName, "dataModify") == 0) {
01378
01379 i = setStrLeafValue(rei->dataModify, TIME_LEN, newVarValue);
01380
01381 return i;
01382 }
01383
01384 if (strcmp(varName, "dataAccess") == 0) {
01385
01386 i = setStrLeafValue(rei->dataAccess, NAME_LEN, newVarValue);
01387
01388 return i;
01389 }
01390
01391 if (strcmp(varName, "dataAccessInx") == 0) {
01392
01393 i = setIntLeafValue(&(rei->dataAccessInx), newVarValue);
01394
01395 return i;
01396 }
01397
01398 if (strcmp(varName, "writeFlag") == 0) {
01399
01400 i = setIntLeafValue(&(rei->writeFlag), newVarValue);
01401
01402 return i;
01403 }
01404
01405 if (strcmp(varName, "destRescName") == 0) {
01406
01407 i = setStrLeafValue(rei->destRescName, NAME_LEN, newVarValue);
01408
01409 return i;
01410 }
01411
01412 if (strcmp(varName, "backupRescName") == 0) {
01413
01414 i = setStrLeafValue(rei->backupRescName, NAME_LEN, newVarValue);
01415
01416 return i;
01417 }
01418
01419 if (strcmp(varName, "subPath") == 0) {
01420
01421 i = setStrLeafValue(rei->subPath, MAX_NAME_LEN, newVarValue);
01422
01423 return i;
01424 }
01425
01426 if (strcmp(varName, "specColl") == 0) {
01427
01428 i = UNDEFINED_VARIABLE_MAP_ERR;
01429
01430 return i;
01431 }
01432
01433 if (strcmp(varName, "regUid") == 0) {
01434
01435 i = setIntLeafValue(&(rei->regUid), newVarValue);
01436
01437 return i;
01438 }
01439
01440 if (strcmp(varName, "otherFlags") == 0) {
01441
01442 i = setIntLeafValue(&(rei->otherFlags), newVarValue);
01443
01444 return i;
01445 }
01446
01447 if (strcmp(varName, "condInput") == 0) {
01448
01449 i = UNDEFINED_VARIABLE_MAP_ERR;
01450
01451 return i;
01452 }
01453
01454 if (strcmp(varName, "next") == 0) {
01455
01456 i = setValFromDataObjInfo(varMapCPtr, &(rei->next), newVarValue);
01457
01458 return i;
01459 }
01460
01461
01462 return(UNDEFINED_VARIABLE_MAP_ERR);
01463 }
01464 ExprType *getVarTypeFromDataObjInfo(char *varMap, Region *r)
01465 {
01466 char varName[NAME_LEN];
01467 char *varMapCPtr;
01468 int i;
01469
01470 if (varMap == NULL) {
01471 return newIRODSType(DataObjInfo_MS_T, r);
01472 }
01473
01474 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
01475 if (i != 0)
01476 return newErrorType(i, r);
01477
01478
01479
01480 if (strcmp(varName, "objPath") == 0) {
01481
01482 return newSimpType(T_STRING, r);
01483
01484 }
01485
01486
01487 if (strcmp(varName, "rescName") == 0) {
01488
01489 return newSimpType(T_STRING, r);
01490
01491 }
01492
01493
01494 if (strcmp(varName, "rescGroupName") == 0) {
01495
01496 return newSimpType(T_STRING, r);
01497
01498 }
01499
01500
01501 if (strcmp(varName, "dataType") == 0) {
01502
01503 return newSimpType(T_STRING, r);
01504
01505 }
01506
01507
01508 if (strcmp(varName, "dataSize") == 0) {
01509
01510 return newSimpType(T_DOUBLE, r);
01511
01512 }
01513
01514
01515 if (strcmp(varName, "chksum") == 0) {
01516
01517 return newSimpType(T_STRING, r);
01518
01519 }
01520
01521
01522 if (strcmp(varName, "version") == 0) {
01523
01524 return newSimpType(T_STRING, r);
01525
01526 }
01527
01528
01529 if (strcmp(varName, "filePath") == 0) {
01530
01531 return newSimpType(T_STRING, r);
01532
01533 }
01534
01535
01536 if (strcmp(varName, "rescInfo") == 0) {
01537
01538 return getVarTypeFromRescInfo(varMapCPtr, r);
01539
01540 }
01541
01542
01543 if (strcmp(varName, "dataOwnerName") == 0) {
01544
01545 return newSimpType(T_STRING, r);
01546
01547 }
01548
01549
01550 if (strcmp(varName, "dataOwnerZone") == 0) {
01551
01552 return newSimpType(T_STRING, r);
01553
01554 }
01555
01556
01557 if (strcmp(varName, "replNum") == 0) {
01558
01559 return newSimpType(T_INT, r);
01560
01561 }
01562
01563
01564 if (strcmp(varName, "replStatus") == 0) {
01565
01566 return newSimpType(T_INT, r);
01567
01568 }
01569
01570
01571 if (strcmp(varName, "statusString") == 0) {
01572
01573 return newSimpType(T_STRING, r);
01574
01575 }
01576
01577
01578 if (strcmp(varName, "dataId") == 0) {
01579
01580 return newSimpType(T_DOUBLE, r);
01581
01582 }
01583
01584
01585 if (strcmp(varName, "collId") == 0) {
01586
01587 return newSimpType(T_DOUBLE, r);
01588
01589 }
01590
01591
01592 if (strcmp(varName, "dataMapId") == 0) {
01593
01594 return newSimpType(T_INT, r);
01595
01596 }
01597
01598
01599 if (strcmp(varName, "flags") == 0) {
01600
01601 return newSimpType(T_INT, r);
01602
01603 }
01604
01605
01606 if (strcmp(varName, "dataComments") == 0) {
01607
01608 return newSimpType(T_STRING, r);
01609
01610 }
01611
01612
01613 if (strcmp(varName, "dataMode") == 0) {
01614
01615 return newSimpType(T_STRING, r);
01616
01617 }
01618
01619
01620 if (strcmp(varName, "dataExpiry") == 0) {
01621
01622 return newSimpType(T_STRING, r);
01623
01624 }
01625
01626
01627 if (strcmp(varName, "dataCreate") == 0) {
01628
01629 return newSimpType(T_STRING, r);
01630
01631 }
01632
01633
01634 if (strcmp(varName, "dataModify") == 0) {
01635
01636 return newSimpType(T_STRING, r);
01637
01638 }
01639
01640
01641 if (strcmp(varName, "dataAccess") == 0) {
01642
01643 return newSimpType(T_STRING, r);
01644
01645 }
01646
01647
01648 if (strcmp(varName, "dataAccessInx") == 0) {
01649
01650 return newSimpType(T_INT, r);
01651
01652 }
01653
01654
01655 if (strcmp(varName, "writeFlag") == 0) {
01656
01657 return newSimpType(T_INT, r);
01658
01659 }
01660
01661
01662 if (strcmp(varName, "destRescName") == 0) {
01663
01664 return newSimpType(T_STRING, r);
01665
01666 }
01667
01668
01669 if (strcmp(varName, "backupRescName") == 0) {
01670
01671 return newSimpType(T_STRING, r);
01672
01673 }
01674
01675
01676 if (strcmp(varName, "subPath") == 0) {
01677
01678 return newSimpType(T_STRING, r);
01679
01680 }
01681
01682
01683 if (strcmp(varName, "specColl") == 0) {
01684
01685 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
01686
01687 }
01688
01689
01690 if (strcmp(varName, "regUid") == 0) {
01691
01692 return newSimpType(T_INT, r);
01693
01694 }
01695
01696
01697 if (strcmp(varName, "otherFlags") == 0) {
01698
01699 return newSimpType(T_INT, r);
01700
01701 }
01702
01703
01704 if (strcmp(varName, "condInput") == 0) {
01705
01706 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
01707
01708 }
01709
01710
01711 if (strcmp(varName, "next") == 0) {
01712
01713 return getVarTypeFromDataObjInfo(varMapCPtr, r);
01714
01715 }
01716
01717
01718 return newErrorType(UNDEFINED_VARIABLE_MAP_ERR, r);
01719 }
01720
01721
01722 int getValFromCollInfo(char *varMap, collInfo_t *rei, Res **varValue, Region *r)
01723 {
01724 char varName[NAME_LEN];
01725 char *varMapCPtr;
01726 int i;
01727
01728 if (varMap == NULL) {
01729 i = getPtrLeafValue(varValue, (void *) rei, NULL, CollInfo_MS_T, r);
01730 return(i);
01731 }
01732 if (rei == NULL)
01733 return(NULL_VALUE_ERR);
01734
01735 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
01736 if (i != 0)
01737 return(i);
01738
01739
01740
01741 if (strcmp(varName, "collId") == 0) {
01742
01743 i = getLongLeafValue(varValue, rei->collId, r);
01744
01745 return i;
01746 }
01747
01748
01749 if (strcmp(varName, "collName") == 0) {
01750
01751 i = getStrLeafValue(varValue, rei->collName, r);
01752
01753 return i;
01754 }
01755
01756
01757 if (strcmp(varName, "collParentName") == 0) {
01758
01759 i = getStrLeafValue(varValue, rei->collParentName, r);
01760
01761 return i;
01762 }
01763
01764
01765 if (strcmp(varName, "collOwnerName") == 0) {
01766
01767 i = getStrLeafValue(varValue, rei->collOwnerName, r);
01768
01769 return i;
01770 }
01771
01772
01773 if (strcmp(varName, "collOwnerZone") == 0) {
01774
01775 i = getStrLeafValue(varValue, rei->collOwnerZone, r);
01776
01777 return i;
01778 }
01779
01780
01781 if (strcmp(varName, "collMapId") == 0) {
01782
01783 i = getIntLeafValue(varValue, rei->collMapId, r);
01784
01785 return i;
01786 }
01787
01788
01789 if (strcmp(varName, "collAccessInx") == 0) {
01790
01791 i = getIntLeafValue(varValue, rei->collAccessInx, r);
01792
01793 return i;
01794 }
01795
01796
01797 if (strcmp(varName, "collComments") == 0) {
01798
01799 i = getStrLeafValue(varValue, rei->collComments, r);
01800
01801 return i;
01802 }
01803
01804
01805 if (strcmp(varName, "collInheritance") == 0) {
01806
01807 i = getStrLeafValue(varValue, rei->collInheritance, r);
01808
01809 return i;
01810 }
01811
01812
01813 if (strcmp(varName, "collExpiry") == 0) {
01814
01815 i = getStrLeafValue(varValue, rei->collExpiry, r);
01816
01817 return i;
01818 }
01819
01820
01821 if (strcmp(varName, "collCreate") == 0) {
01822
01823 i = getStrLeafValue(varValue, rei->collCreate, r);
01824
01825 return i;
01826 }
01827
01828
01829 if (strcmp(varName, "collModify") == 0) {
01830
01831 i = getStrLeafValue(varValue, rei->collModify, r);
01832
01833 return i;
01834 }
01835
01836
01837 if (strcmp(varName, "collAccess") == 0) {
01838
01839 i = getStrLeafValue(varValue, rei->collAccess, r);
01840
01841 return i;
01842 }
01843
01844
01845 if (strcmp(varName, "collType") == 0) {
01846
01847 i = getStrLeafValue(varValue, rei->collType, r);
01848
01849 return i;
01850 }
01851
01852
01853 if (strcmp(varName, "collInfo1") == 0) {
01854
01855 i = getStrLeafValue(varValue, rei->collInfo1, r);
01856
01857 return i;
01858 }
01859
01860
01861 if (strcmp(varName, "collInfo2") == 0) {
01862
01863 i = getStrLeafValue(varValue, rei->collInfo2, r);
01864
01865 return i;
01866 }
01867
01868
01869 if (strcmp(varName, "condInput") == 0) {
01870
01871 i = UNDEFINED_VARIABLE_MAP_ERR;
01872
01873 return i;
01874 }
01875
01876
01877 if (strcmp(varName, "next") == 0) {
01878
01879 i = getValFromCollInfo(varMapCPtr, rei->next, varValue, r);
01880
01881 return i;
01882 }
01883
01884
01885 return(UNDEFINED_VARIABLE_MAP_ERR);
01886 }
01887 int setValFromCollInfo(char *varMap, collInfo_t **inrei, Res *newVarValue)
01888 {
01889 char varName[NAME_LEN];
01890 char *varMapCPtr;
01891 int i;
01892 collInfo_t *rei;
01893
01894 rei = *inrei;
01895
01896 if (varMap == NULL) {
01897 i = setStructPtrLeafValue((void**)inrei, newVarValue);
01898 return(i);
01899 }
01900 if (rei == NULL)
01901 return(NULL_VALUE_ERR);
01902
01903 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
01904 if (i != 0)
01905 return(i);
01906
01907
01908 if (strcmp(varName, "collId") == 0) {
01909
01910 i = setLongLeafValue(&(rei->collId), newVarValue);
01911
01912 return i;
01913 }
01914
01915 if (strcmp(varName, "collName") == 0) {
01916
01917 i = setStrLeafValue(rei->collName, MAX_NAME_LEN, newVarValue);
01918
01919 return i;
01920 }
01921
01922 if (strcmp(varName, "collParentName") == 0) {
01923
01924 i = setStrLeafValue(rei->collParentName, MAX_NAME_LEN, newVarValue);
01925
01926 return i;
01927 }
01928
01929 if (strcmp(varName, "collOwnerName") == 0) {
01930
01931 i = setStrLeafValue(rei->collOwnerName, NAME_LEN, newVarValue);
01932
01933 return i;
01934 }
01935
01936 if (strcmp(varName, "collOwnerZone") == 0) {
01937
01938 i = setStrLeafValue(rei->collOwnerZone, NAME_LEN, newVarValue);
01939
01940 return i;
01941 }
01942
01943 if (strcmp(varName, "collMapId") == 0) {
01944
01945 i = setIntLeafValue(&(rei->collMapId), newVarValue);
01946
01947 return i;
01948 }
01949
01950 if (strcmp(varName, "collAccessInx") == 0) {
01951
01952 i = setIntLeafValue(&(rei->collAccessInx), newVarValue);
01953
01954 return i;
01955 }
01956
01957 if (strcmp(varName, "collComments") == 0) {
01958
01959 i = setStrLeafValue(rei->collComments, LONG_NAME_LEN, newVarValue);
01960
01961 return i;
01962 }
01963
01964 if (strcmp(varName, "collInheritance") == 0) {
01965
01966 i = setStrLeafValue(rei->collInheritance, LONG_NAME_LEN, newVarValue);
01967
01968 return i;
01969 }
01970
01971 if (strcmp(varName, "collExpiry") == 0) {
01972
01973 i = setStrLeafValue(rei->collExpiry, TIME_LEN, newVarValue);
01974
01975 return i;
01976 }
01977
01978 if (strcmp(varName, "collCreate") == 0) {
01979
01980 i = setStrLeafValue(rei->collCreate, TIME_LEN, newVarValue);
01981
01982 return i;
01983 }
01984
01985 if (strcmp(varName, "collModify") == 0) {
01986
01987 i = setStrLeafValue(rei->collModify, TIME_LEN, newVarValue);
01988
01989 return i;
01990 }
01991
01992 if (strcmp(varName, "collAccess") == 0) {
01993
01994 i = setStrLeafValue(rei->collAccess, NAME_LEN, newVarValue);
01995
01996 return i;
01997 }
01998
01999 if (strcmp(varName, "collType") == 0) {
02000
02001 i = setStrLeafValue(rei->collType, NAME_LEN, newVarValue);
02002
02003 return i;
02004 }
02005
02006 if (strcmp(varName, "collInfo1") == 0) {
02007
02008 i = setStrLeafValue(rei->collInfo1, MAX_NAME_LEN, newVarValue);
02009
02010 return i;
02011 }
02012
02013 if (strcmp(varName, "collInfo2") == 0) {
02014
02015 i = setStrLeafValue(rei->collInfo2, MAX_NAME_LEN, newVarValue);
02016
02017 return i;
02018 }
02019
02020 if (strcmp(varName, "condInput") == 0) {
02021
02022 i = UNDEFINED_VARIABLE_MAP_ERR;
02023
02024 return i;
02025 }
02026
02027 if (strcmp(varName, "next") == 0) {
02028
02029 i = setValFromCollInfo(varMapCPtr, &(rei->next), newVarValue);
02030
02031 return i;
02032 }
02033
02034
02035 return(UNDEFINED_VARIABLE_MAP_ERR);
02036 }
02037 ExprType *getVarTypeFromCollInfo(char *varMap, Region *r)
02038 {
02039 char varName[NAME_LEN];
02040 char *varMapCPtr;
02041 int i;
02042
02043 if (varMap == NULL) {
02044 return newIRODSType(CollInfo_MS_T, r);
02045 }
02046
02047 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
02048 if (i != 0)
02049 return newErrorType(i, r);
02050
02051
02052
02053 if (strcmp(varName, "collId") == 0) {
02054
02055 return newSimpType(T_DOUBLE, r);
02056
02057 }
02058
02059
02060 if (strcmp(varName, "collName") == 0) {
02061
02062 return newSimpType(T_STRING, r);
02063
02064 }
02065
02066
02067 if (strcmp(varName, "collParentName") == 0) {
02068
02069 return newSimpType(T_STRING, r);
02070
02071 }
02072
02073
02074 if (strcmp(varName, "collOwnerName") == 0) {
02075
02076 return newSimpType(T_STRING, r);
02077
02078 }
02079
02080
02081 if (strcmp(varName, "collOwnerZone") == 0) {
02082
02083 return newSimpType(T_STRING, r);
02084
02085 }
02086
02087
02088 if (strcmp(varName, "collMapId") == 0) {
02089
02090 return newSimpType(T_INT, r);
02091
02092 }
02093
02094
02095 if (strcmp(varName, "collAccessInx") == 0) {
02096
02097 return newSimpType(T_INT, r);
02098
02099 }
02100
02101
02102 if (strcmp(varName, "collComments") == 0) {
02103
02104 return newSimpType(T_STRING, r);
02105
02106 }
02107
02108
02109 if (strcmp(varName, "collInheritance") == 0) {
02110
02111 return newSimpType(T_STRING, r);
02112
02113 }
02114
02115
02116 if (strcmp(varName, "collExpiry") == 0) {
02117
02118 return newSimpType(T_STRING, r);
02119
02120 }
02121
02122
02123 if (strcmp(varName, "collCreate") == 0) {
02124
02125 return newSimpType(T_STRING, r);
02126
02127 }
02128
02129
02130 if (strcmp(varName, "collModify") == 0) {
02131
02132 return newSimpType(T_STRING, r);
02133
02134 }
02135
02136
02137 if (strcmp(varName, "collAccess") == 0) {
02138
02139 return newSimpType(T_STRING, r);
02140
02141 }
02142
02143
02144 if (strcmp(varName, "collType") == 0) {
02145
02146 return newSimpType(T_STRING, r);
02147
02148 }
02149
02150
02151 if (strcmp(varName, "collInfo1") == 0) {
02152
02153 return newSimpType(T_STRING, r);
02154
02155 }
02156
02157
02158 if (strcmp(varName, "collInfo2") == 0) {
02159
02160 return newSimpType(T_STRING, r);
02161
02162 }
02163
02164
02165 if (strcmp(varName, "condInput") == 0) {
02166
02167 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
02168
02169 }
02170
02171
02172 if (strcmp(varName, "next") == 0) {
02173
02174 return getVarTypeFromCollInfo(varMapCPtr, r);
02175
02176 }
02177
02178
02179 return newErrorType(UNDEFINED_VARIABLE_MAP_ERR, r);
02180 }
02181
02182
02183 int getValFromRuleExecInfo(char *varMap, ruleExecInfo_t *rei, Res **varValue, Region *r)
02184 {
02185 char varName[NAME_LEN];
02186 char *varMapCPtr;
02187 int i;
02188
02189 if (varMap == NULL) {
02190 i = getPtrLeafValue(varValue, (void *) rei, NULL, RuleExecInfo_MS_T, r);
02191 return(i);
02192 }
02193 if (rei == NULL)
02194 return(NULL_VALUE_ERR);
02195
02196 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
02197 if (i != 0)
02198 return(i);
02199
02200 if (strcmp(varName, "pluginInstanceName") == 0) {
02201 i = getStrLeafValue(varValue, rei->pluginInstanceName, r);
02202 return i;
02203 }
02204
02205 if (strcmp(varName, "status") == 0) {
02206
02207 i = getIntLeafValue(varValue, rei->status, r);
02208
02209 return i;
02210 }
02211
02212
02213 if (strcmp(varName, "statusStr") == 0) {
02214
02215 i = getStrLeafValue(varValue, rei->statusStr, r);
02216
02217 return i;
02218 }
02219
02220
02221 if (strcmp(varName, "ruleName") == 0) {
02222
02223 i = getStrLeafValue(varValue, rei->ruleName, r);
02224
02225 return i;
02226 }
02227
02228
02229 if (strcmp(varName, "rsComm") == 0) {
02230
02231 i = getValFromRsComm(varMapCPtr, rei->rsComm, varValue, r);
02232
02233 return i;
02234 }
02235
02236
02237 if (strcmp(varName, "msParamArray") == 0) {
02238
02239 i = UNDEFINED_VARIABLE_MAP_ERR;
02240
02241 return i;
02242 }
02243
02244
02245 if (strcmp(varName, "inOutMsParamArray") == 0) {
02246
02247 i = UNDEFINED_VARIABLE_MAP_ERR;
02248
02249 return i;
02250 }
02251
02252
02253 if (strcmp(varName, "l1descInx") == 0) {
02254
02255 i = getIntLeafValue(varValue, rei->l1descInx, r);
02256
02257 return i;
02258 }
02259
02260
02261 if (strcmp(varName, "doinp") == 0) {
02262
02263 i = getValFromDataObjInp(varMapCPtr, rei->doinp, varValue, r);
02264
02265 return i;
02266 }
02267
02268
02269 if (strcmp(varName, "doi") == 0) {
02270
02271 i = getValFromDataObjInfo(varMapCPtr, rei->doi, varValue, r);
02272
02273 return i;
02274 }
02275
02276
02277 if (strcmp(varName, "rgi") == 0) {
02278
02279 i = getValFromRescGrpInfo(varMapCPtr, rei->rgi, varValue, r);
02280
02281 return i;
02282 }
02283
02284
02285 if (strcmp(varName, "uoic") == 0) {
02286
02287 i = getValFromUserInfo(varMapCPtr, rei->uoic, varValue, r);
02288
02289 return i;
02290 }
02291
02292
02293 if (strcmp(varName, "uoip") == 0) {
02294
02295 i = getValFromUserInfo(varMapCPtr, rei->uoip, varValue, r);
02296
02297 return i;
02298 }
02299
02300
02301 if (strcmp(varName, "coi") == 0) {
02302
02303 i = getValFromCollInfo(varMapCPtr, rei->coi, varValue, r);
02304
02305 return i;
02306 }
02307
02308
02309 if (strcmp(varName, "uoio") == 0) {
02310
02311 i = getValFromUserInfo(varMapCPtr, rei->uoio, varValue, r);
02312
02313 return i;
02314 }
02315
02316
02317 if (strcmp(varName, "condInputData") == 0) {
02318
02319 i = getValFromKeyValPair(varMapCPtr, rei->condInputData, varValue, r);
02320
02321 return i;
02322 }
02323
02324
02325 if (strcmp(varName, "ruleSet") == 0) {
02326
02327 i = getStrLeafValue(varValue, rei->ruleSet, r);
02328
02329 return i;
02330 }
02331
02332
02333 if (strcmp(varName, "next") == 0) {
02334
02335 i = getValFromRuleExecInfo(varMapCPtr, rei->next, varValue, r);
02336
02337 return i;
02338 }
02339
02340
02341 return(UNDEFINED_VARIABLE_MAP_ERR);
02342 }
02343 int setValFromRuleExecInfo(char *varMap, ruleExecInfo_t **inrei, Res *newVarValue)
02344 {
02345 char varName[NAME_LEN];
02346 char *varMapCPtr;
02347 int i;
02348 ruleExecInfo_t *rei;
02349
02350 rei = *inrei;
02351
02352 if (varMap == NULL) {
02353 i = setStructPtrLeafValue((void**)inrei, newVarValue);
02354 return(i);
02355 }
02356 if (rei == NULL)
02357 return(NULL_VALUE_ERR);
02358
02359 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
02360 if (i != 0)
02361 return(i);
02362 if (strcmp(varName, "pluginInstanceName") == 0) {
02363 i = setStrLeafValue( rei->pluginInstanceName, MAX_NAME_LEN, newVarValue );
02364 return i;
02365 }
02366
02367 if (strcmp(varName, "status") == 0) {
02368
02369 i = setIntLeafValue(&(rei->status), newVarValue);
02370
02371 return i;
02372 }
02373
02374 if (strcmp(varName, "statusStr") == 0) {
02375
02376 i = setStrLeafValue(rei->statusStr, MAX_NAME_LEN, newVarValue);
02377
02378 return i;
02379 }
02380
02381 if (strcmp(varName, "ruleName") == 0) {
02382
02383 i = setStrLeafValue(rei->ruleName, NAME_LEN, newVarValue);
02384
02385 return i;
02386 }
02387
02388 if (strcmp(varName, "rsComm") == 0) {
02389
02390 i = setValFromRsComm(varMapCPtr, &(rei->rsComm), newVarValue);
02391
02392 return i;
02393 }
02394
02395 if (strcmp(varName, "msParamArray") == 0) {
02396
02397 i = UNDEFINED_VARIABLE_MAP_ERR;
02398
02399 return i;
02400 }
02401
02402 if (strcmp(varName, "inOutMsParamArray") == 0) {
02403
02404 i = UNDEFINED_VARIABLE_MAP_ERR;
02405
02406 return i;
02407 }
02408
02409 if (strcmp(varName, "l1descInx") == 0) {
02410
02411 i = setIntLeafValue(&(rei->l1descInx), newVarValue);
02412
02413 return i;
02414 }
02415
02416 if (strcmp(varName, "doinp") == 0) {
02417
02418 i = setValFromDataObjInp(varMapCPtr, &(rei->doinp), newVarValue);
02419
02420 return i;
02421 }
02422
02423 if (strcmp(varName, "doi") == 0) {
02424
02425 i = setValFromDataObjInfo(varMapCPtr, &(rei->doi), newVarValue);
02426
02427 return i;
02428 }
02429
02430 if (strcmp(varName, "rgi") == 0) {
02431
02432 i = setValFromRescGrpInfo(varMapCPtr, &(rei->rgi), newVarValue);
02433
02434 return i;
02435 }
02436
02437 if (strcmp(varName, "uoic") == 0) {
02438
02439 i = setValFromUserInfo(varMapCPtr, &(rei->uoic), newVarValue);
02440
02441 return i;
02442 }
02443
02444 if (strcmp(varName, "uoip") == 0) {
02445
02446 i = setValFromUserInfo(varMapCPtr, &(rei->uoip), newVarValue);
02447
02448 return i;
02449 }
02450
02451 if (strcmp(varName, "coi") == 0) {
02452
02453 i = setValFromCollInfo(varMapCPtr, &(rei->coi), newVarValue);
02454
02455 return i;
02456 }
02457
02458 if (strcmp(varName, "uoio") == 0) {
02459
02460 i = setValFromUserInfo(varMapCPtr, &(rei->uoio), newVarValue);
02461
02462 return i;
02463 }
02464
02465 if (strcmp(varName, "condInputData") == 0) {
02466
02467 i = setValFromKeyValPair(varMapCPtr, &(rei->condInputData), newVarValue);
02468
02469 return i;
02470 }
02471
02472 if (strcmp(varName, "ruleSet") == 0) {
02473
02474 i = setStrLeafValue(rei->ruleSet, RULE_SET_DEF_LENGTH, newVarValue);
02475
02476 return i;
02477 }
02478
02479 if (strcmp(varName, "next") == 0) {
02480
02481 i = setValFromRuleExecInfo(varMapCPtr, &(rei->next), newVarValue);
02482
02483 return i;
02484 }
02485
02486
02487 return(UNDEFINED_VARIABLE_MAP_ERR);
02488 }
02489 ExprType *getVarTypeFromRuleExecInfo(char *varMap, Region *r)
02490 {
02491 char varName[NAME_LEN];
02492 char *varMapCPtr;
02493 int i;
02494
02495 if (varMap == NULL) {
02496 return newIRODSType(RuleExecInfo_MS_T, r);
02497 }
02498
02499 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
02500 if (i != 0)
02501 return newErrorType(i, r);
02502
02503 if( strcmp( varName, "pluginInstanceName" ) == 0 ) {
02504 return newSimpType( T_STRING, r );
02505 }
02506
02507 if (strcmp(varName, "status") == 0) {
02508
02509 return newSimpType(T_INT, r);
02510
02511 }
02512
02513
02514 if (strcmp(varName, "statusStr") == 0) {
02515
02516 return newSimpType(T_STRING, r);
02517
02518 }
02519
02520
02521 if (strcmp(varName, "ruleName") == 0) {
02522
02523 return newSimpType(T_STRING, r);
02524
02525 }
02526
02527
02528 if (strcmp(varName, "rsComm") == 0) {
02529
02530 return getVarTypeFromRsComm(varMapCPtr, r);
02531
02532 }
02533
02534
02535 if (strcmp(varName, "msParamArray") == 0) {
02536
02537 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
02538
02539 }
02540
02541
02542 if (strcmp(varName, "inOutMsParamArray") == 0) {
02543
02544 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
02545
02546 }
02547
02548
02549 if (strcmp(varName, "l1descInx") == 0) {
02550
02551 return newSimpType(T_INT, r);
02552
02553 }
02554
02555
02556 if (strcmp(varName, "doinp") == 0) {
02557
02558 return getVarTypeFromDataObjInp(varMapCPtr, r);
02559
02560 }
02561
02562
02563 if (strcmp(varName, "doi") == 0) {
02564
02565 return getVarTypeFromDataObjInfo(varMapCPtr, r);
02566
02567 }
02568
02569
02570 if (strcmp(varName, "rgi") == 0) {
02571
02572 return getVarTypeFromRescGrpInfo(varMapCPtr, r);
02573
02574 }
02575
02576
02577 if (strcmp(varName, "uoic") == 0) {
02578
02579 return getVarTypeFromUserInfo(varMapCPtr, r);
02580
02581 }
02582
02583
02584 if (strcmp(varName, "uoip") == 0) {
02585
02586 return getVarTypeFromUserInfo(varMapCPtr, r);
02587
02588 }
02589
02590
02591 if (strcmp(varName, "coi") == 0) {
02592
02593 return getVarTypeFromCollInfo(varMapCPtr, r);
02594
02595 }
02596
02597
02598 if (strcmp(varName, "uoio") == 0) {
02599
02600 return getVarTypeFromUserInfo(varMapCPtr, r);
02601
02602 }
02603
02604
02605 if (strcmp(varName, "condInputData") == 0) {
02606
02607 return getVarTypeFromKeyValPair(varMapCPtr, r);
02608
02609 }
02610
02611
02612 if (strcmp(varName, "ruleSet") == 0) {
02613
02614 return newSimpType(T_STRING, r);
02615
02616 }
02617
02618
02619 if (strcmp(varName, "next") == 0) {
02620
02621 return getVarTypeFromRuleExecInfo(varMapCPtr, r);
02622
02623 }
02624
02625
02626 return newErrorType(UNDEFINED_VARIABLE_MAP_ERR, r);
02627 }
02628
02629
02630 int getValFromRsComm(char *varMap, rsComm_t *rei, Res **varValue, Region *r)
02631 {
02632 char varName[NAME_LEN];
02633 char *varMapCPtr;
02634 int i;
02635
02636 if (varMap == NULL) {
02637 i = getPtrLeafValue(varValue, (void *) rei, NULL, RsComm_MS_T, r);
02638 return(i);
02639 }
02640 if (rei == NULL)
02641 return(NULL_VALUE_ERR);
02642
02643 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
02644 if (i != 0)
02645 return(i);
02646
02647
02648
02649 if (strcmp(varName, "irodsProt") == 0) {
02650
02651 i = UNDEFINED_VARIABLE_MAP_ERR;
02652
02653 return i;
02654 }
02655
02656
02657 if (strcmp(varName, "sock") == 0) {
02658
02659 i = getIntLeafValue(varValue, rei->sock, r);
02660
02661 return i;
02662 }
02663
02664
02665 if (strcmp(varName, "connectCnt") == 0) {
02666
02667 i = getIntLeafValue(varValue, rei->connectCnt, r);
02668
02669 return i;
02670 }
02671
02672
02673 if (strcmp(varName, "localAddr") == 0) {
02674
02675 i = UNDEFINED_VARIABLE_MAP_ERR;
02676
02677 return i;
02678 }
02679
02680
02681 if (strcmp(varName, "remoteAddr") == 0) {
02682
02683 i = UNDEFINED_VARIABLE_MAP_ERR;
02684
02685 return i;
02686 }
02687
02688
02689 if (strcmp(varName, "clientAddr") == 0) {
02690
02691 i = getStrLeafValue(varValue, rei->clientAddr, r);
02692
02693 return i;
02694 }
02695
02696
02697 if (strcmp(varName, "proxyUser") == 0) {
02698
02699 i = UNDEFINED_VARIABLE_MAP_ERR;
02700
02701 return i;
02702 }
02703
02704
02705 if (strcmp(varName, "clientUser") == 0) {
02706
02707 i = UNDEFINED_VARIABLE_MAP_ERR;
02708
02709 return i;
02710 }
02711
02712
02713 if (strcmp(varName, "myEnv") == 0) {
02714
02715 i = UNDEFINED_VARIABLE_MAP_ERR;
02716
02717 return i;
02718 }
02719
02720
02721 if (strcmp(varName, "cliVersion") == 0) {
02722
02723 i = UNDEFINED_VARIABLE_MAP_ERR;
02724
02725 return i;
02726 }
02727
02728
02729 if (strcmp(varName, "option") == 0) {
02730
02731 i = getStrLeafValue(varValue, rei->option, r);
02732
02733 return i;
02734 }
02735
02736
02737 if (strcmp(varName, "procLogFlag") == 0) {
02738
02739 i = UNDEFINED_VARIABLE_MAP_ERR;
02740
02741 return i;
02742 }
02743
02744
02745 if (strcmp(varName, "rError") == 0) {
02746
02747 i = UNDEFINED_VARIABLE_MAP_ERR;
02748
02749 return i;
02750 }
02751
02752
02753 if (strcmp(varName, "portalOpr") == 0) {
02754
02755 i = UNDEFINED_VARIABLE_MAP_ERR;
02756
02757 return i;
02758 }
02759
02760
02761 if (strcmp(varName, "apiInx") == 0) {
02762
02763 i = getIntLeafValue(varValue, rei->apiInx, r);
02764
02765 return i;
02766 }
02767
02768
02769 if (strcmp(varName, "status") == 0) {
02770
02771 i = getIntLeafValue(varValue, rei->status, r);
02772
02773 return i;
02774 }
02775
02776
02777 if (strcmp(varName, "perfStat") == 0) {
02778
02779 i = UNDEFINED_VARIABLE_MAP_ERR;
02780
02781 return i;
02782 }
02783
02784
02785 if (strcmp(varName, "windowSize") == 0) {
02786
02787 i = getIntLeafValue(varValue, rei->windowSize, r);
02788
02789 return i;
02790 }
02791
02792
02793 if (strcmp(varName, "reconnFlag") == 0) {
02794
02795 i = getIntLeafValue(varValue, rei->reconnFlag, r);
02796
02797 return i;
02798 }
02799
02800
02801 if (strcmp(varName, "reconnSock") == 0) {
02802
02803 i = getIntLeafValue(varValue, rei->reconnSock, r);
02804
02805 return i;
02806 }
02807
02808
02809 if (strcmp(varName, "reconnPort") == 0) {
02810
02811 i = getIntLeafValue(varValue, rei->reconnPort, r);
02812
02813 return i;
02814 }
02815
02816
02817 if (strcmp(varName, "reconnectedSock") == 0) {
02818
02819 i = getIntLeafValue(varValue, rei->reconnectedSock, r);
02820
02821 return i;
02822 }
02823
02824
02825 if (strcmp(varName, "reconnAddr") == 0) {
02826
02827 i = getStrLeafValue(varValue, rei->reconnAddr, r);
02828
02829 return i;
02830 }
02831
02832
02833 if (strcmp(varName, "cookie") == 0) {
02834
02835 i = getIntLeafValue(varValue, rei->cookie, r);
02836
02837 return i;
02838 }
02839
02840
02841 if (strcmp(varName, "reconnThr") == 0) {
02842
02843 i = UNDEFINED_VARIABLE_MAP_ERR;
02844
02845 return i;
02846 }
02847
02848
02849 if (strcmp(varName, "lock") == 0) {
02850
02851 i = UNDEFINED_VARIABLE_MAP_ERR;
02852
02853 return i;
02854 }
02855
02856
02857 if (strcmp(varName, "cond") == 0) {
02858
02859 i = UNDEFINED_VARIABLE_MAP_ERR;
02860
02861 return i;
02862 }
02863
02864
02865 if (strcmp(varName, "agentState") == 0) {
02866
02867 i = UNDEFINED_VARIABLE_MAP_ERR;
02868
02869 return i;
02870 }
02871
02872
02873 if (strcmp(varName, "clientState") == 0) {
02874
02875 i = UNDEFINED_VARIABLE_MAP_ERR;
02876
02877 return i;
02878 }
02879
02880
02881 if (strcmp(varName, "reconnThrState") == 0) {
02882
02883 i = UNDEFINED_VARIABLE_MAP_ERR;
02884
02885 return i;
02886 }
02887
02888
02889 if (strcmp(varName, "gsiRequest") == 0) {
02890
02891 i = getIntLeafValue(varValue, rei->gsiRequest, r);
02892
02893 return i;
02894 }
02895
02896
02897 return(UNDEFINED_VARIABLE_MAP_ERR);
02898 }
02899 int setValFromRsComm(char *varMap, rsComm_t **inrei, Res *newVarValue)
02900 {
02901 char varName[NAME_LEN];
02902 char *varMapCPtr;
02903 int i;
02904 rsComm_t *rei;
02905
02906 rei = *inrei;
02907
02908 if (varMap == NULL) {
02909 i = setStructPtrLeafValue((void**)inrei, newVarValue);
02910 return(i);
02911 }
02912 if (rei == NULL)
02913 return(NULL_VALUE_ERR);
02914
02915 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
02916 if (i != 0)
02917 return(i);
02918
02919
02920 if (strcmp(varName, "irodsProt") == 0) {
02921
02922 i = UNDEFINED_VARIABLE_MAP_ERR;
02923
02924 return i;
02925 }
02926
02927 if (strcmp(varName, "sock") == 0) {
02928
02929 i = setIntLeafValue(&(rei->sock), newVarValue);
02930
02931 return i;
02932 }
02933
02934 if (strcmp(varName, "connectCnt") == 0) {
02935
02936 i = setIntLeafValue(&(rei->connectCnt), newVarValue);
02937
02938 return i;
02939 }
02940
02941 if (strcmp(varName, "localAddr") == 0) {
02942
02943 i = UNDEFINED_VARIABLE_MAP_ERR;
02944
02945 return i;
02946 }
02947
02948 if (strcmp(varName, "remoteAddr") == 0) {
02949
02950 i = UNDEFINED_VARIABLE_MAP_ERR;
02951
02952 return i;
02953 }
02954
02955 if (strcmp(varName, "clientAddr") == 0) {
02956
02957 i = setStrLeafValue(rei->clientAddr, NAME_LEN, newVarValue);
02958
02959 return i;
02960 }
02961
02962 if (strcmp(varName, "proxyUser") == 0) {
02963
02964 i = UNDEFINED_VARIABLE_MAP_ERR;
02965
02966 return i;
02967 }
02968
02969 if (strcmp(varName, "clientUser") == 0) {
02970
02971 i = UNDEFINED_VARIABLE_MAP_ERR;
02972
02973 return i;
02974 }
02975
02976 if (strcmp(varName, "myEnv") == 0) {
02977
02978 i = UNDEFINED_VARIABLE_MAP_ERR;
02979
02980 return i;
02981 }
02982
02983 if (strcmp(varName, "cliVersion") == 0) {
02984
02985 i = UNDEFINED_VARIABLE_MAP_ERR;
02986
02987 return i;
02988 }
02989
02990 if (strcmp(varName, "option") == 0) {
02991
02992 i = setStrLeafValue(rei->option, NAME_LEN, newVarValue);
02993
02994 return i;
02995 }
02996
02997 if (strcmp(varName, "procLogFlag") == 0) {
02998
02999 i = UNDEFINED_VARIABLE_MAP_ERR;
03000
03001 return i;
03002 }
03003
03004 if (strcmp(varName, "rError") == 0) {
03005
03006 i = UNDEFINED_VARIABLE_MAP_ERR;
03007
03008 return i;
03009 }
03010
03011 if (strcmp(varName, "portalOpr") == 0) {
03012
03013 i = UNDEFINED_VARIABLE_MAP_ERR;
03014
03015 return i;
03016 }
03017
03018 if (strcmp(varName, "apiInx") == 0) {
03019
03020 i = setIntLeafValue(&(rei->apiInx), newVarValue);
03021
03022 return i;
03023 }
03024
03025 if (strcmp(varName, "status") == 0) {
03026
03027 i = setIntLeafValue(&(rei->status), newVarValue);
03028
03029 return i;
03030 }
03031
03032 if (strcmp(varName, "perfStat") == 0) {
03033
03034 i = UNDEFINED_VARIABLE_MAP_ERR;
03035
03036 return i;
03037 }
03038
03039 if (strcmp(varName, "windowSize") == 0) {
03040
03041 i = setIntLeafValue(&(rei->windowSize), newVarValue);
03042
03043 return i;
03044 }
03045
03046 if (strcmp(varName, "reconnFlag") == 0) {
03047
03048 i = setIntLeafValue(&(rei->reconnFlag), newVarValue);
03049
03050 return i;
03051 }
03052
03053 if (strcmp(varName, "reconnSock") == 0) {
03054
03055 i = setIntLeafValue(&(rei->reconnSock), newVarValue);
03056
03057 return i;
03058 }
03059
03060 if (strcmp(varName, "reconnPort") == 0) {
03061
03062 i = setIntLeafValue(&(rei->reconnPort), newVarValue);
03063
03064 return i;
03065 }
03066
03067 if (strcmp(varName, "reconnectedSock") == 0) {
03068
03069 i = setIntLeafValue(&(rei->reconnectedSock), newVarValue);
03070
03071 return i;
03072 }
03073
03074 if (strcmp(varName, "reconnAddr") == 0) {
03075
03076 i = setStrDupLeafValue(&(rei->reconnAddr), newVarValue);
03077
03078 return i;
03079 }
03080
03081 if (strcmp(varName, "cookie") == 0) {
03082
03083 i = setIntLeafValue(&(rei->cookie), newVarValue);
03084
03085 return i;
03086 }
03087
03088 if (strcmp(varName, "reconnThr") == 0) {
03089
03090 i = UNDEFINED_VARIABLE_MAP_ERR;
03091
03092 return i;
03093 }
03094
03095 if (strcmp(varName, "lock") == 0) {
03096
03097 i = UNDEFINED_VARIABLE_MAP_ERR;
03098
03099 return i;
03100 }
03101
03102 if (strcmp(varName, "cond") == 0) {
03103
03104 i = UNDEFINED_VARIABLE_MAP_ERR;
03105
03106 return i;
03107 }
03108
03109 if (strcmp(varName, "agentState") == 0) {
03110
03111 i = UNDEFINED_VARIABLE_MAP_ERR;
03112
03113 return i;
03114 }
03115
03116 if (strcmp(varName, "clientState") == 0) {
03117
03118 i = UNDEFINED_VARIABLE_MAP_ERR;
03119
03120 return i;
03121 }
03122
03123 if (strcmp(varName, "reconnThrState") == 0) {
03124
03125 i = UNDEFINED_VARIABLE_MAP_ERR;
03126
03127 return i;
03128 }
03129
03130 if (strcmp(varName, "gsiRequest") == 0) {
03131
03132 i = setIntLeafValue(&(rei->gsiRequest), newVarValue);
03133
03134 return i;
03135 }
03136
03137
03138 return(UNDEFINED_VARIABLE_MAP_ERR);
03139 }
03140 ExprType *getVarTypeFromRsComm(char *varMap, Region *r)
03141 {
03142 char varName[NAME_LEN];
03143 char *varMapCPtr;
03144 int i;
03145
03146 if (varMap == NULL) {
03147 return newIRODSType(RsComm_MS_T, r);
03148 }
03149
03150 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
03151 if (i != 0)
03152 return newErrorType(i, r);
03153
03154
03155
03156 if (strcmp(varName, "irodsProt") == 0) {
03157
03158 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
03159
03160 }
03161
03162
03163 if (strcmp(varName, "sock") == 0) {
03164
03165 return newSimpType(T_INT, r);
03166
03167 }
03168
03169
03170 if (strcmp(varName, "connectCnt") == 0) {
03171
03172 return newSimpType(T_INT, r);
03173
03174 }
03175
03176
03177 if (strcmp(varName, "localAddr") == 0) {
03178
03179 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
03180
03181 }
03182
03183
03184 if (strcmp(varName, "remoteAddr") == 0) {
03185
03186 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
03187
03188 }
03189
03190
03191 if (strcmp(varName, "clientAddr") == 0) {
03192
03193 return newSimpType(T_STRING, r);
03194
03195 }
03196
03197
03198 if (strcmp(varName, "proxyUser") == 0) {
03199
03200 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
03201
03202 }
03203
03204
03205 if (strcmp(varName, "clientUser") == 0) {
03206
03207 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
03208
03209 }
03210
03211
03212 if (strcmp(varName, "myEnv") == 0) {
03213
03214 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
03215
03216 }
03217
03218
03219 if (strcmp(varName, "cliVersion") == 0) {
03220
03221 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
03222
03223 }
03224
03225
03226 if (strcmp(varName, "option") == 0) {
03227
03228 return newSimpType(T_STRING, r);
03229
03230 }
03231
03232
03233 if (strcmp(varName, "procLogFlag") == 0) {
03234
03235 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
03236
03237 }
03238
03239
03240 if (strcmp(varName, "rError") == 0) {
03241
03242 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
03243
03244 }
03245
03246
03247 if (strcmp(varName, "portalOpr") == 0) {
03248
03249 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
03250
03251 }
03252
03253
03254 if (strcmp(varName, "apiInx") == 0) {
03255
03256 return newSimpType(T_INT, r);
03257
03258 }
03259
03260
03261 if (strcmp(varName, "status") == 0) {
03262
03263 return newSimpType(T_INT, r);
03264
03265 }
03266
03267
03268 if (strcmp(varName, "perfStat") == 0) {
03269
03270 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
03271
03272 }
03273
03274
03275 if (strcmp(varName, "windowSize") == 0) {
03276
03277 return newSimpType(T_INT, r);
03278
03279 }
03280
03281
03282 if (strcmp(varName, "reconnFlag") == 0) {
03283
03284 return newSimpType(T_INT, r);
03285
03286 }
03287
03288
03289 if (strcmp(varName, "reconnSock") == 0) {
03290
03291 return newSimpType(T_INT, r);
03292
03293 }
03294
03295
03296 if (strcmp(varName, "reconnPort") == 0) {
03297
03298 return newSimpType(T_INT, r);
03299
03300 }
03301
03302
03303 if (strcmp(varName, "reconnectedSock") == 0) {
03304
03305 return newSimpType(T_INT, r);
03306
03307 }
03308
03309
03310 if (strcmp(varName, "reconnAddr") == 0) {
03311
03312 return newSimpType(T_STRING, r);
03313
03314 }
03315
03316
03317 if (strcmp(varName, "cookie") == 0) {
03318
03319 return newSimpType(T_INT, r);
03320
03321 }
03322
03323
03324 if (strcmp(varName, "reconnThr") == 0) {
03325
03326 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
03327
03328 }
03329
03330
03331 if (strcmp(varName, "lock") == 0) {
03332
03333 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
03334
03335 }
03336
03337
03338 if (strcmp(varName, "cond") == 0) {
03339
03340 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
03341
03342 }
03343
03344
03345 if (strcmp(varName, "agentState") == 0) {
03346
03347 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
03348
03349 }
03350
03351
03352 if (strcmp(varName, "clientState") == 0) {
03353
03354 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
03355
03356 }
03357
03358
03359 if (strcmp(varName, "reconnThrState") == 0) {
03360
03361 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
03362
03363 }
03364
03365
03366 if (strcmp(varName, "gsiRequest") == 0) {
03367
03368 return newSimpType(T_INT, r);
03369
03370 }
03371
03372
03373 return newErrorType(UNDEFINED_VARIABLE_MAP_ERR, r);
03374 }
03375
03376
03377 int getValFromDataObjInp(char *varMap, dataObjInp_t *rei, Res **varValue, Region *r)
03378 {
03379 char varName[NAME_LEN];
03380 char *varMapCPtr;
03381 int i;
03382
03383 if (varMap == NULL) {
03384 i = getPtrLeafValue(varValue, (void *) rei, NULL, DataObjInp_MS_T, r);
03385 return(i);
03386 }
03387 if (rei == NULL)
03388 return(NULL_VALUE_ERR);
03389
03390 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
03391 if (i != 0)
03392 return(i);
03393
03394
03395
03396 if (strcmp(varName, "objPath") == 0) {
03397
03398 i = getStrLeafValue(varValue, rei->objPath, r);
03399
03400 return i;
03401 }
03402
03403
03404 if (strcmp(varName, "createMode") == 0) {
03405
03406 i = getIntLeafValue(varValue, rei->createMode, r);
03407
03408 return i;
03409 }
03410
03411
03412 if (strcmp(varName, "openFlags") == 0) {
03413
03414 i = getIntLeafValue(varValue, rei->openFlags, r);
03415
03416 return i;
03417 }
03418
03419
03420 if (strcmp(varName, "offset") == 0) {
03421
03422 i = getLongLeafValue(varValue, rei->offset, r);
03423
03424 return i;
03425 }
03426
03427
03428 if (strcmp(varName, "dataSize") == 0) {
03429
03430 i = getLongLeafValue(varValue, rei->dataSize, r);
03431
03432 return i;
03433 }
03434
03435
03436 if (strcmp(varName, "numThreads") == 0) {
03437
03438 i = getIntLeafValue(varValue, rei->numThreads, r);
03439
03440 return i;
03441 }
03442
03443
03444 if (strcmp(varName, "oprType") == 0) {
03445
03446 i = getIntLeafValue(varValue, rei->oprType, r);
03447
03448 return i;
03449 }
03450
03451
03452 if (strcmp(varName, "specColl") == 0) {
03453
03454 i = UNDEFINED_VARIABLE_MAP_ERR;
03455
03456 return i;
03457 }
03458
03459
03460 if (strcmp(varName, "condInput") == 0) {
03461
03462 i = UNDEFINED_VARIABLE_MAP_ERR;
03463
03464 return i;
03465 }
03466
03467
03468 return(UNDEFINED_VARIABLE_MAP_ERR);
03469 }
03470 int setValFromDataObjInp(char *varMap, dataObjInp_t **inrei, Res *newVarValue)
03471 {
03472 char varName[NAME_LEN];
03473 char *varMapCPtr;
03474 int i;
03475 dataObjInp_t *rei;
03476
03477 rei = *inrei;
03478
03479 if (varMap == NULL) {
03480 i = setStructPtrLeafValue((void**)inrei, newVarValue);
03481 return(i);
03482 }
03483 if (rei == NULL)
03484 return(NULL_VALUE_ERR);
03485
03486 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
03487 if (i != 0)
03488 return(i);
03489
03490
03491 if (strcmp(varName, "objPath") == 0) {
03492
03493 i = setStrLeafValue(rei->objPath, MAX_NAME_LEN, newVarValue);
03494
03495 return i;
03496 }
03497
03498 if (strcmp(varName, "createMode") == 0) {
03499
03500 i = setIntLeafValue(&(rei->createMode), newVarValue);
03501
03502 return i;
03503 }
03504
03505 if (strcmp(varName, "openFlags") == 0) {
03506
03507 i = setIntLeafValue(&(rei->openFlags), newVarValue);
03508
03509 return i;
03510 }
03511
03512 if (strcmp(varName, "offset") == 0) {
03513
03514 i = setLongLeafValue(&(rei->offset), newVarValue);
03515
03516 return i;
03517 }
03518
03519 if (strcmp(varName, "dataSize") == 0) {
03520
03521 i = setLongLeafValue(&(rei->dataSize), newVarValue);
03522
03523 return i;
03524 }
03525
03526 if (strcmp(varName, "numThreads") == 0) {
03527
03528 i = setIntLeafValue(&(rei->numThreads), newVarValue);
03529
03530 return i;
03531 }
03532
03533 if (strcmp(varName, "oprType") == 0) {
03534
03535 i = setIntLeafValue(&(rei->oprType), newVarValue);
03536
03537 return i;
03538 }
03539
03540 if (strcmp(varName, "specColl") == 0) {
03541
03542 i = UNDEFINED_VARIABLE_MAP_ERR;
03543
03544 return i;
03545 }
03546
03547 if (strcmp(varName, "condInput") == 0) {
03548
03549 i = UNDEFINED_VARIABLE_MAP_ERR;
03550
03551 return i;
03552 }
03553
03554
03555 return(UNDEFINED_VARIABLE_MAP_ERR);
03556 }
03557 ExprType *getVarTypeFromDataObjInp(char *varMap, Region *r)
03558 {
03559 char varName[NAME_LEN];
03560 char *varMapCPtr;
03561 int i;
03562
03563 if (varMap == NULL) {
03564 return newIRODSType(DataObjInp_MS_T, r);
03565 }
03566
03567 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
03568 if (i != 0)
03569 return newErrorType(i, r);
03570
03571
03572
03573 if (strcmp(varName, "objPath") == 0) {
03574
03575 return newSimpType(T_STRING, r);
03576
03577 }
03578
03579
03580 if (strcmp(varName, "createMode") == 0) {
03581
03582 return newSimpType(T_INT, r);
03583
03584 }
03585
03586
03587 if (strcmp(varName, "openFlags") == 0) {
03588
03589 return newSimpType(T_INT, r);
03590
03591 }
03592
03593
03594 if (strcmp(varName, "offset") == 0) {
03595
03596 return newSimpType(T_DOUBLE, r);
03597
03598 }
03599
03600
03601 if (strcmp(varName, "dataSize") == 0) {
03602
03603 return newSimpType(T_DOUBLE, r);
03604
03605 }
03606
03607
03608 if (strcmp(varName, "numThreads") == 0) {
03609
03610 return newSimpType(T_INT, r);
03611
03612 }
03613
03614
03615 if (strcmp(varName, "oprType") == 0) {
03616
03617 return newSimpType(T_INT, r);
03618
03619 }
03620
03621
03622 if (strcmp(varName, "specColl") == 0) {
03623
03624 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
03625
03626 }
03627
03628
03629 if (strcmp(varName, "condInput") == 0) {
03630
03631 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
03632
03633 }
03634
03635
03636 return newErrorType(UNDEFINED_VARIABLE_MAP_ERR, r);
03637 }
03638
03639
03640 int getValFromDataOprInp(char *varMap, dataOprInp_t *rei, Res **varValue, Region *r)
03641 {
03642 char varName[NAME_LEN];
03643 char *varMapCPtr;
03644 int i;
03645
03646 if (varMap == NULL) {
03647 i = getPtrLeafValue(varValue, (void *) rei, NULL, DataOprInp_MS_T, r);
03648 return(i);
03649 }
03650 if (rei == NULL)
03651 return(NULL_VALUE_ERR);
03652
03653 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
03654 if (i != 0)
03655 return(i);
03656
03657
03658
03659 if (strcmp(varName, "oprType") == 0) {
03660
03661 i = getIntLeafValue(varValue, rei->oprType, r);
03662
03663 return i;
03664 }
03665
03666
03667 if (strcmp(varName, "numThreads") == 0) {
03668
03669 i = getIntLeafValue(varValue, rei->numThreads, r);
03670
03671 return i;
03672 }
03673
03674
03675 if (strcmp(varName, "srcL3descInx") == 0) {
03676
03677 i = getIntLeafValue(varValue, rei->srcL3descInx, r);
03678
03679 return i;
03680 }
03681
03682
03683 if (strcmp(varName, "destL3descInx") == 0) {
03684
03685 i = getIntLeafValue(varValue, rei->destL3descInx, r);
03686
03687 return i;
03688 }
03689
03690
03691 if (strcmp(varName, "srcRescTypeInx") == 0) {
03692
03693 i = getIntLeafValue(varValue, rei->srcRescTypeInx, r);
03694
03695 return i;
03696 }
03697
03698
03699 if (strcmp(varName, "destRescTypeInx") == 0) {
03700
03701 i = getIntLeafValue(varValue, rei->destRescTypeInx, r);
03702
03703 return i;
03704 }
03705
03706
03707 if (strcmp(varName, "offset") == 0) {
03708
03709 i = getLongLeafValue(varValue, rei->offset, r);
03710
03711 return i;
03712 }
03713
03714
03715 if (strcmp(varName, "dataSize") == 0) {
03716
03717 i = getLongLeafValue(varValue, rei->dataSize, r);
03718
03719 return i;
03720 }
03721
03722
03723 if (strcmp(varName, "condInput") == 0) {
03724
03725 i = UNDEFINED_VARIABLE_MAP_ERR;
03726
03727 return i;
03728 }
03729
03730
03731 return(UNDEFINED_VARIABLE_MAP_ERR);
03732 }
03733 int setValFromDataOprInp(char *varMap, dataOprInp_t **inrei, Res *newVarValue)
03734 {
03735 char varName[NAME_LEN];
03736 char *varMapCPtr;
03737 int i;
03738 dataOprInp_t *rei;
03739
03740 rei = *inrei;
03741
03742 if (varMap == NULL) {
03743 i = setStructPtrLeafValue((void**)inrei, newVarValue);
03744 return(i);
03745 }
03746 if (rei == NULL)
03747 return(NULL_VALUE_ERR);
03748
03749 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
03750 if (i != 0)
03751 return(i);
03752
03753
03754 if (strcmp(varName, "oprType") == 0) {
03755
03756 i = setIntLeafValue(&(rei->oprType), newVarValue);
03757
03758 return i;
03759 }
03760
03761 if (strcmp(varName, "numThreads") == 0) {
03762
03763 i = setIntLeafValue(&(rei->numThreads), newVarValue);
03764
03765 return i;
03766 }
03767
03768 if (strcmp(varName, "srcL3descInx") == 0) {
03769
03770 i = setIntLeafValue(&(rei->srcL3descInx), newVarValue);
03771
03772 return i;
03773 }
03774
03775 if (strcmp(varName, "destL3descInx") == 0) {
03776
03777 i = setIntLeafValue(&(rei->destL3descInx), newVarValue);
03778
03779 return i;
03780 }
03781
03782 if (strcmp(varName, "srcRescTypeInx") == 0) {
03783
03784 i = setIntLeafValue(&(rei->srcRescTypeInx), newVarValue);
03785
03786 return i;
03787 }
03788
03789 if (strcmp(varName, "destRescTypeInx") == 0) {
03790
03791 i = setIntLeafValue(&(rei->destRescTypeInx), newVarValue);
03792
03793 return i;
03794 }
03795
03796 if (strcmp(varName, "offset") == 0) {
03797
03798 i = setLongLeafValue(&(rei->offset), newVarValue);
03799
03800 return i;
03801 }
03802
03803 if (strcmp(varName, "dataSize") == 0) {
03804
03805 i = setLongLeafValue(&(rei->dataSize), newVarValue);
03806
03807 return i;
03808 }
03809
03810 if (strcmp(varName, "condInput") == 0) {
03811
03812 i = UNDEFINED_VARIABLE_MAP_ERR;
03813
03814 return i;
03815 }
03816
03817
03818 return(UNDEFINED_VARIABLE_MAP_ERR);
03819 }
03820 ExprType *getVarTypeFromDataOprInp(char *varMap, Region *r)
03821 {
03822 char varName[NAME_LEN];
03823 char *varMapCPtr;
03824 int i;
03825
03826 if (varMap == NULL) {
03827 return newIRODSType(DataOprInp_MS_T, r);
03828 }
03829
03830 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
03831 if (i != 0)
03832 return newErrorType(i, r);
03833
03834
03835
03836 if (strcmp(varName, "oprType") == 0) {
03837
03838 return newSimpType(T_INT, r);
03839
03840 }
03841
03842
03843 if (strcmp(varName, "numThreads") == 0) {
03844
03845 return newSimpType(T_INT, r);
03846
03847 }
03848
03849
03850 if (strcmp(varName, "srcL3descInx") == 0) {
03851
03852 return newSimpType(T_INT, r);
03853
03854 }
03855
03856
03857 if (strcmp(varName, "destL3descInx") == 0) {
03858
03859 return newSimpType(T_INT, r);
03860
03861 }
03862
03863
03864 if (strcmp(varName, "srcRescTypeInx") == 0) {
03865
03866 return newSimpType(T_INT, r);
03867
03868 }
03869
03870
03871 if (strcmp(varName, "destRescTypeInx") == 0) {
03872
03873 return newSimpType(T_INT, r);
03874
03875 }
03876
03877
03878 if (strcmp(varName, "offset") == 0) {
03879
03880 return newSimpType(T_DOUBLE, r);
03881
03882 }
03883
03884
03885 if (strcmp(varName, "dataSize") == 0) {
03886
03887 return newSimpType(T_DOUBLE, r);
03888
03889 }
03890
03891
03892 if (strcmp(varName, "condInput") == 0) {
03893
03894 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
03895
03896 }
03897
03898
03899 return newErrorType(UNDEFINED_VARIABLE_MAP_ERR, r);
03900 }
03901
03902
03903 int getValFromAuthInfo(char *varMap, authInfo_t *rei, Res **varValue, Region *r)
03904 {
03905 char varName[NAME_LEN];
03906 char *varMapCPtr;
03907 int i;
03908
03909 if (varMap == NULL) {
03910 i = getPtrLeafValue(varValue, (void *) rei, NULL, AuthInfo_MS_T, r);
03911 return(i);
03912 }
03913 if (rei == NULL)
03914 return(NULL_VALUE_ERR);
03915
03916 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
03917 if (i != 0)
03918 return(i);
03919
03920
03921
03922 if (strcmp(varName, "authScheme") == 0) {
03923
03924 i = getStrLeafValue(varValue, rei->authScheme, r);
03925
03926 return i;
03927 }
03928
03929
03930 if (strcmp(varName, "authFlag") == 0) {
03931
03932 i = getIntLeafValue(varValue, rei->authFlag, r);
03933
03934 return i;
03935 }
03936
03937
03938 if (strcmp(varName, "flag") == 0) {
03939
03940 i = getIntLeafValue(varValue, rei->flag, r);
03941
03942 return i;
03943 }
03944
03945
03946 if (strcmp(varName, "ppid") == 0) {
03947
03948 i = getIntLeafValue(varValue, rei->ppid, r);
03949
03950 return i;
03951 }
03952
03953
03954 if (strcmp(varName, "host") == 0) {
03955
03956 i = getStrLeafValue(varValue, rei->host, r);
03957
03958 return i;
03959 }
03960
03961
03962 if (strcmp(varName, "authStr") == 0) {
03963
03964 i = getStrLeafValue(varValue, rei->authStr, r);
03965
03966 return i;
03967 }
03968
03969
03970 return(UNDEFINED_VARIABLE_MAP_ERR);
03971 }
03972 int setValFromAuthInfo(char *varMap, authInfo_t **inrei, Res *newVarValue)
03973 {
03974 char varName[NAME_LEN];
03975 char *varMapCPtr;
03976 int i;
03977 authInfo_t *rei;
03978
03979 rei = *inrei;
03980
03981 if (varMap == NULL) {
03982 i = setStructPtrLeafValue((void**)inrei, newVarValue);
03983 return(i);
03984 }
03985 if (rei == NULL)
03986 return(NULL_VALUE_ERR);
03987
03988 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
03989 if (i != 0)
03990 return(i);
03991
03992
03993 if (strcmp(varName, "authScheme") == 0) {
03994
03995 i = setStrLeafValue(rei->authScheme, NAME_LEN, newVarValue);
03996
03997 return i;
03998 }
03999
04000 if (strcmp(varName, "authFlag") == 0) {
04001
04002 i = setIntLeafValue(&(rei->authFlag), newVarValue);
04003
04004 return i;
04005 }
04006
04007 if (strcmp(varName, "flag") == 0) {
04008
04009 i = setIntLeafValue(&(rei->flag), newVarValue);
04010
04011 return i;
04012 }
04013
04014 if (strcmp(varName, "ppid") == 0) {
04015
04016 i = setIntLeafValue(&(rei->ppid), newVarValue);
04017
04018 return i;
04019 }
04020
04021 if (strcmp(varName, "host") == 0) {
04022
04023 i = setStrLeafValue(rei->host, NAME_LEN, newVarValue);
04024
04025 return i;
04026 }
04027
04028 if (strcmp(varName, "authStr") == 0) {
04029
04030 i = setStrLeafValue(rei->authStr, NAME_LEN, newVarValue);
04031
04032 return i;
04033 }
04034
04035
04036 return(UNDEFINED_VARIABLE_MAP_ERR);
04037 }
04038 ExprType *getVarTypeFromAuthInfo(char *varMap, Region *r)
04039 {
04040 char varName[NAME_LEN];
04041 char *varMapCPtr;
04042 int i;
04043
04044 if (varMap == NULL) {
04045 return newIRODSType(AuthInfo_MS_T, r);
04046 }
04047
04048 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
04049 if (i != 0)
04050 return newErrorType(i, r);
04051
04052
04053
04054 if (strcmp(varName, "authScheme") == 0) {
04055
04056 return newSimpType(T_STRING, r);
04057
04058 }
04059
04060
04061 if (strcmp(varName, "authFlag") == 0) {
04062
04063 return newSimpType(T_INT, r);
04064
04065 }
04066
04067
04068 if (strcmp(varName, "flag") == 0) {
04069
04070 return newSimpType(T_INT, r);
04071
04072 }
04073
04074
04075 if (strcmp(varName, "ppid") == 0) {
04076
04077 return newSimpType(T_INT, r);
04078
04079 }
04080
04081
04082 if (strcmp(varName, "host") == 0) {
04083
04084 return newSimpType(T_STRING, r);
04085
04086 }
04087
04088
04089 if (strcmp(varName, "authStr") == 0) {
04090
04091 return newSimpType(T_STRING, r);
04092
04093 }
04094
04095
04096 return newErrorType(UNDEFINED_VARIABLE_MAP_ERR, r);
04097 }
04098
04099
04100 int getValFromUserOtherInfo(char *varMap, userOtherInfo_t *rei, Res **varValue, Region *r)
04101 {
04102 char varName[NAME_LEN];
04103 char *varMapCPtr;
04104 int i;
04105
04106 if (varMap == NULL) {
04107 i = getPtrLeafValue(varValue, (void *) rei, NULL, UserOtherInfo_MS_T, r);
04108 return(i);
04109 }
04110 if (rei == NULL)
04111 return(NULL_VALUE_ERR);
04112
04113 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
04114 if (i != 0)
04115 return(i);
04116
04117
04118
04119 if (strcmp(varName, "userInfo") == 0) {
04120
04121 i = getStrLeafValue(varValue, rei->userInfo, r);
04122
04123 return i;
04124 }
04125
04126
04127 if (strcmp(varName, "userComments") == 0) {
04128
04129 i = getStrLeafValue(varValue, rei->userComments, r);
04130
04131 return i;
04132 }
04133
04134
04135 if (strcmp(varName, "userCreate") == 0) {
04136
04137 i = getStrLeafValue(varValue, rei->userCreate, r);
04138
04139 return i;
04140 }
04141
04142
04143 if (strcmp(varName, "userModify") == 0) {
04144
04145 i = getStrLeafValue(varValue, rei->userModify, r);
04146
04147 return i;
04148 }
04149
04150
04151 return(UNDEFINED_VARIABLE_MAP_ERR);
04152 }
04153 int setValFromUserOtherInfo(char *varMap, userOtherInfo_t **inrei, Res *newVarValue)
04154 {
04155 char varName[NAME_LEN];
04156 char *varMapCPtr;
04157 int i;
04158 userOtherInfo_t *rei;
04159
04160 rei = *inrei;
04161
04162 if (varMap == NULL) {
04163 i = setStructPtrLeafValue((void**)inrei, newVarValue);
04164 return(i);
04165 }
04166 if (rei == NULL)
04167 return(NULL_VALUE_ERR);
04168
04169 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
04170 if (i != 0)
04171 return(i);
04172
04173
04174 if (strcmp(varName, "userInfo") == 0) {
04175
04176 i = setStrLeafValue(rei->userInfo, NAME_LEN, newVarValue);
04177
04178 return i;
04179 }
04180
04181 if (strcmp(varName, "userComments") == 0) {
04182
04183 i = setStrLeafValue(rei->userComments, NAME_LEN, newVarValue);
04184
04185 return i;
04186 }
04187
04188 if (strcmp(varName, "userCreate") == 0) {
04189
04190 i = setStrLeafValue(rei->userCreate, TIME_LEN, newVarValue);
04191
04192 return i;
04193 }
04194
04195 if (strcmp(varName, "userModify") == 0) {
04196
04197 i = setStrLeafValue(rei->userModify, TIME_LEN, newVarValue);
04198
04199 return i;
04200 }
04201
04202
04203 return(UNDEFINED_VARIABLE_MAP_ERR);
04204 }
04205 ExprType *getVarTypeFromUserOtherInfo(char *varMap, Region *r)
04206 {
04207 char varName[NAME_LEN];
04208 char *varMapCPtr;
04209 int i;
04210
04211 if (varMap == NULL) {
04212 return newIRODSType(UserOtherInfo_MS_T, r);
04213 }
04214
04215 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
04216 if (i != 0)
04217 return newErrorType(i, r);
04218
04219
04220
04221 if (strcmp(varName, "userInfo") == 0) {
04222
04223 return newSimpType(T_STRING, r);
04224
04225 }
04226
04227
04228 if (strcmp(varName, "userComments") == 0) {
04229
04230 return newSimpType(T_STRING, r);
04231
04232 }
04233
04234
04235 if (strcmp(varName, "userCreate") == 0) {
04236
04237 return newSimpType(T_STRING, r);
04238
04239 }
04240
04241
04242 if (strcmp(varName, "userModify") == 0) {
04243
04244 return newSimpType(T_STRING, r);
04245
04246 }
04247
04248
04249 return newErrorType(UNDEFINED_VARIABLE_MAP_ERR, r);
04250 }
04251
04252
04253 int getValFromUserInfo(char *varMap, userInfo_t *rei, Res **varValue, Region *r)
04254 {
04255 char varName[NAME_LEN];
04256 char *varMapCPtr;
04257 int i;
04258
04259 if (varMap == NULL) {
04260 i = getPtrLeafValue(varValue, (void *) rei, NULL, UserInfo_MS_T, r);
04261 return(i);
04262 }
04263 if (rei == NULL)
04264 return(NULL_VALUE_ERR);
04265
04266 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
04267 if (i != 0)
04268 return(i);
04269
04270
04271
04272 if (strcmp(varName, "userName") == 0) {
04273
04274 i = getStrLeafValue(varValue, rei->userName, r);
04275
04276 return i;
04277 }
04278
04279
04280 if (strcmp(varName, "rodsZone") == 0) {
04281
04282 i = getStrLeafValue(varValue, rei->rodsZone, r);
04283
04284 return i;
04285 }
04286
04287
04288 if (strcmp(varName, "userType") == 0) {
04289
04290 i = getStrLeafValue(varValue, rei->userType, r);
04291
04292 return i;
04293 }
04294
04295
04296 if (strcmp(varName, "sysUid") == 0) {
04297
04298 i = getIntLeafValue(varValue, rei->sysUid, r);
04299
04300 return i;
04301 }
04302
04303
04304 if (strcmp(varName, "authInfo") == 0) {
04305
04306 i = UNDEFINED_VARIABLE_MAP_ERR;
04307
04308 return i;
04309 }
04310
04311
04312 if (strcmp(varName, "userOtherInfo") == 0) {
04313
04314 i = UNDEFINED_VARIABLE_MAP_ERR;
04315
04316 return i;
04317 }
04318
04319
04320 return(UNDEFINED_VARIABLE_MAP_ERR);
04321 }
04322 int setValFromUserInfo(char *varMap, userInfo_t **inrei, Res *newVarValue)
04323 {
04324 char varName[NAME_LEN];
04325 char *varMapCPtr;
04326 int i;
04327 userInfo_t *rei;
04328
04329 rei = *inrei;
04330
04331 if (varMap == NULL) {
04332 i = setStructPtrLeafValue((void**)inrei, newVarValue);
04333 return(i);
04334 }
04335 if (rei == NULL)
04336 return(NULL_VALUE_ERR);
04337
04338 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
04339 if (i != 0)
04340 return(i);
04341
04342
04343 if (strcmp(varName, "userName") == 0) {
04344
04345 i = setStrLeafValue(rei->userName, NAME_LEN, newVarValue);
04346
04347 return i;
04348 }
04349
04350 if (strcmp(varName, "rodsZone") == 0) {
04351
04352 i = setStrLeafValue(rei->rodsZone, NAME_LEN, newVarValue);
04353
04354 return i;
04355 }
04356
04357 if (strcmp(varName, "userType") == 0) {
04358
04359 i = setStrLeafValue(rei->userType, NAME_LEN, newVarValue);
04360
04361 return i;
04362 }
04363
04364 if (strcmp(varName, "sysUid") == 0) {
04365
04366 i = setIntLeafValue(&(rei->sysUid), newVarValue);
04367
04368 return i;
04369 }
04370
04371 if (strcmp(varName, "authInfo") == 0) {
04372
04373 i = UNDEFINED_VARIABLE_MAP_ERR;
04374
04375 return i;
04376 }
04377
04378 if (strcmp(varName, "userOtherInfo") == 0) {
04379
04380 i = UNDEFINED_VARIABLE_MAP_ERR;
04381
04382 return i;
04383 }
04384
04385
04386 return(UNDEFINED_VARIABLE_MAP_ERR);
04387 }
04388 ExprType *getVarTypeFromUserInfo(char *varMap, Region *r)
04389 {
04390 char varName[NAME_LEN];
04391 char *varMapCPtr;
04392 int i;
04393
04394 if (varMap == NULL) {
04395 return newIRODSType(UserInfo_MS_T, r);
04396 }
04397
04398 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
04399 if (i != 0)
04400 return newErrorType(i, r);
04401
04402
04403
04404 if (strcmp(varName, "userName") == 0) {
04405
04406 return newSimpType(T_STRING, r);
04407
04408 }
04409
04410
04411 if (strcmp(varName, "rodsZone") == 0) {
04412
04413 return newSimpType(T_STRING, r);
04414
04415 }
04416
04417
04418 if (strcmp(varName, "userType") == 0) {
04419
04420 return newSimpType(T_STRING, r);
04421
04422 }
04423
04424
04425 if (strcmp(varName, "sysUid") == 0) {
04426
04427 return newSimpType(T_INT, r);
04428
04429 }
04430
04431
04432 if (strcmp(varName, "authInfo") == 0) {
04433
04434 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
04435
04436 }
04437
04438
04439 if (strcmp(varName, "userOtherInfo") == 0) {
04440
04441 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
04442
04443 }
04444
04445
04446 return newErrorType(UNDEFINED_VARIABLE_MAP_ERR, r);
04447 }
04448
04449
04450 int getValFromVersion(char *varMap, version_t *rei, Res **varValue, Region *r)
04451 {
04452 char varName[NAME_LEN];
04453 char *varMapCPtr;
04454 int i;
04455
04456 if (varMap == NULL) {
04457 i = getPtrLeafValue(varValue, (void *) rei, NULL, Version_MS_T, r);
04458 return(i);
04459 }
04460 if (rei == NULL)
04461 return(NULL_VALUE_ERR);
04462
04463 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
04464 if (i != 0)
04465 return(i);
04466
04467
04468
04469 if (strcmp(varName, "status") == 0) {
04470
04471 i = getIntLeafValue(varValue, rei->status, r);
04472
04473 return i;
04474 }
04475
04476
04477 if (strcmp(varName, "relVersion") == 0) {
04478
04479 i = getStrLeafValue(varValue, rei->relVersion, r);
04480
04481 return i;
04482 }
04483
04484
04485 if (strcmp(varName, "apiVersion") == 0) {
04486
04487 i = getStrLeafValue(varValue, rei->apiVersion, r);
04488
04489 return i;
04490 }
04491
04492
04493 if (strcmp(varName, "reconnPort") == 0) {
04494
04495 i = getIntLeafValue(varValue, rei->reconnPort, r);
04496
04497 return i;
04498 }
04499
04500
04501 if (strcmp(varName, "reconnAddr") == 0) {
04502
04503 i = getStrLeafValue(varValue, rei->reconnAddr, r);
04504
04505 return i;
04506 }
04507
04508
04509 if (strcmp(varName, "cookie") == 0) {
04510
04511 i = getIntLeafValue(varValue, rei->cookie, r);
04512
04513 return i;
04514 }
04515
04516
04517 return(UNDEFINED_VARIABLE_MAP_ERR);
04518 }
04519 int setValFromVersion(char *varMap, version_t **inrei, Res *newVarValue)
04520 {
04521 char varName[NAME_LEN];
04522 char *varMapCPtr;
04523 int i;
04524 version_t *rei;
04525
04526 rei = *inrei;
04527
04528 if (varMap == NULL) {
04529 i = setStructPtrLeafValue((void**)inrei, newVarValue);
04530 return(i);
04531 }
04532 if (rei == NULL)
04533 return(NULL_VALUE_ERR);
04534
04535 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
04536 if (i != 0)
04537 return(i);
04538
04539
04540 if (strcmp(varName, "status") == 0) {
04541
04542 i = setIntLeafValue(&(rei->status), newVarValue);
04543
04544 return i;
04545 }
04546
04547 if (strcmp(varName, "relVersion") == 0) {
04548
04549 i = setStrLeafValue(rei->relVersion, NAME_LEN, newVarValue);
04550
04551 return i;
04552 }
04553
04554 if (strcmp(varName, "apiVersion") == 0) {
04555
04556 i = setStrLeafValue(rei->apiVersion, NAME_LEN, newVarValue);
04557
04558 return i;
04559 }
04560
04561 if (strcmp(varName, "reconnPort") == 0) {
04562
04563 i = setIntLeafValue(&(rei->reconnPort), newVarValue);
04564
04565 return i;
04566 }
04567
04568 if (strcmp(varName, "reconnAddr") == 0) {
04569
04570 i = setStrLeafValue(rei->reconnAddr, LONG_NAME_LEN, newVarValue);
04571
04572 return i;
04573 }
04574
04575 if (strcmp(varName, "cookie") == 0) {
04576
04577 i = setIntLeafValue(&(rei->cookie), newVarValue);
04578
04579 return i;
04580 }
04581
04582
04583 return(UNDEFINED_VARIABLE_MAP_ERR);
04584 }
04585 ExprType *getVarTypeFromVersion(char *varMap, Region *r)
04586 {
04587 char varName[NAME_LEN];
04588 char *varMapCPtr;
04589 int i;
04590
04591 if (varMap == NULL) {
04592 return newIRODSType(Version_MS_T, r);
04593 }
04594
04595 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
04596 if (i != 0)
04597 return newErrorType(i, r);
04598
04599
04600
04601 if (strcmp(varName, "status") == 0) {
04602
04603 return newSimpType(T_INT, r);
04604
04605 }
04606
04607
04608 if (strcmp(varName, "relVersion") == 0) {
04609
04610 return newSimpType(T_STRING, r);
04611
04612 }
04613
04614
04615 if (strcmp(varName, "apiVersion") == 0) {
04616
04617 return newSimpType(T_STRING, r);
04618
04619 }
04620
04621
04622 if (strcmp(varName, "reconnPort") == 0) {
04623
04624 return newSimpType(T_INT, r);
04625
04626 }
04627
04628
04629 if (strcmp(varName, "reconnAddr") == 0) {
04630
04631 return newSimpType(T_STRING, r);
04632
04633 }
04634
04635
04636 if (strcmp(varName, "cookie") == 0) {
04637
04638 return newSimpType(T_INT, r);
04639
04640 }
04641
04642
04643 return newErrorType(UNDEFINED_VARIABLE_MAP_ERR, r);
04644 }
04645
04646
04647 int getValFromRodsHostAddr(char *varMap, rodsHostAddr_t *rei, Res **varValue, Region *r)
04648 {
04649 char varName[NAME_LEN];
04650 char *varMapCPtr;
04651 int i;
04652
04653 if (varMap == NULL) {
04654 i = getPtrLeafValue(varValue, (void *) rei, NULL, RodsHostAddr_MS_T, r);
04655 return(i);
04656 }
04657 if (rei == NULL)
04658 return(NULL_VALUE_ERR);
04659
04660 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
04661 if (i != 0)
04662 return(i);
04663
04664
04665
04666 if (strcmp(varName, "hostAddr") == 0) {
04667
04668 i = getStrLeafValue(varValue, rei->hostAddr, r);
04669
04670 return i;
04671 }
04672
04673
04674 if (strcmp(varName, "zoneName") == 0) {
04675
04676 i = getStrLeafValue(varValue, rei->zoneName, r);
04677
04678 return i;
04679 }
04680
04681
04682 if (strcmp(varName, "portNum") == 0) {
04683
04684 i = getIntLeafValue(varValue, rei->portNum, r);
04685
04686 return i;
04687 }
04688
04689
04690 if (strcmp(varName, "dummyInt") == 0) {
04691
04692 i = getIntLeafValue(varValue, rei->dummyInt, r);
04693
04694 return i;
04695 }
04696
04697
04698 return(UNDEFINED_VARIABLE_MAP_ERR);
04699 }
04700 int setValFromRodsHostAddr(char *varMap, rodsHostAddr_t **inrei, Res *newVarValue)
04701 {
04702 char varName[NAME_LEN];
04703 char *varMapCPtr;
04704 int i;
04705 rodsHostAddr_t *rei;
04706
04707 rei = *inrei;
04708
04709 if (varMap == NULL) {
04710 i = setStructPtrLeafValue((void**)inrei, newVarValue);
04711 return(i);
04712 }
04713 if (rei == NULL)
04714 return(NULL_VALUE_ERR);
04715
04716 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
04717 if (i != 0)
04718 return(i);
04719
04720
04721 if (strcmp(varName, "hostAddr") == 0) {
04722
04723 i = setStrLeafValue(rei->hostAddr, LONG_NAME_LEN, newVarValue);
04724
04725 return i;
04726 }
04727
04728 if (strcmp(varName, "zoneName") == 0) {
04729
04730 i = setStrLeafValue(rei->zoneName, NAME_LEN, newVarValue);
04731
04732 return i;
04733 }
04734
04735 if (strcmp(varName, "portNum") == 0) {
04736
04737 i = setIntLeafValue(&(rei->portNum), newVarValue);
04738
04739 return i;
04740 }
04741
04742 if (strcmp(varName, "dummyInt") == 0) {
04743
04744 i = setIntLeafValue(&(rei->dummyInt), newVarValue);
04745
04746 return i;
04747 }
04748
04749
04750 return(UNDEFINED_VARIABLE_MAP_ERR);
04751 }
04752 ExprType *getVarTypeFromRodsHostAddr(char *varMap, Region *r)
04753 {
04754 char varName[NAME_LEN];
04755 char *varMapCPtr;
04756 int i;
04757
04758 if (varMap == NULL) {
04759 return newIRODSType(RodsHostAddr_MS_T, r);
04760 }
04761
04762 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
04763 if (i != 0)
04764 return newErrorType(i, r);
04765
04766
04767
04768 if (strcmp(varName, "hostAddr") == 0) {
04769
04770 return newSimpType(T_STRING, r);
04771
04772 }
04773
04774
04775 if (strcmp(varName, "zoneName") == 0) {
04776
04777 return newSimpType(T_STRING, r);
04778
04779 }
04780
04781
04782 if (strcmp(varName, "portNum") == 0) {
04783
04784 return newSimpType(T_INT, r);
04785
04786 }
04787
04788
04789 if (strcmp(varName, "dummyInt") == 0) {
04790
04791 return newSimpType(T_INT, r);
04792
04793 }
04794
04795
04796 return newErrorType(UNDEFINED_VARIABLE_MAP_ERR, r);
04797 }
04798
04799
04800 int getValFromFileOpenInp(char *varMap, fileOpenInp_t *rei, Res **varValue, Region *r)
04801 {
04802 char varName[NAME_LEN];
04803 char *varMapCPtr;
04804 int i;
04805
04806 if (varMap == NULL) {
04807 i = getPtrLeafValue(varValue, (void *) rei, NULL, FileOpenInp_MS_T, r);
04808 return(i);
04809 }
04810 if (rei == NULL)
04811 return(NULL_VALUE_ERR);
04812
04813 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
04814 if (i != 0)
04815 return(i);
04816
04817
04818
04819 if (strcmp(varName, "fileType") == 0) {
04820
04821 i = UNDEFINED_VARIABLE_MAP_ERR;
04822
04823 return i;
04824 }
04825
04826
04827 if (strcmp(varName, "otherFlags") == 0) {
04828
04829 i = getIntLeafValue(varValue, rei->otherFlags, r);
04830
04831 return i;
04832 }
04833
04834
04835 if (strcmp(varName, "addr") == 0) {
04836
04837 i = UNDEFINED_VARIABLE_MAP_ERR;
04838
04839 return i;
04840 }
04841
04842
04843 if (strcmp(varName, "fileName") == 0) {
04844
04845 i = getStrLeafValue(varValue, rei->fileName, r);
04846
04847 return i;
04848 }
04849
04850
04851 if (strcmp(varName, "flags") == 0) {
04852
04853 i = getIntLeafValue(varValue, rei->flags, r);
04854
04855 return i;
04856 }
04857
04858
04859 if (strcmp(varName, "mode") == 0) {
04860
04861 i = getIntLeafValue(varValue, rei->mode, r);
04862
04863 return i;
04864 }
04865
04866
04867 if (strcmp(varName, "dataSize") == 0) {
04868
04869 i = getLongLeafValue(varValue, rei->dataSize, r);
04870
04871 return i;
04872 }
04873
04874
04875 if (strcmp(varName, "condInput") == 0) {
04876
04877 i = UNDEFINED_VARIABLE_MAP_ERR;
04878
04879 return i;
04880 }
04881
04882
04883 return(UNDEFINED_VARIABLE_MAP_ERR);
04884 }
04885 int setValFromFileOpenInp(char *varMap, fileOpenInp_t **inrei, Res *newVarValue)
04886 {
04887 char varName[NAME_LEN];
04888 char *varMapCPtr;
04889 int i;
04890 fileOpenInp_t *rei;
04891
04892 rei = *inrei;
04893
04894 if (varMap == NULL) {
04895 i = setStructPtrLeafValue((void**)inrei, newVarValue);
04896 return(i);
04897 }
04898 if (rei == NULL)
04899 return(NULL_VALUE_ERR);
04900
04901 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
04902 if (i != 0)
04903 return(i);
04904
04905
04906 if (strcmp(varName, "fileType") == 0) {
04907
04908 i = UNDEFINED_VARIABLE_MAP_ERR;
04909
04910 return i;
04911 }
04912
04913 if (strcmp(varName, "otherFlags") == 0) {
04914
04915 i = setIntLeafValue(&(rei->otherFlags), newVarValue);
04916
04917 return i;
04918 }
04919
04920 if (strcmp(varName, "addr") == 0) {
04921
04922 i = UNDEFINED_VARIABLE_MAP_ERR;
04923
04924 return i;
04925 }
04926
04927 if (strcmp(varName, "fileName") == 0) {
04928
04929 i = setStrLeafValue(rei->fileName, MAX_NAME_LEN, newVarValue);
04930
04931 return i;
04932 }
04933
04934 if (strcmp(varName, "flags") == 0) {
04935
04936 i = setIntLeafValue(&(rei->flags), newVarValue);
04937
04938 return i;
04939 }
04940
04941 if (strcmp(varName, "mode") == 0) {
04942
04943 i = setIntLeafValue(&(rei->mode), newVarValue);
04944
04945 return i;
04946 }
04947
04948 if (strcmp(varName, "dataSize") == 0) {
04949
04950 i = setLongLeafValue(&(rei->dataSize), newVarValue);
04951
04952 return i;
04953 }
04954
04955 if (strcmp(varName, "condInput") == 0) {
04956
04957 i = UNDEFINED_VARIABLE_MAP_ERR;
04958
04959 return i;
04960 }
04961
04962
04963 return(UNDEFINED_VARIABLE_MAP_ERR);
04964 }
04965 ExprType *getVarTypeFromFileOpenInp(char *varMap, Region *r)
04966 {
04967 char varName[NAME_LEN];
04968 char *varMapCPtr;
04969 int i;
04970
04971 if (varMap == NULL) {
04972 return newIRODSType(FileOpenInp_MS_T, r);
04973 }
04974
04975 i = getVarNameFromVarMap(varMap, varName, &varMapCPtr);
04976 if (i != 0)
04977 return newErrorType(i, r);
04978
04979
04980
04981 if (strcmp(varName, "fileType") == 0) {
04982
04983 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
04984
04985 }
04986
04987
04988 if (strcmp(varName, "otherFlags") == 0) {
04989
04990 return newSimpType(T_INT, r);
04991
04992 }
04993
04994
04995 if (strcmp(varName, "addr") == 0) {
04996
04997 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
04998
04999 }
05000
05001
05002 if (strcmp(varName, "fileName") == 0) {
05003
05004 return newSimpType(T_STRING, r);
05005
05006 }
05007
05008
05009 if (strcmp(varName, "flags") == 0) {
05010
05011 return newSimpType(T_INT, r);
05012
05013 }
05014
05015
05016 if (strcmp(varName, "mode") == 0) {
05017
05018 return newSimpType(T_INT, r);
05019
05020 }
05021
05022
05023 if (strcmp(varName, "dataSize") == 0) {
05024
05025 return newSimpType(T_DOUBLE, r);
05026
05027 }
05028
05029
05030 if (strcmp(varName, "condInput") == 0) {
05031
05032 return newErrorType( UNDEFINED_VARIABLE_MAP_ERR, r);
05033
05034 }
05035
05036
05037 return newErrorType(UNDEFINED_VARIABLE_MAP_ERR, r);
05038 }