gxvariant.h

Go to the documentation of this file.

/******************************************************************************
 * GX variants - V7.2.12.1
 *
 * 2006-2015 (c) ARH Inc. (http://www.arh.hu)
 ******************************************************************************/
#if defined(__cplusplus) || defined(USE_COMPAT_VARIANT_1)
    #include "gxvariant_compat.h"
    #if defined(GX_SWIG) || defined(GX_DOTNET) || defined(USE_COMPAT_VARIANT_1)
        #define GX_VARIANT_INCL
    #endif
#endif
/******************************************************************************/
#ifndef GX_VARIANT_INCL
#define GX_VARIANT_INCL
/******************************************************************************/
/******************************************************************************/
#include "gxsd.h"
/******************************************************************************/
#ifdef GX_NAMESPACES
    namespace gx {
#endif
/******************************************************************************/
#ifndef GX_VARIANT_CPT_INCL
/******************************************************************************/
struct GX_VARIANT;

typedef struct GX_VARIANT* gxVARIANT;

enum GX_VARIANT_TYPES
{
    /* Basic types (size = size of one element in bytes, nitems = number of items) */
    GX_VARIANT_NULL         = 0x00,     
    GX_VARIANT_INT          = 0x01,     
    GX_VARIANT_UINT         = 0x02,     
    GX_VARIANT_FLOAT        = 0x03,     
    GX_VARIANT_DATETIME     = 0x04,     
    /* Array types, bit 6 set defines the array type.
     * (size = size of the element in bytes, nitems = number of items) */
    GX_VARIANT_ARRAY        = 0x40,     
    GX_VARIANT_INTARRAY     = 0x41,     
    GX_VARIANT_UINTARRAY    = 0x42,     
    GX_VARIANT_FLOATARRAY   = 0x43,     
    GX_VARIANT_DATETIMEARRAY= 0x44,     
    /* Other dynamically sized types */
    GX_VARIANT_LIST         = 0x80,     
    GX_VARIANT_BINARY       = 0x81,     
    GX_VARIANT_ASCII        = 0x82,     
    GX_VARIANT_UNICODE      = 0x83,     
    GX_VARIANT_CONTAINER    = 0x84,     
    /* Types for creation operation only */
    GX_VARIANT_AC_ASCII     = 0x1082,   
    GX_VARIANT_AC_UNICODE   = 0x1083,   
    GX_VARIANT_AS_ASCII     = 0x2082,   
    GX_VARIANT_AS_UNICODE   = 0x2083,   
};

#ifndef GX_MANUAL

#ifndef __cplusplus
typedef enum GX_VARIANT_TYPES GX_VARIANT_TYPES;
#endif

/******************************************************************************
 * General variant handling                                                   *
 ******************************************************************************/

/* Increases a variant's reference counter. It signs the intention of usage in a multithreading environment. */
inline int gx_refvariant(gxVARIANT variant);

/* Decreases a variant's reference counter. It signs the end of usage in a multithreading environment. */
inline int gx_unrefvariant(gxVARIANT variant);

/* Decreases a variant's reference counter and clears the variant variable. */
inline int gx_leavevariant(gxVARIANT *variant);

/* Duplicates, copies a variant and all of its descendants into a newly allocated memory area. */
inline int gx_duplicatevariant(gxVARIANT *target, gxVARIANT source);

/******************************************************************************
 * Create, modify, read variants                                              *
 ******************************************************************************/

/* Creates a new variant. */
inline int gx_createvariant(gxVARIANT *variant, int id, const wchar_t *name, GX_VARIANT_TYPES type, int size,
                            const void *data, int nitems);

/* Modifies a variant. */
inline int gx_updatevariant(gxVARIANT variant, int id, const wchar_t *name, GX_VARIANT_TYPES type, int size,
                            const void *data, int nitems);

/* Modifies the data of a variant. */
inline int gx_updatevariantdata(gxVARIANT variant, GX_VARIANT_TYPES type, int size, const void *data,
                                int nitems);

/* Changes the id of a variant. */
inline int gx_changevariantid(gxVARIANT variant, int id);

/* Changes the name of a variant. */
inline int gx_changevariantname(gxVARIANT variant, const wchar_t *name);

/* Gives information about a variant. */
inline int gx_getvariantinfo(gxVARIANT variant, int *id, wchar_t *namebuff, int namebuffsize,
                             GX_VARIANT_TYPES *type, int *size, int *nitems, int *nchildren);

/* Returns a variant's data converted to a specified type. */
inline int gx_convertvariant(gxVARIANT variant, GX_VARIANT_TYPES type, void *target, int tgtlen,
                             int *size, int *nitems);

/******************************************************************************
 * Work with list type variants                                               *
 ******************************************************************************/

/* Returns an item from a list type variant. */
inline int gx_getvariantitem(gxVARIANT list, int flags, int id, const wchar_t *name, int *ix, gxVARIANT *target);
#ifdef __cplusplus
inline int gx_getvariantitem(gxVARIANT list, int flags, int id, const wchar_t *name, int ix, gxVARIANT *target);
#endif

/* Cuts and returns an item from a list type variant. */
inline int gx_cutvariantitem(gxVARIANT list, int flags, int id, const wchar_t *name, int ix, gxVARIANT *target);

/* Returns the index of a variant element located in a list type variant. */
inline int gx_findvariantitem(gxVARIANT list, gxVARIANT item, int flags, int *ix);

/* Adds an item to a list type variant. */
inline int gx_addvariantitem(gxVARIANT list, int flags, int id, const wchar_t *name, int ix, gxVARIANT item);

/* Creates a new variant and appends to a list type variant. */
inline int gx_createvariantitem(gxVARIANT list, int id, const wchar_t *name, GX_VARIANT_TYPES type, int size,
                                const void *data, int nitems, gxVARIANT *item);

/* Returns the data of an item in a list type variant converted to a specified type. */
inline int gx_convertvariantitem(gxVARIANT list, int id, const wchar_t *name, int ix, GX_VARIANT_TYPES type,
                                 void *target, int tgtlen, int *size, int *nitems);

/******************************************************************************
 * Work with children                                                         *
 ******************************************************************************/

/* Returns a child of a variant. */
inline int gx_getvariantchild(gxVARIANT parent, int flags, int id, const wchar_t *name, int *ix, gxVARIANT *target);
#ifdef __cplusplus
inline int gx_getvariantchild(gxVARIANT parent, int flags, int id, const wchar_t *name, int ix, gxVARIANT *target);
#endif

/* Cuts and returns a child of a variant. */
inline int gx_cutvariantchild(gxVARIANT parent, int flags, int id, const wchar_t *name, int ix, gxVARIANT *target);

/* Returns the index of a child element located in a variant's children list. */
inline int gx_findvariantchild(gxVARIANT parent, gxVARIANT child, int flags, int *ix);

/* Adds a child element to a variant. */
inline int gx_addvariantchild(gxVARIANT parent, int flags, int id, const wchar_t *name, int ix, gxVARIANT child);

/* Creates a new variant and appends it to a variant as a child. */
inline int gx_createvariantchild(gxVARIANT parent, int id, const wchar_t *name, GX_VARIANT_TYPES type, int size,
                                 const void *data, int nitems, gxVARIANT *child);

/* Returns the data of a variant's child converted to a specified type. */
inline int gx_convertvariantchild(gxVARIANT parent, int id, const wchar_t *name, int ix, GX_VARIANT_TYPES type,
                                  void *target, int tgtlen, int *size, int *nitems);

/******************************************************************************
 * Work with arrays                                                           *
 ******************************************************************************/

/* Returns a part of an array variant's data. */
inline int gx_getvariantvalue(gxVARIANT varray, int size, GX_VARIANT_TYPES type, int ix, int nitems,
                              void *target, int tgtlen);

/* Cuts and returns a part of an array variant's data. */
inline int gx_cutvariantvalue(gxVARIANT varray, int size, GX_VARIANT_TYPES type, int ix, int nitems,
                              void *target, int tgtlen);

/* Inserts one or more values into an array variant's data. */
inline int gx_addvariantvalue(gxVARIANT varray, int size, GX_VARIANT_TYPES type, int ix, int nitems,
                              const void *data);

/******************************************************************************
 * Work with descendant variants                                              *
 ******************************************************************************/

/* Returns a variant from a variant tree. */
inline int gx_getvariantbypath(gxVARIANT root, const wchar_t *path, gxVARIANT *item);

/* Returns the data of a variant located in a variant tree converted to a specified type. */
inline int gx_convertvariantbypath(gxVARIANT root, const wchar_t *path, GX_VARIANT_TYPES type, void *target,
                                   int tgtlen, int *size, int *nitems);

#endif /* GX_MANUAL */

enum GX_VARIANT_FLAGS
{
    GX_VARIANT_BY_INDEX             = 0x0002,   
    GX_VARIANT_BY_ID                = 0x0001,   
    GX_VARIANT_BY_INDEX_AND_ID      = 0x0003,   
    GX_VARIANT_BY_ORDER_AND_ID      = 0x0004,   
    GX_VARIANT_BY_NAME              = 0x0008,   
    GX_VARIANT_BY_INDEX_AND_NAME    = 0x000a,   
    GX_VARIANT_BY_ORDER_AND_NAME    = 0x0010,   
    GX_VARIANT_APPEND               = 0x0100,   
    GX_VARIANT_LAST                 = 0x0200,   
};

/******************************************************************************
 * This is the end of the gxvariant interface. Now the implementation follows *
 ******************************************************************************/
#ifdef __BORLANDC__
    #pragma warn -rch
#endif
/******************************************************************************/
#endif /* GX_VARIANT_CPT_INCL */

#ifndef GX_MANUAL

#ifndef GX_VARIANT_CPT_INCL

/* GX call codes */
enum GX_CALL_VARIANT_CODES
{
    GX_CALL_REFVARIANT          = GX_CALL_GROUP_VARIANT,
    GX_CALL_UNREFVARIANT        = GX_CALL_GROUP_VARIANT+1,
    GX_CALL_CREATEVARIANT       = GX_CALL_GROUP_VARIANT+3,
    GX_CALL_DUPLICATEVARIANT    = GX_CALL_GROUP_VARIANT+4,
    GX_CALL_UPDATEVARIANT       = GX_CALL_GROUP_VARIANT+5,
    GX_CALL_UPDATEVARIANTDATA   = GX_CALL_GROUP_VARIANT+6,
    GX_CALL_GETVARIANT          = GX_CALL_GROUP_VARIANT+7,
    GX_CALL_CONVERTVARIANT      = GX_CALL_GROUP_VARIANT+8,

    GX_CALL_GETVARIANTITEM      = GX_CALL_GROUP_VARIANT+9,
    GX_CALL_CUTVARIANTITEM      = GX_CALL_GROUP_VARIANT+10,
    GX_CALL_FINDVARIANTITEM     = GX_CALL_GROUP_VARIANT+11,
    GX_CALL_ADDVARIANTITEM      = GX_CALL_GROUP_VARIANT+12,
    GX_CALL_REMOVEVARIANTITEM   = GX_CALL_GROUP_VARIANT+13,

    GX_CALL_GETVARIANTCHILD     = GX_CALL_GROUP_VARIANT+14,
    GX_CALL_CUTVARIANTCHILD     = GX_CALL_GROUP_VARIANT+15,
    GX_CALL_FINDVARIANTCHILD    = GX_CALL_GROUP_VARIANT+16,
    GX_CALL_ADDVARIANTCHILD     = GX_CALL_GROUP_VARIANT+17,
    GX_CALL_REMOVEVARIANTCHILD  = GX_CALL_GROUP_VARIANT+18,

    GX_CALL_GETVARIANTVALUE     = GX_CALL_GROUP_VARIANT+19,
    GX_CALL_CUTVARIANTVALUE     = GX_CALL_GROUP_VARIANT+20,
    GX_CALL_ADDVARIANTVALUE     = GX_CALL_GROUP_VARIANT+22,
    GX_CALL_REMOVEVARIANTVALUE  = GX_CALL_GROUP_VARIANT+23,

    GX_CALL_GETVARIANTBYPATH        = GX_CALL_GROUP_VARIANT+24,
    GX_CALL_GETVARIANTBYPATHA       = GX_CALL_GROUP_VARIANT+25,
    GX_CALL_CONVERTVARIANTBYPATH    = GX_CALL_GROUP_VARIANT+26,
    GX_CALL_CONVERTVARIANTBYPATHA   = GX_CALL_GROUP_VARIANT+27,

    GX_CALL_UPDATEVARIANTID     = GX_CALL_GROUP_VARIANT+29,

    GX_CALL_CREATEVARIANTN      = GX_CALL_GROUP_VARIANT+30,
    GX_CALL_UPDATEVARIANTN      = GX_CALL_GROUP_VARIANT+31,
    GX_CALL_UPDATEVARIANTDATAN  = GX_CALL_GROUP_VARIANT+32,
    GX_CALL_CHANGEVARIANTNAME   = GX_CALL_GROUP_VARIANT+33,
    GX_CALL_GETVARIANTINFO      = GX_CALL_GROUP_VARIANT+34,

    GX_CALL_GETVARIANTITEMN     = GX_CALL_GROUP_VARIANT+35,
    GX_CALL_CUTVARIANTITEMN     = GX_CALL_GROUP_VARIANT+36,
    GX_CALL_FINDVARIANTITEMN    = GX_CALL_GROUP_VARIANT+37,
    GX_CALL_ADDVARIANTITEMN     = GX_CALL_GROUP_VARIANT+38,

    GX_CALL_GETVARIANTCHILDN    = GX_CALL_GROUP_VARIANT+39,
    GX_CALL_CUTVARIANTCHILDN    = GX_CALL_GROUP_VARIANT+40,
    GX_CALL_FINDVARIANTCHILDN   = GX_CALL_GROUP_VARIANT+41,
    GX_CALL_ADDVARIANTCHILDN    = GX_CALL_GROUP_VARIANT+42,
};

/******************************************************************************/

/* GX call parameter structures. */

struct GX_PARM_DUPLICATEVARIANT
{
    gxVARIANT    source;
    gxVARIANT    target;
};

#endif /* GX_VARIANT_CPT_INCL */

/* create/updatedata/changeid/changename */
struct GX_PARM_UPDATEVARIANTN
{
    gxVARIANT            variant;
    int                  id;
    const wchar_t       *name;
    GX_VARIANT_TYPES     type;
    int                  size;
    int                  nitems;
    const void          *data;
};

#ifndef GX_VARIANT_CPT_INCL

#define GX_PARM_CREATEVARIANT GX_PARM_UPDATEVARIANT

struct GX_PARM_UPDATEVARIANT
{
    gxVARIANT    variant;
    int          id;
    int          type;
    int          size;
    int          nitems;
    const void  *data;
};

#define GX_PARM_UPDATEVARIANTDATA GX_PARM_UPDATEVARIANT

struct GX_PARM_UPDATEVARIANTID
{
    gxVARIANT    variant;
    int          id;
};

#endif /* GX_VARIANT_CPT_INCL */

struct GX_PARM_GETVARIANTINFO
{
    gxVARIANT            variant;
    int                  id;
    wchar_t             *namebuff;
    int                  namebuffsize;
    GX_VARIANT_TYPES     type;
    int                  size;
    int                  nitems;
    int                  nchildren;
};

#ifndef GX_VARIANT_CPT_INCL

struct GX_PARM_GETVARIANT
{
    gxVARIANT    variant;
    int          id;
    int          type;
    int          size;
    int          nitems;
    int          nchildren;
};

struct GX_PARM_CONVERTVARIANT
{
    gxVARIANT    variant;
    int          id;
    int          type;
    int          size;
    int          nitems;
    void        *target;
    int          tgtlen;
};

#endif /* GX_VARIANT_CPT_INCL */

/* add/get/cut/find item/child */
struct GX_PARM_VARIANTITEM
{
    gxVARIANT        parent;
    int              flags;
    int              id;
    int              ix;
    const wchar_t   *name;
    gxVARIANT        item;
};

#ifndef GX_VARIANT_CPT_INCL

struct GX_PARM_GETVARIANTITEM
{
    gxVARIANT    list;
    int          flags;
    int          id;
    int          ix;
    gxVARIANT    target;
};

#define GX_PARM_CUTVARIANTITEM GX_PARM_GETVARIANTITEM

struct GX_PARM_FINDVARIANTITEM
{
    gxVARIANT    list;
    gxVARIANT    item;
    int          id;
    int          ix;
};

struct GX_PARM_ADDVARIANTITEM
{
    gxVARIANT    list;
    int          flags;
    int          id;
    int          ix;
    gxVARIANT    item;
};

struct GX_PARM_REMOVEVARIANTITEM
{
    gxVARIANT    list;
    int          flags;
    int          id;
    int          ix;
};

struct GX_PARM_GETVARIANTCHILD
{
    gxVARIANT    parent;
    int          flags;
    int          id;
    int          ix;
    gxVARIANT    target;
};

#define GX_PARM_CUTVARIANTCHILD GX_PARM_GETVARIANTCHILD

struct GX_PARM_FINDVARIANTCHILD
{
    gxVARIANT    parent;
    gxVARIANT    child;
    int          id;
    int          ix;
};

struct GX_PARM_ADDVARIANTCHILD
{
    gxVARIANT    parent;
    int          flags;
    int          id;
    int          ix;
    gxVARIANT    child;
};

struct GX_PARM_REMOVEVARIANTCHILD
{
    gxVARIANT    parent;
    int          flags;
    int          id;
    int          ix;
};

struct GX_PARM_GETVARIANTVALUE
{
    gxVARIANT    array;
    int          size;
    int          type;
    int          ix;
    int          nitems;
    void        *target;
    int          tgtlen;
};

#define GX_PARM_CUTVARIANTVALUE GX_PARM_GETVARIANTVALUE

struct GX_PARM_ADDVARIANTVALUE
{
    gxVARIANT    array;
    int          size;
    int          type;
    int          ix;
    int          nitems;
    const void  *data;
};

struct GX_PARM_REMOVEVARIANTVALUE
{
    gxVARIANT    array;
    int          ix;
    int          nitems;
};

struct GX_PARM_GETVARIANTBYPATH
{
    gxVARIANT       root;
    const wchar_t  *path;
    gxVARIANT       item;
};

struct GX_PARM_GETVARIANTBYPATHA
{
    gxVARIANT   root;
    const char *path;
    gxVARIANT   item;
};

struct GX_PARM_CONVERTVARIANTBYPATH
{
    gxVARIANT       root;
    const wchar_t  *path;
    int             id;
    int             type;
    int             size;
    int             nitems;
    void           *target;
    int             tgtlen;
};

struct GX_PARM_CONVERTVARIANTBYPATHA
{
    gxVARIANT   root;
    const char *path;
    int         id;
    int         type;
    int         size;
    int         nitems;
    void       *target;
    int         tgtlen;
};

#endif /* GX_VARIANT_CPT_INCL */

#endif /* GX_MANUAL */

#ifndef GX_VARIANT_CPT_INCL

/******************************************************************************/
inline int gx_refvariant(gxVARIANT variant)
{
    gxHANDLE nullhandle = { 0 };
    assert(variant);
    return gx_call(nullhandle, GX_CALL_REFVARIANT, variant);
}

/******************************************************************************/
inline int gx_unrefvariant(gxVARIANT variant)
{
    gxHANDLE nullhandle = { 0 };
    return gx_call(nullhandle, GX_CALL_UNREFVARIANT, variant);
}

/******************************************************************************/
inline int gx_leavevariant(gxVARIANT *variant)
{
    gxHANDLE nullhandle = { 0 };
    int st;
    assert(variant);
    st = gx_call(nullhandle, GX_CALL_UNREFVARIANT, *variant);
    if(st) {
        *variant = (gxVARIANT)0;
    }
    return st;
}

/******************************************************************************/
inline int gx_duplicatevariant(gxVARIANT *target, gxVARIANT source)
{
    gxHANDLE nullhandle = { 0 };
    struct GX_PARM_DUPLICATEVARIANT dv;
    int st;
    assert(target);
    dv.source = source;
    st = gx_call(nullhandle, GX_CALL_DUPLICATEVARIANT, &dv);
    if(st) {
        *target = dv.target;
    }
    return st;
}

#endif /* GX_VARIANT_CPT_INCL */

/******************************************************************************/
inline int gx_createvariant(gxVARIANT *variant, int id, const wchar_t *name, GX_VARIANT_TYPES type, int size,
                            const void *data, int nitems GX_DEFARG(1))
{
    gxHANDLE nullhandle = { 0 };
    struct GX_PARM_UPDATEVARIANTN cv;
    int st;
    assert(variant);
    cv.variant = (gxVARIANT)0;
    cv.id = id;
    cv.name = name;
    cv.type = type;
    cv.size = size;
    cv.nitems = nitems;
    cv.data = data;
    st = gx_call(nullhandle, GX_CALL_CREATEVARIANTN, &cv);
    if(st) {
        *variant = cv.variant;
    }
    return st;
}

/******************************************************************************/
inline int gx_updatevariant(gxVARIANT variant, int id, const wchar_t *name, GX_VARIANT_TYPES type, int size,
                            const void *data, int nitems GX_DEFARG(1))
{
    gxHANDLE nullhandle = { 0 };
    struct GX_PARM_UPDATEVARIANTN uv;
    assert(variant);
    uv.variant = variant;
    uv.id = id;
    uv.name = name;
    uv.type = type;
    uv.size = size;
    uv.nitems = nitems;
    uv.data = data;
    return gx_call(nullhandle, GX_CALL_UPDATEVARIANTN, &uv);
}

/******************************************************************************/
inline int gx_updatevariantdata(gxVARIANT variant, GX_VARIANT_TYPES type, int size, const void *data,
                                int nitems GX_DEFARG(1))
{
    gxHANDLE nullhandle = { 0 };
    struct GX_PARM_UPDATEVARIANTN uv;
    assert(variant);
    uv.variant = variant;
    uv.type = type;
    uv.size = size;
    uv.nitems = nitems;
    uv.data = data;
    return gx_call(nullhandle, GX_CALL_UPDATEVARIANTDATAN, &uv);
}

#ifndef GX_VARIANT_CPT_INCL

/******************************************************************************/
inline int gx_changevariantid(gxVARIANT variant, int id)
{
    gxHANDLE nullhandle = { 0 };
    struct GX_PARM_UPDATEVARIANTID uv;
    assert(variant);
    uv.variant = variant;
    uv.id = id;
    return gx_call(nullhandle, GX_CALL_UPDATEVARIANTID, &uv);
}

#endif /* GX_VARIANT_CPT_INCL */

/******************************************************************************/
inline int gx_changevariantname(gxVARIANT variant, const wchar_t *name)
{
    gxHANDLE nullhandle = { 0 };
    struct GX_PARM_UPDATEVARIANTN uv;
    assert(variant);
    uv.variant = variant;
    uv.name = name;
    return gx_call(nullhandle, GX_CALL_CHANGEVARIANTNAME, &uv);
}

/******************************************************************************/
inline int gx_getvariantinfo(gxVARIANT variant, int *id, wchar_t *namebuff, int namebuffsize,
                             GX_VARIANT_TYPES *type, int *size, int *nitems, int *nchildren)
{
    gxHANDLE nullhandle = { 0 };
    struct GX_PARM_GETVARIANTINFO gv;
    int st;
    gv.variant = variant;
    gv.namebuff = namebuff;
    gv.namebuffsize = namebuffsize;
    st = gx_call(nullhandle, GX_CALL_GETVARIANTINFO, &gv);
    if(st) {
        if(id) *id = gv.id;
        if(type) *type = gv.type;
        if(size) *size = gv.size;
        if(nitems) *nitems = gv.nitems;
        if(nchildren) *nchildren = gv.nchildren;
    }
    return st;
}

/******************************************************************************/
inline int gx_convertvariant(gxVARIANT variant, GX_VARIANT_TYPES type, void *target, int tgtlen,
                              int *size GX_DEFARG(0), int *nitems GX_DEFARG(0))
{
    gxHANDLE nullhandle = { 0 };
    struct GX_PARM_CONVERTVARIANT cv;
    int st;
    assert(variant);
    cv.variant = variant;
    cv.type = type;
    cv.size = size ? *size : tgtlen;
    cv.nitems = nitems ? *nitems : 1;
    cv.target = target;
    cv.tgtlen = tgtlen;
    st = gx_call(nullhandle, GX_CALL_CONVERTVARIANT, &cv);
    if(st) {
        if(size) *size = cv.size;
        if(nitems) *nitems = cv.nitems;
    }
    return st;
}

/******************************************************************************/
inline int gx_getvariantitem(gxVARIANT list, int flags, int id, const wchar_t *name, int *ix, gxVARIANT *target)
{
    gxHANDLE nullhandle = { 0 };
    struct GX_PARM_VARIANTITEM gi;
    int st;
    assert(list && target);
    gi.parent = list;
    gi.flags = flags;
    gi.id = id;
    gi.name = name;
    gi.ix = ix ? *ix : 0;
    st = gx_call(nullhandle, GX_CALL_GETVARIANTITEMN, &gi);
    if(st) {
        if(ix) *ix = gi.ix;
        *target = gi.item;
    }
    return st;
}

#ifdef __cplusplus
/******************************************************************************/
inline int gx_getvariantitem(gxVARIANT list, int flags, int id, const wchar_t *name, int ix, gxVARIANT *target)
{
    return gx_getvariantitem(list, flags, id, name, &ix, target);
}
#endif

/******************************************************************************/
inline int gx_cutvariantitem(gxVARIANT list, int flags, int id, const wchar_t *name, int ix, gxVARIANT *target GX_DEFARG(0))
{
    gxHANDLE nullhandle = { 0 };
    struct GX_PARM_VARIANTITEM ci;
    int st;
    assert(list);
    ci.parent = list;
    ci.flags = flags;
    ci.id = id;
    ci.name = name;
    ci.ix = ix;
    st = gx_call(nullhandle, GX_CALL_CUTVARIANTITEMN, &ci);
    if(st) {
        if(target) *target = ci.item;
        else gx_leavevariant(&ci.item);
    }
    return st;
}

/******************************************************************************/
inline int gx_findvariantitem(gxVARIANT list, gxVARIANT item, int flags, int *ix)
{
    gxHANDLE nullhandle = { 0 };
    struct GX_PARM_VARIANTITEM fi;
    int st;
    assert(list && item && ix);
    fi.parent = list;
    fi.item = item;
    fi.flags = flags;
    st = gx_call(nullhandle, GX_CALL_FINDVARIANTITEMN, &fi);
    if(st) {
        *ix = fi.ix;
    }
    return st;
}

/******************************************************************************/
inline int gx_addvariantitem(gxVARIANT list, int flags, int id, const wchar_t *name, int ix, gxVARIANT item)
{
    gxHANDLE nullhandle = { 0 };
    struct GX_PARM_VARIANTITEM iv;
    assert(list && item);
    iv.parent = list;
    iv.flags = flags;
    iv.id = id;
    iv.name = name;
    iv.ix = ix;
    iv.item = item;
    return gx_call(nullhandle, GX_CALL_ADDVARIANTITEMN, &iv);
}

/******************************************************************************/
inline int gx_createvariantitem(gxVARIANT list, int id, const wchar_t *name, GX_VARIANT_TYPES type, int size,
                                const void *data, int nitems GX_DEFARG(1), gxVARIANT *item GX_DEFARG(0))
{
    gxVARIANT tmp;
    if(!item) item = &tmp;
    *item = 0;
    if(!gx_createvariant(item, id, name, type, size, data, nitems)) return 0;
    if(!gx_addvariantitem(list, GX_VARIANT_LAST, 0, 0, 0, *item)) {
        gx_pusherror();
        gx_leavevariant(item);
        gx_poperror();
        return 0;
    }
    return gx_unrefvariant(*item);
}

/******************************************************************************/
inline int gx_convertvariantitem(gxVARIANT list, int id, const wchar_t *name, int ix, GX_VARIANT_TYPES type,
                                  void *target, int tgtlen, int *size GX_DEFARG(0), int *nitems GX_DEFARG(0))
{
    gxVARIANT fval = 0;
    int st;
    assert(target && tgtlen>0);
    if(!gx_getvariantitem(list, name ? GX_VARIANT_BY_ORDER_AND_NAME : GX_VARIANT_BY_ORDER_AND_ID,
        id, name, &ix, &fval)) return 0;
    st = gx_convertvariant(fval, type, target, tgtlen, size, nitems);
    if(!st) gx_pusherror();
    gx_leavevariant(&fval);
    if(!st) gx_poperror();
    return st;
}

/******************************************************************************/
inline int gx_getvariantchild(gxVARIANT parent, int flags, int id, const wchar_t *name, int *ix, gxVARIANT *target)
{
    gxHANDLE nullhandle = { 0 };
    struct GX_PARM_VARIANTITEM gc;
    int st;
    assert(parent && target);
    gc.parent = parent;
    gc.flags = flags;
    gc.id = id;
    gc.name = name;
    gc.ix = ix ? *ix : 0;
    st = gx_call(nullhandle, GX_CALL_GETVARIANTCHILDN, &gc);
    if(st) {
        if(ix) *ix = gc.ix;
        *target = gc.item;
    }
    return st;
}

#ifdef __cplusplus
/******************************************************************************/
inline int gx_getvariantchild(gxVARIANT parent, int flags, int id, const wchar_t *name, int ix, gxVARIANT *target)
{
    return gx_getvariantchild(parent, flags, id, name, &ix, target);
}
#endif

/******************************************************************************/
inline int gx_cutvariantchild(gxVARIANT parent, int flags, int id, const wchar_t *name, int ix, gxVARIANT *target GX_DEFARG(0))
{
    gxHANDLE nullhandle = { 0 };
    struct GX_PARM_VARIANTITEM cc;
    int st;
    assert(parent);
    cc.parent = parent;
    cc.flags = flags;
    cc.id = id;
    cc.name = name;
    cc.ix = ix;
    st = gx_call(nullhandle, GX_CALL_CUTVARIANTCHILDN, &cc);
    if(st) {
        if(target) *target = cc.item;
        else gx_leavevariant(&cc.item);
    }
    return st;
}

/******************************************************************************/
inline int gx_findvariantchild(gxVARIANT parent, gxVARIANT child, int flags, int *ix)
{
    gxHANDLE nullhandle = { 0 };
    struct GX_PARM_VARIANTITEM fc;
    int st;
    assert(parent && child && ix);
    fc.parent = parent;
    fc.item = child;
    fc.flags = flags;
    st = gx_call(nullhandle, GX_CALL_FINDVARIANTCHILDN, &fc);
    if(st) {
        *ix = fc.ix;
    }
    return st;
}

/******************************************************************************/
inline int gx_addvariantchild(gxVARIANT parent, int flags, int id, const wchar_t *name, int ix, gxVARIANT child)
{
    gxHANDLE nullhandle = { 0 };
    struct GX_PARM_VARIANTITEM ic;
    assert(parent && child);
    ic.parent = parent;
    ic.flags = flags;
    ic.id = id;
    ic.name = name;
    ic.ix = ix;
    ic.item = child;
    return gx_call(nullhandle, GX_CALL_ADDVARIANTCHILDN, &ic);
}

/******************************************************************************/
inline int gx_createvariantchild(gxVARIANT parent, int id, const wchar_t *name, GX_VARIANT_TYPES type, int size,
                                  const void *data, int nitems GX_DEFARG(1), gxVARIANT *child GX_DEFARG(0))
{
    gxVARIANT tmp;
    if(!child) child = &tmp;
    *child = 0;
    if(!gx_createvariant(child, id, name, type, size, data, nitems)) return 0;
    if(!gx_addvariantchild(parent, GX_VARIANT_LAST, 0, 0, 0, *child)) {
        gx_pusherror();
        gx_leavevariant(child);
        gx_poperror();
        return 0;
    }
    return gx_unrefvariant(*child);
}

/******************************************************************************/
inline int gx_convertvariantchild(gxVARIANT parent, int id, const wchar_t *name, int ix, GX_VARIANT_TYPES type,
                                  void *target, int tgtlen, int *size GX_DEFARG(0), int *nitems GX_DEFARG(0))
{
    gxVARIANT fval = 0;
    int st;
    assert(target && tgtlen>0);
    if(!gx_getvariantchild(parent, name ? GX_VARIANT_BY_ORDER_AND_NAME : GX_VARIANT_BY_ORDER_AND_ID,
        id, name, &ix, &fval)) return 0;
    st = gx_convertvariant(fval, type, target, tgtlen, size, nitems);
    if(!st) gx_pusherror();
    gx_leavevariant(&fval);
    if(!st) gx_poperror();
    return st;
}

#ifndef GX_VARIANT_CPT_INCL

/******************************************************************************/
inline int gx_getvariantvalue(gxVARIANT varray, int size, GX_VARIANT_TYPES type, int ix, int nitems,
                              void *target, int tgtlen)
{
    gxHANDLE nullhandle = { 0 };
    struct GX_PARM_GETVARIANTVALUE gv;
    assert(varray);
    gv.array = varray;
    gv.size = size;
    gv.type = type;
    gv.ix = ix;
    gv.nitems = nitems;
    gv.target = target;
    gv.tgtlen = tgtlen;
    return gx_call(nullhandle, GX_CALL_GETVARIANTVALUE, &gv);
}

/******************************************************************************/
inline int gx_cutvariantvalue(gxVARIANT varray, int size, GX_VARIANT_TYPES type, int ix, int nitems,
                              void *target GX_DEFARG(0), int tgtlen GX_DEFARG(0))
{
    gxHANDLE nullhandle = { 0 };
    struct GX_PARM_CUTVARIANTVALUE gv;
    assert(varray);
    gv.array = varray;
    gv.size = size;
    gv.type = type;
    gv.ix = ix;
    gv.nitems = nitems;
    gv.target = target;
    gv.tgtlen = tgtlen;
    return gx_call(nullhandle, GX_CALL_CUTVARIANTVALUE, &gv);
}

/******************************************************************************/
inline int gx_addvariantvalue(gxVARIANT varray, int size, GX_VARIANT_TYPES type, int ix, int nitems,
                              const void *data)
{
    gxHANDLE nullhandle = { 0 };
    struct GX_PARM_ADDVARIANTVALUE av;
    assert(varray);
    av.array = varray;
    av.size = size;
    av.type = type;
    av.ix = ix;
    av.nitems = nitems;
    av.data = data;
    return gx_call(nullhandle, GX_CALL_ADDVARIANTVALUE, &av);
}

#endif /* GX_VARIANT_CPT_INCL */

#ifndef GX_VARIANT_CPT_INCL

/******************************************************************************/
inline int gx_getvariantbypath(gxVARIANT root, const wchar_t *path, gxVARIANT *item)
{
    gxHANDLE nullhandle = { 0 };
    struct GX_PARM_GETVARIANTBYPATH gp;
    int st;
    assert(root && item);
    gp.root = root;
    gp.path = path;
    st = gx_call(nullhandle, GX_CALL_GETVARIANTBYPATH, &gp);
    if(st) {
        *item = gp.item;
    }
    return st;
}

#endif /* GX_VARIANT_CPT_INCL */

/******************************************************************************/
inline int gx_convertvariantbypath(gxVARIANT root, const wchar_t *path, GX_VARIANT_TYPES type, void *target,
                                   int tgtlen, int *size GX_DEFARG(0), int *nitems GX_DEFARG(0))
{
    gxVARIANT fval = 0;
    int st;
    assert(target && tgtlen>0);
    if(!gx_getvariantbypath(root, path, &fval)) return 0;
    st = gx_convertvariant(fval, type, target, tgtlen, size, nitems);
    if(!st) gx_pusherror();
    gx_leavevariant(&fval);
    if(!st) gx_poperror();
    return st;
}

/******************************************************************************/
#ifdef GX_NAMESPACES
    }   /* namespace */
#endif
#ifdef __BORLANDC__
    #pragma warn .rch
#endif
/******************************************************************************/
#endif /* GX_VARIANT_INCL */

---

Generated  for GX
(c) ARH Inc.