src/SALOMEDS/SALOMEDS_UseCaseBuilder_i.cxx

   1 // Copyright (C) 2007-2013  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
  23 //  File   : SALOMEDS_UseCaseBuilder_i.cxx
  24 //  Author : Sergey RUIN
  25 //  Module : SALOME
  26
  27 #include "SALOMEDS_UseCaseBuilder_i.hxx"
  28 #include "SALOMEDS_UseCaseIterator_i.hxx"
  29 #include "SALOMEDS_SObject_i.hxx"
  30 #include "SALOMEDS.hxx"
  31
  32 #include "utilities.h"
  33
  34 //============================================================================
  35 /*! Function : constructor
  36  *  Purpose  :
  37  */
  38 //============================================================================
  39 SALOMEDS_UseCaseBuilder_i::SALOMEDS_UseCaseBuilder_i(SALOMEDSImpl_UseCaseBuilder* theImpl,
  40                                                      CORBA::ORB_ptr orb)
  41 {
  42   _orb = CORBA::ORB::_duplicate(orb);
  43   _impl = theImpl;
  44 }
  45
  46 //============================================================================
  47 /*! Function : destructor
  48  *  Purpose  :
  49  */
  50 //============================================================================
  51 SALOMEDS_UseCaseBuilder_i::~SALOMEDS_UseCaseBuilder_i()
  52 {
  53 }
  54
  55
  56 //============================================================================
  57 /*! Function : Append
  58  *  Purpose  :
  59  */
  60 //============================================================================
  61 CORBA::Boolean SALOMEDS_UseCaseBuilder_i::Append(SALOMEDS::SObject_ptr theObject)
  62 {
  63   SALOMEDS::Locker lock;
  64   if(!_impl || theObject->_is_nil()) return 0;
  65   return _impl->Append(_impl->GetSObject(theObject->GetID()));
  66 }
  67
  68  //============================================================================
  69 /*! Function : Remove
  70  *  Purpose  :
  71  */
  72 //============================================================================
  73 CORBA::Boolean SALOMEDS_UseCaseBuilder_i::Remove(SALOMEDS::SObject_ptr theObject)
  74 {
  75   SALOMEDS::Locker lock;
  76   if(!_impl || theObject->_is_nil()) return 0;
  77   return _impl->Remove(_impl->GetSObject(theObject->GetID()));
  78 }
  79
  80
  81 //============================================================================
  82 /*! Function : AppendTo
  83  *  Purpose  :
  84  */
  85 //============================================================================
  86 CORBA::Boolean SALOMEDS_UseCaseBuilder_i::AppendTo(SALOMEDS::SObject_ptr theFather,
  87                                                    SALOMEDS::SObject_ptr theObject)
  88 {
  89   SALOMEDS::Locker lock;
  90   if(!_impl || theFather->_is_nil() || theObject->_is_nil()) return 0;
  91   return _impl->AppendTo(_impl->GetSObject(theFather->GetID()), _impl->GetSObject(theObject->GetID()));
  92 }
  93
  94 //============================================================================
  95 /*! Function : InsertBefore
  96  *  Purpose  :
  97  */
  98 //============================================================================
  99 CORBA::Boolean SALOMEDS_UseCaseBuilder_i::InsertBefore(SALOMEDS::SObject_ptr theFirst,
 100                                                        SALOMEDS::SObject_ptr theNext)
 101 {
 102   SALOMEDS::Locker lock;
 103   if(!_impl || theFirst->_is_nil() || theNext->_is_nil()) return 0;
 104   return _impl->InsertBefore(_impl->GetSObject(theFirst->GetID()), _impl->GetSObject(theNext->GetID()));
 105 }
 106
 107
 108 //============================================================================
 109 /*! Function : SetCurrentObject
 110  *  Purpose  :
 111  */
 112 //============================================================================
 113 CORBA::Boolean SALOMEDS_UseCaseBuilder_i::SetCurrentObject(SALOMEDS::SObject_ptr theObject)
 114 {
 115   SALOMEDS::Locker lock;
 116   if(!_impl || theObject->_is_nil()) return 0;
 117   return _impl->SetCurrentObject(_impl->GetSObject(theObject->GetID()));
 118 }
 119
 120 //============================================================================
 121 /*! Function : SetRootCurrent
 122  *  Purpose  :
 123  */
 124 //============================================================================
 125 CORBA::Boolean SALOMEDS_UseCaseBuilder_i::SetRootCurrent()
 126 {
 127   SALOMEDS::Locker lock;
 128   if(!_impl) return 0;
 129   return _impl->SetRootCurrent();
 130 }
 131
 132 //============================================================================
 133 /*! Function : HasChildren
 134  *  Purpose  :
 135  */
 136 //============================================================================
 137 CORBA::Boolean SALOMEDS_UseCaseBuilder_i::HasChildren(SALOMEDS::SObject_ptr theObject)
 138 {
 139   SALOMEDS::Locker lock;
 140   if(!_impl) return 0;
 141   return _impl->HasChildren(_impl->GetSObject(theObject->GetID()));
 142 }
 143
 144 //============================================================================
 145 /*! Function : GetFather
 146  *  Purpose  :
 147  */
 148 //============================================================================
 149 SALOMEDS::SObject_ptr SALOMEDS_UseCaseBuilder_i::GetFather(SALOMEDS::SObject_ptr theObject)
 150 {
 151   SALOMEDS::Locker lock;
 152
 153   if(!_impl) return NULL;
 154   SALOMEDSImpl_SObject aSO = _impl->GetFather(_impl->GetSObject(theObject->GetID()));
 155   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (aSO, _orb);
 156   return so._retn();
 157 }
 158
 159 //============================================================================
 160 /*! Function : SetName
 161  *  Purpose  :
 162  */
 163 //============================================================================
 164 CORBA::Boolean SALOMEDS_UseCaseBuilder_i::SetName(const char* theName)
 165 {
 166   SALOMEDS::Locker lock;
 167   if(!_impl) return 0;
 168   return _impl->SetName((char*)theName);
 169 }
 170
 171
 172 //============================================================================
 173 /*! Function : GetCurrentObject
 174  *  Purpose  :
 175  */
 176 //============================================================================
 177 SALOMEDS::SObject_ptr SALOMEDS_UseCaseBuilder_i::GetCurrentObject()
 178 {
 179   SALOMEDS::Locker lock;
 180
 181   if(!_impl) return NULL;
 182   SALOMEDSImpl_SObject aSO = _impl->GetCurrentObject();
 183   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (aSO, _orb);
 184   return so._retn();
 185 }
 186
 187 //============================================================================
 188 /*! Function : GetName
 189  *  Purpose  :
 190  */
 191 //============================================================================
 192 char* SALOMEDS_UseCaseBuilder_i::GetName()
 193 {
 194   SALOMEDS::Locker lock;
 195   return CORBA::string_dup(_impl->GetName().c_str());
 196 }
 197
 198 //============================================================================
 199 /*! Function :  IsUseCase
 200  *  Purpose  :
 201  */
 202 //============================================================================
 203 CORBA::Boolean SALOMEDS_UseCaseBuilder_i::IsUseCase(SALOMEDS::SObject_ptr theObject)
 204 {
 205   SALOMEDS::Locker lock;
 206
 207   if(!_impl || theObject->_is_nil()) return false;
 208   return _impl->IsUseCase(_impl->GetSObject(theObject->GetID()));
 209 }
 210
 211 //============================================================================
 212 /*! Function :  IsUseCaseNode
 213  *  Purpose  :
 214  */
 215 //============================================================================
 216 CORBA::Boolean SALOMEDS_UseCaseBuilder_i::IsUseCaseNode(SALOMEDS::SObject_ptr theObject)
 217 {
 218   SALOMEDS::Locker lock;
 219
 220   if(!_impl || theObject->_is_nil()) return false;
 221   return _impl->IsUseCaseNode(_impl->GetSObject(theObject->GetID()));
 222 }
 223
 224 //============================================================================
 225 /*! Function : NewUseCase
 226  *  Purpose  :
 227  */
 228 //============================================================================
 229 SALOMEDS::SObject_ptr SALOMEDS_UseCaseBuilder_i::AddUseCase(const char* theName)
 230 {
 231   SALOMEDS::Locker lock;
 232
 233   if(!_impl) return SALOMEDS::SObject::_nil();
 234   SALOMEDSImpl_SObject aSO = _impl->AddUseCase((char*)theName);
 235   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (aSO, _orb);
 236   return so._retn();
 237 }
 238
 239 //============================================================================
 240 /*! Function : GetUseCaseIterator
 241  *  Purpose  : Creates a new UseCase iterator, if anObject is null all use cases are iterated
 242  */
 243 //============================================================================
 244 SALOMEDS::UseCaseIterator_ptr SALOMEDS_UseCaseBuilder_i::GetUseCaseIterator(SALOMEDS::SObject_ptr theObject)
 245 {
 246   SALOMEDS::Locker lock;
 247
 248   if(!_impl) return SALOMEDS::UseCaseIterator::_nil();
 249   SALOMEDSImpl_UseCaseIterator anItr;
 250   if(!CORBA::is_nil(theObject)) anItr = _impl->GetUseCaseIterator(_impl->GetSObject(theObject->GetID()));
 251   else anItr = _impl->GetUseCaseIterator(SALOMEDSImpl_SObject());
 252   SALOMEDS_UseCaseIterator_i* aServant = new SALOMEDS_UseCaseIterator_i(anItr, _orb);
 253   SALOMEDS::UseCaseIterator_var anIterator = SALOMEDS::UseCaseIterator::_narrow(aServant->_this());
 254   return anIterator._retn();
 255 }