mlUtilsAPI.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_UTILS_API_H
#define ML_UTILS_API_H
 
 
// Attention: All includes must be pure C!
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifndef ML_DISABLE_CPP
#define ML_DISABLE_CPP
#endif
 
#include "mlUtilsSystemC.h"
 
//--------------------------------------------------------------------------------------------
//
//
//--------------------------------------------------------------------------------------------
 
extern ML_UTILS_EXPORT const char*  MLTerminatorStrings[MLNumTerminators];
 
ML_UTILS_EXPORT const char*         MLGetErrorCodeDescription(MLErrorCode errCode);
 
[[nodiscard]]
ML_UTILS_EXPORT MLErrorCode         MLAddNewErrorCodeDescription(const char* errorString);
 
[[nodiscard]]
ML_UTILS_EXPORT MLErrorCode         MLFindErrorCodeDescription(const char* errorString);
 
ML_UTILS_EXPORT MLuint32            MLGetNumErrorCodes();
 
ML_UTILS_EXPORT const char* const* MLGetErrorCodeDescriptionTable();
 
 
//-----------------------------------------------------------------------------------
//
//
//-----------------------------------------------------------------------------------
 
ML_UTILS_EXPORT MLint32             MLInitializeUtils();
 
ML_UTILS_EXPORT MLint32             MLIsUtilsInitialized();
 
ML_UTILS_EXPORT MLint32             MLUtilsDestroy();
 
 
//-----------------------------------------------------------------------------------
//
//
//-----------------------------------------------------------------------------------
 
ML_UTILS_EXPORT MLuint32            MLGetCheckBitMask();
 
ML_UTILS_EXPORT void                MLSetCheckBitMask(MLuint32 bitMask);
 
 
 
//-----------------------------------------------------------------------------------
//
//
//-----------------------------------------------------------------------------------
 
ML_UTILS_EXPORT MLint32             MLIsMultithreadingActive();
 
ML_UTILS_EXPORT void                _MLSetMultithreadingActive(MLint32 isActive);
 
 
//-----------------------------------------------------------------------------------
//
//
//-----------------------------------------------------------------------------------
 
ML_UTILS_EXPORT MLThreadId MLGetCurrentThreadID();
 
ML_UTILS_EXPORT MLint32    MLIsCurrentThreadMainThread();
 
ML_UTILS_EXPORT MLThreadId MLGetMainThreadID();
 
ML_UTILS_EXPORT void       MLSetMainThreadID(MLThreadId threadId);
 
ML_UTILS_EXPORT MLint32    MLCompareThreadIDs(const MLThreadId& id1, const MLThreadId& id2);
 
extern ML_UTILS_EXPORT MLThreadId _MLMainThreadId;
 
ML_UTILS_EXPORT void MLSetThreadName(const char* threadName);
 
 
 
//-----------------------------------------------------------------------------------
//
//
//-----------------------------------------------------------------------------------
 
ML_UTILS_EXPORT char* MLIntToStringCopy(int intValue);
 
ML_UTILS_EXPORT char* MLInt64ToStringCopy(MLint64 int64Value);
 
ML_UTILS_EXPORT char* MLDoubleToStringCopy(double doubleValue);
 
 
 
//--------------------------------------------------------------------------------------------------
//
//
//--------------------------------------------------------------------------------------------------
 
[[nodiscard]]
ML_UTILS_EXPORT void* MLAlloc(MLuint numBytes, MLMemoryErrorHandling handleFailure);
 
[[nodiscard]]
ML_UTILS_EXPORT void* MLRealloc(void* ptr, MLuint numBytes, MLMemoryErrorHandling handleFailure);
 
ML_UTILS_EXPORT void  MLFree(void* ptr);
ML_UTILS_EXPORT void  MLFreeMemoryManagerCallback(void* ptr, const size_t size, void* userData);
 
[[nodiscard]]
ML_UTILS_EXPORT void* MLMemDup(const void* src, MLuint numBytes, MLMemoryErrorHandling handleFailure);
 
[[nodiscard]]
ML_UTILS_EXPORT char* MLStrDup(const char* str, MLMemoryErrorHandling handleFailure);
 
 
 
 
 
//-----------------------------------------------------------------------------------
//
//
//-----------------------------------------------------------------------------------
//      void MLMessageCB(void* usrData,
//                       MLErrorCode errCode,
//                       MLMessageType messageType,
//                       const char* messStr,
//                       int line,
//                       const char** infos)
ML_UTILS_EXPORT void          MLSetMessageCB(void* userData, MLMessageCB* callback);
 
ML_UTILS_EXPORT void          MLGetMessageCB(void** userData, MLMessageCB** callback);
 
 
 
//-----------------------------------------------------------------------------------
//
//
//-----------------------------------------------------------------------------------
ML_UTILS_EXPORT void          MLDebugAddEnvName(const char* envName);
 
ML_UTILS_EXPORT void          MLDebugRemoveEnvName(const char* envName);
 
ML_UTILS_EXPORT MLint32       MLDebugHasEnvName(const char* envName);
 
ML_UTILS_EXPORT const char *  MLDebugGetEnvName(MLuint32 envNameIdx);
 
ML_UTILS_EXPORT void          MLDebugRemoveAllEnvNames();
 
ML_UTILS_EXPORT size_t        MLDebugGetNumEnvNames();
 
 
 
//-----------------------------------------------------------------------------------
//
//
//-----------------------------------------------------------------------------------
ML_UTILS_EXPORT void MLPrintAndNotify(MLMessageType messageType,
                                      const char*  libraryPrefix,
                                      const char*  fPrefix,
                                      const char*  functionName,
                                      const char*  reason,
                                      const char*  handling,
                                      const char*  file,
                                      int           line,
                                      MLErrorCode   errCode);
 
ML_UTILS_EXPORT void MLPrintAndNotifyFatal(const char*  file,
                                           int          line,
                                           MLErrorCode  errCode);
 
ML_UTILS_EXPORT void MLHandleDebugPrint(const char* envVar,
                                        const char* libraryPrefix,
                                        const char* outStr,
                                        const char* file,
                                        int         line);
 
 
//-----------------------------------------------------------------------------------
//
//
//-----------------------------------------------------------------------------------
ML_UTILS_EXPORT void          MLSetTerminationType(MLMessageType level, MLTerminator term);
 
ML_UTILS_EXPORT MLTerminator  MLGetTerminationType(MLMessageType level);
 
 
//-----------------------------------------------------------------------------------
//
//
//-----------------------------------------------------------------------------------
ML_UTILS_EXPORT MLErrorCode   MLEnableExceptionHandling(MLuint32 enable);
 
ML_UTILS_EXPORT MLuint32      MLIsExceptionHandlingEnabled();
 
 
//-----------------------------------------------------------------------------------
//
//
//-----------------------------------------------------------------------------------
ML_UTILS_EXPORT void          MLSetMessageFilter(MLuint32 messageTypes);
 
ML_UTILS_EXPORT MLuint32      MLGetMessageFilter();
 
 
//-----------------------------------------------------------------------------------
//
//
//-----------------------------------------------------------------------------------
ML_UTILS_EXPORT MLErrorCode   MLEnableFullDebugging(MLuint32 enable);
 
ML_UTILS_EXPORT MLuint32      MLIsFullDebuggingEnabled();
 
 
//-----------------------------------------------------------------------------------
//
//
//-----------------------------------------------------------------------------------
 
ML_UTILS_EXPORT void MLAddEventFilterCB(MLEventFilterCB* cb, void* usrData,
                                        MLuint32 fromMessageId, MLuint32 toMessageId);
 
ML_UTILS_EXPORT void MLRemoveEventFilterCB(MLEventFilterCB* cb, void* usrData);
 
 
//-----------------------------------------------------------------------------------
//
//
//-----------------------------------------------------------------------------------
 
ML_UTILS_EXPORT void MLSetApplicationPropertiesHook(MLApplicationPropertyCallbacks* callbacks);
 
ML_UTILS_EXPORT const MLApplicationPropertyCallbacks* MLGetApplicationPropertiesHook();
 
 
ML_UTILS_EXPORT void MLSetEventFilterApplicationHook(MLEventFilterApplicationHookCB* cb, void* usrData);
 
ML_UTILS_EXPORT MLEventFilterApplicationHookCB* MLGetEventFilterApplicationHookCB();
 
ML_UTILS_EXPORT void *MLGetEventFilterApplicationHookCBUserData();
 
//-----------------------------------------------------------------------------------
//
//
//-----------------------------------------------------------------------------------
 
ML_UTILS_EXPORT MLint32 MLSetNotifyEnabled(MLint32 flag);
 
ML_UTILS_EXPORT MLint32 MLIsNotifyEnabled();
 
ML_UTILS_EXPORT int MLSetHighPrecisionMessageTimeStampsEnabled(int enabled);
 
 
//-----------------------------------------------------------------------------------
//
//
//-----------------------------------------------------------------------------------
 
ML_UTILS_EXPORT void* MLStringToPtr(const char* valueString, int postError, const char* errFunc);
 
 
 
//--------------------------------------------------------------------------------------------------
//
//
//--------------------------------------------------------------------------------------------------
ML_UTILS_EXPORT MLint32 MLIsLittleEndian();
 
ML_UTILS_EXPORT void MLMakeLittleEndian(unsigned char* data, size_t numBytes, size_t dTypeSize);
 
ML_UTILS_EXPORT void MLMakeBigEndian(unsigned char* data, size_t numBytes, size_t dTypeSize);
 
ML_UTILS_EXPORT void MLSwapBytes(unsigned char* data, size_t numBytes, size_t dTypeSize);
 
 
//-----------------------------------------------------------------------------------
//
//
//-----------------------------------------------------------------------------------
ML_UTILS_EXPORT void          MLSetMaxNumTraceListDumps(MLuint32 numMaxEntries);
 
ML_UTILS_EXPORT MLuint32      MLGetMaxNumTraceListDumps();
 
//-----------------------------------------------------------------------------------
//
//
//-----------------------------------------------------------------------------------
ML_UTILS_EXPORT void          MLSetMaxNumTraceStackDumps(MLuint32 numMaxEntries);
 
ML_UTILS_EXPORT MLuint32      MLGetMaxNumTraceStackDumps();
 
//-----------------------------------------------------------------------------------
//
//
//-----------------------------------------------------------------------------------
ML_UTILS_EXPORT void          MLSetTraceDumpMessageBits(MLuint32 messageBitMask);
 
ML_UTILS_EXPORT MLuint32      MLGetTraceDumpMessageBits();
 
 
ML_UTILS_EXPORT MLuint32      MLGetRandomNumber();
 
 
#ifdef __cplusplus
}
#endif
 
#undef ML_DISABLE_CPP
 
#endif // __mlUtilsAPI_H