RxDynamicModule.h

Go to the documentation of this file.

 
// Copyright (C) 2002-2022, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2022 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
 
 
#ifndef _OD_RXDYNAMICMODULE_H_
#define _OD_RXDYNAMICMODULE_H_
 
#include "RxModule.h"
#include "TDVersion.h"
#include "OdString.h"
#include "OdAllocOp.h"
#include "Tf/TfSchemaManagerInterface.h"
 
#include "TD_PackPush.h"
 
template<class T, class TInterface = T>
class OdRxStaticModule : public T
{
  ODRX_HEAP_OPERATORS();
 
  OdRefCounter m_nLockCount;
  OdString     m_sName;
 
  OdRxStaticModule(const OdString& sName)
    : m_nLockCount(0)
    , m_sName(sName)
  { }
  void addRef() 
  { 
    ++m_nLockCount; 
  }
  void release() 
  { 
    ODA_ASSERT(m_nLockCount); 
    --m_nLockCount; 
  }
  long numRefs() const { return m_nLockCount; }
public:
  void* sysData() { return 0; }
  
  static OdRxModule* createModule(const OdString& name)
  {
    return new OdRxStaticModule(name);
  }
 
  void deleteModule() { delete this; }
 
  OdString moduleName() const { return m_sName; }
};
 
typedef OdRxModule* (*StaticModuleEntryPoint)(const OdString& szModuleName);
 
#define ODRX_STATIC_MODULE_ENTRY_POINT(_UserModuleClass) odrxCreateModuleObject_For_##_UserModuleClass
 
#define ODRX_DECLARE_STATIC_MODULE_ENTRY_POINT(_UserModuleClass) \
OdRxModule* ODRX_STATIC_MODULE_ENTRY_POINT(_UserModuleClass)(const OdString& szModuleName)
 
      struct STATIC_MODULE_DESC
{
  const wchar_t*           szAppName;
  StaticModuleEntryPoint  entryPoint;
};
 
#define ODRX_BEGIN_STATIC_MODULE_MAP() \
STATIC_MODULE_DESC g_ODRX_STATIC_MODULE_MAP[] = {
 
#define ODRX_DEFINE_STATIC_APPLICATION(AppName, ModuleClassName) \
{ AppName, ODRX_STATIC_MODULE_ENTRY_POINT(ModuleClassName) },
 
#define ODRX_DEFINE_STATIC_APPMODULE(moduleName, ModuleClassName) \
ODRX_DEFINE_STATIC_APPLICATION(moduleName, ModuleClassName)
 
#define ODRX_END_STATIC_MODULE_MAP() \
{ 0, 0 } };
 
#define ODRX_DECLARE_EXTERN_STATIC_MODULE_MAP extern STATIC_MODULE_DESC g_ODRX_STATIC_MODULE_MAP[];
 
FIRSTDLL_EXPORT void odrxInitStaticModuleMap(STATIC_MODULE_DESC* pMap);
 
#define ODRX_INIT_STATIC_MODULE_MAP() odrxInitStaticModuleMap(g_ODRX_STATIC_MODULE_MAP)
 
#define ODRX_DEFINE_STATIC_MODULE(_UserModuleClass)\
\
  static OdRxModule* g_pSingletonModule##_UserModuleClass = 0;\
\
ODRX_DECLARE_STATIC_MODULE_ENTRY_POINT(_UserModuleClass)\
{\
  return OdRxStaticModule<_UserModuleClass >::createModule(szModuleName);\
}
 
template<class T, class TInterface = T>
class OdRxPseudoStaticModule : public T
{
  ODRX_HEAP_OPERATORS();
 
  OdRefCounter m_nLockCount;
  OdString     m_sName;
 
  OdRxPseudoStaticModule(const OdString& sName)
    : m_nLockCount(0)
    , m_sName(sName)
  { }
  void addRef() 
  { 
    ++m_nLockCount; 
  }
  void release() 
  { 
    ODA_ASSERT(m_nLockCount); 
    --m_nLockCount; 
    if (m_nLockCount == 0){
      delete this;
    }
  }
  long numRefs() const { return m_nLockCount; }
public:
  void* sysData() { return 0; }
 
  static OdRxModule* createModule(const OdString& name)
  {
    return new OdRxPseudoStaticModule(name);
  }
 
  void deleteModule() { delete this; }
 
  OdString moduleName() const { return m_sName; }
};
 
// For internal use only
#define ODRX_DEFINE_PSEUDO_STATIC_MODULE(_UserModuleClass)\
  ODRX_DECLARE_STATIC_MODULE_ENTRY_POINT(_UserModuleClass)\
{\
  return OdRxPseudoStaticModule<_UserModuleClass >::createModule(szModuleName);\
}
 
#if defined(_TOOLKIT_IN_DLL_) 
 
//IR.111706. MacOS X dynamic library loading.
#if defined(__GNUC__) && defined(__APPLE__) // GNU compiler MacOS X
 
#define ODRX_STATIC_MODULE_PATH "{5CEAD1EF-4D33-48fe-99E4-E09176BCF088}/"
 
#define ODRX_STATIC_APP_MODULE_NAME(AppName) (OdString(ODRX_STATIC_MODULE_PATH) + AppName + DEFAULT_MODULE_EXTENSION_DOT_W)
 
void deleteModuleObject();
 
template<class T, class TInterface = T>
class OdRxMacModule : public T
{
  OdRefCounter   m_nLockCount;
  void          *m_hModule;
  const OdString m_name;
 
  OdRxMacModule(void *hModule, const OdString name)
    : m_nLockCount(0)
    , m_hModule(hModule)
    , m_name(name)
  {}
  void addRef() 
  { 
    ++m_nLockCount; 
  }
  void release() 
  { 
    ODA_ASSERT(m_nLockCount); 
    --m_nLockCount; 
  }
  long numRefs() const { return m_nLockCount; }
  ODRX_HEAP_OPERATORS();
public:
  void* sysData() { return m_hModule; }
 
  static OdRxMacModule* createModule(void *hModule, const OdString name) 
  { 
    return new OdRxMacModule(hModule, name); 
  }
 
  void deleteModule()
  {
    deleteModuleObject();
    delete this;
  }
 
  OdString moduleName() const
  {
    return m_name;
  }
};
 
#define ODRX_DEFINE_DYNAMIC_MODULE(_UserModuleClass)\
ODRX_ALLOC_OPERATORS()\
  static OdRxModule* g_pSingletonModule = 0;\
  extern "C" { \
  __attribute__ ((visibility("default"))) \
  OdRxModule* odrxCreateModuleObject(void *hModule, OdChar *name)\
{\
  if(!g_pSingletonModule)\
{\
  g_pSingletonModule = OdRxMacModule<_UserModuleClass >::createModule(hModule, name);\
  hModule = NULL;\
}\
  return g_pSingletonModule;\
}\
  void odrxGetAPIVersion(int& nMajorVersion, int& nMinorVersion,\
  int& nMajorBuildVersion, int& nMinorBuildVersion)\
{\
  nMajorVersion       = TD_MAJOR_VERSION;\
  nMinorVersion       = TD_MINOR_VERSION;\
  nMajorBuildVersion  = TD_MAJOR_BUILD;\
  nMinorBuildVersion  = TD_MINOR_BUILD;\
}\
}\
  void deleteModuleObject()\
{\
  g_pSingletonModule = NULL;\
}
 
#elif defined(__GNUC__) && !defined(_WIN32)
 
#define ODRX_STATIC_MODULE_PATH "{5CEAD1EF-4D33-48fe-99E4-E09176BCF088}/"
 
#define ODRX_STATIC_APP_MODULE_NAME(AppName) (OdString(ODRX_STATIC_MODULE_PATH) + AppName + DEFAULT_MODULE_EXTENSION_DOT_W)
 
void deleteModuleObject();
 
template<class T, class TInterface = T>
class OdRxUnixModule : public T
{
  OdRefCounter   m_nLockCount;
  void          *m_hModule;
  const OdString m_name;
protected:
  OdRxUnixModule(void *hModule, const OdString name)
    : m_nLockCount(0)
    , m_hModule(hModule)
    , m_name(name)
  {}
private:
  void addRef() 
  { 
    ++m_nLockCount; 
  }
  void release() 
  { 
    ODA_ASSERT(m_nLockCount); 
    --m_nLockCount; 
  }
  long numRefs() const { return m_nLockCount; }
  ODRX_HEAP_OPERATORS();
public:
  void* sysData() { return m_hModule; }
  
  static OdRxUnixModule* createModule(void *hModule, const OdString name) 
  { 
    return new OdRxUnixModule(hModule, name); 
  }
 
  void deleteModule()
  {
    deleteModuleObject();
    delete this;
  }
 
  OdString moduleName() const
  {
    return m_name;
  }
};
 
#define ODRX_DEFINE_DYNAMIC_MODULE(_UserModuleClass)\
ODRX_ALLOC_OPERATORS()\
  static OdRxModule* g_pSingletonModule = 0;\
\
class OdRxUnixModule##_UserModuleClass : public OdRxUnixModule<_UserModuleClass>\
{\
  ODRX_HEAP_OPERATORS();\
  OdRxUnixModule##_UserModuleClass(void *hModule, const OdString name)\
    : OdRxUnixModule<_UserModuleClass>(hModule, name)\
  {\
  }\
public:\
  static _UserModuleClass* createModule(void *hModule, const OdString name) \
  { \
    return new OdRxUnixModule##_UserModuleClass(hModule, name);\
  }\
\
  virtual void deleteModule()\
  {\
    g_pSingletonModule = 0;\
    delete this;\
  }\
};\
\
  extern "C" { \
  __attribute__ ((visibility("default"))) \
  OdRxModule* odrxCreateModuleObject(void *hModule, OdChar *name)\
{\
  if(!g_pSingletonModule)\
{\
  g_pSingletonModule = OdRxUnixModule##_UserModuleClass::createModule(hModule, name);\
  hModule = NULL;\
}\
  return g_pSingletonModule;\
}\
  __attribute__ ((visibility("default"))) \
  void odrxGetAPIVersion(int& nMajorVersion, int& nMinorVersion,\
  int& nMajorBuildVersion, int& nMinorBuildVersion)\
{\
  nMajorVersion       = TD_MAJOR_VERSION;\
  nMinorVersion       = TD_MINOR_VERSION;\
  nMajorBuildVersion  = TD_MAJOR_BUILD;\
  nMinorBuildVersion  = TD_MINOR_BUILD;\
}\
}\
  void deleteModuleObject()\
{\
  g_pSingletonModule = NULL;\
}\
 
#else //defined(__GNUC__)
 
#define ODRX_STATIC_MODULE_PATH "{5CEAD1EF-4D33-48fe-99E4-E09176BCF088}/"
 
#define ODRX_STATIC_APP_MODULE_NAME(AppName) (OdString(ODRX_STATIC_MODULE_PATH) + AppName + DEFAULT_MODULE_EXTENSION_DOT_W)
 
#ifdef __BORLANDC__
 
 
template<class T, class TInterface = T>
class OdRxWin32Module : public T
{
  OdRefCounter   m_nLockCount;
  HMODULE        m_hModule;
  const OdString m_sModuleName;
  OdRxWin32Module() : m_nLockCount(0) { }
  void addRef()
  {
        ++m_nLockCount;
  }
  void release()
  {
        ODA_ASSERT(m_nLockCount);
        --m_nLockCount;
  }
  long numRefs() const { return m_nLockCount; }
  OdRxWin32Module(HMODULE hModule , const OdString name )
        : m_nLockCount(0)
        , m_hModule(hModule)
        , m_sModuleName(name)
  {}
  ODRX_HEAP_OPERATORS();
public:
  void* sysData() { return reinterpret_cast<void*>(m_hModule); }
 
  static OdRxWin32Module* createModule(HMODULE hModule, const OdString name ) { return new OdRxWin32Module(hModule,name); }
 
  void deleteModule()
  {
     g_pSingletonModule = 0;
     delete this;
  }
 
  OdString moduleName() const
  {
     return m_sModuleName;
  }
};
 
#define ODRX_DEFINE_DYNAMIC_MODULE(_UserModuleClass)\
ODRX_ALLOC_OPERATORS()\
static OdRxModule* g_pSingletonModule = 0;\
  extern "C" {\
__declspec(dllexport) OdRxModule* odrxCreateModuleObject(HMODULE& hModule, const OdChar *name)\
{\
  if(!g_pSingletonModule)\
  {\
    g_pSingletonModule = OdRxWin32Module<_UserModuleClass >::createModule(hModule, name);\
    hModule = 0;\
  }\
  return g_pSingletonModule;\
}\
__declspec(dllexport) void odrxGetAPIVersion(int& nMajorVersion, int& nMinorVersion,\
                                             int& nMajorBuildVersion, int& nMinorBuildVersion)\
{\
  nMajorVersion       = TD_MAJOR_VERSION;\
  nMinorVersion       = TD_MINOR_VERSION;\
  nMajorBuildVersion  = TD_MAJOR_BUILD;\
  nMinorBuildVersion  = TD_MINOR_BUILD;\
}\
}\
 
#else //__BORLANDC__
 
void deleteModuleObject();
 
template<class T, class TInterface = T>
class OdRxWin32Module : public T
{
  OdRefCounter m_nLockCount;
  HMODULE      m_hModule;
  OdRxWin32Module() : m_nLockCount(0) { }
  void addRef()
  {
        ++m_nLockCount;
  }
  void release()
  {
        ODA_ASSERT(m_nLockCount);
        --m_nLockCount;
  }
  long numRefs() const { return m_nLockCount; }
  OdRxWin32Module(HMODULE hModule )
        : m_nLockCount(0)
        , m_hModule(hModule)
  {}
  ODRX_HEAP_OPERATORS();
public:
  void* sysData() { return reinterpret_cast<void*>(m_hModule); }
 
  static OdRxWin32Module* createModule(HMODULE hModule) { return new OdRxWin32Module(hModule); }
 
  void deleteModule()
  {
     deleteModuleObject();
     delete this;
  }
 
  OdString moduleName() const
  {
     wchar_t buffer[_MAX_PATH];
     ::GetModuleFileNameW(m_hModule, buffer, _MAX_PATH );
     return buffer;
  }
};
 
 
#define ODRX_DEFINE_DYNAMIC_MODULE(_UserModuleClass)\
ODRX_ALLOC_OPERATORS()\
static OdRxModule* g_pSingletonModule = 0;\
  extern "C" {\
__declspec(dllexport) OdRxModule* odrxCreateModuleObject(HMODULE& hModule)\
{\
  if(!g_pSingletonModule)\
  {\
    g_pSingletonModule = OdRxWin32Module<_UserModuleClass >::createModule(hModule);\
    hModule = 0;\
  }\
  return g_pSingletonModule;\
}\
__declspec(dllexport) void odrxGetAPIVersion(int& nMajorVersion, int& nMinorVersion,\
                                             int& nMajorBuildVersion, int& nMinorBuildVersion)\
{\
  nMajorVersion       = TD_MAJOR_VERSION;\
  nMinorVersion       = TD_MINOR_VERSION;\
  nMajorBuildVersion  = TD_MAJOR_BUILD;\
  nMinorBuildVersion  = TD_MINOR_BUILD;\
}\
}\
  void deleteModuleObject()\
{\
  g_pSingletonModule = NULL;\
}
 
#endif //__BORLANDC__
 
 
 
#endif //defined(__GNUC__) && defined(__APPLE__)
 
# define ODRX_GET_MODULE_OBJECT(_UserModuleClass) g_pSingletonModule
 
#else //#ifdef _TOOLKIT_IN_DLL_ ////////////////////////////////////////////////////////////////////////////////
 
#define ODRX_STATIC_MODULE_PATH ""
 
#define ODRX_STATIC_APP_MODULE_NAME(AppName) AppName
 
#define ODRX_DEFINE_DYNAMIC_MODULE(_UserModuleClass) ODRX_DEFINE_STATIC_MODULE(_UserModuleClass)
 
# define ODRX_GET_MODULE_OBJECT(_UserModuleClass) g_pSingletonModule##_UserModuleClass
 
 
#endif //#ifdef _TOOLKIT_IN_DLL_ ////////////////////////////////////////////////////////////////////////////////
 
 
 
#if defined(_TOOLKIT_IN_DLL_) && (defined(_MSC_VER) || (defined(_WIN32) && defined(__GNUC__)))
 
#define DISABLE_THREAD_LIBRARY_CALLS()\
extern "C" int APIENTRY DllMain(HINSTANCE h, DWORD reason, LPVOID ) {\
  if(reason==DLL_PROCESS_ATTACH)\
    DisableThreadLibraryCalls((HMODULE)h);\
  return TRUE;\
}
 
#else
 
#define DISABLE_THREAD_LIBRARY_CALLS()
 
#endif //#if defined(_TOOLKIT_IN_DLL_) && defined(_MSC_VER)
 
 
#include "TD_PackPop.h"
 
#endif // _OD_RXDYNAMICMODULE_H_