dvdatabase.c

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

{
    dvModpath nextModpath = dvModpathGetNextRootModpath(prevModpath);

#if defined(DD_DEBUG)
    if(Root == dvRootNull) {
        utExit("Non-existent Root");
    }
    if(_Modpath == dvModpathNull) {
        utExit("Non-existent Modpath");
    }
    if(dvModpathGetRoot(_Modpath) != dvRootNull) {
        utExit("Attempting to add dv to Root twice");
    }
#endif
    dvModpathSetNextRootModpath(_Modpath, nextModpath);
    dvModpathSetNextRootModpath(prevModpath, _Modpath);
    dvModpathSetPrevRootModpath(_Modpath, prevModpath);
    if(nextModpath != dvModpathNull) {
        dvModpathSetPrevRootModpath(nextModpath, _Modpath);
    }
    if(dvRootGetLastModpath(Root) == prevModpath) {
        dvRootSetLastModpath(Root, _Modpath);
    }
    dvModpathSetRoot(_Modpath, Root);
    if(dvModpathGetSym(_Modpath) != utSymNull) {
        addRootModpathToHashTable(Root, _Modpath);
    }
}

/*----------------------------------------------------------------------------------------
 Remove the Modpath from the Root.
----------------------------------------------------------------------------------------*/
void dvRootRemoveModpath(
    dvRoot Root,
    dvModpath _Modpath)
{
    dvModpath pModpath, nModpath;

#if defined(DD_DEBUG)
    if(_Modpath == dvModpathNull) {
        utExit("Non-existent Modpath");
    }
    if(dvModpathGetRoot(_Modpath) != dvRootNull && dvModpathGetRoot(_Modpath) != Root) {
        utExit("Delete Modpath from non-owning Root");
    }
#endif
    nModpath = dvModpathGetNextRootModpath(_Modpath);
    pModpath = dvModpathGetPrevRootModpath(_Modpath);
    if(pModpath != dvModpathNull) {
        dvModpathSetNextRootModpath(pModpath, nModpath);
    } else if(dvRootGetFirstModpath(Root) == _Modpath) {
        dvRootSetFirstModpath(Root, nModpath);
    }
    if(nModpath != dvModpathNull) {
        dvModpathSetPrevRootModpath(nModpath, pModpath);
    } else if(dvRootGetLastModpath(Root) == _Modpath) {
        dvRootSetLastModpath(Root, pModpath);
    }
    dvModpathSetNextRootModpath(_Modpath, dvModpathNull);
    dvModpathSetPrevRootModpath(_Modpath, dvModpathNull);
    dvModpathSetRoot(_Modpath, dvRootNull);
    if(dvModpathGetSym(_Modpath) != utSymNull) {
        removeRootModpathFromHashTable(Root, _Modpath);
    }
}

static void addRootModuleToHashTable(dvRoot Root, dvModule _Module);
/*----------------------------------------------------------------------------------------
  Increase the size of the hash table.
----------------------------------------------------------------------------------------*/
static void resizeRootModuleHashTable(
    dvRoot Root)
{
    dvModule _Module;
    dvModule *Modules;
    uint32 numModules = dvRootGetNumModuleTable(Root) << 1;

    if(numModules == 0) {
        numModules = 2;
        dvRootAllocModuleTables(Root, 2);
    } else {
        dvRootResizeModuleTables(Root, numModules);
    }
    Modules = dvRootGetModuleTables(Root);
    /* Zero out the table */
    while(numModules-- != 0) {
        *Modules++ = dvModuleNull;
    }
    dvRootSetNumModule(Root, 0);
    dvForeachRootModule(Root, _Module) {
        if(dvModuleGetSym(_Module) != utSymNull) {
            addRootModuleToHashTable(Root, _Module);
        }
    } dvEndForeachRootModule;
}

/*----------------------------------------------------------------------------------------
  Add an  to the Root.  If the table is near full, build a new one twice
  as big, delete the old one, and return the new one.
----------------------------------------------------------------------------------------*/
static void addRootModuleToHashTable(
    dvRoot Root,
    dvModule _Module)
{
    dvModule nextModule;
    uint32 index;

    if(dvRootGetNumModule(Root) >= dvRootGetNumModuleTable(Root)) {
        resizeRootModuleHashTable(Root);
        return;
    }
    index = (dvRootGetNumModuleTable(Root) - 1) & utSymGetHashValue(dvModuleGetSym(_Module));
    nextModule = dvRootGetiModuleTable(Root, index);
    dvModuleSetNextTableRootModule(_Module, nextModule);
    dvRootSetiModuleTable(Root, index, _Module);
    dvRootSetNumModule(Root, dvRootGetNumModule(Root) + 1);
}

/*----------------------------------------------------------------------------------------
  Remove the Module from the hash table.
----------------------------------------------------------------------------------------*/
static void removeRootModuleFromHashTable(
   dvRoot Root,
   dvModule _Module)
{
    uint32 index = (dvRootGetNumModuleTable(Root) - 1) & utSymGetHashValue(dvModuleGetSym(_Module));
    dvModule prevModule, nextModule;
    
    nextModule = dvRootGetiModuleTable(Root, index);
    if(nextModule == _Module) {
        dvRootSetiModuleTable(Root, index, dvModuleGetNextTableRootModule(nextModule));
    } else {
        do {
            prevModule = nextModule;
            nextModule = dvModuleGetNextTableRootModule(nextModule);
        } while(nextModule != _Module);
        dvModuleSetNextTableRootModule(prevModule, dvModuleGetNextTableRootModule(_Module));
    }
    dvRootSetNumModule(Root, dvRootGetNumModule(Root) - 1);
    dvModuleSetNextTableRootModule(_Module, dvModuleNull);
}

/*----------------------------------------------------------------------------------------
  Find the Module from the Root and its name.
----------------------------------------------------------------------------------------*/
dvModule dvRootFindModule(
    dvRoot Root,
    utSym sym)
{
    uint32 mask = dvRootGetNumModuleTable(Root) - 1;
    dvModule _Module;

    if(mask + 1 != 0) {
        _Module = dvRootGetiModuleTable(Root, utSymGetHashValue(sym) & mask);
        while(_Module != dvModuleNull) {
            if(dvModuleGetSym(_Module) == sym) {
                return _Module;
            }
            _Module = dvModuleGetNextTableRootModule(_Module);
        }
    }
    return dvModuleNull;
}

/*----------------------------------------------------------------------------------------
  Find the Module from the Root and its name.
----------------------------------------------------------------------------------------*/
void dvRootRenameModule(
    dvRoot Root,
    dvModule _Module,
    utSym sym)
{
    if(dvModuleGetSym(_Module) != utSymNull) {
        removeRootModuleFromHashTable(Root, _Module);
    }
    dvModuleSetSym(_Module, sym);
    if(sym != utSymNull) {
        addRootModuleToHashTable(Root, _Module);
    }
}

/*----------------------------------------------------------------------------------------
  Add the Module to the head of the list on the Root.
----------------------------------------------------------------------------------------*/
void dvRootInsertModule(
    dvRoot Root,
    dvModule _Module)
{
#if defined(DD_DEBUG)
    if(Root == dvRootNull) {
        utExit("Non-existent Root");
    }
    if(_Module == dvModuleNull) {
        utExit("Non-existent Module");
    }
#endif
    dvModuleSetNextRootModule(_Module, dvRootGetFirstModule(Root));
    if(dvRootGetFirstModule(Root) != dvModuleNull) {
        dvModuleSetPrevRootModule(dvRootGetFirstModule(Root), _Module);
    }
    dvRootSetFirstModule(Root, _Module);
    dvModuleSetPrevRootModule(_Module, dvModuleNull);
    if(dvRootGetLastModule(Root) == dvModuleNull) {
        dvRootSetLastModule(Root, _Module);
    }
    if(dvModuleGetSym(_Module) != utSymNull) {
        addRootModuleToHashTable(Root, _Module);
    }
}

/*----------------------------------------------------------------------------------------
  Add the Module to the end of the list on the Root.
----------------------------------------------------------------------------------------*/
void dvRootAppendModule(
    dvRoot Root,
    dvModule _Module)
{
#if defined(DD_DEBUG)
    if(Root == dvRootNull) {
        utExit("Non-existent Root");
    }
    if(_Module == dvModuleNull) {
        utExit("Non-existent Module");
    }
#endif
    dvModuleSetPrevRootModule(_Module, dvRootGetLastModule(Root));
    if(dvRootGetLastModule(Root) != dvModuleNull) {
        dvModuleSetNextRootModule(dvRootGetLastModule(Root), _Module);
    }
    dvRootSetLastModule(Root, _Module);
    dvModuleSetNextRootModule(_Module, dvModuleNull);
    if(dvRootGetFirstModule(Root) == dvModuleNull) {
        dvRootSetFirstModule(Root, _Module);
    }
    if(dvModuleGetSym(_Module) != utSymNull) {
        addRootModuleToHashTable(Root, _Module);
    }
}

/*----------------------------------------------------------------------------------------
  Insert the Module to the Root after the previous Module.
----------------------------------------------------------------------------------------*/
void dvRootInsertAfterModule(
    dvRoot Root,
    dvModule prevModule,
    dvModule _Module)
{
    dvModule nextModule = dvModuleGetNextRootModule(prevModule);

#if defined(DD_DEBUG)
    if(Root == dvRootNull) {
        utExit("Non-existent Root");
    }
    if(_Module == dvModuleNull) {
        utExit("Non-existent Module");
    }
#endif
    dvModuleSetNextRootModule(_Module, nextModule);
    dvModuleSetNextRootModule(prevModule, _Module);
    dvModuleSetPrevRootModule(_Module, prevModule);
    if(nextModule != dvModuleNull) {
        dvModuleSetPrevRootModule(nextModule, _Module);
    }
    if(dvRootGetLastModule(Root) == prevModule) {
        dvRootSetLastModule(Root, _Module);
    }
    if(dvModuleGetSym(_Module) != utSymNull) {
        addRootModuleToHashTable(Root, _Module);
    }
}

/*----------------------------------------------------------------------------------------
 Remove the Module from the Root.
----------------------------------------------------------------------------------------*/
void dvRootRemoveModule(
    dvRoot Root,
    dvModule _Module)
{
    dvModule pModule, nModule;

#if defined(DD_DEBUG)
    if(_Module == dvModuleNull) {
        utExit("Non-existent Module");
    }
#endif
    nModule = dvModuleGetNextRootModule(_Module);
    pModule = dvModuleGetPrevRootModule(_Module);
    if(pModule != dvModuleNull) {
        dvModuleSetNextRootModule(pModule, nModule);
    } else if(dvRootGetFirstModule(Root) == _Module) {
        dvRootSetFirstModule(Root, nModule);
    }
    if(nModule != dvModuleNull) {
        dvModuleSetPrevRootModule(nModule, pModule);
    } else if(dvRootGetLastModule(Root) == _Module) {
        dvRootSetLastModule(Root, pModule);
    }
    dvModuleSetNextRootModule(_Module, dvModuleNull);
    dvModuleSetPrevRootModule(_Module, dvModuleNull);
    if(dvModuleGetSym(_Module) != utSymNull) {
        removeRootModuleFromHashTable(Root, _Module);
    }
}

#if defined(DD_DEBUG)
/*----------------------------------------------------------------------------------------
  Write out all the fields of an object.
----------------------------------------------------------------------------------------*/
void dvShowRoot(
    dvRoot Root)
{
    utDatabaseShowObject("dv", "Root", dvRoot2Index(Root));
}
#endif

/*----------------------------------------------------------------------------------------
  Default constructor wrapper for the database manager.
----------------------------------------------------------------------------------------*/
static uint64 allocModpath(void)
{
    dvModpath Modpath = dvModpathAlloc();