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