dvdatabase.h

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

    dvModuleSetNextTableRootModule(dvTemp_.Module, dvModuleNull), \
    dvModuleSetFirstClass(dvTemp_.Module, dvClassNull), \
    dvModuleSetLastClass(dvTemp_.Module, dvClassNull), \
    dvModuleSetClassTableIndex(dvTemp_.Module, 0), \
    dvModuleSetNumClassTable(dvTemp_.Module, 0), \
    dvModuleSetNumClassTable(dvTemp_.Module, 0), \
    dvModuleSetNumClass(dvTemp_.Module, 0), \
    dvModuleSetFirstEnum(dvTemp_.Module, dvEnumNull), \
    dvModuleSetLastEnum(dvTemp_.Module, dvEnumNull), \
    dvModuleSetEnumTableIndex(dvTemp_.Module, 0), \
    dvModuleSetNumEnumTable(dvTemp_.Module, 0), \
    dvModuleSetNumEnumTable(dvTemp_.Module, 0), \
    dvModuleSetNumEnum(dvTemp_.Module, 0), \
    dvModuleSetFirstTypedef(dvTemp_.Module, dvTypedefNull), \
    dvModuleSetLastTypedef(dvTemp_.Module, dvTypedefNull), \
    dvModuleSetTypedefTableIndex(dvTemp_.Module, 0), \
    dvModuleSetNumTypedefTable(dvTemp_.Module, 0), \
    dvModuleSetNumTypedefTable(dvTemp_.Module, 0), \
    dvModuleSetNumTypedef(dvTemp_.Module, 0), \
    dvModuleSetFirstSchema(dvTemp_.Module, dvSchemaNull), \
    dvModuleSetLastSchema(dvTemp_.Module, dvSchemaNull), \
    dvModuleSetSchemaTableIndex(dvTemp_.Module, 0), \
    dvModuleSetNumSchemaTable(dvTemp_.Module, 0), \
    dvModuleSetNumSchemaTable(dvTemp_.Module, 0), \
    dvModuleSetNumSchema(dvTemp_.Module, 0), \
    dvModuleSetFirstImportLink(dvTemp_.Module, dvLinkNull), \
    dvModuleSetLastImportLink(dvTemp_.Module, dvLinkNull), \
    dvModuleSetFirstExportLink(dvTemp_.Module, dvLinkNull), \
    dvModuleSetLastExportLink(dvTemp_.Module, dvLinkNull), \
    dvModuleConstructorCallback != NULL && (dvModuleConstructorCallback(dvTemp_.Module), true), \
    dvTemp_.Module)

void dvModuleAllocMore(void);
void dvModuleAllocClassTables(dvModule Module, uint32 numClassTables);
void dvModuleResizeClassTables(dvModule Module, uint32 numClassTables);
void dvModuleFreeClassTables(dvModule Module);
void dvCompactModuleClassTables(void);
void dvModuleAllocEnumTables(dvModule Module, uint32 numEnumTables);
void dvModuleResizeEnumTables(dvModule Module, uint32 numEnumTables);
void dvModuleFreeEnumTables(dvModule Module);
void dvCompactModuleEnumTables(void);
void dvModuleAllocTypedefTables(dvModule Module, uint32 numTypedefTables);
void dvModuleResizeTypedefTables(dvModule Module, uint32 numTypedefTables);
void dvModuleFreeTypedefTables(dvModule Module);
void dvCompactModuleTypedefTables(void);
void dvModuleAllocSchemaTables(dvModule Module, uint32 numSchemaTables);
void dvModuleResizeSchemaTables(dvModule Module, uint32 numSchemaTables);
void dvModuleFreeSchemaTables(dvModule Module);
void dvCompactModuleSchemaTables(void);
void dvModuleInsertClass(dvModule Module, dvClass _Class);
void dvModuleRemoveClass(dvModule Module, dvClass _Class);
void dvModuleInsertAfterClass(dvModule Module, dvClass prevClass, dvClass _Class);
void dvModuleAppendClass(dvModule Module, dvClass _Class);
void dvModuleInsertEnum(dvModule Module, dvEnum _Enum);
void dvModuleRemoveEnum(dvModule Module, dvEnum _Enum);
void dvModuleInsertAfterEnum(dvModule Module, dvEnum prevEnum, dvEnum _Enum);
void dvModuleAppendEnum(dvModule Module, dvEnum _Enum);
void dvModuleInsertTypedef(dvModule Module, dvTypedef _Typedef);
void dvModuleRemoveTypedef(dvModule Module, dvTypedef _Typedef);
void dvModuleInsertAfterTypedef(dvModule Module, dvTypedef prevTypedef, dvTypedef _Typedef);
void dvModuleAppendTypedef(dvModule Module, dvTypedef _Typedef);
void dvModuleInsertSchema(dvModule Module, dvSchema _Schema);
void dvModuleRemoveSchema(dvModule Module, dvSchema _Schema);
void dvModuleInsertAfterSchema(dvModule Module, dvSchema prevSchema, dvSchema _Schema);
void dvModuleAppendSchema(dvModule Module, dvSchema _Schema);
void dvModuleInsertImportLink(dvModule Module, dvLink _Link);
void dvModuleRemoveImportLink(dvModule Module, dvLink _Link);
void dvModuleInsertAfterImportLink(dvModule Module, dvLink prevLink, dvLink _Link);
void dvModuleAppendImportLink(dvModule Module, dvLink _Link);
void dvModuleInsertExportLink(dvModule Module, dvLink _Link);
void dvModuleRemoveExportLink(dvModule Module, dvLink _Link);
void dvModuleInsertAfterExportLink(dvModule Module, dvLink prevLink, dvLink _Link);
void dvModuleAppendExportLink(dvModule Module, dvLink _Link);

/*----------------------------------------------------------------------------------------
  Fields for class Link.
----------------------------------------------------------------------------------------*/
struct dvLinkFields {
    dvModule *ImportModule;
    dvLink *NextModuleImportLink;
    dvModule *ExportModule;
    dvLink *NextModuleExportLink;
};
extern struct dvLinkFields dvLinks;

#define dvLinkGetImportModule(_Link) (dvLinks.ImportModule[dvLink2ValidIndex(_Link)])
#define dvLinkSetImportModule(_Link, value) ((dvLinks.ImportModule)[dvLink2ValidIndex(_Link)] = (value))
#define dvLinkGetNextModuleImportLink(_Link) (dvLinks.NextModuleImportLink[dvLink2ValidIndex(_Link)])
#define dvLinkSetNextModuleImportLink(_Link, value) ((dvLinks.NextModuleImportLink)[dvLink2ValidIndex(_Link)] = (value))
#define dvLinkGetExportModule(_Link) (dvLinks.ExportModule[dvLink2ValidIndex(_Link)])
#define dvLinkSetExportModule(_Link, value) ((dvLinks.ExportModule)[dvLink2ValidIndex(_Link)] = (value))
#define dvLinkGetNextModuleExportLink(_Link) (dvLinks.NextModuleExportLink[dvLink2ValidIndex(_Link)])
#define dvLinkSetNextModuleExportLink(_Link, value) ((dvLinks.NextModuleExportLink)[dvLink2ValidIndex(_Link)] = (value))
#define dvLinkSetConstructorCallback(func) (dvLinkConstructorCallback = (func))
#define dvLinkGetConstructorCallback() (dvLinkConstructorCallback)
#define dvFirstLink() (dvRootData.usedLink == 0? dvLinkNull : dvIndex2Link(0))
#define dvLastLink() (dvRootData.usedLink == 0? dvLinkNull : \
    dvIndex2Link(dvRootData.usedLink - 1))
#define dvNextLink(Link) (dvLink2ValidIndex(Link) + 1 == dvRootData.usedLink? dvLinkNull : \
    (Link) + 1)
#define dvPrevLink(Link) (dvLink2ValidIndex(Link) == 0? dvLinkNull : (Link) - 1)
#define dvForeachLink(var) \
    for(var = dvIndex2Link(0); dvLink2Index(var) != dvRootData.usedLink; var++)
#define dvEndForeachLink
#define dvLinkFreeAll() (dvSetUsedLink(0))
#define dvLinkAllocRaw() ( \
    dvRootData.usedLink == dvRootData.allocatedLink && (dvLinkAllocMore(), true), \
    dvTemp_.Link = dvIndex2Link(dvRootData.usedLink), \
    dvSetUsedLink(dvUsedLink() + 1), \
    dvTemp_.Link)
#define dvLinkAlloc() ( \
    dvRootData.usedLink == dvRootData.allocatedLink && (dvLinkAllocMore(), true), \
    dvTemp_.Link = dvIndex2Link(dvRootData.usedLink), \
    dvSetUsedLink(dvUsedLink() + 1), \
    dvLinkSetImportModule(dvTemp_.Link, dvModuleNull), \
    dvLinkSetNextModuleImportLink(dvTemp_.Link, dvLinkNull), \
    dvLinkSetExportModule(dvTemp_.Link, dvModuleNull), \
    dvLinkSetNextModuleExportLink(dvTemp_.Link, dvLinkNull), \
    dvLinkConstructorCallback != NULL && (dvLinkConstructorCallback(dvTemp_.Link), true), \
    dvTemp_.Link)

void dvLinkAllocMore(void);

/*----------------------------------------------------------------------------------------
  Fields for class Schema.
----------------------------------------------------------------------------------------*/
struct dvSchemaFields {
    dvModule *Module;
    dvSchema *NextModuleSchema;
    dvSchema *PrevModuleSchema;
    utSym *Sym;
    dvSchema *NextTableModuleSchema;
    dvClass *FirstClass;
    dvClass *LastClass;
};
extern struct dvSchemaFields dvSchemas;

#define dvSchemaGetModule(_Schema) (dvSchemas.Module[dvSchema2ValidIndex(_Schema)])
#define dvSchemaSetModule(_Schema, value) ((dvSchemas.Module)[dvSchema2ValidIndex(_Schema)] = (value))
#define dvSchemaGetNextModuleSchema(_Schema) (dvSchemas.NextModuleSchema[dvSchema2ValidIndex(_Schema)])
#define dvSchemaSetNextModuleSchema(_Schema, value) ((dvSchemas.NextModuleSchema)[dvSchema2ValidIndex(_Schema)] = (value))
#define dvSchemaGetPrevModuleSchema(_Schema) (dvSchemas.PrevModuleSchema[dvSchema2ValidIndex(_Schema)])
#define dvSchemaSetPrevModuleSchema(_Schema, value) ((dvSchemas.PrevModuleSchema)[dvSchema2ValidIndex(_Schema)] = (value))
#define dvSchemaGetSym(_Schema) (dvSchemas.Sym[dvSchema2ValidIndex(_Schema)])
#define dvSchemaSetSym(_Schema, value) ((dvSchemas.Sym)[dvSchema2ValidIndex(_Schema)] = (value))
#define dvSchemaGetNextTableModuleSchema(_Schema) (dvSchemas.NextTableModuleSchema[dvSchema2ValidIndex(_Schema)])
#define dvSchemaSetNextTableModuleSchema(_Schema, value) ((dvSchemas.NextTableModuleSchema)[dvSchema2ValidIndex(_Schema)] = (value))
#define dvSchemaGetFirstClass(_Schema) (dvSchemas.FirstClass[dvSchema2ValidIndex(_Schema)])
#define dvSchemaSetFirstClass(_Schema, value) ((dvSchemas.FirstClass)[dvSchema2ValidIndex(_Schema)] = (value))
#define dvSchemaGetLastClass(_Schema) (dvSchemas.LastClass[dvSchema2ValidIndex(_Schema)])
#define dvSchemaSetLastClass(_Schema, value) ((dvSchemas.LastClass)[dvSchema2ValidIndex(_Schema)] = (value))
#define dvForeachSchemaClass(pVar, cVar) \
    for(cVar = dvSchemaGetFirstClass(pVar); cVar != dvClassNull; \
        cVar = dvClassGetNextSchemaClass(cVar))
#define dvEndForeachSchemaClass
#define dvSafeForeachSchemaClass(pVar, cVar) { \
    dvClass _nextClass; \
    for(cVar = dvSchemaGetFirstClass(pVar); cVar != dvClassNull; cVar = _nextClass) { \
        _nextClass = dvClassGetNextSchemaClass(cVar);
#define dvEndSafeForeachSchemaClass }}
#define dvSchemaSetConstructorCallback(func) (dvSchemaConstructorCallback = (func))
#define dvSchemaGetConstructorCallback() (dvSchemaConstructorCallback)
#define dvFirstSchema() (dvRootData.usedSchema == 0? dvSchemaNull : dvIndex2Schema(0))
#define dvLastSchema() (dvRootData.usedSchema == 0? dvSchemaNull : \
    dvIndex2Schema(dvRootData.usedSchema - 1))
#define dvNextSchema(Schema) (dvSchema2ValidIndex(Schema) + 1 == dvRootData.usedSchema? dvSchemaNull : \
    (Schema) + 1)
#define dvPrevSchema(Schema) (dvSchema2ValidIndex(Schema) == 0? dvSchemaNull : (Schema) - 1)
#define dvForeachSchema(var) \
    for(var = dvIndex2Schema(0); dvSchema2Index(var) != dvRootData.usedSchema; var++)
#define dvEndForeachSchema
#define dvSchemaFreeAll() (dvSetUsedSchema(0))
#define dvSchemaAllocRaw() ( \
    dvRootData.usedSchema == dvRootData.allocatedSchema && (dvSchemaAllocMore(), true), \
    dvTemp_.Schema = dvIndex2Schema(dvRootData.usedSchema), \
    dvSetUsedSchema(dvUsedSchema() + 1), \
    dvTemp_.Schema)
#define dvSchemaAlloc() ( \
    dvRootData.usedSchema == dvRootData.allocatedSchema && (dvSchemaAllocMore(), true), \
    dvTemp_.Schema = dvIndex2Schema(dvRootData.usedSchema), \
    dvSetUsedSchema(dvUsedSchema() + 1), \
    dvSchemaSetModule(dvTemp_.Schema, dvModuleNull), \
    dvSchemaSetNextModuleSchema(dvTemp_.Schema, dvSchemaNull), \
    dvSchemaSetPrevModuleSchema(dvTemp_.Schema, dvSchemaNull), \
    dvSchemaSetSym(dvTemp_.Schema, 0), \
    dvSchemaSetNextTableModuleSchema(dvTemp_.Schema, dvSchemaNull), \
    dvSchemaSetFirstClass(dvTemp_.Schema, dvClassNull), \
    dvSchemaSetLastClass(dvTemp_.Schema, dvClassNull), \
    dvSchemaConstructorCallback != NULL && (dvSchemaConstructorCallback(dvTemp_.Schema), true), \
    dvTemp_.Schema)

void dvSchemaAllocMore(void);
void dvSchemaInsertClass(dvSchema Schema, dvClass _Class);
void dvSchemaRemoveClass(dvSchema Schema, dvClass _Class);
void dvSchemaInsertAfterClass(dvSchema Schema, dvClass prevClass, dvClass _Class);
void dvSchemaAppendClass(dvSchema Schema, dvClass _Class);

/*----------------------------------------------------------------------------------------
  Fields for class Enum.
----------------------------------------------------------------------------------------*/
struct dvEnumFields {
    utSym *PrefixSym;
    uint16 *NumEntries;
    dvModule *Module;
    dvEnum *NextModuleEnum;
    dvEnum *PrevModuleEnum;
    utSym *Sym;
    dvEnum *NextTableModuleEnum;
    dvEntry *FirstEntry;
    dvEntry *LastEntry;
    uint32 *EntryTableIndex;
    uint32 *NumEntryTable;
    dvEntry *EntryTable;
    uint32 *NumEntry;
};
extern struct dvEnumFields dvEnums;

#define dvEnumGetPrefixSym(_Enum) (dvEnums.PrefixSym[dvEnum2ValidIndex(_Enum)])
#define dvEnumSetPrefixSym(_Enum, value) ((dvEnums.PrefixSym)[dvEnum2ValidIndex(_Enum)] = (value))
#define dvEnumGetNumEntries(_Enum) (dvEnums.NumEntries[dvEnum2ValidIndex(_Enum)])
#define dvEnumSetNumEntries(_Enum, value) ((dvEnums.NumEntries)[dvEnum2ValidIndex(_Enum)] = (value))
#define dvEnumGetModule(_Enum) (dvEnums.Module[dvEnum2ValidIndex(_Enum)])
#define dvEnumSetModule(_Enum, value) ((dvEnums.Module)[dvEnum2ValidIndex(_Enum)] = (value))
#define dvEnumGetNextModuleEnum(_Enum) (dvEnums.NextModuleEnum[dvEnum2ValidIndex(_Enum)])
#define dvEnumSetNextModuleEnum(_Enum, value) ((dvEnums.NextModuleEnum)[dvEnum2ValidIndex(_Enum)] = (value))
#define dvEnumGetPrevModuleEnum(_Enum) (dvEnums.PrevModuleEnum[dvEnum2ValidIndex(_Enum)])
#define dvEnumSetPrevModuleEnum(_Enum, value) ((dvEnums.PrevModuleEnum)[dvEnum2ValidIndex(_Enum)] = (value))
#define dvEnumGetSym(_Enum) (dvEnums.Sym[dvEnum2ValidIndex(_Enum)])
#define dvEnumSetSym(_Enum, value) ((dvEnums.Sym)[dvEnum2ValidIndex(_Enum)] = (value))
#define dvEnumGetNextTableModuleEnum(_Enum) (dvEnums.NextTableModuleEnum[dvEnum2ValidIndex(_Enum)])