src/SALOMEDS/SALOMEDS_UseCaseBuilder.cxx

   1 //  Copyright (C) 2007-2008  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.
  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 //  File   : SALOMEDS_UseCaseBuilder.cxx
  23 //  Author : Sergey RUIN
  24 //  Module : SALOME
  25 //
  26 #include "SALOMEDS_UseCaseBuilder.hxx"
  27
  28 #include "SALOMEDS.hxx"
  29 #include "SALOMEDS_SObject.hxx"
  30 #include "SALOMEDS_UseCaseIterator.hxx"
  31
  32 #include "SALOMEDSImpl_SObject.hxx"
  33 #include "SALOMEDSImpl_UseCaseIterator.hxx"
  34
  35 #include <string>
  36
  37 using namespace std;
  38
  39 SALOMEDS_UseCaseBuilder::SALOMEDS_UseCaseBuilder(SALOMEDSImpl_UseCaseBuilder* theBuilder)
  40 {
  41   _isLocal = true;
  42   _local_impl = theBuilder;
  43   _corba_impl = SALOMEDS::UseCaseBuilder::_nil();
  44 }
  45
  46 SALOMEDS_UseCaseBuilder::SALOMEDS_UseCaseBuilder(SALOMEDS::UseCaseBuilder_ptr theBuilder)
  47 {
  48   _isLocal = false;
  49   _local_impl = NULL;
  50   _corba_impl = SALOMEDS::UseCaseBuilder::_duplicate(theBuilder);
  51 }
  52
  53 SALOMEDS_UseCaseBuilder::~SALOMEDS_UseCaseBuilder()
  54 {
  55   if(!_isLocal) _corba_impl->Destroy();
  56 }
  57
  58 bool SALOMEDS_UseCaseBuilder::Append(const _PTR(SObject)& theObject)
  59 {
  60   bool ret;
  61   SALOMEDS_SObject* obj = dynamic_cast<SALOMEDS_SObject*>(theObject.get());
  62   if (_isLocal) {
  63     SALOMEDS::Locker lock;
  64     ret = _local_impl->Append(*(obj->GetLocalImpl()));
  65   }
  66   else ret = _corba_impl->Append(obj->GetCORBAImpl());
  67   return ret;
  68 }
  69
  70 bool SALOMEDS_UseCaseBuilder::Remove(const _PTR(SObject)& theObject)
  71 {
  72   bool ret;
  73   SALOMEDS_SObject* obj = dynamic_cast<SALOMEDS_SObject*>(theObject.get());
  74   if (_isLocal) {
  75     SALOMEDS::Locker lock;
  76     ret = _local_impl->Remove(*(obj->GetLocalImpl()));
  77   }
  78   else ret = _corba_impl->Remove(obj->GetCORBAImpl());
  79   return ret;
  80 }
  81
  82 bool SALOMEDS_UseCaseBuilder::AppendTo(const _PTR(SObject)& theFather, _PTR(SObject) theObject)
  83 {
  84   bool ret;
  85   SALOMEDS_SObject* father = dynamic_cast<SALOMEDS_SObject*>(theFather.get());
  86   SALOMEDS_SObject* obj = dynamic_cast<SALOMEDS_SObject*>(theObject.get());
  87   if (_isLocal) {
  88     SALOMEDS::Locker lock;
  89     ret = _local_impl->AppendTo(*(father->GetLocalImpl()), *(obj->GetLocalImpl()));
  90   }
  91   else ret = _corba_impl->AppendTo(father->GetCORBAImpl(), obj->GetCORBAImpl());
  92   return ret;
  93 }
  94
  95 bool SALOMEDS_UseCaseBuilder::InsertBefore(const _PTR(SObject)& theFirst, _PTR(SObject) theNext)
  96 {
  97   bool ret;
  98   SALOMEDS_SObject* first = dynamic_cast<SALOMEDS_SObject*>(theFirst.get());
  99   SALOMEDS_SObject* next = dynamic_cast<SALOMEDS_SObject*>(theNext.get());
 100   if (_isLocal) {
 101     SALOMEDS::Locker lock;
 102     ret = _local_impl->InsertBefore(*(first->GetLocalImpl()), *(next->GetLocalImpl()));
 103   }
 104   else ret = _corba_impl->InsertBefore(first->GetCORBAImpl(), next->GetCORBAImpl());
 105   return ret;
 106 }
 107
 108 bool SALOMEDS_UseCaseBuilder::SetCurrentObject(const _PTR(SObject)& theObject)
 109 {
 110   bool ret;
 111   SALOMEDS_SObject* obj = dynamic_cast<SALOMEDS_SObject*>(theObject.get());
 112   if (_isLocal) {
 113     SALOMEDS::Locker lock;
 114     ret = _local_impl->SetCurrentObject(*(obj->GetLocalImpl()));
 115   }
 116   else ret = _corba_impl->SetCurrentObject(obj->GetCORBAImpl());
 117   return ret;
 118 }
 119
 120 bool SALOMEDS_UseCaseBuilder::SetRootCurrent()
 121 {
 122   bool ret;
 123   if (_isLocal) {
 124     SALOMEDS::Locker lock;
 125     ret = _local_impl->SetRootCurrent();
 126   }
 127   else ret = _corba_impl->SetRootCurrent();
 128   return ret;
 129 }
 130
 131 bool SALOMEDS_UseCaseBuilder::HasChildren(const _PTR(SObject)& theObject)
 132 {
 133   bool ret;
 134   SALOMEDS_SObject* obj = dynamic_cast<SALOMEDS_SObject*>(theObject.get());
 135   if (_isLocal) {
 136     SALOMEDS::Locker lock;
 137     ret = _local_impl->HasChildren(*(obj->GetLocalImpl()));
 138   }
 139   else ret = _corba_impl->HasChildren(obj->GetCORBAImpl());
 140   return ret;
 141 }
 142
 143 bool SALOMEDS_UseCaseBuilder::IsUseCase(const _PTR(SObject)& theObject)
 144 {
 145   bool ret;
 146   SALOMEDS_SObject* obj = dynamic_cast<SALOMEDS_SObject*>(theObject.get());
 147   if (_isLocal) {
 148     SALOMEDS::Locker lock;
 149     ret = _local_impl->IsUseCase(*(obj->GetLocalImpl()));
 150   }
 151   else ret = _corba_impl->IsUseCase(obj->GetCORBAImpl());
 152   return ret;
 153 }
 154
 155 bool SALOMEDS_UseCaseBuilder::SetName(const std::string& theName)
 156 {
 157   bool ret;
 158   if (_isLocal) {
 159     SALOMEDS::Locker lock;
 160     ret = _local_impl->SetName(theName);
 161   }
 162   else ret = _corba_impl->SetName((char*)theName.c_str());
 163   return ret;
 164 }
 165
 166 _PTR(SObject) SALOMEDS_UseCaseBuilder::GetCurrentObject()
 167 {
 168   SALOMEDS_SObject* obj = NULL;
 169   if (_isLocal) {
 170     SALOMEDS::Locker lock;
 171     obj = new SALOMEDS_SObject(_local_impl->GetCurrentObject());
 172   }
 173   else obj = new SALOMEDS_SObject(_corba_impl->GetCurrentObject());
 174   return _PTR(SObject)(obj);
 175 }
 176
 177 std::string SALOMEDS_UseCaseBuilder::GetName()
 178 {
 179   std::string aName;
 180   if (_isLocal) {
 181     SALOMEDS::Locker lock;
 182     aName = _local_impl->GetName();
 183   }
 184   else aName = _corba_impl->GetName();
 185   return aName;
 186 }
 187
 188 _PTR(SObject) SALOMEDS_UseCaseBuilder::AddUseCase(const std::string& theName)
 189 {
 190   SALOMEDS_SObject* obj = NULL;
 191   if (_isLocal) {
 192     SALOMEDS::Locker lock;
 193     obj = new SALOMEDS_SObject(_local_impl->AddUseCase(theName));
 194   }
 195   else obj = new SALOMEDS_SObject(_corba_impl->AddUseCase((char*)theName.c_str()));
 196   return _PTR(SObject)(obj);
 197 }
 198
 199 _PTR(UseCaseIterator) SALOMEDS_UseCaseBuilder::GetUseCaseIterator(const _PTR(SObject)& theObject)
 200 {
 201   SALOMEDS_UseCaseIterator* it = NULL;
 202   SALOMEDS_SObject* obj = (theObject)?dynamic_cast<SALOMEDS_SObject*>(theObject.get()):NULL;
 203   if (_isLocal) {
 204     SALOMEDS::Locker lock;
 205     if(obj)
 206       it = new SALOMEDS_UseCaseIterator(_local_impl->GetUseCaseIterator(*(obj->GetLocalImpl())));
 207     else
 208       it = new SALOMEDS_UseCaseIterator(_local_impl->GetUseCaseIterator(SALOMEDSImpl_SObject()));
 209   }
 210   else {
 211     if(obj)
 212       it = new SALOMEDS_UseCaseIterator(_corba_impl->GetUseCaseIterator(obj->GetCORBAImpl()));
 213     else
 214       it = new SALOMEDS_UseCaseIterator(_corba_impl->GetUseCaseIterator(SALOMEDS::SObject::_nil()));
 215   }
 216   return _PTR(UseCaseIterator)(it);
 217 }