ddutil.h

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

void utLogMessage(char *format, ...);
void utLogString(char *format, ...);
char *utGetCompileTime(void);
char *utCompileTime(void);
char *utGetDateAndTime(void);
bool utDebug(char *format,... );
void utLogError(char *format, ...);
void utLogTimeStamp(char *message, ...);
uint32 utStartTimer(char *message, ...);
void utStopTimer(uint32 timerID, char *message, ...);
void utStatus(char *format, ...);
void utExit_ (char *format, ...);
typedef void(*utExitProcType)(char *format, ...);
utExitProcType utSetFileAndLineAndReturnExitFunc(char *fileName, uint32 lineNum);
#define utExit utSetFileAndLineAndReturnExitFunc(__FILE__, __LINE__)
void utWarning(char *format, ...);
void utNote(char *format, ...);
uint32 utError(char *format, ...);
/* Log a message to the log file and exit if false is passed. */
void utAssert_(char *fileName, uint32 line, char *text);
#define utAssert(assertion) ((void)(utLikely(assertion) || (utAssert_(__FILE__, __LINE__, #assertion), 0)))
void utSetErrorCallback(utErrorProc errorProc);
void utSetWarningCallback(utErrorProc warningProc);
void utSetStatusCallback(utErrorProc statusProc);
void utInitLogFile(char *fileName);
void utSetLogFile(char *fileName);
char *utGetLogFileName(void);
#define utIfDebug(minVal) if(utUnlikely(utDebugVal >= minVal))
#define utIfVerbose(minVal) if(utUnlikely(utVerboseVal >= minVal))

#define UT_MAX_SETJMP_DEPTH 5
#if defined(_WINDOWS) && !defined(_WIN32)
#if !defined(CATCHBUF)
typedef int CATCHBUF[9];
#endif
extern CATCHBUF utCatchBuf[UT_MAX_SETJMP_DEPTH];
#else
extern jmp_buf utJmpBuf[UT_MAX_SETJMP_DEPTH];
#endif

/*--------------------------------------------------------------------------------------------------
  Macros for computing simple hashed signatures.
--------------------------------------------------------------------------------------------------*/
extern uint32 utHashValue;
#define utStartHash() (utHashValue = 0)
#define utHashChar(c) (utHashValue = (utHashValue ^ (char)(c))*1103515245 + 12345)
#define utHashBool(value) (utHashValue = (utHashValue ^ (bool)(value))*1103515245 + 12345)
#define utHashUint8(value) (utHashValue = (utHashValue ^ (uint8)(value))*1103515245 + 12345)
#define utHashUint16(value) (utHashValue = (utHashValue ^ (uint16)(value))*1103515245 + 12345)
#define utHashUint32(value) (utHashValue = (utHashValue ^ (uint32)(value))*1103515245 + 12345)
#define utHashSym(sym) (utHashValue = (utHashValue ^ utSymGetHashValue(sym))*1103515245 + 12345)

/*--------------------------------------------------------------------------------------------------
  Setjmp/longjmp stack.
--------------------------------------------------------------------------------------------------*/
extern int16 utSetjmpDepth;
extern uint32 utSetjmpLine[UT_MAX_SETJMP_DEPTH];
extern char *utSetjmpFile[UT_MAX_SETJMP_DEPTH];
#define utUnsetjmp() (utSetjmpDepth--,\
      !strcmp(utSetjmpFile[utSetjmpDepth],__FILE__) ||\
      (utExit("Mismatched utUnsetjmp in file %s, line %u", __FILE__, __LINE__), 1))
#define utSetjmp() (++utSetjmpDepth,\
      utSetjmpFile[utSetjmpDepth - 1] = __FILE__,\
      utSetjmpLine[utSetjmpDepth - 1] = __LINE__,\
      setjmp(utJmpBuf[utSetjmpDepth - 1]))
void utLongjmp(void);

/*--------------------------------------------------------------------------------------------------
  Functions supporting database persistence.
--------------------------------------------------------------------------------------------------*/
typedef enum {
    UT_BIT,
    UT_BOOL,
    UT_INT,
    UT_UINT,
    UT_CHAR,
    UT_FLOAT,
    UT_DOUBLE,
    UT_POINTER,
    UT_TYPEDEF,
    UT_ENUM,
    UT_SYM,
    UT_UNION
} utFieldType;

/* These are used by DataDraw to manage the database, and can generally be ignored */
uint8 utRegisterModule(char *prefix, uint32 hashValue, uint16 numClasses, uint16 numFields,
    uint16 numEnums, uint16 globalSize, void *globalData, void (*start)(void), void (*stop)(void));
void utUnregisterModule(uint8 moduleID);
void utRegisterClass(char *name, uint16 numFields, void *numUsedPtr, void *numAllocatedPtr,
    void *firstFreePtr, uint16 nextFreeFieldIndex, uint8 referenceSize,
    uint64 (*constructor)(void), void (*destructor)(uint64 objectIndex));
void utRegisterField(char *name, void *arrayPtr, uint32 size, utFieldType type,
    char *destName);
void utSetFieldHidden(void);
void utRegisterArray(uint32 *numUsedPtr, uint32 *numAllocatedPtr,
    void *(*getValues)(uint64 objectNumber, uint32 *numValues),
    void *(*allocValues)(uint64 objectNumber, uint32 numValues));
void utRegisterEnum(char *name, uint16 numEntries);
void utRegisterEntry(char *name, uint32 value);
void utRegisterUnion(char *switchFieldName, uint16 numCases);
void utRegisterUnionCase(uint32 value, utFieldType type, uint32 size);
void utRecordField(uint8 moduleID, uint16 fieldIndex, uint64 objectNumber, bool undo);
void utRecordArray(uint8 moduleID, uint16 fieldIndex, uint32 dataIndex, uint32 length, bool undo);
void utRecordGlobal(uint8 moduleID, uint8 numBytes, void *location, bool undo);
void utRecordResize(uint8 moduleID, uint16 fieldIndex, uint64 length, bool undo);
void utAllocPersistenceObjects(void);
void utFreePersistenceObjects(void);
void utInitSymTable(void);
void utDatabaseManagerStart(void);
void utDatabaseManagerStop(void);

/* These are the useful functions */
bool utStartPersistence(char *directory, bool useTextDatabaseFormat, bool keepBackup);
void utStopPersistence(void);
uint32 utUndo(uint32 numChanges);
uint32 utRedo(uint32 numChanges);
void utStartUndoRedo(void);
void utStopUndoRedo(void);
void utTransactionComplete(bool flushToDisk);
void utLoadBinaryDatabase(FILE *file);
void utSaveBinaryDatabase(FILE *file);
void utLoadTextDatabase(FILE *file);
void utSaveTextDatabase(FILE *file);
void utManager(void);
void utDatabaseShowObject(char *modulePrefix, char *className, uint64 objectNumber);
void utResetDatabase(void);
void utCompactDatabase(void);

/* Some dynamic array stuff */
#ifdef DD_DEBUG
/* this double-evaluates and might cause side-effects */
#define utDynarrayGetiValueType(Dynarray, type, x) (utAssert((uint32)(x) < utDynarrayGetSize( \
    Dynarray)), ((type *)(utDynarrayGetValues(Dynarray)))[x])
#define utDynarraySetiValueType(Dynarray, type, x, Value) (utAssert((uint32)(x) < \
    utDynarrayGetSize(Dynarray)), ((type *)(utDynarrayGetValues(Dynarray)))[x] = (Value))
#else
#define utDynarrayGetiValueType(Dynarray, type, x) (((type *)(utDynarrayGetValues(Dynarray)))[x])
#define utDynarraySetiValueType(Dynarray, type, x, Value) \
    (((type *)utDynarrayGetValues(Dynarray))[x] = (Value))
#endif
utDynarray utDynarrayCreate_(uint16 valueSize);
#define utDynarrayCreate(type) utDynarrayCreate_(sizeof(type))
void utDynarrayResize(utDynarray dynarray, uint32 newSize);
#define utDynarrayAppendValue(dynarray, type, value) \
    (utDynarrayGetUsedValue(dynarray) == utDynarrayGetSize(dynarray) && \
    (utDynarrayResize((dynarray), 1 + utDynarrayGetSize(dynarray) + \
    (utDynarrayGetSize(dynarray) >> 1)), true),\
    utDynarraySetiValueType(dynarray, type, utDynarrayGetUsedValue(dynarray), (value)),\
    utDynarraySetUsedValue(dynarray, utDynarrayGetUsedValue(dynarray) + 1))
#define utForeachDynarrayValue(dynarray, type, value) \
{\
    uint32 _xValue;\
    for(_xValue = 0; _xValue < utDynarrayGetUsedValue(dynarray); _xValue++) {\
        (value) = utDynarrayGetiValueType((dynarray), type, _xValue);
#define utEndForeachDynarrayValue }}
#define utDynarrayCopy(destDynarray, sourceDynarray, type) { \
    uint32 _xValue; \
    if (utDynarrayGetSize(destDynarray) < utDynarrayGetSize(sourceDynarray)) { \
        utDynarrayResize(destDynarray, utDynarrayGetSize(sourceDynarray)); \
    } \
    utDynarraySetUsedValue(destDynarray, utDynarrayGetUsedValue(sourceDynarray)); \
    for(_xValue = 0; _xValue < utDynarrayGetUsedValue(sourceDynarray); _xValue++) { \
        utDynarraySetiValueType((destDynarray), type, _xValue, \
            utDynarrayGetiValueType((sourceDynarray), type, _xValue)); \
    } \
}

#if __cplusplus
}
#endif

#endif