mlTypeDefs.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_TYPE_DEFS_H
#define ML_TYPE_DEFS_H
 
 
#include "MeVisLabVersion.h"
#include "mlMacros.h"
 
// Include global compiler switches for the ML.
#include "mlConfig.h"
#include "mlUtilities.h"
 
// We always need stdlib.h for e.g., size_t.
#include <ThirdPartyWarningsDisable.h>
#include <cstdlib>
#include <cstdint>
#include <cfloat>
 
#if !defined(WIN32)
  #include <pthread.h>
  #include <sys/types.h>
#endif
 
#include <ThirdPartyWarningsRestore.h>
 
 
#if ML_DEPRECATED_SINCE(3,5,0)
  #define ML_IS_64_BIT_SYSTEM
#endif
 
 
//---------------------------------------------------------------------------------------------
//
//
//                                DEFINES
//
//
//---------------------------------------------------------------------------------------------
 
 
//------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------
#ifndef ML_NAMESPACE
  #define ML_NAMESPACE       ml
#endif
 
#ifndef ML_START_NAMESPACE
  #define ML_START_NAMESPACE namespace ML_NAMESPACE {
#endif
 
#ifndef ML_END_NAMESPACE
  #define ML_END_NAMESPACE   }
#endif
 
//--------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------
 
//--------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------
#define ML_PREFIX          "ML"
 
//--------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------
#define ML_CONSTANT_PREFIX "ML_"
 
 
 
//--------------------------------------------------------------------------------------------
// MLTypes. They define all basic integer data types.
//--------------------------------------------------------------------------------------------
#ifndef _ML_INT8
  // Should be signed but that causes too many consequences.
  typedef /*signed*/ char  MLint8;
  typedef /*signed*/ char* MLint8Ptr;
  #define ML_INT8_MIN -128
  #define ML_INT8_MAX 0x7F
  #define _ML_INT8 MLint8
#endif
 
#ifndef _ML_UINT8
  typedef unsigned char  MLuint8;
  typedef unsigned char* MLuint8Ptr;
  #define ML_UINT8_MIN 0x00
  #define ML_UINT8_MAX 0xFF
  #define _ML_UINT8 MLuint8
#endif
 
#ifndef _ML_INT16
  #if (__GNUC__ >= 3)
    typedef int16_t       MLint16;
    typedef int16_t*      MLint16Ptr;
  #else
    typedef signed short  MLint16;
    typedef signed short* MLint16Ptr;
  #endif
  #define ML_INT16_MIN -32768
  #define ML_INT16_MAX 0x7FFF
  #define _ML_INT16 MLint16
#endif
 
#ifndef _ML_UINT16
  #if (__GNUC__ >= 3)
    typedef uint16_t        MLuint16;
    typedef uint16_t*       MLuint16Ptr;
  #else
    typedef unsigned short  MLuint16;
    typedef unsigned short* MLuint16Ptr;
  #endif
  #define ML_UINT16_MIN 0x0000
  #define ML_UINT16_MAX 0xFFFF
  #define _ML_UINT16 MLuint16
#endif
 
 
#ifndef _ML_INT32
 
  #if (__GNUC__ >= 3)
    typedef int32_t     MLint32;
    typedef int32_t*    MLint32Ptr;
  #else
    typedef signed int  MLint32;
    typedef signed int* MLint32Ptr;
  #endif
 
  // Note: Do not use simply 0x80000000L since that
  // might be assigned as positive value to
  // floating point values. Force an explicit cast
  // to avoid that error. Cast values to avoid that
  // they are considered as long values.
  #define ML_INT32_MIN (static_cast<MLint32>(0x80000000L))
  #define ML_INT32_MAX (static_cast<MLint32>(0x7FFFFFFFL))
  #define _ML_INT32 MLint32
#endif
 
 
#ifndef _ML_UINT32
  #if (__GNUC__ >= 3)
    typedef uint32_t      MLuint32;
    typedef uint32_t*     MLuint32Ptr;
  #else
    typedef unsigned int  MLuint32;
    typedef unsigned int* MLuint32Ptr;
  #endif
 
  // Cast values to avoid that they are considered as long values.
  #define ML_UINT32_MIN (static_cast<MLuint32>(0x00000000L))
  #define ML_UINT32_MAX (static_cast<MLuint32>(0xFFFFFFFFL))
  #define _ML_UINT32 MLuint32
#endif
 
 
#ifndef _ML_FLOAT
  typedef float  MLfloat;
  typedef float* MLfloatPtr;
  #define ML_FLOAT_MIN     FLT_MIN
  #define ML_FLOAT_MAX     FLT_MAX
  #define ML_FLOAT_EPSILON FLT_EPSILON
  // use more digits in string representation to retain full precision of binary value:
  #define ML_FLOAT_DIG     (FLT_DIG+2)
  #define _ML_FLOAT MLfloat
#endif
 
 
#ifndef _ML_DOUBLE
  typedef double  MLdouble;
  typedef double* MLdoublePtr;
  #define ML_DOUBLE_MIN     DBL_MIN
  #define ML_DOUBLE_MAX     DBL_MAX
  #define ML_DOUBLE_EPSILON DBL_EPSILON
  #define ML_DOUBLE_DIG     DBL_DIG
  #define _ML_DOUBLE MLdouble
#endif
 
 
#ifndef _ML_LDOUBLE
  typedef long double  MLldouble;
  typedef long double* MLldoublePtr;
  #define ML_LDOUBLE_MIN     LDBL_MIN
  #define ML_LDOUBLE_MAX     LDBL_MAX
  #define ML_LDOUBLE_EPSILON LDBL_EPSILON
  #define ML_LDOUBLE_DIG     LDBL_DIG
  #define _ML_LDOUBLE MLldouble
#endif
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define ML_NUM_STANDARD_TYPES        10
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define ML_MAX_COMPONENTS_EXTENDED_TYPE 512
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define  ML_LUMINANCE        "LUMINANCE"
#define  ML_NEGATIVE         "NEGATIVE"
#define  ML_PALETTE          "PALETTE"
 
// Codes for multiple channel images.
 
#define  ML_RED              "RED"
#define  ML_GREEN            "GREEN"
#define  ML_BLUE             "BLUE"
#define  ML_ALPHA            "ALPHA"
 
#define  ML_CYAN             "CYAN"
#define  ML_MAGENTA          "MAGENTA"
#define  ML_YELLOW           "YELLOW"
#define  ML_BLACK            "BLACK"
 
#define  ML_HUE              "HUE"
#define  ML_SATURATION       "SATURATION"
#define  ML_VALUE            "VALUE"
#define  ML_LIGHTNESS        "LIGHTNESS"
 
#define  ML_YIQ_Y            "YIQ_Y"
#define  ML_YIQ_I            "YIQ_I"
#define  ML_YIQ_Q            "YIQ_Q"
 
#define  ML_CIE_X            "CIE_X"
#define  ML_CIE_Y            "CIE_Y"
#define  ML_CIE_Z            "CIE_Z"
#define  ML_LUV_L            "LUV_L"
#define  ML_LUV_U            "LUV_U"
#define  ML_LUV_V            "LUV_V"
 
#define  ML_UNKNOWN          "UNKNOWN"
 
 
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define  ML_REAL             "REAL_PART"
#define  ML_IMAG             "IMAG_PART"
 
#define  ML_V0               "V0"
#define  ML_V1               "V1"
#define  ML_V2               "V2"
#define  ML_V3               "V3"
#define  ML_V4               "V4"
#define  ML_V5               "V5"
 
#define  ML_MAGNITUDE        "MAGNITUDE"
#define  ML_ANGLE            "ANGLE"
 
 
 
//------------------------------------------------------------------------------------
//
//
//------------------------------------------------------------------------------------
 
#ifndef ML_QUOTE
  #define ML_QUOTE_INTERNAL(A) #A
  #define ML_QUOTE(A) ML_QUOTE_INTERNAL(A)
#endif
 
 
#ifndef ML_MIN
  #ifdef ML_DISABLE_CPP
    #define ML_MIN(X, Y)   (((X) < (Y)) ? (X) : (Y))
  #else
    #if ML_DEPRECATED_SINCE(3,5,0)
      template<typename T>
      #ifndef ML_NO_DEPRECATED_WARNINGS
        [[deprecated("ML_MIN is deprecated since MeVisLab 3.5.0. Please use std::min() instead")]]
      #endif
      constexpr const T& ml_deprecated_since_350_min(const T& a, const T& b) { return (b < a) ? b : a; }
      #define ML_MIN(A, B) ml_deprecated_since_350_min((A), (B))
    #endif
  #endif
#endif
 
 
#ifndef ML_MAX
  #ifdef ML_DISABLE_CPP
    #define ML_MAX(X, Y)   (((X) > (Y)) ? (X) : (Y))
  #else
    #if ML_DEPRECATED_SINCE(3,5,0)
      template<typename T>
      #ifndef ML_NO_DEPRECATED_WARNINGS
        [[deprecated("ML_MAX is deprecated since MeVisLab 3.5.0. Please use std::max() instead")]]
      #endif
      constexpr const T& ml_deprecated_since_350_max(const T& a, const T& b) { return (a < b) ? b : a; }
      #define ML_MAX(A, B) ml_deprecated_since_350_max((A), (B))
    #endif
  #endif
#endif
 
 
#ifndef ML_ABS
  #ifdef ML_DISABLE_CPP
    #define ML_ABS(X)   (((X) < (0)) ? ((X) * (-1)) : (X))
  #else
    #if ML_DEPRECATED_SINCE(3,5,0)
      template<typename T>
      #ifndef ML_NO_DEPRECATED_WARNINGS
        [[deprecated("ML_ABS is deprecated since MeVisLab 3.5.0. Please use std::abs() instead")]]
      #endif
      auto ml_deprecated_since_350_abs(T x) { return x < 0? (static_cast<T>(-1) * x) : x; }
      #define ML_ABS(X) ml_deprecated_since_350_abs((X))
    #endif
  #endif
#endif
 
 
#ifndef ML_CLAMP
  #ifdef ML_DISABLE_CPP
    #define ML_CLAMP(v,l,h)  ((v)<(l) ? (l) : (v) > (h) ? (h) : (v))
  #else
    #if ML_DEPRECATED_SINCE(3,5,0)
      template<typename T>
      #ifndef ML_NO_DEPRECATED_WARNINGS
        [[deprecated("ML_CLAMP is deprecated since MeVisLab 3.5.0. Please use std::clamp() instead")]]
      #endif
      constexpr const T& ml_deprecated_since_350_clamp(const T& v, const T& lo, const T& hi) { return v < lo? lo : (hi < v? hi : v); }
      #define ML_CLAMP(V, L, H) ml_deprecated_since_350_clamp((V), (L), (H));
    #endif
  #endif
#endif
 
#ifndef ML_LERP
  #define ML_LERP(a,l,h) ((l)+(((h)-(l))*(a)))
#endif
 
 
#ifndef ML_M_PI
# define ML_M_PI           3.14159265358979323846  /* pi */
#endif
#ifndef ML_M_PI_2
# define ML_M_PI_2         1.57079632679489661923  /* pi/2 */
#endif
 
//---------------------------------------------------------------------------------------------
//
//
//                                64 BIT SUPPORT
//
//
//---------------------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------
#ifndef ML_SYSTEM_HAS_NO_64
 
  #ifdef WIN32
    #include <ThirdPartyWarningsDisable.h>
    #include <basetsd.h>
    #include <ThirdPartyWarningsRestore.h>
  #else
    #ifndef __STDC_LIMIT_MACROS
      #define __STDC_LIMIT_MACROS
    #endif
 
    #include <cstdint>
 
    #if !defined(INT64_MIN)
      #error "mlTypeDefs.h must be included first or the macro __STDC_LIMIT_MACROS must be defined!"
    #endif
 
  #endif
 
 
  // Defines MLint64 type and its corresponding pointer type.
  #if defined(WIN32)
 
    typedef INT64          MLint64;
    typedef INT64*         MLint64Ptr;
 
    #ifndef INT64_MIN
      #define INT64_MIN   0x8000000000000000I64
    #endif
    #ifndef INT64_MAX
      #define INT64_MAX   0x7FFFFFFFFFFFFFFFI64
    #endif
 
    typedef UINT64         MLuint64;
    typedef UINT64*        MLuint64Ptr;
 
    #ifndef UINT64_MIN
      #define UINT64_MIN     static_cast<MLuint64>(0)
    #endif
    #ifndef UINT64_MAX
      #define UINT64_MAX     0xFFFFFFFFFFFFFFFFUI64
    #endif
 
  #else
      typedef long long      MLint64;
      typedef MLint64*       MLint64Ptr;
 
      typedef unsigned long long   MLuint64;
      typedef MLuint64*            MLuint64Ptr;
  #endif
 
#else
 
  typedef unsigned char    MLint64[8];
  typedef MLint64*         MLint64Ptr;
  typedef unsigned char    MLuint64[8];
  typedef MLuint64*        MLuint64Ptr;
 
#endif
 
 
#ifndef _ML_INT64
  #define ML_INT64_MIN     INT64_MIN
  #define ML_INT64_MAX     INT64_MAX
  #define _ML_INT64        MLint64
#endif
 
#ifndef _ML_UINT64
  #define ML_UINT64_MIN     static_cast<MLuint64>(0)
  #define ML_UINT64_MAX     UINT64_MAX
  #define _ML_UINT64        MLuint64
#endif
 
//--------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------
 
typedef MLint64      MLint;
 
typedef MLint64*     MLintPtr;
 
#define ML_INT_MIN   ML_INT64_MIN
 
#define ML_INT_MAX   ML_INT64_MAX
 
 
typedef MLuint64     MLuint;
 
typedef MLuint64*    MLuintPtr;
 
#define ML_UINT_MIN  UINT64_MIN
 
#define ML_UINT_MAX  UINT64_MAX
 
 
 
 
//-------------------------------------------------------------------------------------
// Introduce signed and unsigned size and offset types for pointers which are 32 bit
// on 32 bit systems and 64 bit on 64 bit systems. This is necessary, because integer
// is not large enough on 64 bit systems, because it remains 32 bit even on many 64 bit
// platforms.
// Notes:
// - size   types should be used for memory, file, array and object sizes.
// - offset types should be used as offsets typically added to pointers.
//-------------------------------------------------------------------------------------
#ifndef _ML_USIZE_T
  #define _ML_USIZE_T
 
  typedef MLuint64       MLuoffset;
 
  typedef size_t           MLusize_t;
 
  #define ML_USIZE_T_MIN   ( static_cast<size_t>(0))
 
  #define ML_USIZE_T_MAX   (~static_cast<size_t>(0))
 
  #define ML_SIZE_T_MIN   ML_USIZE_T_MIN
 
  #define ML_SIZE_T_MAX   ML_USIZE_T_MAX
 
#endif
 
 
#ifndef _ML_SIZE_T
  #define _ML_SIZE_T
 
  typedef MLint          MLsoffset;
 
  #if defined(WIN32)
    typedef SSIZE_T        MLssize_t;
  #else
    typedef ssize_t        MLssize_t;
  #endif
 
  #define ML_SSIZE_T_MIN   (static_cast<MLssize_t>(1) << (sizeof(MLssize_t)*8-1))
 
  // Take the
  #define ML_SSIZE_T_MAX   (static_cast<MLssize_t>(ML_USIZE_T_MAX ^ ML_SSIZE_T_MIN))
#endif
 
 
 
 
//---------------------------------------------------------------------------------------------
//
//
//                                TYPEDEFS, MOSTLY ENUMS
//
//
//---------------------------------------------------------------------------------------------
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
typedef MLint32 MLDataType;
 
 
#if ML_DEPRECATED_SINCE(3,5,0)
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
typedef MLint32 MLPhysicalDataType;
 
#if defined(WIN32) && !defined(ML_NO_DEPRECATED_WARNINGS)
#pragma deprecated("MLPhysicalDataType")
#endif
 
#endif 
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define ML_UNDEFINED_THREADID 0
 
#ifdef WIN32
typedef MLuint32 MLThreadId;
#else
typedef pthread_t MLThreadId;
#endif
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define ML_INVALID_DATA_TYPE -1
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
typedef enum {
  MLint8Type       =  0,                  
  MLuint8Type      =  1,                  
  MLint16Type      =  2,                  
  MLuint16Type     =  3,                  
  MLint32Type      =  4,                  
  MLuint32Type     =  5,                  
  MLfloatType      =  6,                  
  MLdoubleType     =  7,                  
  MLint64Type      =  8,                  
  MLuint64Type     =  9,                  
 
  // Type IDs for extended data types:
  MLComplexfType,     MLComplexdType,
 
  MLQuaternionfType,  MLQuaterniondType,
 
  MLVector2fType,     MLVector2dType,
  MLVector3fType,     MLVector3dType,
  MLVector4fType,     MLVector4dType,
  MLVector5fType,     MLVector5dType,
  MLVector6fType,     MLVector6dType,
  MLVector7fType,     MLVector7dType,
  MLVector8fType,     MLVector8dType,
  MLVector9fType,     MLVector9dType,
  MLVector10fType,    MLVector10dType,
  MLVector16fType,    MLVector16dType,
  MLVector32fType,    MLVector32dType,
  MLVector64fType,    MLVector64dType,
 
  MLMatrix2fType,     MLMatrix2dType,
  MLMatrix3fType,     MLMatrix3dType,
  MLMatrix4fType,     MLMatrix4dType,
  MLMatrix5fType,     MLMatrix5dType,
  MLMatrix6fType,     MLMatrix6dType,
 
  MLVector2i8Type,    MLVector2i16Type,   MLVector2i32Type,   MLVector2i64Type,
  MLVector3i8Type,    MLVector3i16Type,   MLVector3i32Type,   MLVector3i64Type,
  MLVector4i8Type,    MLVector4i16Type,   MLVector4i32Type,   MLVector4i64Type,
  MLVector5i8Type,    MLVector5i16Type,   MLVector5i32Type,   MLVector5i64Type,
  MLVector6i8Type,    MLVector6i16Type,   MLVector6i32Type,   MLVector6i64Type,
  MLVector7i8Type,    MLVector7i16Type,   MLVector7i32Type,   MLVector7i64Type,
  MLVector8i8Type,    MLVector8i16Type,   MLVector8i32Type,   MLVector8i64Type,
  MLVector9i8Type,    MLVector9i16Type,   MLVector9i32Type,   MLVector9i64Type,
  MLVector10i8Type,   MLVector10i16Type,  MLVector10i32Type,  MLVector10i64Type,
  MLVector16i8Type,   MLVector16i16Type,  MLVector16i32Type,  MLVector16i64Type,
  MLVector32i8Type,   MLVector32i16Type,  MLVector32i32Type,  MLVector32i64Type,
  MLVector64i8Type,   MLVector64i16Type,  MLVector64i32Type,  MLVector64i64Type,
 
  // this type is more or less deprecated
  MLldoubleType
 
} MLDataTypeIds;
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
typedef enum { ML_RETURN_NULL                            = 0x0, 
               ML_FATAL_MEMORY_ERROR                     = 0x1, 
               ML_THROW_NO_MEMORY                        = 0x2, 
               ML_FATAL_MEMORY_ERROR_AND_THROW_NO_MEMORY = 0x3  
} MLMemoryErrorHandling;
 
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
typedef enum { ML_FINAL_RUNTIME_CHECK_BIT                = 0x1, 
               // Todo if memory manager knows how much memory is freed/allocated on reallocs:
               //ML_FINAL_MEMORY_CHECK_BIT                 = 0x2, //!< Final checks in the Memory class are activated.
               ML_NO_CHECKS_BITS                         = 0x0, 
               ML_ALL_CHECKS_BITS                        = 0x1  
} MLCheckBits;
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
typedef enum { ML_WARNING       = 0x01,
               ML_ERROR         = 0x02,
               ML_FATAL         = 0x04,
               ML_DEBUG         = 0x08,
               ML_COUT          = 0x10,
               ML_CERR          = 0x20,
               ML_INFORMATION   = 0x40,
               ML_OTHER_MESSAGE = 0x80,
 
               ML_ALL_MESSAGES  = 0xff } MLMessageType;
 
 
//-----------------------------------------------------------------------------------
 
typedef MLint32 MLErrorCode;
 
// Note: Be sure to cast them all to the correct MLErrorCode type.
 
#define ML_INVALID_ERROR_CODE                             static_cast<MLErrorCode>(-1)
 
#define ML_RESULT_OK                                      static_cast<MLErrorCode>( 0)
 
#define ML_UNKNOWN_EXCEPTION                              static_cast<MLErrorCode>( 1)
 
#define ML_NO_MEMORY                                      static_cast<MLErrorCode>( 2)
 
#define ML_DISCONNECTED_GRAPH                             static_cast<MLErrorCode>( 3)
 
#define ML_CYCLIC_GRAPH                                   static_cast<MLErrorCode>( 4)
 
#define ML_BAD_OPERATOR_POINTER                           static_cast<MLErrorCode>( 5)
 
#define ML_BAD_OPERATOR_OUTPUT_INDEX                      static_cast<MLErrorCode>( 6)
 
#define ML_BAD_FIELD                                      static_cast<MLErrorCode>( 7)
 
#define ML_IMAGE_DATA_CALCULATION_FAILED                  static_cast<MLErrorCode>( 8)
 
#define ML_NO_IMAGE_INPUT_EXTENSION                       static_cast<MLErrorCode>( 9)
 
#define ML_NO_IMAGE_PROPS                                 static_cast<MLErrorCode>(10)
 
#define ML_BAD_OPERATOR_INPUT_INDEX                       static_cast<MLErrorCode>(11)
 
#define ML_BAD_INPUT_IMAGE_POINTER                        static_cast<MLErrorCode>(12)
 
#define ML_BAD_DATA_TYPE                                  static_cast<MLErrorCode>(13)
 
#define ML_PROGRAMMING_ERROR                              static_cast<MLErrorCode>(14)
 
#define ML_EMPTY_MESSAGE                                  static_cast<MLErrorCode>(15)
 
#define ML_PAGE_CALCULATION_ERROR_IN_MODULE               static_cast<MLErrorCode>(16)
 
#define ML_PROPERTY_CALCULATION_ERROR_IN_MODULE           static_cast<MLErrorCode>(17)
 
#define ML_INBOX_CALCULATION_ERROR_IN_MODULE              static_cast<MLErrorCode>(18)
 
#define ML_BAD_PARAMETER                                  static_cast<MLErrorCode>(19)
 
#define ML_CALCULATION_ERROR                              static_cast<MLErrorCode>(20)
 
#define ML_BAD_DIMENSION                                  static_cast<MLErrorCode>(21)
 
#define ML_RECURSION_ERROR                                static_cast<MLErrorCode>(22)
 
#define ML_LIBRARY_LOAD_ERROR                             static_cast<MLErrorCode>(23)
 
#define ML_FILE_IO_ERROR                                  static_cast<MLErrorCode>(24)
 
#define ML_AFTER_EFFECT                                   static_cast<MLErrorCode>(25)
 
#define ML_BAD_INDEX                                      static_cast<MLErrorCode>(26)
 
#define ML_OUT_OF_RANGE                                   static_cast<MLErrorCode>(27)
 
#define ML_MISSING_VOXEL_TYPE_OPERATIONS                  static_cast<MLErrorCode>(28)
 
#define ML_BAD_FIELD_TYPE                                 static_cast<MLErrorCode>(29)
 
#define ML_BAD_FIELD_POINTER_OR_NO_MEMORY                 static_cast<MLErrorCode>(30)
 
#define ML_FIELD_CREATION_ERROR_OR_NO_MEMORY              static_cast<MLErrorCode>(31)
 
#define ML_TYPE_INITIALIZATION_ERROR                      static_cast<MLErrorCode>(32)
 
#define ML_CONSTRUCTOR_EXCEPTION                          static_cast<MLErrorCode>(33)
 
#define ML_DESTRUCTOR_EXCEPTION                           static_cast<MLErrorCode>(34)
 
#define ML_TABLE_FULL                                     static_cast<MLErrorCode>(35)
 
#define ML_EXTERNAL_ERROR                                 static_cast<MLErrorCode>(36)
 
#define ML_BAD_BASE_FIELD                                 static_cast<MLErrorCode>(37)
 
#define ML_BAD_BASE_FIELD_CONTENT                         static_cast<MLErrorCode>(38)
 
#define ML_TYPE_NOT_REGISTERED                            static_cast<MLErrorCode>(39)
 
#define ML_LIBRARY_INIT_ERROR                             static_cast<MLErrorCode>(40)
 
#define ML_BAD_POINTER_OR_0                               static_cast<MLErrorCode>(41)
 
#define ML_BAD_STATE                                      static_cast<MLErrorCode>(42)
 
#define ML_TOO_MANY_PUSHES_OR_ADDS                        static_cast<MLErrorCode>(43)
 
#define ML_TOO_MANY_POPS_OR_REMOVES                       static_cast<MLErrorCode>(44)
 
#define ML_STACK_TABLE_OR_BUFFER_EMPTY                    static_cast<MLErrorCode>(45)
 
#define ML_STACK_TABLE_OR_BUFFER_NOT_EMPTY                static_cast<MLErrorCode>(46)
 
#define ML_ELEMENT_NOT_FOUND                              static_cast<MLErrorCode>(47)
 
#define ML_INVALID_FILE_NAME                              static_cast<MLErrorCode>(48)
 
#define ML_INVALID_FILE_DESCRIPTOR                        static_cast<MLErrorCode>(49)
 
#define ML_FILE_NOT_OPEN                                  static_cast<MLErrorCode>(50)
 
#define ML_NO_OR_INVALID_PERMISSIONS                      static_cast<MLErrorCode>(51)
 
#define ML_DISK_OR_RESSOURCE_FULL                         static_cast<MLErrorCode>(52)
 
#define ML_FILE_OR_DATA_STRUCTURE_CORRUPTED               static_cast<MLErrorCode>(53)
 
#define ML_INVALID_VERSION                                static_cast<MLErrorCode>(54)
 
#define ML_UNKNOWN_OR_INVALID_COMPRESSION_SCHEME          static_cast<MLErrorCode>(55)
 
#define ML_TYPE_ALREADY_REGISTERED                        static_cast<MLErrorCode>(56)
 
#define ML_TYPE_IS_ABSTRACT                               static_cast<MLErrorCode>(57)
 
#define ML_TYPE_NOT_DERIVED_FROM_EXPECTED_PARENT_CLASS    static_cast<MLErrorCode>(58)
 
#define ML_OPERATION_INTERRUPTED                          static_cast<MLErrorCode>(59)
 
#define ML_BAD_PAGE_ID                                    static_cast<MLErrorCode>(60)
 
#define ML_OUT_OF_RESSOURCES                              static_cast<MLErrorCode>(61)
 
#define ML_OBJECT_OR_FILE_EXISTS                          static_cast<MLErrorCode>(62)
 
#define ML_OBJECT_OR_FILE_DOES_NOT_EXIST                  static_cast<MLErrorCode>(63)
 
#define ML_DEADLOCK_WOULD_OCCURR                          static_cast<MLErrorCode>(64)
 
#define ML_COULD_NOT_OPEN_FILE                            static_cast<MLErrorCode>(65)
 
#define ML_COULD_NOT_CREATE_OPEN_OR_MODIFY_FILE           ML_COULD_NOT_OPEN_FILE
 
#define ML_LIBRARY_UNLOAD_ERROR                           static_cast<MLErrorCode>(66)
 
#define ML_LIBRARY_UNLOAD_EXCEPTION                       static_cast<MLErrorCode>(67)
 
#define ML_NOT_SUPPORTED_ON_THIS_SYSTEM                   static_cast<MLErrorCode>(68)
 
#define ML_OBJECT_STILL_REFERENCED                        static_cast<MLErrorCode>(69)
 
#define ML_REQUEST_OUTSIDE_OF_IMAGE                        static_cast<MLErrorCode>(70)
 
#define MLNumDefaultErrorCodes                            static_cast<MLErrorCode>(71)
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
typedef enum { ML_CONTINUE= 0,   
               ML_ABORT,         
               ML_EXIT0,         
               ML_EXITCODE,      
               MLNumTerminators
} MLTerminator;
 
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
typedef enum { ML_NOTIFY_NO_OBJECT     = 0x00000000,   
               ML_NOTIFY_ERROR_OUTPUT  = 0x00010000,   
               ML_NOTIFY_API           = 0x00020000,   
               ML_NOTIFY_RUNTIME       = 0x00040000,   
               ML_NOTIFY_CACHE         = 0x00080000,   
               ML_NOTIFY_HOST          = 0x00100000,   
               ML_NOTIFY_MODULE        = 0x00200000,    
 
#if ML_DEPRECATED_SINCE(3,5,0)
               ML_NOTIFY_BASEOP        = ML_NOTIFY_MODULE,
#endif
 
 
               ML_NOTIFY_LAST_CLASS    = 0x00400000
} MLNotifyChangedClassType;
 
typedef enum { ML_NOTIFY_NO_OBJECT_TYPE                 = 0x0000 | ML_NOTIFY_NO_OBJECT,
 
               ML_NOTIFY_ERROR_OUTPUT_ERROR_OUTPUT_CB   = 0x0001 | ML_NOTIFY_ERROR_OUTPUT,
               ML_NOTIFY_ERROR_OUTPUT_FULL_DEBUGGING    = 0x0002 | ML_NOTIFY_ERROR_OUTPUT,
               ML_NOTIFY_ERROR_OUTPUT_TERMINATION_TYPE  = 0x0004 | ML_NOTIFY_ERROR_OUTPUT,
               ML_NOTIFY_ERROR_OUTPUT_MESSAGE_FILTER    = 0x0008 | ML_NOTIFY_ERROR_OUTPUT,
               ML_NOTIFY_ERROR_OUTPUT_DEBUG_ENV_NAMES   = 0x0010 | ML_NOTIFY_ERROR_OUTPUT,
               ML_NOTIFY_ERROR_OUTPUT_OTHER_CHANGES     = 0x0020 | ML_NOTIFY_ERROR_OUTPUT,
 
               ML_NOTIFY_API_EXCEPTIONS                 = 0x0001 | ML_NOTIFY_API,
               ML_NOTIFY_API_CHECKS_BITS                = 0x0002 | ML_NOTIFY_API,
 
               ML_NOTIFY_RUNTIME_TYPE_ADDED             = 0x0001 | ML_NOTIFY_RUNTIME,
               ML_NOTIFY_RUNTIME_TYPE_REMOVED           = 0x0002 | ML_NOTIFY_RUNTIME,
 
               ML_NOTIFY_CACHE_CLEAR                    = 0x0001 | ML_NOTIFY_CACHE,
               ML_NOTIFY_CACHE_MEM_OPT_LEVEL            = 0x0002 | ML_NOTIFY_CACHE,
               ML_NOTIFY_CACHE_FLUSH                    = 0x0004 | ML_NOTIFY_CACHE,
               ML_NOTIFY_CACHE_MAX_SIZE                 = 0x0008 | ML_NOTIFY_CACHE,
               ML_NOTIFY_CACHE_MONITORING_LEVEL         = 0x0010 | ML_NOTIFY_CACHE,
 
               ML_NOTIFY_HOST_MAX_NUM_THREADS           = 0x0001 | ML_NOTIFY_HOST,
               ML_NOTIFY_HOST_BREAK_CHECK_CB            = 0x0002 | ML_NOTIFY_HOST,
               ML_NOTIFY_HOST_PROGRESS_CB               = 0x0004 | ML_NOTIFY_HOST,
               ML_NOTIFY_HOST_USE_CLASSIC_HOST          = 0x0008 | ML_NOTIFY_HOST,
 
               ML_NOTIFY_FIELD_HANDLED                  = 0x0001 | ML_NOTIFY_MODULE,
               ML_NOTIFY_MODULE_INSTANTIATED            = 0x0002 | ML_NOTIFY_MODULE,
               ML_NOTIFY_MODULE_DELETED                 = 0x0004 | ML_NOTIFY_MODULE
#if ML_DEPRECATED_SINCE(3,5,0)
              ,ML_NOTIFY_BASEOP_INSTANTIATED            = ML_NOTIFY_MODULE_INSTANTIATED, 
               ML_NOTIFY_BASEOP_DELETED                 = ML_NOTIFY_MODULE_DELETED       
#endif
 
 
 
} MLNotifyChangedObjectType;
 
 
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
typedef enum {
  ML_EVENTFILTER_ADD_CB=0,
  ML_EVENTFILTER_REMOVE_CB
} MLEventFilterApplicationMessage;
 
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
typedef enum {
  ML_ZERO_SIGN = 0,             
  ML_NEGATIVE_SIGN,             
  ML_POSITIVE_SIGN              
} MLSign;
 
 
typedef enum {
  ML_VX = 0,     
  ML_VY = 1,     
  ML_VZ = 2,     
  ML_VW = 3,     
  ML_VC = 3,     
  ML_VT = 4,     
  ML_VU = 5      
} MLArrayIndex;
 
 
//---------------------------------------------------------------------------------------------
//
//
//                                FUNCTION TYPEDEFS
//
//
//---------------------------------------------------------------------------------------------
 
typedef double (*MLDblFuncPtr)(double);
 
 
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
typedef void  MLMessageCB(void*         usrData,
                          MLErrorCode   errCode,
                          MLMessageType messageType,
                          const char*   messStr,
                          int           line,
                          const char**  infos);
 
 
//---------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------
typedef void  MLNotifyCB(MLuint32 objType,
                         void*    usrData,
                         void* objectData1, void* objData2);
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
typedef void    MLSensorCB         (void* usrData, void* sensor);
typedef void    MLHostProgressCB   (void* usrData, const char* info1, const char* info2);
typedef MLint32 MLHostBreakCheckCB (void* usrData, void** hitField);
typedef void    MLRequestProgressCB(void* usrData, double progress);
 
 
//-----------------------------------------------------------------------------------
//
//
//-----------------------------------------------------------------------------------
 
typedef const char* MLApplicationGetStringPropertyCB(void* applicationUsrData, const char* propertyName, MLint16* found);
 
typedef MLint32     MLApplicationGetInt32PropertyCB (void* applicationUsrData, const char* propertyName, MLint16* found);
 
typedef double      MLApplicationGetDoublePropertyCB(void* applicationUsrData, const char* propertyName, MLint16* found);
 
typedef MLint32     MLApplicationGetBoolPropertyCB  (void* applicationUsrData, const char* propertyName, MLint16* found);
 
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
typedef MLint32     MLEventFilterCB                 (void* usrData, void* event);
 
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
typedef struct
{
  MLApplicationGetStringPropertyCB* _getStringCB;
 
  MLApplicationGetInt32PropertyCB*  _getInt32CB;
 
  MLApplicationGetDoublePropertyCB* _getDoubleCB;
 
  MLApplicationGetBoolPropertyCB*   _getBoolCB;
 
  void* _applicationUsrData;
 
} MLApplicationPropertyCallbacks;
 
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
typedef void  MLEventFilterApplicationHookCB(void*                           applicationUsrData,
                                             MLEventFilterApplicationMessage type,
                                             MLEventFilterCB*                cb,
                                             void *                          usrData,
                                             MLuint32                        fromMessageId,
                                             MLuint32                        toMessageId);
 
 
 
 
 
//---------------------------------------------------------------------------------------------
//
//
//                                REGISTERED TYPE SUPPORT
//
//
//---------------------------------------------------------------------------------------------
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
typedef MLuint64 MLTypePropertyBits;
 
#if ML_DEPRECATED_SINCE(3,5,0)
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
ML_DEPRECATED typedef MLTypePropertyBits MLTypePropBits;
ML_DEPRECATED typedef bool MLCTBool;
ML_DEPRECATED typedef MLint MLCTInt;
ML_DEPRECATED typedef MLuint64 MLCTUInt;
#endif
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
typedef unsigned char MLTypeData;
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
struct MLTypeInfos;
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
typedef MLint32 MLTypeGroup;
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
typedef enum {
  MLNoTypeGroup = -1,
  MLScalarTypeGroup,
  MLVectorTypeGroup,
  MLMatrixTypeGroup
} MLTypeGroupIds;
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
struct MLTypeInfos {
 
 
#if ML_DEPRECATED_SINCE(3,5,0)
  union {
    size_t               numComponents;
    size_t               numComps;
  };
#else
  size_t               numComponents;
#endif
 
  size_t               typeSize;
 
  const char*          name;
 
  MLDataType           rangeAndPrecisionEquivalent;
 
  MLdouble             dblMin;
 
  MLdouble             dblMax;
 
  const MLTypeData*    typeMinPtr;
 
  const MLTypeData*    typeMaxPtr;
 
  const MLTypeData*    typeDefaultPtr;
 
  size_t               numGoodCastTos;
 
  const char**         goodCastTos;
 
#if ML_DEPRECATED_SINCE(3,5,0)
  union {
    size_t             componentOffsets[ML_MAX_COMPONENTS_EXTENDED_TYPE];
    size_t             compOffsets[ML_MAX_COMPONENTS_EXTENDED_TYPE];
  };
#else
  size_t               componentOffsets[ML_MAX_COMPONENTS_EXTENDED_TYPE];
#endif
 
  const char*          structInfoString;
 
  MLint32              dataTypeId;
 
  MLTypeGroup          typeGroup;
 
  MLTypePropertyBits   propertyBits;
 
  //--------------------------------------------------------------------------------------------------
  //--------------------------------------------------------------------------------------------------
  typedef void        (*Function_SetTo                                   ) (MLTypeData* dest);
  typedef bool        (*Function_CastToBool                              ) (const MLTypeData* p);
  typedef MLint       (*Function_CastToInt                               ) (const MLTypeData* p);
  typedef MLdouble    (*Function_CastToDouble                            ) (const MLTypeData* p);
  typedef char*       (*Function_GetStringValue                          ) (const MLTypeData* p);
  typedef void        (*Function_CastFromInt                             ) (MLint             value,   MLTypeData* result);
  typedef void        (*Function_CastFromDouble                          ) (MLdouble          value,   MLTypeData* result);
  typedef void        (*Function_SetStringValue                          ) (const char*       str,     MLTypeData* result);
  typedef void        (*Function_CopyValue                               ) (const MLTypeData* source,  MLTypeData* dest);
  typedef bool        (*Function_IsEqualToType                           ) (const MLTypeData* source1,  const MLTypeData* source2);
  typedef bool        (*Function_IsEqualToTypeWithEpsilon                ) (const MLTypeData* source1,  const MLTypeData* source2, MLdouble epsilon);
  typedef void        (*Function_ApplyIntOperation                       ) (const MLTypeData* source,  MLint value, MLTypeData* result);
  typedef void        (*Function_ApplyDoubleOperation                    ) (const MLTypeData* source,  MLdouble value, MLTypeData* result);
  typedef void        (*Function_ApplyOperation                          ) (const MLTypeData* source1,  const MLTypeData* source2,  MLTypeData* result);
  typedef void        (*Function_CastToOtherType                         ) (const MLTypeData* myData,   const MLTypeInfos* otherInfos, MLTypeData* otherData);
  typedef void        (*Function_CastFromOtherType                       ) (const MLTypeInfos* myInfos, const MLTypeData* myData, MLTypeData* otherData);
  typedef void        (*Function_MultWithOtherType                       ) (const MLTypeInfos* myInfos, const MLTypeData* myData, const MLTypeData* otherData, MLTypeData* result);
  typedef void        (*Function_ArrayCopy                               ) (const MLTypeData* source, MLTypeData* dest, size_t size);
  typedef void        (*Function_ArrayFill                               ) (const MLTypeData* fillValue, MLTypeData* dest, size_t size);
  typedef void        (*Function_ArrayCopyWithStrides                    ) (const MLTypeData* source, MLssize_t sourceStride, MLTypeData* dest, MLssize_t destStride, size_t size);
  typedef void        (*Function_Interpolate                             ) (const MLTypeData* source1, const MLTypeData* source2, MLdouble alpha, MLTypeData* result);
  typedef void        (*Function_ArrayRescale                            ) (const MLTypeData* source, MLdouble scaleFactor, const MLTypeData* offset, MLTypeData* dest, size_t size);
  typedef bool        (*Function_ArrayEqualsValue                        ) (const MLTypeData* value, const MLTypeData* buffer, size_t size);
  typedef void        (*Function_ArrayGetMinMax                          ) (const MLTypeData* source, size_t size, MLdouble& min, MLdouble& max);
  typedef MLdouble    (*Function_GetComponent                            ) (const MLTypeData* source, size_t componentIndex);
  typedef void        (*Function_SetComponent                            ) (MLTypeData* dest, size_t componentIndex, MLdouble value);
 
 
  Function_GetStringValue getStringValue;
  Function_SetStringValue setStringValue;
 
  Function_SetTo          setToMinimum;
  Function_SetTo          setToMaximum;
  Function_SetTo          setToDefault;
  Function_GetComponent   getComponent;
  Function_SetComponent   setComponent;
  Function_CopyValue      copy;
  Function_ArrayCopy      arrayCopy;
  Function_ArrayCopyWithStrides arrayCopyWithStrides;
  Function_ArrayFill      arrayFill;
 
  Function_CastToBool   castToBool;
  Function_CastToInt    castToInt;
  Function_CastToDouble castToDouble;
  Function_CastToOtherType castToOtherType;
 
  Function_CastFromInt       castFromInt;
  Function_CastFromDouble    castFromDouble;
  Function_CastFromOtherType castFromOtherType;
 
  Function_IsEqualToType     isEqualToType;
 
  Function_IsEqualToTypeWithEpsilon isEqualToTypeWithEpsilon;
 
  Function_CopyValue negate;
  Function_CopyValue normalize;
 
  Function_ArrayRescale arrayRescale;
 
  Function_ArrayEqualsValue arrayEqualsValue;
 
  Function_ArrayGetMinMax arrayGetMinMax;
 
  Function_Interpolate interpolate;
 
  Function_ApplyIntOperation    multWithInt;
  Function_ApplyDoubleOperation multWithDouble;
  Function_ApplyOperation       multWithType;
  Function_MultWithOtherType    multWithOtherType;
 
  Function_ApplyIntOperation    plusInt;
  Function_ApplyDoubleOperation plusDouble;
  Function_ApplyOperation       plusType;
};
 
ML_START_NAMESPACE
 
void ML_UTILS_EXPORT logTypeComponentsFromStringError(const char* function);
 
ML_END_NAMESPACE
 
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define ML_CALC_FTYPE MLdouble
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define ML_CALC_ITYPE MLint
 
 
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define ML_TYPE_ASSIGN_FUNCTION_POINTERS()                    \
    getStringValue          = MLTYPE_getStringValue;          \
    setStringValue          = MLTYPE_setStringValue;          \
    setToMinimum            = MLTYPE_setToMinimum;            \
    setToMaximum            = MLTYPE_setToMaximum;            \
    setToDefault            = MLTYPE_setToDefault;            \
    getComponent            = MLTYPE_getComponent;            \
    setComponent            = MLTYPE_setComponent;            \
    copy                    = MLTYPE_copy;                    \
    arrayCopy               = MLTYPE_arrayCopy;               \
    arrayCopyWithStrides    = MLTYPE_arrayCopyWithStrides;    \
    arrayFill               = MLTYPE_arrayFill;               \
                                                              \
    castToBool              = MLTYPE_castToBool;              \
    castToInt               = MLTYPE_castToInt;               \
    castToDouble            = MLTYPE_castToDouble;            \
    castToOtherType         = MLTYPE_castToOtherType;         \
    castFromInt             = MLTYPE_castFromInt;             \
    castFromDouble          = MLTYPE_castFromDouble;          \
    castFromOtherType       = MLTYPE_castFromOtherType;       \
                                                              \
    isEqualToType           = MLTYPE_isEqualToType;           \
    isEqualToTypeWithEpsilon= MLTYPE_isEqualToTypeWithEpsilon;\
                                                              \
    negate                  = MLTYPE_negate;                  \
    normalize               = MLTYPE_normalize;               \
                                                              \
    arrayRescale            = MLTYPE_arrayRescale;            \
    interpolate             = MLTYPE_interpolate;             \
    arrayEqualsValue        = MLTYPE_arrayEqualsValue;        \
    arrayGetMinMax          = MLTYPE_arrayGetMinMax;          \
                                                              \
    multWithInt             = MLTYPE_multWithInt;             \
    multWithDouble          = MLTYPE_multWithDouble;          \
    multWithType            = MLTYPE_multWithType;            \
    multWithOtherType       = MLTYPE_multWithOtherType;       \
                                                              \
    plusInt                 = MLTYPE_plusInt;                 \
    plusDouble              = MLTYPE_plusDouble;              \
    plusType                = MLTYPE_plusType;
 
 
#endif // __mlTypeDefs_H