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