dvdatabase.h

DataDraw is an ultra-fast persistent database for high performance programs written in C. It s so fa

struct dvRootFields {
    dvModpath *FirstModpath;
    dvModpath *LastModpath;
    uint32 *ModpathTableIndex;
    uint32 *NumModpathTable;
    dvModpath *ModpathTable;
    uint32 *NumModpath;
    dvModule *FirstModule;
    dvModule *LastModule;
    uint32 *ModuleTableIndex;
    uint32 *NumModuleTable;
    dvModule *ModuleTable;
    uint32 *NumModule;
};
extern struct dvRootFields dvRoots;

#define dvRootGetFirstModpath(_Root) (dvRoots.FirstModpath[dvRoot2ValidIndex(_Root)])
#define dvRootSetFirstModpath(_Root, value) ((dvRoots.FirstModpath)[dvRoot2ValidIndex(_Root)] = (value))
#define dvRootGetLastModpath(_Root) (dvRoots.LastModpath[dvRoot2ValidIndex(_Root)])
#define dvRootSetLastModpath(_Root, value) ((dvRoots.LastModpath)[dvRoot2ValidIndex(_Root)] = (value))
#define dvRootGetModpathTableIndex(_Root) (dvRoots.ModpathTableIndex[dvRoot2ValidIndex(_Root)])
#define dvRootSetModpathTableIndex(_Root, value) ((dvRoots.ModpathTableIndex)[dvRoot2ValidIndex(_Root)] = (value))
#define dvRootGetNumModpathTable(_Root) (dvRoots.NumModpathTable[dvRoot2ValidIndex(_Root)])
#define dvRootSetNumModpathTable(_Root, value) ((dvRoots.NumModpathTable)[dvRoot2ValidIndex(_Root)] = (value))
#if defined(DD_DEBUG)
#define dvRootCheckModpathTableIndex(Root, x) ((uint32)(x) < dvRootGetNumModpathTable(Root)? (x) : \
    (utAssert(false),(x)))
#else
#define dvRootCheckModpathTableIndex(Root, x) (x)
#endif
#define dvRootGetiModpathTable(_Root, x) ((dvRoots.ModpathTable)[ \
    dvRootGetModpathTableIndex(_Root) + dvRootCheckModpathTableIndex(_Root, (x))])
#define dvRootGetModpathTables(Root) (dvRoots.ModpathTable + dvRootGetModpathTableIndex(Root))
#define dvRootSetModpathTable(Root, valuePtr) (memcpy(dvRootGetModpathTables(Root), valuePtr, \
    dvRootGetNumModpathTable(Root)*sizeof(dvModpath)))
#define dvRootSetiModpathTable(Root, x, value) ((dvRoots.ModpathTable)[ \
    dvRootGetModpathTableIndex(Root) + dvRootCheckModpathTableIndex(Root, (x))] = (value))
#define dvRootGetNumModpath(_Root) (dvRoots.NumModpath[dvRoot2ValidIndex(_Root)])
#define dvRootSetNumModpath(_Root, value) ((dvRoots.NumModpath)[dvRoot2ValidIndex(_Root)] = (value))
#define dvRootGetFirstModule(_Root) (dvRoots.FirstModule[dvRoot2ValidIndex(_Root)])
#define dvRootSetFirstModule(_Root, value) ((dvRoots.FirstModule)[dvRoot2ValidIndex(_Root)] = (value))
#define dvRootGetLastModule(_Root) (dvRoots.LastModule[dvRoot2ValidIndex(_Root)])
#define dvRootSetLastModule(_Root, value) ((dvRoots.LastModule)[dvRoot2ValidIndex(_Root)] = (value))
#define dvRootGetModuleTableIndex(_Root) (dvRoots.ModuleTableIndex[dvRoot2ValidIndex(_Root)])
#define dvRootSetModuleTableIndex(_Root, value) ((dvRoots.ModuleTableIndex)[dvRoot2ValidIndex(_Root)] = (value))
#define dvRootGetNumModuleTable(_Root) (dvRoots.NumModuleTable[dvRoot2ValidIndex(_Root)])
#define dvRootSetNumModuleTable(_Root, value) ((dvRoots.NumModuleTable)[dvRoot2ValidIndex(_Root)] = (value))
#if defined(DD_DEBUG)
#define dvRootCheckModuleTableIndex(Root, x) ((uint32)(x) < dvRootGetNumModuleTable(Root)? (x) : \
    (utAssert(false),(x)))
#else
#define dvRootCheckModuleTableIndex(Root, x) (x)
#endif
#define dvRootGetiModuleTable(_Root, x) ((dvRoots.ModuleTable)[ \
    dvRootGetModuleTableIndex(_Root) + dvRootCheckModuleTableIndex(_Root, (x))])
#define dvRootGetModuleTables(Root) (dvRoots.ModuleTable + dvRootGetModuleTableIndex(Root))
#define dvRootSetModuleTable(Root, valuePtr) (memcpy(dvRootGetModuleTables(Root), valuePtr, \
    dvRootGetNumModuleTable(Root)*sizeof(dvModule)))
#define dvRootSetiModuleTable(Root, x, value) ((dvRoots.ModuleTable)[ \
    dvRootGetModuleTableIndex(Root) + dvRootCheckModuleTableIndex(Root, (x))] = (value))
#define dvRootGetNumModule(_Root) (dvRoots.NumModule[dvRoot2ValidIndex(_Root)])
#define dvRootSetNumModule(_Root, value) ((dvRoots.NumModule)[dvRoot2ValidIndex(_Root)] = (value))
dvModpath dvRootFindModpath(dvRoot Root, utSym sym);
void dvRootRenameModpath(dvRoot Root, dvModpath _Modpath, utSym sym);
#define dvModpathGetName(Modpath) utSymGetName(dvModpathGetSym(Modpath))
#define dvForeachRootModpath(pVar, cVar) \
    for(cVar = dvRootGetFirstModpath(pVar); cVar != dvModpathNull; \
        cVar = dvModpathGetNextRootModpath(cVar))
#define dvEndForeachRootModpath
#define dvSafeForeachRootModpath(pVar, cVar) { \
    dvModpath _nextModpath; \
    for(cVar = dvRootGetFirstModpath(pVar); cVar != dvModpathNull; cVar = _nextModpath) { \
        _nextModpath = dvModpathGetNextRootModpath(cVar);
#define dvEndSafeForeachRootModpath }}
dvModule dvRootFindModule(dvRoot Root, utSym sym);
void dvRootRenameModule(dvRoot Root, dvModule _Module, utSym sym);
#define dvModuleGetName(Module) utSymGetName(dvModuleGetSym(Module))
#define dvForeachRootModule(pVar, cVar) \
    for(cVar = dvRootGetFirstModule(pVar); cVar != dvModuleNull; \
        cVar = dvModuleGetNextRootModule(cVar))
#define dvEndForeachRootModule
#define dvSafeForeachRootModule(pVar, cVar) { \
    dvModule _nextModule; \
    for(cVar = dvRootGetFirstModule(pVar); cVar != dvModuleNull; cVar = _nextModule) { \
        _nextModule = dvModuleGetNextRootModule(cVar);
#define dvEndSafeForeachRootModule }}
#define dvRootSetConstructorCallback(func) (dvRootConstructorCallback = (func))
#define dvRootGetConstructorCallback() (dvRootConstructorCallback)
#define dvFirstRoot() (dvRootData.usedRoot == 0? dvRootNull : dvIndex2Root(0))
#define dvLastRoot() (dvRootData.usedRoot == 0? dvRootNull : \
    dvIndex2Root(dvRootData.usedRoot - 1))
#define dvNextRoot(Root) (dvRoot2ValidIndex(Root) + 1 == dvRootData.usedRoot? dvRootNull : \
    (Root) + 1)
#define dvPrevRoot(Root) (dvRoot2ValidIndex(Root) == 0? dvRootNull : (Root) - 1)
#define dvForeachRoot(var) \
    for(var = dvIndex2Root(0); dvRoot2Index(var) != dvRootData.usedRoot; var++)
#define dvEndForeachRoot
#define dvRootFreeAll() (dvSetUsedRoot(0), dvSetUsedRootModpathTable(0), dvSetUsedRootModuleTable(0))
#define dvRootAllocRaw() ( \
    dvRootData.usedRoot == dvRootData.allocatedRoot && (dvRootAllocMore(), true), \
    dvTemp_.Root = dvIndex2Root(dvRootData.usedRoot), \
    dvSetUsedRoot(dvUsedRoot() + 1), \
    dvTemp_.Root)
#define dvRootAlloc() ( \
    dvRootData.usedRoot == dvRootData.allocatedRoot && (dvRootAllocMore(), true), \
    dvTemp_.Root = dvIndex2Root(dvRootData.usedRoot), \
    dvSetUsedRoot(dvUsedRoot() + 1), \
    dvRootSetFirstModpath(dvTemp_.Root, dvModpathNull), \
    dvRootSetLastModpath(dvTemp_.Root, dvModpathNull), \
    dvRootSetModpathTableIndex(dvTemp_.Root, 0), \
    dvRootSetNumModpathTable(dvTemp_.Root, 0), \
    dvRootSetNumModpathTable(dvTemp_.Root, 0), \
    dvRootSetNumModpath(dvTemp_.Root, 0), \
    dvRootSetFirstModule(dvTemp_.Root, dvModuleNull), \
    dvRootSetLastModule(dvTemp_.Root, dvModuleNull), \
    dvRootSetModuleTableIndex(dvTemp_.Root, 0), \
    dvRootSetNumModuleTable(dvTemp_.Root, 0), \
    dvRootSetNumModuleTable(dvTemp_.Root, 0), \
    dvRootSetNumModule(dvTemp_.Root, 0), \
    dvRootConstructorCallback != NULL && (dvRootConstructorCallback(dvTemp_.Root), true), \
    dvTemp_.Root)

void dvRootAllocMore(void);
void dvRootAllocModpathTables(dvRoot Root, uint32 numModpathTables);
void dvRootResizeModpathTables(dvRoot Root, uint32 numModpathTables);
void dvRootFreeModpathTables(dvRoot Root);
void dvCompactRootModpathTables(void);
void dvRootAllocModuleTables(dvRoot Root, uint32 numModuleTables);
void dvRootResizeModuleTables(dvRoot Root, uint32 numModuleTables);
void dvRootFreeModuleTables(dvRoot Root);
void dvCompactRootModuleTables(void);
void dvRootInsertModpath(dvRoot Root, dvModpath _Modpath);
void dvRootRemoveModpath(dvRoot Root, dvModpath _Modpath);
void dvRootInsertAfterModpath(dvRoot Root, dvModpath prevModpath, dvModpath _Modpath);
void dvRootAppendModpath(dvRoot Root, dvModpath _Modpath);
void dvRootInsertModule(dvRoot Root, dvModule _Module);
void dvRootRemoveModule(dvRoot Root, dvModule _Module);
void dvRootInsertAfterModule(dvRoot Root, dvModule prevModule, dvModule _Module);
void dvRootAppendModule(dvRoot Root, dvModule _Module);

/*----------------------------------------------------------------------------------------
  Fields for class Modpath.
----------------------------------------------------------------------------------------*/
struct dvModpathFields {
    dvRoot *Root;
    dvModpath *NextRootModpath;
    dvModpath *PrevRootModpath;
    utSym *Sym;
    dvModpath *NextTableRootModpath;
};
extern struct dvModpathFields dvModpaths;

#define dvModpathGetRoot(_Modpath) (dvModpaths.Root[dvModpath2ValidIndex(_Modpath)])
#define dvModpathSetRoot(_Modpath, value) ((dvModpaths.Root)[dvModpath2ValidIndex(_Modpath)] = (value))
#define dvModpathGetNextRootModpath(_Modpath) (dvModpaths.NextRootModpath[dvModpath2ValidIndex(_Modpath)])
#define dvModpathSetNextRootModpath(_Modpath, value) ((dvModpaths.NextRootModpath)[dvModpath2ValidIndex(_Modpath)] = (value))
#define dvModpathGetPrevRootModpath(_Modpath) (dvModpaths.PrevRootModpath[dvModpath2ValidIndex(_Modpath)])
#define dvModpathSetPrevRootModpath(_Modpath, value) ((dvModpaths.PrevRootModpath)[dvModpath2ValidIndex(_Modpath)] = (value))
#define dvModpathGetSym(_Modpath) (dvModpaths.Sym[dvModpath2ValidIndex(_Modpath)])
#define dvModpathSetSym(_Modpath, value) ((dvModpaths.Sym)[dvModpath2ValidIndex(_Modpath)] = (value))
#define dvModpathGetNextTableRootModpath(_Modpath) (dvModpaths.NextTableRootModpath[dvModpath2ValidIndex(_Modpath)])
#define dvModpathSetNextTableRootModpath(_Modpath, value) ((dvModpaths.NextTableRootModpath)[dvModpath2ValidIndex(_Modpath)] = (value))
#define dvModpathSetConstructorCallback(func) (dvModpathConstructorCallback = (func))
#define dvModpathGetConstructorCallback() (dvModpathConstructorCallback)
#define dvFirstModpath() (dvRootData.usedModpath == 0? dvModpathNull : dvIndex2Modpath(0))
#define dvLastModpath() (dvRootData.usedModpath == 0? dvModpathNull : \
    dvIndex2Modpath(dvRootData.usedModpath - 1))
#define dvNextModpath(Modpath) (dvModpath2ValidIndex(Modpath) + 1 == dvRootData.usedModpath? dvModpathNull : \
    (Modpath) + 1)
#define dvPrevModpath(Modpath) (dvModpath2ValidIndex(Modpath) == 0? dvModpathNull : (Modpath) - 1)
#define dvForeachModpath(var) \
    for(var = dvIndex2Modpath(0); dvModpath2Index(var) != dvRootData.usedModpath; var++)
#define dvEndForeachModpath
#define dvModpathFreeAll() (dvSetUsedModpath(0))
#define dvModpathAllocRaw() ( \
    dvRootData.usedModpath == dvRootData.allocatedModpath && (dvModpathAllocMore(), true), \
    dvTemp_.Modpath = dvIndex2Modpath(dvRootData.usedModpath), \
    dvSetUsedModpath(dvUsedModpath() + 1), \
    dvTemp_.Modpath)
#define dvModpathAlloc() ( \
    dvRootData.usedModpath == dvRootData.allocatedModpath && (dvModpathAllocMore(), true), \
    dvTemp_.Modpath = dvIndex2Modpath(dvRootData.usedModpath), \
    dvSetUsedModpath(dvUsedModpath() + 1), \
    dvModpathSetRoot(dvTemp_.Modpath, dvRootNull), \
    dvModpathSetNextRootModpath(dvTemp_.Modpath, dvModpathNull), \
    dvModpathSetPrevRootModpath(dvTemp_.Modpath, dvModpathNull), \
    dvModpathSetSym(dvTemp_.Modpath, 0), \
    dvModpathSetNextTableRootModpath(dvTemp_.Modpath, dvModpathNull), \
    dvModpathConstructorCallback != NULL && (dvModpathConstructorCallback(dvTemp_.Modpath), true), \
    dvTemp_.Modpath)

void dvModpathAllocMore(void);

/*----------------------------------------------------------------------------------------
  Fields for class Module.
----------------------------------------------------------------------------------------*/
struct dvModuleFields {
    utSym *PrefixSym;
    uint8 *Persistent;
    uint8 *UndoRedo;
    uint16 *NumFields;
    uint32 *NumClasses;
    uint32 *NumEnums;
    dvModule *NextRootModule;
    dvModule *PrevRootModule;
    utSym *Sym;
    dvModule *NextTableRootModule;
    dvClass *FirstClass;
    dvClass *LastClass;
    uint32 *ClassTableIndex;
    uint32 *NumClassTable;
    dvClass *ClassTable;
    uint32 *NumClass;
    dvEnum *FirstEnum;
    dvEnum *LastEnum;
    uint32 *EnumTableIndex;
    uint32 *NumEnumTable;
    dvEnum *EnumTable;
    uint32 *NumEnum;
    dvTypedef *FirstTypedef;
    dvTypedef *LastTypedef;
    uint32 *TypedefTableIndex;
    uint32 *NumTypedefTable;
    dvTypedef *TypedefTable;
    uint32 *NumTypedef;
    dvSchema *FirstSchema;
    dvSchema *LastSchema;
    uint32 *SchemaTableIndex;
    uint32 *NumSchemaTable;
    dvSchema *SchemaTable;