mlUtilsLibraryInitMacros.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_LIBRARY_INIT_MACROS_H
#define ML_UTILS_LIBRARY_INIT_MACROS_H
 
 
// This file defines ML_UTILS_INIT_LIBRARY(initMethod) macros.
// See also mlRuntimeType.h, mlRuntime.h and mlRuntimeDict.h.
//
// Remark: These macros are inserted in the header- and source files
// of the image processing modules (e.g., class Module)
// or in in the library initialization.
 
#ifdef _MSC_VER
 
#pragma warning(disable : 4786 )
 
// This stuff is needed only for windows DLL initialization.
// It is borrowed form VC++ automatic DLL project creation.
#if !defined(AFX_STDAFX_H__17533C48_9DB6_4FA8_AEC3_550E71AF7183__INCLUDED_)
#define AFX_STDAFX_H__17533C48_9DB6_4FA8_AEC3_550E71AF7183__INCLUDED_
 
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
 
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN   // Do not include rarely used parts of windows header
#endif
 
#ifndef ML_SUPPRESS_LIBRARY_INIT_MACROS_WINDOWS_H_INCLUDE
  #include <ThirdPartyWarningsDisable.h>
  #include <windows.h>
  #include <ThirdPartyWarningsRestore.h>
#endif
 
#endif // !defined(AFX_STDAFX_H__17533C48_9DB6_4FA8_AEC3_550E71AF7183__INCLUDED_)
 
#endif // _MSC_VER
 
 
 
// Include normal ML runtime system and error handling stuff.
#include "mlVersion.h"
#include "mlErrorOutput.h"
#include "mlErrorOutputInfos.h"
#include "mlRuntime.h"
 
//--------------------------------------------------------------
//--------------------------------------------------------------
#ifdef WIN32
 
// WIN32 case :
// Macro to implement win32 DLL initialization function.
// It is called after automatic instance initialization.
#define ML_UTILS_INIT_LIBRARY_EXT_3(initMethod, NAMESP, LIB_TARGET)       \
  extern "C" {                                                            \
    extern int MLIsCPPAPILinkCompatible(int majorVersion,                 \
                                        int majorCAPIVersion,             \
                                        int verCPPAPI);                   \
  }                                                                       \
  BOOL APIENTRY DllMain( HANDLE /*hModule*/,                              \
                         DWORD  ul_reason_for_call,                       \
                         LPVOID /*lpReserved*/                            \
                       )                                                  \
  {                                                                       \
                                                                          \
    switch (ul_reason_for_call){                                          \
    case DLL_PROCESS_ATTACH:                                              \
      /* Set the name of the init method as library name.   */            \
      ML_UTILS_NAMESPACE::Runtime::setRecentlyLoadedDllName(#LIB_TARGET); \
                                                                          \
      /* Check whether the ML C++ API has a valid version number so */    \
      /* that the library can be linked safely.                     */    \
      MLCheckCPPAPILinkCompatibility(ML_MAJOR_VERSION,                    \
                                     ML_MAJOR_CAPI_VERSION,               \
                                     ML_CPPAPI_VERSION,                   \
                                     ML_CAPI_REVISION,                    \
                                     ML_VERSION_STRING,                   \
                                     #initMethod);                        \
                                                                          \
      /* Call the initialization method of the library even on load   */  \
      /* failures. That function will usually register runtime types. */  \
      /* It turned out that suppressing library init will cause more  */  \
      /* problems than trying it anyway.                              */  \
      NAMESP::initMethod();                                               \
    break;                                                                \
                                                                          \
    case DLL_THREAD_ATTACH:                                               \
    break;                                                                \
                                                                          \
    case DLL_THREAD_DETACH:                                               \
    break;                                                                \
                                                                          \
    case DLL_PROCESS_DETACH:                                              \
      MLUtilsDestroy();                                                   \
    break;                                                                \
    }                                                                     \
    return TRUE;                                                          \
  }
 
#else
 
// Unix case:
// Macro to implement Unix shared object initialization function.
// It is called after automatic instance initialization.
#define ML_UTILS_INIT_LIBRARY_EXT_3(initMethod, NAMESP, LIB_TARGET)       \
  extern "C" {                                                            \
    extern int MLInitializeUtils();                                       \
    extern int MLIsCPPAPILinkCompatible(int majorVersion,                 \
                                        int majorCAPIVersion,             \
                                        int verCPPAPI);                   \
  }                                                                       \
  void initMethod##initDll() __attribute__ ((constructor));               \
  void initMethod##initDll()                                              \
  {                                                                       \
                                                                          \
    static bool initDone = false;                                         \
    if (!initDone) {                                                      \
      /* On Unix we must guarantee that ML is initialized, because  */    \
      /* otherwise global variables or singletons are still not     */    \
      /* valid for init class calls. We need to do that here        */    \
      /* because order of variable initialization and dll           */    \
      /* initialization differs on windows and Unix.                */    \
      MLInitializeUtils();                                                \
                                                                          \
      /* Set the name of the init method as library name.   */            \
      ML_UTILS_NAMESPACE::Runtime::setRecentlyLoadedDllName(#LIB_TARGET); \
                                                                          \
      /* Check whether the ML C++ API has a valid version number so */    \
      /* that the library can be linked safely.                     */    \
      MLCheckCPPAPILinkCompatibility(ML_MAJOR_VERSION,                    \
                                     ML_MAJOR_CAPI_VERSION,               \
                                     ML_CPPAPI_VERSION,                   \
                                     ML_CAPI_REVISION,                    \
                                     ML_VERSION_STRING,                   \
                                     #initMethod);                        \
                                                                          \
      /* Call the initialization method of the library even on load   */  \
      /* failures. That function will usually register runtime types. */  \
      /* It turned out that suppressing library init will cause more  */  \
      /* problems than trying it anyway.                              */  \
      NAMESP::initMethod();                                               \
      initDone = true;                                                    \
    }                                                                     \
  }
 
#endif
 
 
//--------------------------------------------------------------
//--------------------------------------------------------------
#define ML_UTILS_INIT_LIBRARY(initMethod) \
  _ML_UTILS_INIT_LIBRARY_EXT_HELPER(initMethod, ML_UTILS_NAMESPACE, MEVIS_TARGET)
 
//--------------------------------------------------------------
//--------------------------------------------------------------
#define ML_UTILS_INIT_LIBRARY_EXT(initMethod, NAME_SP) \
  _ML_UTILS_INIT_LIBRARY_EXT_HELPER(initMethod, NAME_SP, MEVIS_TARGET)
 
//--------------------------------------------------------------
//--------------------------------------------------------------
#define _ML_UTILS_INIT_LIBRARY_EXT_HELPER(initMethod, NAME_SP, LIB_TARGET) \
  ML_UTILS_INIT_LIBRARY_EXT_2(initMethod, NAME_SP, LIB_TARGET)
 
//--------------------------------------------------------------
//--------------------------------------------------------------
#ifndef ML_STATIC_BUILD
#define ML_UTILS_INIT_LIBRARY_EXT_2(initMethod, NAME_SP, LIB_TARGET) \
  ML_UTILS_INIT_LIBRARY_EXT_3(initMethod, NAME_SP, LIB_TARGET)
#else
#define ML_UTILS_INIT_LIBRARY_EXT_2(initMethod, NAME_SP, LIB_TARGET)
#endif
 
#endif  // __mlUtilsLibraryInitMacros_H