src/SALOMEDS/SALOMEDS_StudyBuilder.cxx

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