src/SALOMEDS/SALOMEDS_StudyBuilder.cxx

   1 // Copyright (C) 2005  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   2 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   3 //
   4 // This library is free software; you can redistribute it and/or
   5 // modify it under the terms of the GNU Lesser General Public
   6 // License as published by the Free Software Foundation; either
   7 // version 2.1 of the License.
   8 //
   9 // This library is distributed in the hope that it will be useful
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 // Lesser General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Lesser General Public
  15 // License along with this library; if not, write to the Free Software
  16 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 //
  18 // See http://www.salome-platform.org/
  19 //
  20 //  File   : SALOMEDS_StudyBuilder.cxx
  21 //  Author : Sergey RUIN
  22 //  Module : SALOME
  23
  24
  25
  26 #include "utilities.h"
  27
  28 #include "SALOMEDS_StudyBuilder.hxx"
  29 #include "SALOMEDS_SObject.hxx"
  30 #include "SALOMEDSImpl_SObject.hxx"
  31 #include "SALOMEDS_SComponent.hxx"
  32 #include "SALOMEDSImpl_SComponent.hxx"
  33 #include "SALOMEDS_Driver_i.hxx"
  34 #include "SALOMEDS_GenericAttribute.hxx"
  35 #include "SALOMEDSImpl_GenericAttribute.hxx"
  36 #include <string>
  37 #include <TCollection_AsciiString.hxx>
  38 #include <TDF_Attribute.hxx>
  39 #include "SALOMEDS_StudyManager.hxx"
  40
  41 #include "Utils_CorbaException.hxx"
  42 #include "Utils_ORB_INIT.hxx"
  43 #include "Utils_SINGLETON.hxx"
  44
  45 using namespace std;
  46
  47 SALOMEDS_StudyBuilder::SALOMEDS_StudyBuilder(const Handle(SALOMEDSImpl_StudyBuilder)& theBuilder)
  48 {
  49   _isLocal = true;
  50   _local_impl = theBuilder;
  51   _corba_impl = SALOMEDS::StudyBuilder::_nil();
  52
  53   init_orb();
  54 }
  55
  56 SALOMEDS_StudyBuilder::SALOMEDS_StudyBuilder(SALOMEDS::StudyBuilder_ptr theBuilder)
  57 {
  58   _isLocal = false;
  59   _local_impl = NULL;
  60   _corba_impl = SALOMEDS::StudyBuilder::_duplicate(theBuilder);
  61
  62   init_orb();
  63 }
  64
  65 SALOMEDS_StudyBuilder::~SALOMEDS_StudyBuilder()
  66 {
  67 }
  68
  69 _PTR(SComponent) SALOMEDS_StudyBuilder::NewComponent(const std::string& ComponentDataType)
  70 {
  71   CheckLocked();
  72
  73   SALOMEDSClient_SComponent* aSCO = NULL;
  74
  75   if(_isLocal) {
  76     Handle(SALOMEDSImpl_SComponent) aSCO_impl =_local_impl->NewComponent((char*)ComponentDataType.c_str());
  77     if(aSCO_impl.IsNull()) return _PTR(SComponent)(aSCO);
  78     aSCO = new SALOMEDS_SComponent(aSCO_impl);
  79   }
  80   else {
  81     SALOMEDS::SComponent_var aSCO_impl = _corba_impl->NewComponent((char*)ComponentDataType.c_str());
  82     if(CORBA::is_nil(aSCO_impl)) return _PTR(SComponent)(aSCO);
  83     aSCO = new SALOMEDS_SComponent(aSCO_impl);
  84   }
  85
  86   return _PTR(SComponent)(aSCO);
  87 }
  88
  89 void SALOMEDS_StudyBuilder::DefineComponentInstance (const _PTR(SComponent)& theSCO,
  90                                                      const std::string& ComponentIOR)
  91 {
  92   CheckLocked();
  93
  94   SALOMEDS_SComponent* aSCO = dynamic_cast<SALOMEDS_SComponent*>(theSCO.get());
  95   if(_isLocal) _local_impl->DefineComponentInstance(Handle(SALOMEDSImpl_SComponent)::DownCast(aSCO->GetLocalImpl()),
  96                                                     (char*)ComponentIOR.c_str());
  97   else {
  98     CORBA::Object_var obj = _orb->string_to_object(ComponentIOR.c_str());
  99     _corba_impl->DefineComponentInstance(SALOMEDS::SComponent::_narrow(aSCO->GetCORBAImpl()), obj);
 100   }
 101 }
 102
 103 void SALOMEDS_StudyBuilder::RemoveComponent(const _PTR(SComponent)& theSCO)
 104 {
 105   CheckLocked();
 106
 107   SALOMEDS_SComponent* aSCO = dynamic_cast<SALOMEDS_SComponent*>(theSCO.get());
 108   if(_isLocal) _local_impl->RemoveComponent(Handle(SALOMEDSImpl_SComponent)::DownCast(aSCO->GetLocalImpl()));
 109   else _corba_impl->RemoveComponent(SALOMEDS::SComponent::_narrow(aSCO->GetCORBAImpl()));
 110 }
 111
 112 _PTR(SObject) SALOMEDS_StudyBuilder::NewObject(const _PTR(SObject)& theFatherObject)
 113 {
 114   CheckLocked();
 115
 116   SALOMEDSClient_SObject* aSO = NULL;
 117   SALOMEDS_SObject* father = dynamic_cast< SALOMEDS_SObject*>(theFatherObject.get());
 118   if(father == NULL) return _PTR(SObject)(aSO);
 119   if(_isLocal) {
 120     Handle(SALOMEDSImpl_SObject) aSO_impl = _local_impl->NewObject(father->GetLocalImpl());
 121     if(aSO_impl.IsNull()) return _PTR(SObject)(aSO);
 122     aSO = new SALOMEDS_SObject(aSO_impl);
 123   }
 124   else {
 125     SALOMEDS::SObject_var aSO_impl = _corba_impl->NewObject(father->GetCORBAImpl());
 126     if(CORBA::is_nil(aSO_impl)) return _PTR(SObject)(aSO);
 127     aSO = new SALOMEDS_SObject(aSO_impl);
 128   }
 129
 130   return _PTR(SObject)(aSO);
 131 }
 132
 133 _PTR(SObject) SALOMEDS_StudyBuilder::NewObjectToTag(const _PTR(SObject)& theFatherObject, int theTag)
 134 {
 135   CheckLocked();
 136
 137   SALOMEDSClient_SObject* aSO = NULL;
 138   SALOMEDS_SObject* father = dynamic_cast< SALOMEDS_SObject*>(theFatherObject.get());
 139   if(father == NULL) return _PTR(SObject)(aSO);
 140   if(_isLocal) {
 141     Handle(SALOMEDSImpl_SObject) aSO_impl = _local_impl->NewObjectToTag(father->GetLocalImpl(), theTag);
 142     if(aSO_impl.IsNull()) return _PTR(SObject)(aSO);
 143     aSO = new SALOMEDS_SObject(aSO_impl);
 144   }
 145   else {
 146     SALOMEDS::SObject_var aSO_impl = _corba_impl->NewObjectToTag(father->GetCORBAImpl(), theTag);
 147     if(CORBA::is_nil(aSO_impl)) return _PTR(SObject)(aSO);
 148     aSO = new SALOMEDS_SObject(aSO_impl);
 149   }
 150
 151   return _PTR(SObject)(aSO);
 152
 153 }
 154
 155 void SALOMEDS_StudyBuilder::AddDirectory(const std::string& thePath)
 156 {
 157   CheckLocked();
 158
 159   if(_isLocal) {
 160     _local_impl->AddDirectory((char*)thePath.c_str());
 161     if(_local_impl->IsError()) {
 162       std::string anErrorCode = _local_impl->GetErrorCode().ToCString();
 163       if(anErrorCode == "StudyNameAlreadyUsed") throw SALOMEDS::Study::StudyNameAlreadyUsed();
 164       if(anErrorCode == "StudyInvalidDirectory") throw SALOMEDS::Study::StudyInvalidDirectory();
 165       if(anErrorCode == "StudyInvalidComponent") throw SALOMEDS::Study::StudyInvalidComponent();
 166     }
 167   }
 168   else _corba_impl->AddDirectory((char*)thePath.c_str());
 169 }
 170
 171 void SALOMEDS_StudyBuilder::LoadWith(const _PTR(SComponent)& theSCO, const std::string& theIOR)
 172 {
 173   SALOMEDS_SComponent* aSCO = dynamic_cast<SALOMEDS_SComponent*>(theSCO.get());
 174   CORBA::Object_var obj = _orb->string_to_object(theIOR.c_str());
 175   SALOMEDS::Driver_var aDriver = SALOMEDS::Driver::_narrow(obj);
 176
 177   if(_isLocal) {
 178     SALOMEDS_Driver_i* drv = new SALOMEDS_Driver_i(aDriver, _orb);
 179     Handle(SALOMEDSImpl_SComponent) aSCO_impl = Handle(SALOMEDSImpl_SComponent)::DownCast(aSCO->GetLocalImpl());
 180     bool isDone = _local_impl->LoadWith(aSCO_impl, drv);
 181     delete drv;
 182     if(!isDone && _local_impl->IsError())
 183       THROW_SALOME_CORBA_EXCEPTION(_local_impl->GetErrorCode().ToCString(),SALOME::BAD_PARAM);
 184   }
 185   else {
 186     _corba_impl->LoadWith(SALOMEDS::SComponent::_narrow(aSCO->GetCORBAImpl()), aDriver);
 187   }
 188 }
 189
 190 void SALOMEDS_StudyBuilder::Load(const _PTR(SObject)& theSCO)
 191 {
 192   SALOMEDS_SComponent* aSCO = dynamic_cast<SALOMEDS_SComponent*>(theSCO.get());
 193   if(_isLocal) _local_impl->Load(Handle(SALOMEDSImpl_SComponent)::DownCast(aSCO->GetLocalImpl()));
 194   else _corba_impl->Load(SALOMEDS::SComponent::_narrow(aSCO->GetCORBAImpl()));
 195 }
 196
 197 void SALOMEDS_StudyBuilder::RemoveObject(const _PTR(SObject)& theSO)
 198 {
 199   CheckLocked();
 200
 201   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
 202   if(_isLocal) _local_impl->RemoveObject(aSO->GetLocalImpl());
 203   else _corba_impl->RemoveObject(aSO->GetCORBAImpl());
 204 }
 205
 206 void SALOMEDS_StudyBuilder::RemoveObjectWithChildren(const _PTR(SObject)& theSO)
 207 {
 208   CheckLocked();
 209
 210   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
 211   if(_isLocal) _local_impl->RemoveObjectWithChildren(aSO->GetLocalImpl());
 212   else _corba_impl->RemoveObjectWithChildren(aSO->GetCORBAImpl());
 213 }
 214
 215 _PTR(GenericAttribute) SALOMEDS_StudyBuilder::FindOrCreateAttribute(const _PTR(SObject)& theSO,
 216                                                                     const std::string& aTypeOfAttribute)
 217 {
 218   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
 219   SALOMEDSClient_GenericAttribute* anAttr = NULL;
 220   if(_isLocal) {
 221     Handle(SALOMEDSImpl_GenericAttribute) aGA;
 222     try {
 223       aGA=Handle(SALOMEDSImpl_GenericAttribute)::DownCast(_local_impl->FindOrCreateAttribute(aSO->GetLocalImpl(),
 224                                                                                              (char*)aTypeOfAttribute.c_str()));
 225      }
 226     catch (...) {
 227       throw SALOMEDS::StudyBuilder::LockProtection();
 228     }
 229     anAttr = SALOMEDS_GenericAttribute::CreateAttribute(aGA);
 230   }
 231   else {
 232     SALOMEDS::GenericAttribute_var aGA = _corba_impl->FindOrCreateAttribute(aSO->GetCORBAImpl(), (char*)aTypeOfAttribute.c_str());
 233     anAttr = SALOMEDS_GenericAttribute::CreateAttribute(aGA);
 234   }
 235
 236   return _PTR(GenericAttribute)(anAttr);
 237 }
 238
 239 bool SALOMEDS_StudyBuilder::FindAttribute(const _PTR(SObject)& theSO,
 240                                           _PTR(GenericAttribute)& anAttribute,
 241                                           const std::string& aTypeOfAttribute)
 242 {
 243   bool ret;
 244   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
 245   if(_isLocal) {
 246     Handle(SALOMEDSImpl_GenericAttribute) aGA;
 247     ret = _local_impl->FindAttribute(aSO->GetLocalImpl(), aGA, (char*)aTypeOfAttribute.c_str());
 248     if(ret) anAttribute = _PTR(GenericAttribute)(SALOMEDS_GenericAttribute::CreateAttribute(aGA));
 249   }
 250   else {
 251     SALOMEDS::GenericAttribute_var aGA;
 252     ret = _corba_impl->FindAttribute(aSO->GetCORBAImpl(), aGA.out(), (char*)aTypeOfAttribute.c_str());
 253     if(ret) anAttribute = _PTR(GenericAttribute)(SALOMEDS_GenericAttribute::CreateAttribute(aGA));
 254   }
 255
 256   return ret;
 257 }
 258
 259 void SALOMEDS_StudyBuilder::RemoveAttribute(const _PTR(SObject)& theSO, const std::string& aTypeOfAttribute)
 260 {
 261   CheckLocked();
 262
 263   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
 264   if(_isLocal) _local_impl->RemoveAttribute(aSO->GetLocalImpl(), (char*)aTypeOfAttribute.c_str());
 265   else _corba_impl->RemoveAttribute(aSO->GetCORBAImpl(), (char*)aTypeOfAttribute.c_str());
 266 }
 267
 268 void SALOMEDS_StudyBuilder::Addreference(const _PTR(SObject)& me, const _PTR(SObject)& thereferencedObject)
 269 {
 270   CheckLocked();
 271
 272   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(me.get());
 273   SALOMEDS_SObject* aRefSO = dynamic_cast<SALOMEDS_SObject*>(thereferencedObject.get());
 274   if(_isLocal) _local_impl->Addreference(aSO->GetLocalImpl(), aRefSO->GetLocalImpl());
 275   else _corba_impl->Addreference(aSO->GetCORBAImpl(), aRefSO->GetCORBAImpl());
 276 }
 277
 278 void SALOMEDS_StudyBuilder::RemoveReference(const _PTR(SObject)& me)
 279 {
 280   CheckLocked();
 281
 282   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(me.get());
 283   if(_isLocal) _local_impl->RemoveReference(aSO->GetLocalImpl());
 284   else _corba_impl->RemoveReference(aSO->GetCORBAImpl());
 285 }
 286
 287 void SALOMEDS_StudyBuilder::SetGUID(const _PTR(SObject)& theSO, const std::string& theGUID)
 288 {
 289   CheckLocked();
 290
 291   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
 292   if(_isLocal) _local_impl->SetGUID(aSO->GetLocalImpl(), (char*)theGUID.c_str());
 293   else _corba_impl->SetGUID(aSO->GetCORBAImpl(), (char*)theGUID.c_str());
 294 }
 295
 296 bool SALOMEDS_StudyBuilder::IsGUID(const _PTR(SObject)& theSO, const std::string& theGUID)
 297 {
 298   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
 299   bool ret;
 300   if(_isLocal) ret = _local_impl->IsGUID(aSO->GetLocalImpl(), (char*)theGUID.c_str());
 301   else ret = _corba_impl->IsGUID(aSO->GetCORBAImpl(), (char*)theGUID.c_str());
 302
 303   return ret;
 304 }
 305
 306 void SALOMEDS_StudyBuilder::NewCommand()
 307 {
 308   if(_isLocal) _local_impl->NewCommand();
 309   else _corba_impl->NewCommand();
 310 }
 311
 312 void SALOMEDS_StudyBuilder::CommitCommand()
 313 {
 314   if(_isLocal) {
 315     try {
 316       _local_impl->CommitCommand();
 317     }
 318     catch(...) {
 319       throw SALOMEDS::StudyBuilder::LockProtection();
 320     }
 321   }
 322   else _corba_impl->CommitCommand();
 323 }
 324
 325 bool SALOMEDS_StudyBuilder::HasOpenCommand()
 326 {
 327   bool ret;
 328   if(_isLocal) ret = _local_impl->HasOpenCommand();
 329   else ret = _corba_impl->HasOpenCommand();
 330   return ret;
 331 }
 332
 333 void SALOMEDS_StudyBuilder::AbortCommand()
 334 {
 335   if(_isLocal) _local_impl->AbortCommand();
 336   else _corba_impl->AbortCommand();
 337 }
 338
 339 void SALOMEDS_StudyBuilder::Undo()
 340 {
 341   if(_isLocal) {
 342     try {
 343       _local_impl->Undo();
 344     }
 345     catch(...) {
 346       throw SALOMEDS::StudyBuilder::LockProtection();
 347     }
 348   }
 349   else _corba_impl->Undo();
 350 }
 351
 352 void SALOMEDS_StudyBuilder::Redo()
 353 {
 354   if(_isLocal) {
 355     try {
 356       _local_impl->Redo();
 357     }
 358     catch(...) {
 359       throw SALOMEDS::StudyBuilder::LockProtection();
 360     }
 361   }
 362   else _corba_impl->Redo();
 363 }
 364
 365 bool SALOMEDS_StudyBuilder::GetAvailableUndos()
 366 {
 367   bool ret;
 368   if(_isLocal) ret = _local_impl->GetAvailableUndos();
 369   else ret = _corba_impl->GetAvailableUndos();
 370   return ret;
 371 }
 372
 373 bool SALOMEDS_StudyBuilder::GetAvailableRedos()
 374 {
 375   bool ret;
 376   if(_isLocal) ret = _local_impl->GetAvailableRedos();
 377   else ret = _corba_impl->GetAvailableRedos();
 378   return ret;
 379 }
 380
 381 int SALOMEDS_StudyBuilder::UndoLimit()
 382 {
 383   int aLimit;
 384   if(_isLocal) aLimit = _local_impl->UndoLimit();
 385   else aLimit = _corba_impl->UndoLimit();
 386   return aLimit;
 387 }
 388
 389 void SALOMEDS_StudyBuilder::UndoLimit(int theLimit)
 390 {
 391   CheckLocked();
 392
 393   if(_isLocal) _local_impl->UndoLimit(theLimit);
 394   else _corba_impl->UndoLimit(theLimit);
 395 }
 396
 397 void SALOMEDS_StudyBuilder::CheckLocked()
 398 {
 399   //There is only local part as CORBA part throws the correct exeception
 400   if(_isLocal) {
 401     try {
 402       _local_impl->CheckLocked();
 403     }
 404     catch(...) {
 405       throw SALOMEDS::StudyBuilder::LockProtection();
 406     }
 407   }
 408 }
 409
 410 void SALOMEDS_StudyBuilder::SetName(const _PTR(SObject)& theSO, const std::string& theValue)
 411 {
 412   CheckLocked();
 413
 414   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
 415   if(_isLocal) _local_impl->SetName(aSO->GetLocalImpl(), (char*)theValue.c_str());
 416   else _corba_impl->SetName(aSO->GetCORBAImpl(), (char*)theValue.c_str());
 417 }
 418
 419 void SALOMEDS_StudyBuilder::SetComment(const _PTR(SObject)& theSO, const std::string& theValue)
 420 {
 421   CheckLocked();
 422
 423   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
 424   if(_isLocal) _local_impl->SetComment(aSO->GetLocalImpl(), (char*)theValue.c_str());
 425   else _corba_impl->SetComment(aSO->GetCORBAImpl(), (char*)theValue.c_str());
 426 }
 427
 428 void SALOMEDS_StudyBuilder::SetIOR(const _PTR(SObject)& theSO, const std::string& theValue)
 429 {
 430   CheckLocked();
 431
 432   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
 433   if(_isLocal) _local_impl->SetIOR(aSO->GetLocalImpl(), (char*)theValue.c_str());
 434   else _corba_impl->SetIOR(aSO->GetCORBAImpl(), (char*)theValue.c_str());
 435 }
 436
 437 void SALOMEDS_StudyBuilder::init_orb()
 438 {
 439   ORB_INIT &init = *SINGLETON_<ORB_INIT>::Instance() ;
 440   ASSERT(SINGLETON_<ORB_INIT>::IsAlreadyExisting());
 441   _orb = init(0 , 0 ) ;
 442 }