clCorSimpleApi.h

#ifndef CL_COR_SIMPLE_API_H
#define CL_COR_SIMPLE_API_H

#include <clCorApi.h>
#include <clCorServiceId.h>
#include <clMemGroup.h>

typedef struct ClCorObjectReference
{
   ClCorObjectHandleT objHandle;
   ClCorMOIdT moId;
   /*
    * maybe something extra that I am not aware of: like txn session
ID, etc.
    */
} ClCorObjectReferenceT;

#define clFieldOffset(_type,_field) ((ClUint32T)(ClWordT)&(((_type*) 0)->_field))
#define clField(_type,_field) ((ClUint32T)(ClWordT)&(((_type*) 0)->_field)), sizeof((((_type*) 0)->_field))

typedef ClCorObjectReferenceT* ClCorHandleT;

typedef enum ClCorObjectFlags
{
   CL_COR_OBJECT_CREATE,
} ClCorObjectFlagsT;



typedef struct ClCor2CEntry
{
    ClCorAttrIdT attrId;
    ClUint32T    offset;
    ClUint32T    length;
    
} ClCor2CEntryT;

typedef struct ClCor2C
{
    ClUint32T     length;
    ClCor2CEntryT* itemDef;    
} ClCor2CT;

typedef struct ClCorTree
{
    ClMemGroupT  allocated;
    ClOsalMutexT mutex;
    ClWordT      nodeSize;    
} ClCorTreeT;

typedef struct ClCorTreeNode
{
    struct ClCorTreeNode* sib;
    struct ClCorTreeNode* child;
    struct ClCorTreeNode* parent;
} ClCorTreeNodeT;

typedef struct ClCorObjectTreeNode
{
    ClCorTreeNodeT      cmn;
    
    ClNameT             name;    
    ClPtrT*             value;
    ClWordT             size;
    ClCorTypeT          type;
    ClCorAttrTypeT      ordinality;    
} ClCorObjectTreeNodeT;

typedef struct ClCorClassTreeNode
{
    ClCorTreeNodeT      cmn;
    ClNameT             name;
} ClCorClassTreeNodeT;

typedef struct ClCorObjectTree
{
    ClCorTreeT            cmn;
    ClCorObjectTreeNodeT* root;    
} ClCorObjectTreeT;

typedef struct ClCorClassTree
{
    ClCorTreeT            cmn;
    ClCorClassTreeNodeT* root;    
} ClCorClassTreeT;


ClCorObjectReferenceT *clCorObjRefGet(const ClCharT *name,ClCorServiceIdT type);

void clCorObjRefRelease(ClCorObjectReferenceT *ref);

ClRcT clCorOpen(const ClCharT *name, ClCorObjectFlagsT flags, ClCorHandleT *fd);

ClRcT clCorHandleRelease(ClCorHandleT hdl);

ClRcT clCorDelete(const ClCharT *name);

ClRcT clCorCreate(const ClCharT *name,void* myObj, ClCor2CT* objDef, ClCorHandleT *fd);

ClRcT clCorSetPrimary(const ClCharT *name, ClBoolT val);

ClRcT clCorSetPrimaryByMoid(void* moId, ClBoolT state);

ClRcT clCorRead(const ClCharT *name,void* myObj, ClCor2CT* objDef);

ClRcT clCorReadByMoid(void* MoId, void* myObj, ClCor2CT* objDef);

ClCorAttributeValueListT* clCorGetAttValueList(void* myObj,ClCor2CT* objDef);
void clCorReleaseAttValueList(ClCorAttributeValueListT* obj);


ClCorAttrValueDescriptorListT* clCorGetAttValueDescList(void* myObj,ClCor2CT* objDef,ClCorJobStatusT* jobStatus);
void clCorReleaseAttValueDescList(ClCorAttrValueDescriptorListT* obj);

void clCorTreeNodeInit(ClCorTreeNodeT* obj);


void clCorTreeInit(ClCorTreeT* obj,ClWordT nSize);

void clCorTreeDelete(ClCorTreeT* obj);

void clCorObjectTreeInit(ClCorObjectTreeT* obj);

void clCorObjectTreeDelete(ClCorObjectTreeT* obj);

void clCorClassTreeInit(ClCorClassTreeT* obj);

void clCorClassTreeDelete(ClCorClassTreeT* obj);


void clCorObjectTreeNodeInit(ClCorObjectTreeNodeT* obj);
void clCorClassTreeNodeInit(ClCorClassTreeNodeT* obj);

ClCorObjectTreeNodeT* clCorObjectTreeNewNode(ClCorObjectTreeT* tree);

ClCorClassTreeNodeT* clCorClassTreeNewNode(ClCorClassTreeT* tree);

void clCorClassTreePrint(ClCorClassTreeT* tree);

void clCorObjectTreePrint(ClCorObjectTreeT* tree);

ClRcT clCorClassTreeFill(ClCorClassTreeT* tree);

ClRcT clCorObjectTreeFill(ClCorObjectTreeT* tree);

/* internal functions (not really independently useful) */
ClCorObjectTreeNodeT* clCorObjectTreeNodeFindSib(ClCorObjectTreeNodeT* sib,char* str,int len);
ClCorClassTreeNodeT* clCorClassTreeNodeFindSib(ClCorClassTreeNodeT* sib,char* str,int len);

void clCorObjectTreeNodePrint(ClCorObjectTreeNodeT* node,ClWordT indent);
void clCorClassTreeNodePrint(ClCorClassTreeNodeT* node,ClWordT indent);

#endif