src/SALOMEDSClient/SALOMEDSClient_ClientFactory.cxx

   1 //  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 //  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 #include "SALOMEDSClient_ClientFactory.hxx"
  23
  24 #ifdef WIN32
  25 #include <windows.h>
  26 static HMODULE _libHandle = 0;
  27 #define SALOMEDS_LIB_NAME "SalomeDS.dll"
  28 #else
  29 #include <dlfcn.h>
  30 static void* _libHandle = NULL;
  31 #define SALOMEDS_LIB_NAME "libSalomeDS.so"
  32 #endif
  33
  34 #define SOBJECT_FACTORY      "SObjectFactory"
  35 #define SCOMPONENT_FACTORY   "SComponentFactory"
  36 #define STUDY_FACTORY        "StudyFactory"
  37 #define BUILDER_FACTORY      "BuilderFactory"
  38 #define STUDYMANAGER_FACTORY "StudyManagerFactory"
  39 #define STUDYMANAGER_CREATE  "CreateStudyManager"
  40 #define GET_PARAMETERS       "GetIParameters"
  41 #define CONVERT_SOBJECT      "ConvertSObject"
  42 #define CONVERT_STUDY        "ConvertStudy"
  43 #define CONVERT_BUILDER      "ConvertBuilder"
  44
  45 typedef SALOMEDSClient_SObject* (*SOBJECT_FACTORY_FUNCTION) (SALOMEDS::SObject_ptr);
  46 typedef SALOMEDSClient_SComponent* (*SCOMPONENT_FACTORY_FUNCTION) (SALOMEDS::SComponent_ptr);
  47 typedef SALOMEDSClient_Study* (*STUDY_FACTORY_FUNCTION) (SALOMEDS::Study_ptr);
  48 typedef SALOMEDSClient_StudyManager* (*STUDYMANAGER_FACTORY_FUNCTION) ();
  49 typedef SALOMEDSClient_StudyBuilder* (*BUILDER_FACTORY_FUNCTION) (SALOMEDS::StudyBuilder_ptr);
  50 typedef SALOMEDSClient_StudyManager* (*STUDYMANAGER_CREATE_FUNCTION) (CORBA::ORB_ptr, PortableServer::POA_ptr);
  51 typedef SALOMEDSClient_IParameters* (*GET_PARAMETERS_FACTORY) (const _PTR(AttributeParameter)&);
  52 typedef SALOMEDS::SObject_ptr (*CONVERT_SOBJECT_FUNCTION) (const _PTR(SObject)&);
  53 typedef SALOMEDS::Study_ptr (*CONVERT_STUDY_FUNCTION) (const _PTR(Study)&);
  54 typedef SALOMEDS::StudyBuilder_ptr (*CONVERT_BUILDER_FUNCTION) (const _PTR(StudyBuilder)&);
  55
  56
  57 static SOBJECT_FACTORY_FUNCTION aSObjectFactory = NULL;
  58 static SCOMPONENT_FACTORY_FUNCTION aSComponentFactory = NULL;
  59 static STUDY_FACTORY_FUNCTION aStudyFactory = NULL;
  60 static BUILDER_FACTORY_FUNCTION aBuilderFactory = NULL;
  61 static STUDYMANAGER_FACTORY_FUNCTION aManagerFactory = NULL;
  62 static STUDYMANAGER_CREATE_FUNCTION aCreateFactory = NULL;
  63 static GET_PARAMETERS_FACTORY aGetIParameters = NULL;
  64 static CONVERT_SOBJECT_FUNCTION aConvertSObject = NULL;
  65 static CONVERT_STUDY_FUNCTION aConvertStudy = NULL;
  66 static CONVERT_BUILDER_FUNCTION aConvertBuilder = NULL;
  67
  68 using namespace std;
  69
  70 _PTR(SObject) ClientFactory::SObject(SALOMEDS::SObject_ptr theSObject)
  71 {
  72   SALOMEDSClient_SObject* so = NULL;
  73
  74 #ifdef WIN32
  75   if(!_libHandle) _libHandle = ::LoadLibrary(SALOMEDS_LIB_NAME);
  76   if(!aSObjectFactory) aSObjectFactory = (SOBJECT_FACTORY_FUNCTION)::GetProcAddress(_libHandle, SOBJECT_FACTORY);
  77 #else
  78   if(!_libHandle) _libHandle = dlopen(SALOMEDS_LIB_NAME, RTLD_LAZY | RTLD_GLOBAL);
  79   if(!aSObjectFactory) aSObjectFactory = (SOBJECT_FACTORY_FUNCTION) dlsym(_libHandle, SOBJECT_FACTORY);
  80 #endif
  81
  82   if(aSObjectFactory) so = aSObjectFactory(theSObject);
  83   return _PTR(SObject)(so);
  84 }
  85
  86 _PTR(SComponent) ClientFactory::SComponent(SALOMEDS::SComponent_ptr theSComponent)
  87 {
  88   SALOMEDSClient_SComponent* sco = NULL;
  89
  90 #ifdef WIN32
  91   if(!_libHandle) _libHandle = ::LoadLibrary(SALOMEDS_LIB_NAME);
  92   if(!aSComponentFactory) aSComponentFactory = (SCOMPONENT_FACTORY_FUNCTION)::GetProcAddress(_libHandle, SCOMPONENT_FACTORY);
  93 #else
  94   if(!_libHandle) _libHandle = dlopen(SALOMEDS_LIB_NAME, RTLD_LAZY | RTLD_GLOBAL);
  95   if(!aSComponentFactory) aSComponentFactory = (SCOMPONENT_FACTORY_FUNCTION) dlsym(_libHandle, SCOMPONENT_FACTORY);
  96 #endif
  97
  98   if(aSComponentFactory) sco = aSComponentFactory(theSComponent);
  99   return _PTR(SComponent)(sco);
 100 }
 101
 102 _PTR(Study) ClientFactory::Study(SALOMEDS::Study_ptr theStudy)
 103 {
 104   SALOMEDSClient_Study* study = NULL;
 105
 106 #ifdef WIN32
 107   if(!_libHandle) _libHandle = ::LoadLibrary(SALOMEDS_LIB_NAME);
 108   if(!aStudyFactory) aStudyFactory = (STUDY_FACTORY_FUNCTION)::GetProcAddress(_libHandle, STUDY_FACTORY);
 109 #else
 110   if(!_libHandle) _libHandle = dlopen(SALOMEDS_LIB_NAME, RTLD_LAZY | RTLD_GLOBAL);
 111   if(!aStudyFactory) aStudyFactory = (STUDY_FACTORY_FUNCTION) dlsym(_libHandle, STUDY_FACTORY);
 112 #endif
 113
 114   if(aStudyFactory) study = aStudyFactory(theStudy);
 115   return _PTR(Study)(study);
 116 }
 117
 118 _PTR(StudyBuilder) ClientFactory::StudyBuilder(SALOMEDS::StudyBuilder_ptr theStudyBuilder)
 119 {
 120   SALOMEDSClient_StudyBuilder* studyBuilder = NULL;
 121
 122 #ifdef WIN32
 123   if(!_libHandle) _libHandle = ::LoadLibrary(SALOMEDS_LIB_NAME);
 124   if(!aBuilderFactory) aBuilderFactory = (BUILDER_FACTORY_FUNCTION)::GetProcAddress(_libHandle, BUILDER_FACTORY);
 125 #else
 126   if(!_libHandle) _libHandle = dlopen(SALOMEDS_LIB_NAME, RTLD_LAZY | RTLD_GLOBAL);
 127   if(!aBuilderFactory) aBuilderFactory = (BUILDER_FACTORY_FUNCTION) dlsym(_libHandle, BUILDER_FACTORY);
 128 #endif
 129
 130   if(aBuilderFactory) studyBuilder = aBuilderFactory(theStudyBuilder);
 131   return _PTR(StudyBuilder)(studyBuilder);
 132 }
 133
 134 _PTR(StudyManager) ClientFactory::StudyManager()
 135 {
 136   SALOMEDSClient_StudyManager* manager = NULL;
 137
 138 #ifdef WIN32
 139   if(!_libHandle) _libHandle = ::LoadLibrary(SALOMEDS_LIB_NAME);
 140   if(!aManagerFactory) aManagerFactory = (STUDYMANAGER_FACTORY_FUNCTION)::GetProcAddress(_libHandle, STUDYMANAGER_FACTORY);
 141 #else
 142   if(!_libHandle) _libHandle = dlopen(SALOMEDS_LIB_NAME, RTLD_LAZY | RTLD_GLOBAL);
 143   if(!aManagerFactory) aManagerFactory = (STUDYMANAGER_FACTORY_FUNCTION) dlsym(_libHandle, STUDYMANAGER_FACTORY);
 144 #endif
 145
 146   if(aManagerFactory) manager = aManagerFactory();
 147   return _PTR(StudyManager)(manager);
 148 }
 149
 150 _PTR(StudyManager) ClientFactory::createStudyManager(CORBA::ORB_ptr orb, PortableServer::POA_ptr poa)
 151 {
 152   SALOMEDSClient_StudyManager* manager = NULL;
 153
 154 #ifdef WIN32
 155   if(!_libHandle) _libHandle = ::LoadLibrary(SALOMEDS_LIB_NAME);
 156   if(!aCreateFactory) aCreateFactory = (STUDYMANAGER_CREATE_FUNCTION)::GetProcAddress(_libHandle, STUDYMANAGER_CREATE);
 157 #else
 158   if(!_libHandle) _libHandle = dlopen(SALOMEDS_LIB_NAME, RTLD_LAZY | RTLD_GLOBAL);
 159   if(!aCreateFactory) aCreateFactory = (STUDYMANAGER_CREATE_FUNCTION) dlsym(_libHandle, STUDYMANAGER_CREATE);
 160 #endif
 161
 162   if(aCreateFactory)  manager = aCreateFactory(orb, poa);
 163   return _PTR(StudyManager)(manager);
 164 }
 165
 166 _PTR(IParameters) ClientFactory::getIParameters(const _PTR(AttributeParameter)& ap)
 167 {
 168   SALOMEDSClient_IParameters* interface = NULL;
 169
 170 #ifdef WIN32
 171   if(!_libHandle) _libHandle = ::LoadLibrary(SALOMEDS_LIB_NAME);
 172   if(!aGetIParameters) aGetIParameters = (GET_PARAMETERS_FACTORY)::GetProcAddress(_libHandle, GET_PARAMETERS);
 173 #else
 174   if(!_libHandle) _libHandle = dlopen(SALOMEDS_LIB_NAME, RTLD_LAZY | RTLD_GLOBAL);
 175   if(!aGetIParameters) aGetIParameters = (GET_PARAMETERS_FACTORY) dlsym(_libHandle, GET_PARAMETERS);
 176 #endif
 177
 178   if(aGetIParameters) interface = aGetIParameters(ap);
 179   return _PTR(IParameters)(interface);
 180 }
 181
 182 SALOMEDS::SObject_ptr ClientFactory::crbSObject(const _PTR(SObject)& theSObject)
 183 {
 184   SALOMEDS::SObject_var so;
 185
 186 #ifdef WIN32
 187   if(!_libHandle) _libHandle = ::LoadLibrary(SALOMEDS_LIB_NAME);
 188   if(!aConvertSObject) aConvertSObject = (CONVERT_SOBJECT_FUNCTION)::GetProcAddress(_libHandle, CONVERT_SOBJECT);
 189 #else
 190   if(!_libHandle) _libHandle = dlopen(SALOMEDS_LIB_NAME, RTLD_LAZY | RTLD_GLOBAL);
 191   if(!aConvertSObject) aConvertSObject = (CONVERT_SOBJECT_FUNCTION) dlsym(_libHandle, CONVERT_SOBJECT);
 192 #endif
 193
 194   if(aConvertSObject) so = aConvertSObject(theSObject);
 195
 196   if(CORBA::is_nil(so)) return SALOMEDS::SObject::_nil();
 197   return so._retn();
 198 }
 199
 200
 201 SALOMEDS::Study_ptr ClientFactory::crbStudy(const _PTR(Study)& theStudy)
 202 {
 203   SALOMEDS::Study_var study;
 204
 205 #ifdef WIN32
 206   if(!_libHandle) _libHandle = ::LoadLibrary(SALOMEDS_LIB_NAME);
 207   if(!aConvertStudy) aConvertStudy = (CONVERT_STUDY_FUNCTION)::GetProcAddress(_libHandle, CONVERT_STUDY);
 208 #else
 209   if(!_libHandle) _libHandle = dlopen(SALOMEDS_LIB_NAME, RTLD_LAZY | RTLD_GLOBAL);
 210   if(!aConvertStudy) aConvertStudy = (CONVERT_STUDY_FUNCTION) dlsym(_libHandle, CONVERT_STUDY);
 211 #endif
 212
 213   if(aConvertStudy) study = aConvertStudy(theStudy);
 214
 215   if(CORBA::is_nil(study)) return SALOMEDS::Study::_nil();
 216   return study._retn();
 217 }
 218
 219 SALOMEDS::StudyBuilder_ptr ClientFactory::crbStudyBuilder(const _PTR(StudyBuilder)& theStudyBuilder)
 220 {
 221   SALOMEDS::StudyBuilder_var studyBuilder;
 222
 223 #ifdef WIN32
 224   if(!_libHandle) _libHandle = ::LoadLibrary(SALOMEDS_LIB_NAME);
 225   if(!aConvertBuilder)aConvertBuilder  = (CONVERT_BUILDER_FUNCTION)::GetProcAddress(_libHandle, CONVERT_BUILDER);
 226 #else
 227   if(!_libHandle) _libHandle = dlopen(SALOMEDS_LIB_NAME, RTLD_LAZY | RTLD_GLOBAL);
 228   if(!aConvertBuilder) aConvertBuilder = (CONVERT_BUILDER_FUNCTION) dlsym(_libHandle, CONVERT_BUILDER);
 229 #endif
 230
 231   if(aConvertBuilder) studyBuilder = aConvertBuilder(theStudyBuilder);
 232
 233   if(CORBA::is_nil(studyBuilder)) return SALOMEDS::StudyBuilder::_nil();
 234   return studyBuilder._retn();
 235 }