src/SALOMEDS/SALOMEDS_StudyBuilder.cxx

   1 // Copyright (C) 2007-2016  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, or (at your option) any later version.
  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_StudyBuilder.cxx
  24 //  Author : Sergey RUIN
  25 //  Module : SALOME
  26 //
  27 #include "utilities.h"
  28
  29 #include "SALOMEDS_StudyBuilder.hxx"
  30
  31 #include "SALOMEDS.hxx"
  32 #include "SALOMEDS_SObject.hxx"
  33 #include "SALOMEDS_SComponent.hxx"
  34 #include "SALOMEDS_GenericAttribute.hxx"
  35 #include "SALOMEDS_StudyBuilder_i.hxx"
  36
  37 #include "SALOMEDS_Driver_i.hxx"
  38
  39 #include "SALOMEDSImpl_SObject.hxx"
  40 #include "SALOMEDSImpl_SComponent.hxx"
  41 #include "SALOMEDSImpl_GenericAttribute.hxx"
  42
  43 #include <string>
  44 #include <stdexcept>
  45
  46 #include "DF_Attribute.hxx"
  47
  48 #include "Utils_CorbaException.hxx"
  49 #include "Utils_ORB_INIT.hxx"
  50 #include "Utils_SINGLETON.hxx"
  51
  52 SALOMEDS_StudyBuilder::SALOMEDS_StudyBuilder(SALOMEDSImpl_StudyBuilder* theBuilder)
  53 {
  54   _isLocal = true;
  55   _local_impl = theBuilder;
  56   _corba_impl = SALOMEDS::StudyBuilder::_nil();
  57
  58   init_orb();
  59 }
  60
  61 SALOMEDS_StudyBuilder::SALOMEDS_StudyBuilder(SALOMEDS::StudyBuilder_ptr theBuilder)
  62 {
  63   _isLocal = false;
  64   _local_impl = NULL;
  65   _corba_impl = SALOMEDS::StudyBuilder::_duplicate(theBuilder);
  66
  67   init_orb();
  68 }
  69
  70 SALOMEDS_StudyBuilder::~SALOMEDS_StudyBuilder()
  71 {
  72 }
  73
  74 _PTR(SComponent) SALOMEDS_StudyBuilder::NewComponent(const std::string& ComponentDataType)
  75 {
  76   SALOMEDSClient_SComponent* aSCO = NULL;
  77
  78   if (_isLocal) {
  79     CheckLocked();
  80     SALOMEDS::Locker lock;
  81
  82     SALOMEDSImpl_SComponent aSCO_impl =_local_impl->NewComponent(ComponentDataType);
  83     if(!aSCO_impl) return _PTR(SComponent)(aSCO);
  84     aSCO = new SALOMEDS_SComponent(aSCO_impl);
  85   }
  86   else {
  87     SALOMEDS::SComponent_var aSCO_impl = _corba_impl->NewComponent((char*)ComponentDataType.c_str());
  88     if(CORBA::is_nil(aSCO_impl)) return _PTR(SComponent)(aSCO);
  89     aSCO = new SALOMEDS_SComponent(aSCO_impl);
  90   }
  91
  92   return _PTR(SComponent)(aSCO);
  93 }
  94
  95 void SALOMEDS_StudyBuilder::DefineComponentInstance (const _PTR(SComponent)& theSCO,
  96                                                      const std::string& ComponentIOR)
  97 {
  98   if(!theSCO) return;
  99
 100   SALOMEDS_SComponent* aSCO = dynamic_cast<SALOMEDS_SComponent*>(theSCO.get());
 101   if (_isLocal) {
 102     CheckLocked();
 103     SALOMEDS::Locker lock;
 104
 105     _local_impl->DefineComponentInstance(*(dynamic_cast<SALOMEDSImpl_SComponent*>(aSCO->GetLocalImpl())),
 106                                          ComponentIOR);
 107   }
 108   else {
 109     CORBA::Object_var obj = _orb->string_to_object(ComponentIOR.c_str());
 110     _corba_impl->DefineComponentInstance(SALOMEDS::SComponent::_narrow(aSCO->GetCORBAImpl()), obj);
 111   }
 112 }
 113
 114 void SALOMEDS_StudyBuilder::RemoveComponent(const _PTR(SComponent)& theSCO)
 115 {
 116   if(!theSCO) return;
 117   SALOMEDS_SComponent* aSCO = dynamic_cast<SALOMEDS_SComponent*>(theSCO.get());
 118   if (_isLocal) {
 119     CheckLocked();
 120     SALOMEDS::Locker lock;
 121
 122     _local_impl->RemoveComponent(*(dynamic_cast<SALOMEDSImpl_SComponent*>(aSCO->GetLocalImpl())));
 123   }
 124   else _corba_impl->RemoveComponent(SALOMEDS::SComponent::_narrow(aSCO->GetCORBAImpl()));
 125 }
 126
 127 _PTR(SObject) SALOMEDS_StudyBuilder::NewObject(const _PTR(SObject)& theFatherObject)
 128 {
 129   CheckLocked();
 130
 131   SALOMEDSClient_SObject* aSO = NULL;
 132   SALOMEDS_SObject* father = dynamic_cast< SALOMEDS_SObject*>(theFatherObject.get());
 133   if (father == NULL) return _PTR(SObject)(aSO);
 134   if (_isLocal) {
 135     SALOMEDS::Locker lock;
 136
 137     SALOMEDSImpl_SObject aSO_impl = _local_impl->NewObject(*(father->GetLocalImpl()));
 138     if(!aSO_impl) return _PTR(SObject)(aSO);
 139     aSO = new SALOMEDS_SObject(aSO_impl);
 140   }
 141   else {
 142     SALOMEDS::SObject_var aSO_impl = _corba_impl->NewObject(father->GetCORBAImpl());
 143     if(CORBA::is_nil(aSO_impl)) return _PTR(SObject)(aSO);
 144     aSO = new SALOMEDS_SObject(aSO_impl);
 145   }
 146
 147   return _PTR(SObject)(aSO);
 148 }
 149
 150 _PTR(SObject) SALOMEDS_StudyBuilder::NewObjectToTag(const _PTR(SObject)& theFatherObject, int theTag)
 151 {
 152   CheckLocked();
 153
 154   SALOMEDSClient_SObject* aSO = NULL;
 155   SALOMEDS_SObject* father = dynamic_cast< SALOMEDS_SObject*>(theFatherObject.get());
 156   if (father == NULL) return _PTR(SObject)(aSO);
 157   if (_isLocal) {
 158     SALOMEDS::Locker lock;
 159
 160     SALOMEDSImpl_SObject aSO_impl = _local_impl->NewObjectToTag(*(father->GetLocalImpl()), theTag);
 161     if(aSO_impl.IsNull()) return _PTR(SObject)(aSO);
 162     aSO = new SALOMEDS_SObject(aSO_impl);
 163   }
 164   else {
 165     SALOMEDS::SObject_var aSO_impl = _corba_impl->NewObjectToTag(father->GetCORBAImpl(), theTag);
 166     if(CORBA::is_nil(aSO_impl)) return _PTR(SObject)(aSO);
 167     aSO = new SALOMEDS_SObject(aSO_impl);
 168   }
 169
 170   return _PTR(SObject)(aSO);
 171 }
 172
 173 void SALOMEDS_StudyBuilder::LoadWith(const _PTR(SComponent)& theSCO, const std::string& theIOR)
 174 {
 175   if(!theSCO) return;
 176
 177   SALOMEDS_SComponent* aSCO = dynamic_cast<SALOMEDS_SComponent*>(theSCO.get());
 178   CORBA::Object_var obj = _orb->string_to_object(theIOR.c_str());
 179   Engines::EngineComponent_var anEngine = Engines::EngineComponent::_narrow(obj);
 180   SALOMEDS::Driver_var aDriver = SALOMEDS::Driver::_narrow(obj);
 181
 182   if (_isLocal) {
 183     SALOMEDS::Locker lock;
 184
 185     SALOMEDS_Driver_i* drv = new SALOMEDS_Driver_i(anEngine, _orb);
 186     SALOMEDSImpl_SComponent aSCO_impl = *(dynamic_cast<SALOMEDSImpl_SComponent*>(aSCO->GetLocalImpl()));
 187     bool isDone = _local_impl->LoadWith(aSCO_impl, drv);
 188     delete drv;
 189     if(!isDone && _local_impl->IsError())
 190       THROW_SALOME_CORBA_EXCEPTION(_local_impl->GetErrorCode().c_str(),SALOME::BAD_PARAM);
 191   }
 192   else {
 193     _corba_impl->LoadWith(SALOMEDS::SComponent::_narrow(aSCO->GetCORBAImpl()), aDriver);
 194   }
 195 }
 196
 197 void SALOMEDS_StudyBuilder::Load(const _PTR(SObject)& theSCO)
 198 {
 199   SALOMEDS_SComponent* aSCO = dynamic_cast<SALOMEDS_SComponent*>(theSCO.get());
 200   if (_isLocal) _local_impl->Load(*(dynamic_cast<SALOMEDSImpl_SComponent*>(aSCO->GetLocalImpl())));
 201   else _corba_impl->Load(SALOMEDS::SComponent::_narrow(aSCO->GetCORBAImpl()));
 202 }
 203
 204 void SALOMEDS_StudyBuilder::RemoveObject(const _PTR(SObject)& theSO)
 205 {
 206   if(!theSO) return;
 207
 208   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
 209   if (_isLocal) {
 210     CheckLocked();
 211     SALOMEDS::Locker lock;
 212
 213     _local_impl->RemoveObject(*(aSO->GetLocalImpl()));
 214   }
 215   else _corba_impl->RemoveObject(aSO->GetCORBAImpl());
 216 }
 217
 218 void SALOMEDS_StudyBuilder::RemoveObjectWithChildren(const _PTR(SObject)& theSO)
 219 {
 220   if(!theSO) return;
 221
 222   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
 223   if (_isLocal) {
 224     CheckLocked();
 225     SALOMEDS::Locker lock;
 226
 227     _local_impl->RemoveObjectWithChildren(*(aSO->GetLocalImpl()));
 228   }
 229   else _corba_impl->RemoveObjectWithChildren(aSO->GetCORBAImpl());
 230 }
 231
 232 _PTR(GenericAttribute) SALOMEDS_StudyBuilder::FindOrCreateAttribute(const _PTR(SObject)& theSO,
 233                                                                     const std::string& aTypeOfAttribute)
 234 {
 235   SALOMEDSClient_GenericAttribute* anAttr = NULL;
 236   if(!theSO) return _PTR(GenericAttribute)(anAttr);
 237   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
 238   if (_isLocal) {
 239     SALOMEDS::Locker lock;
 240
 241     SALOMEDSImpl_GenericAttribute* aGA;
 242     try {
 243       aGA = dynamic_cast<SALOMEDSImpl_GenericAttribute*>
 244         (_local_impl->FindOrCreateAttribute(*(aSO->GetLocalImpl()), aTypeOfAttribute));
 245     }
 246     catch (...) {
 247       throw SALOMEDS::StudyBuilder::LockProtection();
 248     }
 249     anAttr = SALOMEDS_GenericAttribute::CreateAttribute(aGA);
 250   }
 251   else {
 252     SALOMEDS::GenericAttribute_var aGA =
 253       _corba_impl->FindOrCreateAttribute(aSO->GetCORBAImpl(), (char*)aTypeOfAttribute.c_str());
 254     anAttr = SALOMEDS_GenericAttribute::CreateAttribute(aGA);
 255   }
 256
 257   return _PTR(GenericAttribute)(anAttr);
 258 }
 259
 260 bool SALOMEDS_StudyBuilder::FindAttribute(const _PTR(SObject)& theSO,
 261                                           _PTR(GenericAttribute)& anAttribute,
 262                                           const std::string& aTypeOfAttribute)
 263 {
 264   bool ret;
 265
 266   if(!theSO) return false;
 267
 268   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
 269   if (_isLocal) {
 270     SALOMEDS::Locker lock;
 271
 272     DF_Attribute* anAttr = NULL;
 273     ret = _local_impl->FindAttribute(*(aSO->GetLocalImpl()), anAttr, aTypeOfAttribute);
 274     if(ret) {
 275       SALOMEDSImpl_GenericAttribute* aGA = dynamic_cast<SALOMEDSImpl_GenericAttribute*>(anAttr);
 276       anAttribute = _PTR(GenericAttribute)(SALOMEDS_GenericAttribute::CreateAttribute(aGA));
 277     }
 278   }
 279   else {
 280     SALOMEDS::GenericAttribute_var aGA;
 281     ret = _corba_impl->FindAttribute(aSO->GetCORBAImpl(), aGA.out(), (char*)aTypeOfAttribute.c_str());
 282     if(ret) anAttribute = _PTR(GenericAttribute)(SALOMEDS_GenericAttribute::CreateAttribute(aGA));
 283   }
 284
 285   return ret;
 286 }
 287
 288 void SALOMEDS_StudyBuilder::RemoveAttribute(const _PTR(SObject)& theSO, const std::string& aTypeOfAttribute)
 289 {
 290   if(!theSO) return;
 291
 292   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
 293   if (_isLocal) {
 294     CheckLocked();
 295     SALOMEDS::Locker lock;
 296
 297     _local_impl->RemoveAttribute(*(aSO->GetLocalImpl()), (char*)aTypeOfAttribute.c_str());
 298   }
 299   else _corba_impl->RemoveAttribute(aSO->GetCORBAImpl(), (char*)aTypeOfAttribute.c_str());
 300 }
 301
 302 void SALOMEDS_StudyBuilder::Addreference(const _PTR(SObject)& me, const _PTR(SObject)& thereferencedObject)
 303 {
 304   if(!me || !thereferencedObject) {
 305     throw DFexception("Invalid arguments");
 306   }
 307
 308   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(me.get());
 309   SALOMEDS_SObject* aRefSO = dynamic_cast<SALOMEDS_SObject*>(thereferencedObject.get());
 310   if (_isLocal) {
 311     CheckLocked();
 312     SALOMEDS::Locker lock;
 313
 314     _local_impl->Addreference(*(aSO->GetLocalImpl()), *(aRefSO->GetLocalImpl()));
 315   }
 316   else _corba_impl->Addreference(aSO->GetCORBAImpl(), aRefSO->GetCORBAImpl());
 317 }
 318
 319 void SALOMEDS_StudyBuilder::RemoveReference(const _PTR(SObject)& me)
 320 {
 321   if(!me) return;
 322   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(me.get());
 323   if (_isLocal) {
 324     CheckLocked();
 325     SALOMEDS::Locker lock;
 326
 327     _local_impl->RemoveReference(*(aSO->GetLocalImpl()));
 328   }
 329   else _corba_impl->RemoveReference(aSO->GetCORBAImpl());
 330 }
 331
 332 void SALOMEDS_StudyBuilder::SetGUID(const _PTR(SObject)& theSO, const std::string& theGUID)
 333 {
 334   if(!theSO) return;
 335
 336   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
 337   if (_isLocal) {
 338     CheckLocked();
 339     SALOMEDS::Locker lock;
 340
 341     _local_impl->SetGUID(*(aSO->GetLocalImpl()), theGUID);
 342   }
 343   else _corba_impl->SetGUID(aSO->GetCORBAImpl(), (char*)theGUID.c_str());
 344 }
 345
 346 bool SALOMEDS_StudyBuilder::IsGUID(const _PTR(SObject)& theSO, const std::string& theGUID)
 347 {
 348   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
 349   bool ret;
 350   if (_isLocal) {
 351     SALOMEDS::Locker lock;
 352
 353     ret = _local_impl->IsGUID(*(aSO->GetLocalImpl()), (char*)theGUID.c_str());
 354   }
 355   else ret = _corba_impl->IsGUID(aSO->GetCORBAImpl(), (char*)theGUID.c_str());
 356
 357   return ret;
 358 }
 359
 360 void SALOMEDS_StudyBuilder::NewCommand()
 361 {
 362   if (_isLocal) {
 363     SALOMEDS::Locker lock;
 364     _local_impl->NewCommand();
 365   }
 366   else _corba_impl->NewCommand();
 367 }
 368
 369 void SALOMEDS_StudyBuilder::CommitCommand()
 370 {
 371   if (_isLocal) {
 372     SALOMEDS::Locker lock;
 373     try {
 374       _local_impl->CommitCommand();
 375     }
 376     catch(...) {
 377       throw SALOMEDS::StudyBuilder::LockProtection();
 378     }
 379   }
 380   else _corba_impl->CommitCommand();
 381 }
 382
 383 bool SALOMEDS_StudyBuilder::HasOpenCommand()
 384 {
 385   bool ret;
 386   if (_isLocal) {
 387     SALOMEDS::Locker lock;
 388     ret = _local_impl->HasOpenCommand();
 389   }
 390   else ret = _corba_impl->HasOpenCommand();
 391   return ret;
 392 }
 393
 394 void SALOMEDS_StudyBuilder::AbortCommand()
 395 {
 396   if (_isLocal) {
 397     SALOMEDS::Locker lock;
 398     _local_impl->AbortCommand();
 399   }
 400   else _corba_impl->AbortCommand();
 401 }
 402
 403 void SALOMEDS_StudyBuilder::Undo()
 404 {
 405   if (_isLocal) {
 406     SALOMEDS::Locker lock;
 407     try {
 408       _local_impl->Undo();
 409     }
 410     catch(...) {
 411       throw SALOMEDS::StudyBuilder::LockProtection();
 412     }
 413   }
 414   else _corba_impl->Undo();
 415 }
 416
 417 void SALOMEDS_StudyBuilder::Redo()
 418 {
 419   if (_isLocal) {
 420     SALOMEDS::Locker lock;
 421     try {
 422       _local_impl->Redo();
 423     }
 424     catch(...) {
 425       throw SALOMEDS::StudyBuilder::LockProtection();
 426     }
 427   }
 428   else _corba_impl->Redo();
 429 }
 430
 431 bool SALOMEDS_StudyBuilder::GetAvailableUndos()
 432 {
 433   bool ret;
 434   if (_isLocal) {
 435     SALOMEDS::Locker lock;
 436     ret = _local_impl->GetAvailableUndos();
 437   }
 438   else ret = _corba_impl->GetAvailableUndos();
 439   return ret;
 440 }
 441
 442 bool SALOMEDS_StudyBuilder::GetAvailableRedos()
 443 {
 444   bool ret;
 445   if (_isLocal) {
 446     SALOMEDS::Locker lock;
 447     ret = _local_impl->GetAvailableRedos();
 448   }
 449   else ret = _corba_impl->GetAvailableRedos();
 450   return ret;
 451 }
 452
 453 int SALOMEDS_StudyBuilder::UndoLimit()
 454 {
 455   int aLimit;
 456   if (_isLocal) {
 457     SALOMEDS::Locker lock;
 458     aLimit = _local_impl->UndoLimit();
 459   }
 460   else aLimit = _corba_impl->UndoLimit();
 461   return aLimit;
 462 }
 463
 464 void SALOMEDS_StudyBuilder::UndoLimit(int theLimit)
 465 {
 466   if (_isLocal) {
 467     CheckLocked();
 468     SALOMEDS::Locker lock;
 469
 470     _local_impl->UndoLimit(theLimit);
 471   }
 472   else _corba_impl->UndoLimit(theLimit);
 473 }
 474
 475 void SALOMEDS_StudyBuilder::CheckLocked()
 476 {
 477   //There is only local part as CORBA part throws the correct exeception
 478   if (_isLocal) {
 479     SALOMEDS::Locker lock;
 480     try {
 481       _local_impl->CheckLocked();
 482     }
 483     catch(...) {
 484       throw SALOMEDS::StudyBuilder::LockProtection();
 485     }
 486   }
 487 }
 488
 489 void SALOMEDS_StudyBuilder::SetName(const _PTR(SObject)& theSO, const std::string& theValue)
 490 {
 491   if(!theSO) return;
 492
 493   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
 494   if (_isLocal) {
 495     CheckLocked();
 496     SALOMEDS::Locker lock;
 497
 498     _local_impl->SetName(*(aSO->GetLocalImpl()), theValue);
 499   }
 500   else _corba_impl->SetName(aSO->GetCORBAImpl(), (char*)theValue.c_str());
 501 }
 502
 503 void SALOMEDS_StudyBuilder::SetComment(const _PTR(SObject)& theSO, const std::string& theValue)
 504 {
 505   if(!theSO) return;
 506
 507   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
 508   if (_isLocal) {
 509     CheckLocked();
 510     SALOMEDS::Locker lock;
 511
 512     _local_impl->SetComment(*(aSO->GetLocalImpl()), theValue);
 513   }
 514   else _corba_impl->SetComment(aSO->GetCORBAImpl(), (char*)theValue.c_str());
 515 }
 516
 517 void SALOMEDS_StudyBuilder::SetIOR(const _PTR(SObject)& theSO, const std::string& theValue)
 518 {
 519   if(!theSO) return;
 520
 521   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
 522   if (_isLocal) {
 523     CheckLocked();
 524     SALOMEDS::Locker lock;
 525
 526     _local_impl->SetIOR(*(aSO->GetLocalImpl()), theValue);
 527   }
 528   else _corba_impl->SetIOR(aSO->GetCORBAImpl(), (char*)theValue.c_str());
 529 }
 530
 531 SALOMEDS::StudyBuilder_ptr SALOMEDS_StudyBuilder::GetBuilder()
 532 {
 533   if(_isLocal) {
 534     if(!CORBA::is_nil(_corba_impl)) return SALOMEDS::StudyBuilder::_duplicate(_corba_impl);
 535     SALOMEDS_StudyBuilder_i* servant = new SALOMEDS_StudyBuilder_i(_local_impl, _orb);
 536     SALOMEDS::StudyBuilder_var aBuilder = servant->StudyBuilder::_this();
 537     _corba_impl = SALOMEDS::StudyBuilder::_duplicate(aBuilder);
 538     return aBuilder._retn();
 539   }
 540   else {
 541     return SALOMEDS::StudyBuilder::_duplicate(_corba_impl);
 542   }
 543   return SALOMEDS::StudyBuilder::_nil();
 544 }
 545
 546 void SALOMEDS_StudyBuilder::init_orb()
 547 {
 548   ORB_INIT &init = *SINGLETON_<ORB_INIT>::Instance();
 549   ASSERT(SINGLETON_<ORB_INIT>::IsAlreadyExisting());
 550   _orb = init(0 , 0 );
 551 }