![]() |
![]() |
00001 /****************************************************************************** 00002 * GX variants - V7.2.12.1 00003 * 00004 * 2006-2015 (c) Adaptive Recognition (https://adaptiverecognition.com) 00005 ******************************************************************************/ 00006 #if defined(__cplusplus) || defined(USE_COMPAT_VARIANT_1) 00007 #include "gxvariant_compat.h" 00008 #if defined(GX_SWIG) || defined(GX_DOTNET) || defined(USE_COMPAT_VARIANT_1) 00009 #define GX_VARIANT_INCL 00010 #endif 00011 #endif 00012 /******************************************************************************/ 00013 #ifndef GX_VARIANT_INCL 00014 #define GX_VARIANT_INCL 00015 /******************************************************************************/ 00033 /******************************************************************************/ 00034 #include "gxsd.h" 00035 /******************************************************************************/ 00036 #ifdef GX_NAMESPACES 00037 namespace gx { 00038 #endif 00039 /******************************************************************************/ 00040 #ifndef GX_VARIANT_CPT_INCL 00041 /******************************************************************************/ 00043 struct GX_VARIANT; 00044 00046 typedef struct GX_VARIANT* gxVARIANT; 00047 00054 enum GX_VARIANT_TYPES 00055 { 00056 /* Basic types (size = size of one element in bytes, nitems = number of items) */ 00057 GX_VARIANT_NULL = 0x00, 00058 GX_VARIANT_INT = 0x01, 00059 GX_VARIANT_UINT = 0x02, 00060 GX_VARIANT_FLOAT = 0x03, 00061 GX_VARIANT_DATETIME = 0x04, 00063 /* Array types, bit 6 set defines the array type. 00064 * (size = size of the element in bytes, nitems = number of items) */ 00065 GX_VARIANT_ARRAY = 0x40, 00066 GX_VARIANT_INTARRAY = 0x41, 00067 GX_VARIANT_UINTARRAY = 0x42, 00068 GX_VARIANT_FLOATARRAY = 0x43, 00069 GX_VARIANT_DATETIMEARRAY= 0x44, 00071 /* Other dynamically sized types */ 00072 GX_VARIANT_LIST = 0x80, 00073 GX_VARIANT_BINARY = 0x81, 00074 GX_VARIANT_ASCII = 0x82, 00075 GX_VARIANT_UNICODE = 0x83, 00076 GX_VARIANT_CONTAINER = 0x84, 00078 /* Types for creation operation only */ 00079 GX_VARIANT_AC_ASCII = 0x1082, 00080 GX_VARIANT_AC_UNICODE = 0x1083, 00081 GX_VARIANT_AS_ASCII = 0x2082, 00082 GX_VARIANT_AS_UNICODE = 0x2083, 00083 }; 00084 00085 #ifndef GX_MANUAL 00086 00087 #ifndef __cplusplus 00088 typedef enum GX_VARIANT_TYPES GX_VARIANT_TYPES; 00089 #endif 00090 00091 /****************************************************************************** 00092 * General variant handling * 00093 ******************************************************************************/ 00094 00095 /* Increases a variant's reference counter. It signs the intention of usage in a multithreading environment. */ 00096 inline int gx_refvariant(gxVARIANT variant); 00097 00098 /* Decreases a variant's reference counter. It signs the end of usage in a multithreading environment. */ 00099 inline int gx_unrefvariant(gxVARIANT variant); 00100 00101 /* Decreases a variant's reference counter and clears the variant variable. */ 00102 inline int gx_leavevariant(gxVARIANT *variant); 00103 00104 /* Duplicates, copies a variant and all of its descendants into a newly allocated memory area. */ 00105 inline int gx_duplicatevariant(gxVARIANT *target, gxVARIANT source); 00106 00107 /****************************************************************************** 00108 * Create, modify, read variants * 00109 ******************************************************************************/ 00110 00111 /* Creates a new variant. */ 00112 inline int gx_createvariant(gxVARIANT *variant, int id, const wchar_t *name, GX_VARIANT_TYPES type, int size, 00113 const void *data, int nitems); 00114 00115 /* Modifies a variant. */ 00116 inline int gx_updatevariant(gxVARIANT variant, int id, const wchar_t *name, GX_VARIANT_TYPES type, int size, 00117 const void *data, int nitems); 00118 00119 /* Modifies the data of a variant. */ 00120 inline int gx_updatevariantdata(gxVARIANT variant, GX_VARIANT_TYPES type, int size, const void *data, 00121 int nitems); 00122 00123 /* Changes the id of a variant. */ 00124 inline int gx_changevariantid(gxVARIANT variant, int id); 00125 00126 /* Changes the name of a variant. */ 00127 inline int gx_changevariantname(gxVARIANT variant, const wchar_t *name); 00128 00129 /* Gives information about a variant. */ 00130 inline int gx_getvariantinfo(gxVARIANT variant, int *id, wchar_t *namebuff, int namebuffsize, 00131 GX_VARIANT_TYPES *type, int *size, int *nitems, int *nchildren); 00132 00133 /* Returns a variant's data converted to a specified type. */ 00134 inline int gx_convertvariant(gxVARIANT variant, GX_VARIANT_TYPES type, void *target, int tgtlen, 00135 int *size, int *nitems); 00136 00137 /****************************************************************************** 00138 * Work with list type variants * 00139 ******************************************************************************/ 00140 00141 /* Returns an item from a list type variant. */ 00142 inline int gx_getvariantitem(gxVARIANT list, int flags, int id, const wchar_t *name, int *ix, gxVARIANT *target); 00143 #ifdef __cplusplus 00144 inline int gx_getvariantitem(gxVARIANT list, int flags, int id, const wchar_t *name, int ix, gxVARIANT *target); 00145 #endif 00146 00147 /* Cuts and returns an item from a list type variant. */ 00148 inline int gx_cutvariantitem(gxVARIANT list, int flags, int id, const wchar_t *name, int ix, gxVARIANT *target); 00149 00150 /* Returns the index of a variant element located in a list type variant. */ 00151 inline int gx_findvariantitem(gxVARIANT list, gxVARIANT item, int flags, int *ix); 00152 00153 /* Adds an item to a list type variant. */ 00154 inline int gx_addvariantitem(gxVARIANT list, int flags, int id, const wchar_t *name, int ix, gxVARIANT item); 00155 00156 /* Creates a new variant and appends to a list type variant. */ 00157 inline int gx_createvariantitem(gxVARIANT list, int id, const wchar_t *name, GX_VARIANT_TYPES type, int size, 00158 const void *data, int nitems, gxVARIANT *item); 00159 00160 /* Returns the data of an item in a list type variant converted to a specified type. */ 00161 inline int gx_convertvariantitem(gxVARIANT list, int id, const wchar_t *name, int ix, GX_VARIANT_TYPES type, 00162 void *target, int tgtlen, int *size, int *nitems); 00163 00164 /****************************************************************************** 00165 * Work with children * 00166 ******************************************************************************/ 00167 00168 /* Returns a child of a variant. */ 00169 inline int gx_getvariantchild(gxVARIANT parent, int flags, int id, const wchar_t *name, int *ix, gxVARIANT *target); 00170 #ifdef __cplusplus 00171 inline int gx_getvariantchild(gxVARIANT parent, int flags, int id, const wchar_t *name, int ix, gxVARIANT *target); 00172 #endif 00173 00174 /* Cuts and returns a child of a variant. */ 00175 inline int gx_cutvariantchild(gxVARIANT parent, int flags, int id, const wchar_t *name, int ix, gxVARIANT *target); 00176 00177 /* Returns the index of a child element located in a variant's children list. */ 00178 inline int gx_findvariantchild(gxVARIANT parent, gxVARIANT child, int flags, int *ix); 00179 00180 /* Adds a child element to a variant. */ 00181 inline int gx_addvariantchild(gxVARIANT parent, int flags, int id, const wchar_t *name, int ix, gxVARIANT child); 00182 00183 /* Creates a new variant and appends it to a variant as a child. */ 00184 inline int gx_createvariantchild(gxVARIANT parent, int id, const wchar_t *name, GX_VARIANT_TYPES type, int size, 00185 const void *data, int nitems, gxVARIANT *child); 00186 00187 /* Returns the data of a variant's child converted to a specified type. */ 00188 inline int gx_convertvariantchild(gxVARIANT parent, int id, const wchar_t *name, int ix, GX_VARIANT_TYPES type, 00189 void *target, int tgtlen, int *size, int *nitems); 00190 00191 /****************************************************************************** 00192 * Work with arrays * 00193 ******************************************************************************/ 00194 00195 /* Returns a part of an array variant's data. */ 00196 inline int gx_getvariantvalue(gxVARIANT varray, int size, GX_VARIANT_TYPES type, int ix, int nitems, 00197 void *target, int tgtlen); 00198 00199 /* Cuts and returns a part of an array variant's data. */ 00200 inline int gx_cutvariantvalue(gxVARIANT varray, int size, GX_VARIANT_TYPES type, int ix, int nitems, 00201 void *target, int tgtlen); 00202 00203 /* Inserts one or more values into an array variant's data. */ 00204 inline int gx_addvariantvalue(gxVARIANT varray, int size, GX_VARIANT_TYPES type, int ix, int nitems, 00205 const void *data); 00206 00207 /****************************************************************************** 00208 * Work with descendant variants * 00209 ******************************************************************************/ 00210 00211 /* Returns a variant from a variant tree. */ 00212 inline int gx_getvariantbypath(gxVARIANT root, const wchar_t *path, gxVARIANT *item); 00213 00214 /* Returns the data of a variant located in a variant tree converted to a specified type. */ 00215 inline int gx_convertvariantbypath(gxVARIANT root, const wchar_t *path, GX_VARIANT_TYPES type, void *target, 00216 int tgtlen, int *size, int *nitems); 00217 00218 #endif /* GX_MANUAL */ 00219 00221 enum GX_VARIANT_FLAGS 00222 { 00223 GX_VARIANT_BY_INDEX = 0x0002, 00225 GX_VARIANT_BY_ID = 0x0001, 00226 GX_VARIANT_BY_INDEX_AND_ID = 0x0003, 00227 GX_VARIANT_BY_ORDER_AND_ID = 0x0004, 00229 GX_VARIANT_BY_NAME = 0x0008, 00230 GX_VARIANT_BY_INDEX_AND_NAME = 0x000a, 00231 GX_VARIANT_BY_ORDER_AND_NAME = 0x0010, 00233 GX_VARIANT_APPEND = 0x0100, 00234 GX_VARIANT_LAST = 0x0200, 00235 }; 00236 00237 /****************************************************************************** 00238 * This is the end of the gxvariant interface. Now the implementation follows * 00239 ******************************************************************************/ 00240 #ifdef __BORLANDC__ 00241 #pragma warn -rch 00242 #endif 00243 /******************************************************************************/ 00244 #endif /* GX_VARIANT_CPT_INCL */ 00245 00246 #ifndef GX_MANUAL 00247 00248 #ifndef GX_VARIANT_CPT_INCL 00249 00250 /* GX call codes */ 00251 enum GX_CALL_VARIANT_CODES 00252 { 00253 GX_CALL_REFVARIANT = GX_CALL_GROUP_VARIANT, 00254 GX_CALL_UNREFVARIANT = GX_CALL_GROUP_VARIANT+1, 00255 GX_CALL_CREATEVARIANT = GX_CALL_GROUP_VARIANT+3, 00256 GX_CALL_DUPLICATEVARIANT = GX_CALL_GROUP_VARIANT+4, 00257 GX_CALL_UPDATEVARIANT = GX_CALL_GROUP_VARIANT+5, 00258 GX_CALL_UPDATEVARIANTDATA = GX_CALL_GROUP_VARIANT+6, 00259 GX_CALL_GETVARIANT = GX_CALL_GROUP_VARIANT+7, 00260 GX_CALL_CONVERTVARIANT = GX_CALL_GROUP_VARIANT+8, 00261 00262 GX_CALL_GETVARIANTITEM = GX_CALL_GROUP_VARIANT+9, 00263 GX_CALL_CUTVARIANTITEM = GX_CALL_GROUP_VARIANT+10, 00264 GX_CALL_FINDVARIANTITEM = GX_CALL_GROUP_VARIANT+11, 00265 GX_CALL_ADDVARIANTITEM = GX_CALL_GROUP_VARIANT+12, 00266 GX_CALL_REMOVEVARIANTITEM = GX_CALL_GROUP_VARIANT+13, 00267 00268 GX_CALL_GETVARIANTCHILD = GX_CALL_GROUP_VARIANT+14, 00269 GX_CALL_CUTVARIANTCHILD = GX_CALL_GROUP_VARIANT+15, 00270 GX_CALL_FINDVARIANTCHILD = GX_CALL_GROUP_VARIANT+16, 00271 GX_CALL_ADDVARIANTCHILD = GX_CALL_GROUP_VARIANT+17, 00272 GX_CALL_REMOVEVARIANTCHILD = GX_CALL_GROUP_VARIANT+18, 00273 00274 GX_CALL_GETVARIANTVALUE = GX_CALL_GROUP_VARIANT+19, 00275 GX_CALL_CUTVARIANTVALUE = GX_CALL_GROUP_VARIANT+20, 00276 GX_CALL_ADDVARIANTVALUE = GX_CALL_GROUP_VARIANT+22, 00277 GX_CALL_REMOVEVARIANTVALUE = GX_CALL_GROUP_VARIANT+23, 00278 00279 GX_CALL_GETVARIANTBYPATH = GX_CALL_GROUP_VARIANT+24, 00280 GX_CALL_GETVARIANTBYPATHA = GX_CALL_GROUP_VARIANT+25, 00281 GX_CALL_CONVERTVARIANTBYPATH = GX_CALL_GROUP_VARIANT+26, 00282 GX_CALL_CONVERTVARIANTBYPATHA = GX_CALL_GROUP_VARIANT+27, 00283 00284 GX_CALL_UPDATEVARIANTID = GX_CALL_GROUP_VARIANT+29, 00285 00286 GX_CALL_CREATEVARIANTN = GX_CALL_GROUP_VARIANT+30, 00287 GX_CALL_UPDATEVARIANTN = GX_CALL_GROUP_VARIANT+31, 00288 GX_CALL_UPDATEVARIANTDATAN = GX_CALL_GROUP_VARIANT+32, 00289 GX_CALL_CHANGEVARIANTNAME = GX_CALL_GROUP_VARIANT+33, 00290 GX_CALL_GETVARIANTINFO = GX_CALL_GROUP_VARIANT+34, 00291 00292 GX_CALL_GETVARIANTITEMN = GX_CALL_GROUP_VARIANT+35, 00293 GX_CALL_CUTVARIANTITEMN = GX_CALL_GROUP_VARIANT+36, 00294 GX_CALL_FINDVARIANTITEMN = GX_CALL_GROUP_VARIANT+37, 00295 GX_CALL_ADDVARIANTITEMN = GX_CALL_GROUP_VARIANT+38, 00296 00297 GX_CALL_GETVARIANTCHILDN = GX_CALL_GROUP_VARIANT+39, 00298 GX_CALL_CUTVARIANTCHILDN = GX_CALL_GROUP_VARIANT+40, 00299 GX_CALL_FINDVARIANTCHILDN = GX_CALL_GROUP_VARIANT+41, 00300 GX_CALL_ADDVARIANTCHILDN = GX_CALL_GROUP_VARIANT+42, 00301 }; 00302 00303 /******************************************************************************/ 00304 00305 /* GX call parameter structures. */ 00306 00307 struct GX_PARM_DUPLICATEVARIANT 00308 { 00309 gxVARIANT source; 00310 gxVARIANT target; 00311 }; 00312 00313 #endif /* GX_VARIANT_CPT_INCL */ 00314 00315 /* create/updatedata/changeid/changename */ 00316 struct GX_PARM_UPDATEVARIANTN 00317 { 00318 gxVARIANT variant; 00319 int id; 00320 const wchar_t *name; 00321 GX_VARIANT_TYPES type; 00322 int size; 00323 int nitems; 00324 const void *data; 00325 }; 00326 00327 #ifndef GX_VARIANT_CPT_INCL 00328 00329 #define GX_PARM_CREATEVARIANT GX_PARM_UPDATEVARIANT 00330 00331 struct GX_PARM_UPDATEVARIANT 00332 { 00333 gxVARIANT variant; 00334 int id; 00335 int type; 00336 int size; 00337 int nitems; 00338 const void *data; 00339 }; 00340 00341 #define GX_PARM_UPDATEVARIANTDATA GX_PARM_UPDATEVARIANT 00342 00343 struct GX_PARM_UPDATEVARIANTID 00344 { 00345 gxVARIANT variant; 00346 int id; 00347 }; 00348 00349 #endif /* GX_VARIANT_CPT_INCL */ 00350 00351 struct GX_PARM_GETVARIANTINFO 00352 { 00353 gxVARIANT variant; 00354 int id; 00355 wchar_t *namebuff; 00356 int namebuffsize; 00357 GX_VARIANT_TYPES type; 00358 int size; 00359 int nitems; 00360 int nchildren; 00361 }; 00362 00363 #ifndef GX_VARIANT_CPT_INCL 00364 00365 struct GX_PARM_GETVARIANT 00366 { 00367 gxVARIANT variant; 00368 int id; 00369 int type; 00370 int size; 00371 int nitems; 00372 int nchildren; 00373 }; 00374 00375 struct GX_PARM_CONVERTVARIANT 00376 { 00377 gxVARIANT variant; 00378 int id; 00379 int type; 00380 int size; 00381 int nitems; 00382 void *target; 00383 int tgtlen; 00384 }; 00385 00386 #endif /* GX_VARIANT_CPT_INCL */ 00387 00388 /* add/get/cut/find item/child */ 00389 struct GX_PARM_VARIANTITEM 00390 { 00391 gxVARIANT parent; 00392 int flags; 00393 int id; 00394 int ix; 00395 const wchar_t *name; 00396 gxVARIANT item; 00397 }; 00398 00399 #ifndef GX_VARIANT_CPT_INCL 00400 00401 struct GX_PARM_GETVARIANTITEM 00402 { 00403 gxVARIANT list; 00404 int flags; 00405 int id; 00406 int ix; 00407 gxVARIANT target; 00408 }; 00409 00410 #define GX_PARM_CUTVARIANTITEM GX_PARM_GETVARIANTITEM 00411 00412 struct GX_PARM_FINDVARIANTITEM 00413 { 00414 gxVARIANT list; 00415 gxVARIANT item; 00416 int id; 00417 int ix; 00418 }; 00419 00420 struct GX_PARM_ADDVARIANTITEM 00421 { 00422 gxVARIANT list; 00423 int flags; 00424 int id; 00425 int ix; 00426 gxVARIANT item; 00427 }; 00428 00429 struct GX_PARM_REMOVEVARIANTITEM 00430 { 00431 gxVARIANT list; 00432 int flags; 00433 int id; 00434 int ix; 00435 }; 00436 00437 struct GX_PARM_GETVARIANTCHILD 00438 { 00439 gxVARIANT parent; 00440 int flags; 00441 int id; 00442 int ix; 00443 gxVARIANT target; 00444 }; 00445 00446 #define GX_PARM_CUTVARIANTCHILD GX_PARM_GETVARIANTCHILD 00447 00448 struct GX_PARM_FINDVARIANTCHILD 00449 { 00450 gxVARIANT parent; 00451 gxVARIANT child; 00452 int id; 00453 int ix; 00454 }; 00455 00456 struct GX_PARM_ADDVARIANTCHILD 00457 { 00458 gxVARIANT parent; 00459 int flags; 00460 int id; 00461 int ix; 00462 gxVARIANT child; 00463 }; 00464 00465 struct GX_PARM_REMOVEVARIANTCHILD 00466 { 00467 gxVARIANT parent; 00468 int flags; 00469 int id; 00470 int ix; 00471 }; 00472 00473 struct GX_PARM_GETVARIANTVALUE 00474 { 00475 gxVARIANT array; 00476 int size; 00477 int type; 00478 int ix; 00479 int nitems; 00480 void *target; 00481 int tgtlen; 00482 }; 00483 00484 #define GX_PARM_CUTVARIANTVALUE GX_PARM_GETVARIANTVALUE 00485 00486 struct GX_PARM_ADDVARIANTVALUE 00487 { 00488 gxVARIANT array; 00489 int size; 00490 int type; 00491 int ix; 00492 int nitems; 00493 const void *data; 00494 }; 00495 00496 struct GX_PARM_REMOVEVARIANTVALUE 00497 { 00498 gxVARIANT array; 00499 int ix; 00500 int nitems; 00501 }; 00502 00503 struct GX_PARM_GETVARIANTBYPATH 00504 { 00505 gxVARIANT root; 00506 const wchar_t *path; 00507 gxVARIANT item; 00508 }; 00509 00510 struct GX_PARM_GETVARIANTBYPATHA 00511 { 00512 gxVARIANT root; 00513 const char *path; 00514 gxVARIANT item; 00515 }; 00516 00517 struct GX_PARM_CONVERTVARIANTBYPATH 00518 { 00519 gxVARIANT root; 00520 const wchar_t *path; 00521 int id; 00522 int type; 00523 int size; 00524 int nitems; 00525 void *target; 00526 int tgtlen; 00527 }; 00528 00529 struct GX_PARM_CONVERTVARIANTBYPATHA 00530 { 00531 gxVARIANT root; 00532 const char *path; 00533 int id; 00534 int type; 00535 int size; 00536 int nitems; 00537 void *target; 00538 int tgtlen; 00539 }; 00540 00541 #endif /* GX_VARIANT_CPT_INCL */ 00542 00543 #endif /* GX_MANUAL */ 00544 00545 #ifndef GX_VARIANT_CPT_INCL 00546 00551 /******************************************************************************/ 00563 inline int gx_refvariant(gxVARIANT variant) 00564 { 00565 gxHANDLE nullhandle = { 0 }; 00566 assert(variant); 00567 return gx_call(nullhandle, GX_CALL_REFVARIANT, variant); 00568 } 00569 00570 /******************************************************************************/ 00581 inline int gx_unrefvariant(gxVARIANT variant) 00582 { 00583 gxHANDLE nullhandle = { 0 }; 00584 return gx_call(nullhandle, GX_CALL_UNREFVARIANT, variant); 00585 } 00586 00587 /******************************************************************************/ 00598 inline int gx_leavevariant(gxVARIANT *variant) 00599 { 00600 gxHANDLE nullhandle = { 0 }; 00601 int st; 00602 assert(variant); 00603 st = gx_call(nullhandle, GX_CALL_UNREFVARIANT, *variant); 00604 if(st) { 00605 *variant = (gxVARIANT)0; 00606 } 00607 return st; 00608 } 00609 00610 /******************************************************************************/ 00624 inline int gx_duplicatevariant(gxVARIANT *target, gxVARIANT source) 00625 { 00626 gxHANDLE nullhandle = { 0 }; 00627 struct GX_PARM_DUPLICATEVARIANT dv; 00628 int st; 00629 assert(target); 00630 dv.source = source; 00631 st = gx_call(nullhandle, GX_CALL_DUPLICATEVARIANT, &dv); 00632 if(st) { 00633 *target = dv.target; 00634 } 00635 return st; 00636 } 00637 00640 #endif /* GX_VARIANT_CPT_INCL */ 00641 00646 /******************************************************************************/ 00663 inline int gx_createvariant(gxVARIANT *variant, int id, const wchar_t *name, GX_VARIANT_TYPES type, int size, 00664 const void *data, int nitems GX_DEFARG(1)) 00665 { 00666 gxHANDLE nullhandle = { 0 }; 00667 struct GX_PARM_UPDATEVARIANTN cv; 00668 int st; 00669 assert(variant); 00670 cv.variant = (gxVARIANT)0; 00671 cv.id = id; 00672 cv.name = name; 00673 cv.type = type; 00674 cv.size = size; 00675 cv.nitems = nitems; 00676 cv.data = data; 00677 st = gx_call(nullhandle, GX_CALL_CREATEVARIANTN, &cv); 00678 if(st) { 00679 *variant = cv.variant; 00680 } 00681 return st; 00682 } 00683 00684 /******************************************************************************/ 00705 inline int gx_updatevariant(gxVARIANT variant, int id, const wchar_t *name, GX_VARIANT_TYPES type, int size, 00706 const void *data, int nitems GX_DEFARG(1)) 00707 { 00708 gxHANDLE nullhandle = { 0 }; 00709 struct GX_PARM_UPDATEVARIANTN uv; 00710 assert(variant); 00711 uv.variant = variant; 00712 uv.id = id; 00713 uv.name = name; 00714 uv.type = type; 00715 uv.size = size; 00716 uv.nitems = nitems; 00717 uv.data = data; 00718 return gx_call(nullhandle, GX_CALL_UPDATEVARIANTN, &uv); 00719 } 00720 00721 /******************************************************************************/ 00740 inline int gx_updatevariantdata(gxVARIANT variant, GX_VARIANT_TYPES type, int size, const void *data, 00741 int nitems GX_DEFARG(1)) 00742 { 00743 gxHANDLE nullhandle = { 0 }; 00744 struct GX_PARM_UPDATEVARIANTN uv; 00745 assert(variant); 00746 uv.variant = variant; 00747 uv.type = type; 00748 uv.size = size; 00749 uv.nitems = nitems; 00750 uv.data = data; 00751 return gx_call(nullhandle, GX_CALL_UPDATEVARIANTDATAN, &uv); 00752 } 00753 00754 #ifndef GX_VARIANT_CPT_INCL 00755 00756 /******************************************************************************/ 00767 inline int gx_changevariantid(gxVARIANT variant, int id) 00768 { 00769 gxHANDLE nullhandle = { 0 }; 00770 struct GX_PARM_UPDATEVARIANTID uv; 00771 assert(variant); 00772 uv.variant = variant; 00773 uv.id = id; 00774 return gx_call(nullhandle, GX_CALL_UPDATEVARIANTID, &uv); 00775 } 00776 00777 #endif /* GX_VARIANT_CPT_INCL */ 00778 00779 /******************************************************************************/ 00790 inline int gx_changevariantname(gxVARIANT variant, const wchar_t *name) 00791 { 00792 gxHANDLE nullhandle = { 0 }; 00793 struct GX_PARM_UPDATEVARIANTN uv; 00794 assert(variant); 00795 uv.variant = variant; 00796 uv.name = name; 00797 return gx_call(nullhandle, GX_CALL_CHANGEVARIANTNAME, &uv); 00798 } 00799 00800 /******************************************************************************/ 00815 inline int gx_getvariantinfo(gxVARIANT variant, int *id, wchar_t *namebuff, int namebuffsize, 00816 GX_VARIANT_TYPES *type, int *size, int *nitems, int *nchildren) 00817 { 00818 gxHANDLE nullhandle = { 0 }; 00819 struct GX_PARM_GETVARIANTINFO gv; 00820 int st; 00821 gv.variant = variant; 00822 gv.namebuff = namebuff; 00823 gv.namebuffsize = namebuffsize; 00824 st = gx_call(nullhandle, GX_CALL_GETVARIANTINFO, &gv); 00825 if(st) { 00826 if(id) *id = gv.id; 00827 if(type) *type = gv.type; 00828 if(size) *size = gv.size; 00829 if(nitems) *nitems = gv.nitems; 00830 if(nchildren) *nchildren = gv.nchildren; 00831 } 00832 return st; 00833 } 00834 00835 /******************************************************************************/ 00849 inline int gx_convertvariant(gxVARIANT variant, GX_VARIANT_TYPES type, void *target, int tgtlen, 00850 int *size GX_DEFARG(0), int *nitems GX_DEFARG(0)) 00851 { 00852 gxHANDLE nullhandle = { 0 }; 00853 struct GX_PARM_CONVERTVARIANT cv; 00854 int st; 00855 assert(variant); 00856 cv.variant = variant; 00857 cv.type = type; 00858 cv.size = size ? *size : tgtlen; 00859 cv.nitems = nitems ? *nitems : 1; 00860 cv.target = target; 00861 cv.tgtlen = tgtlen; 00862 st = gx_call(nullhandle, GX_CALL_CONVERTVARIANT, &cv); 00863 if(st) { 00864 if(size) *size = cv.size; 00865 if(nitems) *nitems = cv.nitems; 00866 } 00867 return st; 00868 } 00869 00875 /******************************************************************************/ 00891 inline int gx_getvariantitem(gxVARIANT list, int flags, int id, const wchar_t *name, int *ix, gxVARIANT *target) 00892 { 00893 gxHANDLE nullhandle = { 0 }; 00894 struct GX_PARM_VARIANTITEM gi; 00895 int st; 00896 assert(list && target); 00897 gi.parent = list; 00898 gi.flags = flags; 00899 gi.id = id; 00900 gi.name = name; 00901 gi.ix = ix ? *ix : 0; 00902 st = gx_call(nullhandle, GX_CALL_GETVARIANTITEMN, &gi); 00903 if(st) { 00904 if(ix) *ix = gi.ix; 00905 *target = gi.item; 00906 } 00907 return st; 00908 } 00909 00910 #ifdef __cplusplus 00911 /******************************************************************************/ 00926 inline int gx_getvariantitem(gxVARIANT list, int flags, int id, const wchar_t *name, int ix, gxVARIANT *target) 00927 { 00928 return gx_getvariantitem(list, flags, id, name, &ix, target); 00929 } 00930 #endif 00931 00932 /******************************************************************************/ 00948 inline int gx_cutvariantitem(gxVARIANT list, int flags, int id, const wchar_t *name, int ix, gxVARIANT *target GX_DEFARG(0)) 00949 { 00950 gxHANDLE nullhandle = { 0 }; 00951 struct GX_PARM_VARIANTITEM ci; 00952 int st; 00953 assert(list); 00954 ci.parent = list; 00955 ci.flags = flags; 00956 ci.id = id; 00957 ci.name = name; 00958 ci.ix = ix; 00959 st = gx_call(nullhandle, GX_CALL_CUTVARIANTITEMN, &ci); 00960 if(st) { 00961 if(target) *target = ci.item; 00962 else gx_leavevariant(&ci.item); 00963 } 00964 return st; 00965 } 00966 00967 /******************************************************************************/ 00976 inline int gx_findvariantitem(gxVARIANT list, gxVARIANT item, int flags, int *ix) 00977 { 00978 gxHANDLE nullhandle = { 0 }; 00979 struct GX_PARM_VARIANTITEM fi; 00980 int st; 00981 assert(list && item && ix); 00982 fi.parent = list; 00983 fi.item = item; 00984 fi.flags = flags; 00985 st = gx_call(nullhandle, GX_CALL_FINDVARIANTITEMN, &fi); 00986 if(st) { 00987 *ix = fi.ix; 00988 } 00989 return st; 00990 } 00991 00992 /******************************************************************************/ 01006 inline int gx_addvariantitem(gxVARIANT list, int flags, int id, const wchar_t *name, int ix, gxVARIANT item) 01007 { 01008 gxHANDLE nullhandle = { 0 }; 01009 struct GX_PARM_VARIANTITEM iv; 01010 assert(list && item); 01011 iv.parent = list; 01012 iv.flags = flags; 01013 iv.id = id; 01014 iv.name = name; 01015 iv.ix = ix; 01016 iv.item = item; 01017 return gx_call(nullhandle, GX_CALL_ADDVARIANTITEMN, &iv); 01018 } 01019 01020 /******************************************************************************/ 01038 inline int gx_createvariantitem(gxVARIANT list, int id, const wchar_t *name, GX_VARIANT_TYPES type, int size, 01039 const void *data, int nitems GX_DEFARG(1), gxVARIANT *item GX_DEFARG(0)) 01040 { 01041 gxVARIANT tmp; 01042 if(!item) item = &tmp; 01043 *item = 0; 01044 if(!gx_createvariant(item, id, name, type, size, data, nitems)) return 0; 01045 if(!gx_addvariantitem(list, GX_VARIANT_LAST, 0, 0, 0, *item)) { 01046 gx_pusherror(); 01047 gx_leavevariant(item); 01048 gx_poperror(); 01049 return 0; 01050 } 01051 return gx_unrefvariant(*item); 01052 } 01053 01054 /******************************************************************************/ 01075 inline int gx_convertvariantitem(gxVARIANT list, int id, const wchar_t *name, int ix, GX_VARIANT_TYPES type, 01076 void *target, int tgtlen, int *size GX_DEFARG(0), int *nitems GX_DEFARG(0)) 01077 { 01078 gxVARIANT fval = 0; 01079 int st; 01080 assert(target && tgtlen>0); 01081 if(!gx_getvariantitem(list, name ? GX_VARIANT_BY_ORDER_AND_NAME : GX_VARIANT_BY_ORDER_AND_ID, 01082 id, name, &ix, &fval)) return 0; 01083 st = gx_convertvariant(fval, type, target, tgtlen, size, nitems); 01084 if(!st) gx_pusherror(); 01085 gx_leavevariant(&fval); 01086 if(!st) gx_poperror(); 01087 return st; 01088 } 01089 01095 /******************************************************************************/ 01111 inline int gx_getvariantchild(gxVARIANT parent, int flags, int id, const wchar_t *name, int *ix, gxVARIANT *target) 01112 { 01113 gxHANDLE nullhandle = { 0 }; 01114 struct GX_PARM_VARIANTITEM gc; 01115 int st; 01116 assert(parent && target); 01117 gc.parent = parent; 01118 gc.flags = flags; 01119 gc.id = id; 01120 gc.name = name; 01121 gc.ix = ix ? *ix : 0; 01122 st = gx_call(nullhandle, GX_CALL_GETVARIANTCHILDN, &gc); 01123 if(st) { 01124 if(ix) *ix = gc.ix; 01125 *target = gc.item; 01126 } 01127 return st; 01128 } 01129 01130 #ifdef __cplusplus 01131 /******************************************************************************/ 01146 inline int gx_getvariantchild(gxVARIANT parent, int flags, int id, const wchar_t *name, int ix, gxVARIANT *target) 01147 { 01148 return gx_getvariantchild(parent, flags, id, name, &ix, target); 01149 } 01150 #endif 01151 01152 /******************************************************************************/ 01168 inline int gx_cutvariantchild(gxVARIANT parent, int flags, int id, const wchar_t *name, int ix, gxVARIANT *target GX_DEFARG(0)) 01169 { 01170 gxHANDLE nullhandle = { 0 }; 01171 struct GX_PARM_VARIANTITEM cc; 01172 int st; 01173 assert(parent); 01174 cc.parent = parent; 01175 cc.flags = flags; 01176 cc.id = id; 01177 cc.name = name; 01178 cc.ix = ix; 01179 st = gx_call(nullhandle, GX_CALL_CUTVARIANTCHILDN, &cc); 01180 if(st) { 01181 if(target) *target = cc.item; 01182 else gx_leavevariant(&cc.item); 01183 } 01184 return st; 01185 } 01186 01187 /******************************************************************************/ 01196 inline int gx_findvariantchild(gxVARIANT parent, gxVARIANT child, int flags, int *ix) 01197 { 01198 gxHANDLE nullhandle = { 0 }; 01199 struct GX_PARM_VARIANTITEM fc; 01200 int st; 01201 assert(parent && child && ix); 01202 fc.parent = parent; 01203 fc.item = child; 01204 fc.flags = flags; 01205 st = gx_call(nullhandle, GX_CALL_FINDVARIANTCHILDN, &fc); 01206 if(st) { 01207 *ix = fc.ix; 01208 } 01209 return st; 01210 } 01211 01212 /******************************************************************************/ 01226 inline int gx_addvariantchild(gxVARIANT parent, int flags, int id, const wchar_t *name, int ix, gxVARIANT child) 01227 { 01228 gxHANDLE nullhandle = { 0 }; 01229 struct GX_PARM_VARIANTITEM ic; 01230 assert(parent && child); 01231 ic.parent = parent; 01232 ic.flags = flags; 01233 ic.id = id; 01234 ic.name = name; 01235 ic.ix = ix; 01236 ic.item = child; 01237 return gx_call(nullhandle, GX_CALL_ADDVARIANTCHILDN, &ic); 01238 } 01239 01240 /******************************************************************************/ 01258 inline int gx_createvariantchild(gxVARIANT parent, int id, const wchar_t *name, GX_VARIANT_TYPES type, int size, 01259 const void *data, int nitems GX_DEFARG(1), gxVARIANT *child GX_DEFARG(0)) 01260 { 01261 gxVARIANT tmp; 01262 if(!child) child = &tmp; 01263 *child = 0; 01264 if(!gx_createvariant(child, id, name, type, size, data, nitems)) return 0; 01265 if(!gx_addvariantchild(parent, GX_VARIANT_LAST, 0, 0, 0, *child)) { 01266 gx_pusherror(); 01267 gx_leavevariant(child); 01268 gx_poperror(); 01269 return 0; 01270 } 01271 return gx_unrefvariant(*child); 01272 } 01273 01274 /******************************************************************************/ 01295 inline int gx_convertvariantchild(gxVARIANT parent, int id, const wchar_t *name, int ix, GX_VARIANT_TYPES type, 01296 void *target, int tgtlen, int *size GX_DEFARG(0), int *nitems GX_DEFARG(0)) 01297 { 01298 gxVARIANT fval = 0; 01299 int st; 01300 assert(target && tgtlen>0); 01301 if(!gx_getvariantchild(parent, name ? GX_VARIANT_BY_ORDER_AND_NAME : GX_VARIANT_BY_ORDER_AND_ID, 01302 id, name, &ix, &fval)) return 0; 01303 st = gx_convertvariant(fval, type, target, tgtlen, size, nitems); 01304 if(!st) gx_pusherror(); 01305 gx_leavevariant(&fval); 01306 if(!st) gx_poperror(); 01307 return st; 01308 } 01309 01312 #ifndef GX_VARIANT_CPT_INCL 01313 01318 /******************************************************************************/ 01331 inline int gx_getvariantvalue(gxVARIANT varray, int size, GX_VARIANT_TYPES type, int ix, int nitems, 01332 void *target, int tgtlen) 01333 { 01334 gxHANDLE nullhandle = { 0 }; 01335 struct GX_PARM_GETVARIANTVALUE gv; 01336 assert(varray); 01337 gv.array = varray; 01338 gv.size = size; 01339 gv.type = type; 01340 gv.ix = ix; 01341 gv.nitems = nitems; 01342 gv.target = target; 01343 gv.tgtlen = tgtlen; 01344 return gx_call(nullhandle, GX_CALL_GETVARIANTVALUE, &gv); 01345 } 01346 01347 /******************************************************************************/ 01361 inline int gx_cutvariantvalue(gxVARIANT varray, int size, GX_VARIANT_TYPES type, int ix, int nitems, 01362 void *target GX_DEFARG(0), int tgtlen GX_DEFARG(0)) 01363 { 01364 gxHANDLE nullhandle = { 0 }; 01365 struct GX_PARM_CUTVARIANTVALUE gv; 01366 assert(varray); 01367 gv.array = varray; 01368 gv.size = size; 01369 gv.type = type; 01370 gv.ix = ix; 01371 gv.nitems = nitems; 01372 gv.target = target; 01373 gv.tgtlen = tgtlen; 01374 return gx_call(nullhandle, GX_CALL_CUTVARIANTVALUE, &gv); 01375 } 01376 01377 /******************************************************************************/ 01388 inline int gx_addvariantvalue(gxVARIANT varray, int size, GX_VARIANT_TYPES type, int ix, int nitems, 01389 const void *data) 01390 { 01391 gxHANDLE nullhandle = { 0 }; 01392 struct GX_PARM_ADDVARIANTVALUE av; 01393 assert(varray); 01394 av.array = varray; 01395 av.size = size; 01396 av.type = type; 01397 av.ix = ix; 01398 av.nitems = nitems; 01399 av.data = data; 01400 return gx_call(nullhandle, GX_CALL_ADDVARIANTVALUE, &av); 01401 } 01402 01405 #endif /* GX_VARIANT_CPT_INCL */ 01406 01411 #ifndef GX_VARIANT_CPT_INCL 01412 01413 /******************************************************************************/ 01455 inline int gx_getvariantbypath(gxVARIANT root, const wchar_t *path, gxVARIANT *item) 01456 { 01457 gxHANDLE nullhandle = { 0 }; 01458 struct GX_PARM_GETVARIANTBYPATH gp; 01459 int st; 01460 assert(root && item); 01461 gp.root = root; 01462 gp.path = path; 01463 st = gx_call(nullhandle, GX_CALL_GETVARIANTBYPATH, &gp); 01464 if(st) { 01465 *item = gp.item; 01466 } 01467 return st; 01468 } 01469 01470 #endif /* GX_VARIANT_CPT_INCL */ 01471 01472 /******************************************************************************/ 01520 inline int gx_convertvariantbypath(gxVARIANT root, const wchar_t *path, GX_VARIANT_TYPES type, void *target, 01521 int tgtlen, int *size GX_DEFARG(0), int *nitems GX_DEFARG(0)) 01522 { 01523 gxVARIANT fval = 0; 01524 int st; 01525 assert(target && tgtlen>0); 01526 if(!gx_getvariantbypath(root, path, &fval)) return 0; 01527 st = gx_convertvariant(fval, type, target, tgtlen, size, nitems); 01528 if(!st) gx_pusherror(); 01529 gx_leavevariant(&fval); 01530 if(!st) gx_poperror(); 01531 return st; 01532 } 01533 01536 /******************************************************************************/ 01537 #ifdef GX_NAMESPACES 01538 } /* namespace */ 01539 #endif 01540 #ifdef __BORLANDC__ 01541 #pragma warn .rch 01542 #endif 01543 /******************************************************************************/ 01544 #endif /* GX_VARIANT_INCL */