src/SALOMEDS/SALOMEDS_SObject.cxx

   1 //  Copyright (C) 2007-2010  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
  23 //  File   : SALOMEDS_SObject.hxx
  24 //  Author : Sergey RUIN
  25 //  Module : SALOME
  26 //
  27 #include <string>
  28
  29 #include "SALOMEDS_SObject.hxx"
  30
  31 #include "SALOMEDS.hxx"
  32 #include "SALOMEDS_SComponent.hxx"
  33 #include "SALOMEDS_GenericAttribute.hxx"
  34 #include "SALOMEDS_Study.hxx"
  35 #include "SALOMEDS_SObject_i.hxx"
  36
  37 #include "SALOMEDSImpl_SComponent.hxx"
  38 #include "SALOMEDSImpl_GenericAttribute.hxx"
  39 #include "SALOMEDSImpl_Study.hxx"
  40
  41 #include "Utils_ORB_INIT.hxx"
  42 #include "Utils_SINGLETON.hxx"
  43
  44 #include "Basics_Utils.hxx"
  45
  46 #include "utilities.h"
  47
  48 #ifdef WIN32
  49 #include <windows.h>
  50 #include <process.h>
  51 #else
  52 #include <sys/types.h>
  53 #include <unistd.h>
  54 #endif
  55
  56
  57 SALOMEDS_SObject::SALOMEDS_SObject(SALOMEDS::SObject_ptr theSObject)
  58 {
  59 #ifdef WIN32
  60   long pid =  (long)_getpid();
  61 #else
  62   long pid =  (long)getpid();
  63 #endif
  64
  65   CORBA::LongLong addr =  // mpv: fix for IPAL13534: for 64-bit platforms use 8-bytes long for pointer storage
  66   theSObject->GetLocalImpl(Kernel_Utils::GetHostname().c_str(), pid, _isLocal);
  67
  68   if(_isLocal) {
  69     _local_impl = reinterpret_cast<SALOMEDSImpl_SObject*>(addr);
  70     _corba_impl = SALOMEDS::SObject::_duplicate(theSObject);
  71   }
  72   else {
  73     _local_impl = NULL;
  74     _corba_impl = SALOMEDS::SObject::_duplicate(theSObject);
  75   }
  76
  77   init_orb();
  78 }
  79
  80 SALOMEDS_SObject::SALOMEDS_SObject(const SALOMEDSImpl_SObject& theSObject)
  81 :_isLocal(true)
  82 {
  83   _corba_impl = SALOMEDS::SObject::_nil();
  84
  85   if(theSObject.IsComponent()) {
  86     SALOMEDSImpl_SComponent sco = theSObject;
  87     _local_impl = sco.GetPersistentCopy();
  88   }
  89   else {
  90     _local_impl = theSObject.GetPersistentCopy();
  91   }
  92
  93   init_orb();
  94 }
  95
  96 SALOMEDS_SObject::~SALOMEDS_SObject()
  97 {
  98   if (!_isLocal) {
  99     _corba_impl->Destroy();
 100   }
 101   else {
 102     if(_local_impl) delete _local_impl;
 103   }
 104 }
 105
 106 std::string SALOMEDS_SObject::GetID()
 107 {
 108   std::string aValue;
 109   if (_isLocal) {
 110     SALOMEDS::Locker lock;
 111     aValue = _local_impl->GetID();
 112   }
 113   else aValue = (CORBA::String_var)_corba_impl->GetID();
 114   return aValue;
 115 }
 116
 117 _PTR(SComponent) SALOMEDS_SObject::GetFatherComponent()
 118 {
 119   if (_isLocal) {
 120     SALOMEDS::Locker lock;
 121     return _PTR(SComponent)(new SALOMEDS_SComponent(_local_impl->GetFatherComponent()));
 122   }
 123   return _PTR(SComponent)(new SALOMEDS_SComponent((SALOMEDS::SComponent_var)_corba_impl->GetFatherComponent()));
 124 }
 125
 126 _PTR(SObject) SALOMEDS_SObject::GetFather()
 127 {
 128   if (_isLocal) {
 129     SALOMEDS::Locker lock;
 130     return _PTR(SObject)(new SALOMEDS_SObject(_local_impl->GetFather()));
 131   }
 132   return _PTR(SObject)(new SALOMEDS_SObject((SALOMEDS::SObject_var)_corba_impl->GetFather()));
 133 }
 134
 135 bool SALOMEDS_SObject::FindAttribute(_PTR(GenericAttribute)& anAttribute,
 136                                      const std::string& aTypeOfAttribute)
 137 {
 138   bool ret = false;
 139   if (_isLocal) {
 140     SALOMEDS::Locker lock;
 141     DF_Attribute* anAttr = NULL;
 142     ret = _local_impl->FindAttribute(anAttr, aTypeOfAttribute);
 143     if(ret) {
 144       SALOMEDSImpl_GenericAttribute* ga = dynamic_cast<SALOMEDSImpl_GenericAttribute*>(anAttr);
 145       anAttribute = _PTR(GenericAttribute)(SALOMEDS_GenericAttribute::CreateAttribute(ga));
 146     }
 147   }
 148   else {
 149     SALOMEDS::GenericAttribute_var anAttr;
 150     ret = _corba_impl->FindAttribute(anAttr.out(), aTypeOfAttribute.c_str());
 151     if(ret) anAttribute = _PTR(GenericAttribute)(SALOMEDS_GenericAttribute::CreateAttribute(anAttr));
 152   }
 153
 154   return ret;
 155 }
 156
 157 bool SALOMEDS_SObject::ReferencedObject(_PTR(SObject)& theObject)
 158 {
 159   bool ret = false;
 160   if (_isLocal) {
 161     SALOMEDS::Locker lock;
 162     SALOMEDSImpl_SObject aSO;
 163     ret = _local_impl->ReferencedObject(aSO);
 164     if(ret) theObject = _PTR(SObject)(new SALOMEDS_SObject(aSO));
 165   }
 166   else {
 167     SALOMEDS::SObject_var aSO;
 168     ret = _corba_impl->ReferencedObject(aSO.out());
 169     if(ret) theObject = _PTR(SObject)(new SALOMEDS_SObject(aSO));
 170   }
 171
 172   return ret;
 173 }
 174
 175
 176 bool SALOMEDS_SObject::FindSubObject(int theTag, _PTR(SObject)& theObject)
 177 {
 178   bool ret = false;
 179   if (_isLocal) {
 180     SALOMEDS::Locker lock;
 181     SALOMEDSImpl_SObject aSO;
 182     ret = _local_impl->FindSubObject(theTag, aSO);
 183     if(ret) theObject = _PTR(SObject)(new SALOMEDS_SObject(aSO));
 184   }
 185   else {
 186     SALOMEDS::SObject_var aSO;
 187     ret = _corba_impl->FindSubObject(theTag, aSO.out());
 188     if(ret) theObject = _PTR(SObject)(new SALOMEDS_SObject(aSO));
 189   }
 190
 191   return ret;
 192 }
 193
 194 _PTR(Study) SALOMEDS_SObject::GetStudy()
 195 {
 196   if (_isLocal) {
 197     SALOMEDS::Locker lock;
 198     return _PTR(Study)(new SALOMEDS_Study(_local_impl->GetStudy()));
 199   }
 200   SALOMEDS::Study_var study=_corba_impl->GetStudy();
 201   return _PTR(Study)(new SALOMEDS_Study(study));
 202 }
 203
 204 std::string SALOMEDS_SObject::Name()
 205 {
 206   std::string aName;
 207   if (_isLocal) {
 208     SALOMEDS::Locker lock;
 209     aName = _local_impl->Name();
 210   }
 211   else aName = (CORBA::String_var)_corba_impl->Name();
 212
 213   return aName;
 214 }
 215
 216 void  SALOMEDS_SObject::Name(const std::string& theName)
 217 {
 218   if (_isLocal) {
 219     SALOMEDS::Locker lock;
 220     _local_impl->Name(theName);
 221   }
 222   else _corba_impl->Name(theName.c_str());
 223 }
 224
 225 std::vector<_PTR(GenericAttribute)> SALOMEDS_SObject::GetAllAttributes()
 226 {
 227   std::vector<_PTR(GenericAttribute)> aVector;
 228   int aLength = 0;
 229   SALOMEDSClient_GenericAttribute* anAttr;
 230
 231   if (_isLocal) {
 232     SALOMEDS::Locker lock;
 233     std::vector<DF_Attribute*> aSeq = _local_impl->GetAllAttributes();
 234     aLength = aSeq.size();
 235     for (int i = 0; i < aLength; i++) {
 236       anAttr = SALOMEDS_GenericAttribute::CreateAttribute(dynamic_cast<SALOMEDSImpl_GenericAttribute*>(aSeq[i]));
 237       aVector.push_back(_PTR(GenericAttribute)(anAttr));
 238     }
 239   }
 240   else {
 241     SALOMEDS::ListOfAttributes_var aSeq = _corba_impl->GetAllAttributes();
 242     aLength = aSeq->length();
 243     for (int i = 0; i < aLength; i++) {
 244       anAttr = SALOMEDS_GenericAttribute::CreateAttribute(aSeq[i]);
 245       aVector.push_back(_PTR(GenericAttribute)(anAttr));
 246     }
 247   }
 248
 249   return aVector;
 250 }
 251
 252 std::string SALOMEDS_SObject::GetName()
 253 {
 254   std::string aName;
 255   if (_isLocal) {
 256     SALOMEDS::Locker lock;
 257     aName = _local_impl->GetName();
 258   }
 259   else aName = (CORBA::String_var) _corba_impl->GetName();
 260
 261   return aName;
 262 }
 263
 264 std::string SALOMEDS_SObject::GetComment()
 265 {
 266   std::string aComment;
 267   if (_isLocal) {
 268     SALOMEDS::Locker lock;
 269     aComment = _local_impl->GetComment();
 270   }
 271   else aComment = (CORBA::String_var) _corba_impl->GetComment();
 272
 273   return aComment;
 274 }
 275
 276 std::string SALOMEDS_SObject::GetIOR()
 277 {
 278   std::string anIOR;
 279   if (_isLocal) {
 280     SALOMEDS::Locker lock;
 281     anIOR = _local_impl->GetIOR();
 282   }
 283   else anIOR = (CORBA::String_var) _corba_impl->GetIOR();
 284
 285   return anIOR;
 286 }
 287
 288 int SALOMEDS_SObject::Tag()
 289 {
 290   if (_isLocal) {
 291     SALOMEDS::Locker lock;
 292     return _local_impl->Tag();
 293   }
 294   return _corba_impl->Tag();
 295 }
 296
 297 int SALOMEDS_SObject::Depth()
 298 {
 299   if (_isLocal) {
 300     SALOMEDS::Locker lock;
 301     return _local_impl->Depth();
 302   }
 303   return _corba_impl->Depth();
 304 }
 305
 306 CORBA::Object_ptr SALOMEDS_SObject::GetObject()
 307 {
 308   CORBA::Object_var obj;
 309   if (_isLocal) {
 310     SALOMEDS::Locker lock;
 311     std::string anIOR = GetIOR();
 312     if (!anIOR.empty())
 313       obj = _orb->string_to_object(anIOR.c_str());
 314     return obj._retn();
 315   }
 316   else {
 317     obj = _corba_impl->GetObject();
 318     return obj._retn();
 319   }
 320
 321   return CORBA::Object::_nil();
 322 }
 323
 324 SALOMEDS::SObject_ptr SALOMEDS_SObject::GetSObject()
 325 {
 326   if(_isLocal) {
 327     if(!CORBA::is_nil(_corba_impl)) return SALOMEDS::SObject::_duplicate(_corba_impl);
 328     SALOMEDS::SObject_var aSO = SALOMEDS_SObject_i::New(*_local_impl, _orb);
 329     _corba_impl = SALOMEDS::SObject::_duplicate(aSO);
 330     return aSO._retn();
 331   }
 332   else {
 333     return SALOMEDS::SObject::_duplicate(_corba_impl);
 334   }
 335   return SALOMEDS::SObject::_nil();
 336 }
 337
 338
 339 void SALOMEDS_SObject::init_orb()
 340 {
 341   ORB_INIT &init = *SINGLETON_<ORB_INIT>::Instance() ;
 342   ASSERT(SINGLETON_<ORB_INIT>::IsAlreadyExisting());
 343   _orb = init(0 , 0 ) ;
 344 }
 345
 346 void SALOMEDS_SObject::SetAttrString(const std::string& name, const std::string& value)
 347 {
 348   if(_isLocal)
 349     {
 350       SALOMEDS::Locker lock;
 351       _local_impl->SetAttrString(name,value);
 352     }
 353   else
 354     {
 355       _corba_impl->SetAttrString(name.c_str(),value.c_str());
 356     }
 357 }