]> SALOME platform Git repositories - modules/kernel.git/blob - src/SALOMEDS/SALOMEDS_StudyManager.cxx
Salome HOME
Join modifications from BR_Dev_For_4_0 tag V4_1_1.
[modules/kernel.git] / src / SALOMEDS / SALOMEDS_StudyManager.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/ or email : webmaster.salome@opencascade.com
19 //
20 //  File   : SALOMEDSClient_StudyManager.cxx
21 //  Author : Sergey RUIN
22 //  Module : SALOME
23
24
25 #include "SALOMEDS_StudyManager.hxx"
26
27 #include "SALOMEDS.hxx"
28 #include "SALOMEDS_Study.hxx"
29 #include "SALOMEDS_SObject.hxx"
30
31 #include "SALOMEDS_Driver_i.hxx"
32
33 #include "SALOMEDSImpl_Study.hxx"
34
35 #include "Utils_ORB_INIT.hxx" 
36 #include "Utils_SINGLETON.hxx" 
37
38 #ifdef WIN32
39 #include <process.h>
40 #else
41 #include <sys/types.h>
42 #include <unistd.h>
43 #endif
44
45 #include "OpUtil.hxx"
46
47 using namespace std;
48
49 SALOMEDS_Driver_i* GetDriver(const SALOMEDSImpl_SObject& theObject, CORBA::ORB_ptr orb);
50
51 SALOMEDS_StudyManager::SALOMEDS_StudyManager(SALOMEDS::StudyManager_ptr theManager)
52 {
53
54 #ifdef WIN32
55   long pid =  (long)_getpid();
56 #else
57   long pid =  (long)getpid();
58 #endif  
59
60   CORBA::LongLong addr = theManager->GetLocalImpl(GetHostname().c_str(), pid, _isLocal);
61   if(_isLocal) {
62     _local_impl = ((SALOMEDSImpl_StudyManager*)(addr));
63     _corba_impl = SALOMEDS::StudyManager::_duplicate(theManager);
64   }
65   else {
66     _local_impl = NULL;
67     _corba_impl = SALOMEDS::StudyManager::_duplicate(theManager);
68   }
69
70   init_orb();
71 }
72
73 SALOMEDS_StudyManager::SALOMEDS_StudyManager()
74 {
75   init_orb();
76
77   SALOME_NamingService namingService(_orb);
78   CORBA::Object_var obj = namingService.Resolve( "/myStudyManager" );
79   SALOMEDS::StudyManager_var theManager = SALOMEDS::StudyManager::_narrow( obj );
80   ASSERT( !CORBA::is_nil(theManager) );
81
82 #ifdef WIN32
83   long pid =  (long)_getpid();
84 #else
85   long pid =  (long)getpid();
86 #endif  
87
88   CORBA::LongLong addr = theManager->GetLocalImpl(GetHostname().c_str(), pid, _isLocal);
89   if(_isLocal) {
90     _local_impl = ((SALOMEDSImpl_StudyManager*)(addr));
91     _corba_impl = SALOMEDS::StudyManager::_duplicate(theManager);
92   }
93   else {
94     _local_impl = NULL;
95     _corba_impl = SALOMEDS::StudyManager::_duplicate(theManager);
96   }
97 }
98
99 SALOMEDS_StudyManager::~SALOMEDS_StudyManager()
100 {
101 }
102
103 _PTR(Study) SALOMEDS_StudyManager::NewStudy(const std::string& study_name)
104 {
105   //SRN: Pure CORBA NewStudy as it does more initialization than the local one   
106   SALOMEDSClient_Study* aStudy = NULL;
107
108   SALOMEDS::Study_var aStudy_impl = _corba_impl->NewStudy((char*)study_name.c_str());
109   if(CORBA::is_nil(aStudy_impl)) return _PTR(Study)(aStudy);
110   aStudy = new SALOMEDS_Study(aStudy_impl);
111
112   return _PTR(Study)(aStudy);
113 }
114
115 _PTR(Study) SALOMEDS_StudyManager::Open(const std::string& theStudyUrl)
116 {
117   //SRN: Pure CORBA Open as it does more initialization than the local one   
118   SALOMEDSClient_Study* aStudy = NULL;
119
120   SALOMEDS::Study_var aStudy_impl = _corba_impl->Open((char*)theStudyUrl.c_str());
121   if(CORBA::is_nil(aStudy_impl)) return  _PTR(Study)(aStudy);
122     
123   aStudy = new SALOMEDS_Study(aStudy_impl.in());
124
125   return _PTR(Study)(aStudy);
126 }
127  
128 void SALOMEDS_StudyManager::Close(const _PTR(Study)& theStudy)
129 {
130   //SRN: Pure CORBA close as it does more cleaning than the local one
131   SALOMEDS::Study_var aStudy = _corba_impl->GetStudyByID(theStudy->StudyId());
132   _corba_impl->Close(aStudy);
133 }
134  
135 bool SALOMEDS_StudyManager::Save(const _PTR(Study)& theStudy, bool theMultiFile)
136 {
137   //SRN: Pure CORBA save as the save operation require CORBA in any case 
138   SALOMEDS::Study_var aStudy = _corba_impl->GetStudyByID(theStudy->StudyId());
139   return _corba_impl->Save(aStudy, theMultiFile);
140 }
141  
142 bool SALOMEDS_StudyManager::SaveASCII(const _PTR(Study)& theStudy, bool theMultiFile)
143 {
144   //SRN: Pure CORBA save as the save operation require CORBA in any case 
145   SALOMEDS::Study_var aStudy = _corba_impl->GetStudyByID(theStudy->StudyId());
146   return _corba_impl->SaveASCII(aStudy, theMultiFile);
147 }
148  
149 bool SALOMEDS_StudyManager::SaveAs(const std::string& theUrl,  const _PTR(Study)& theStudy, bool theMultiFile)
150 {
151   //SRN: Pure CORBA save as the save operation require CORBA in any case 
152   SALOMEDS::Study_var aStudy = _corba_impl->GetStudyByID(theStudy->StudyId());
153   return _corba_impl->SaveAs((char*)theUrl.c_str(), aStudy, theMultiFile);
154 }
155  
156 bool SALOMEDS_StudyManager::SaveAsASCII(const std::string& theUrl,  const _PTR(Study)& theStudy, bool theMultiFile)
157 {
158   //SRN: Pure CORBA save as the save operation require CORBA in any case 
159   SALOMEDS::Study_var aStudy = _corba_impl->GetStudyByID(theStudy->StudyId());
160   return _corba_impl->SaveAsASCII((char*)theUrl.c_str(), aStudy, theMultiFile);
161 }
162
163 std::vector<std::string> SALOMEDS_StudyManager::GetOpenStudies()
164 {
165   std::vector<std::string> aVector;
166   int aLength, i;
167
168   if (_isLocal) {
169     SALOMEDS::Locker lock;
170
171     vector<SALOMEDSImpl_Study*> aSeq = _local_impl->GetOpenStudies();
172     aLength = aSeq.size();
173     for(i = 0; i < aLength; i++) 
174       aVector.push_back(aSeq[i]->Name());
175   }
176   else {
177     SALOMEDS::ListOfOpenStudies_var aSeq = _corba_impl->GetOpenStudies();
178     aLength = aSeq->length();
179     for(i = 0; i < aLength; i++) 
180       aVector.push_back(aSeq[i].in());
181   }
182   return aVector;
183 }
184
185 _PTR(Study) SALOMEDS_StudyManager::GetStudyByName(const std::string& theStudyName) 
186 {
187   SALOMEDSClient_Study* aStudy = NULL;
188   if (_isLocal) {
189     SALOMEDS::Locker lock;
190
191     SALOMEDSImpl_Study* aStudy_impl = _local_impl->GetStudyByName(theStudyName);
192     if(!aStudy_impl) return _PTR(Study)(aStudy);
193     aStudy = new SALOMEDS_Study(aStudy_impl);
194   }
195   else  {
196     SALOMEDS::Study_var aStudy_impl = _corba_impl->GetStudyByName((char*)theStudyName.c_str());
197     if(CORBA::is_nil(aStudy_impl)) return _PTR(Study)(aStudy);
198     aStudy = new SALOMEDS_Study(aStudy_impl);
199   }
200   return _PTR(Study)(aStudy);
201 }
202
203 _PTR(Study) SALOMEDS_StudyManager::GetStudyByID(int theStudyID) 
204 {
205   SALOMEDSClient_Study* aStudy = NULL;
206   if (_isLocal) {
207     SALOMEDS::Locker lock;
208
209     SALOMEDSImpl_Study* aStudy_impl = _local_impl->GetStudyByID(theStudyID);
210     if(!aStudy_impl) return _PTR(Study)(aStudy);
211     aStudy = new SALOMEDS_Study(aStudy_impl);
212   }
213   else { 
214     SALOMEDS::Study_var aStudy_impl = _corba_impl->GetStudyByID(theStudyID);
215     if(CORBA::is_nil(aStudy_impl)) return _PTR(Study)(aStudy);
216     aStudy = new SALOMEDS_Study(aStudy_impl);
217   }
218   return _PTR(Study)(aStudy);
219 }
220
221 bool SALOMEDS_StudyManager::CanCopy(const _PTR(SObject)& theSO)
222 {
223   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
224   bool ret;
225
226   if (_isLocal) {
227     SALOMEDS::Locker lock;
228
229     SALOMEDSImpl_SObject aSO_impl = *(aSO->GetLocalImpl());
230     SALOMEDS_Driver_i* aDriver = GetDriver(aSO_impl, _orb);
231     ret = _local_impl->CanCopy(aSO_impl, aDriver);
232     delete aDriver;
233   }
234   else {
235     ret = _corba_impl->CanCopy(aSO->GetCORBAImpl());
236   }
237
238   return ret;
239 }
240
241 bool SALOMEDS_StudyManager::Copy(const _PTR(SObject)& theSO)
242 {
243   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
244   bool ret;
245   if (_isLocal) {
246     SALOMEDS::Locker lock;
247
248     SALOMEDSImpl_SObject aSO_impl = *(aSO->GetLocalImpl());
249     SALOMEDS_Driver_i* aDriver = GetDriver(aSO_impl, _orb);
250     ret = _local_impl->Copy(aSO_impl, aDriver);
251     delete aDriver;
252   }
253   else {
254     ret = _corba_impl->Copy(aSO->GetCORBAImpl());
255   }
256   return ret;
257 }
258
259 bool SALOMEDS_StudyManager::CanPaste(const _PTR(SObject)& theSO)
260 {
261   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
262   bool ret;
263
264   if (_isLocal) {
265     SALOMEDS::Locker lock;
266
267     SALOMEDSImpl_SObject aSO_impl = *(aSO->GetLocalImpl());
268     SALOMEDS_Driver_i* aDriver = GetDriver(aSO_impl, _orb);
269     ret = _local_impl->CanPaste(aSO_impl, aDriver);
270     delete aDriver;
271   }
272   else {
273     ret = _corba_impl->CanPaste(aSO->GetCORBAImpl());
274   }
275
276   return ret;
277 }
278
279 _PTR(SObject) SALOMEDS_StudyManager::Paste(const _PTR(SObject)& theSO)
280 {
281   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
282   SALOMEDSClient_SObject* aResult = NULL;
283
284   if (_isLocal) {
285     SALOMEDS::Locker lock;
286
287     SALOMEDSImpl_SObject aSO_impl = *(aSO->GetLocalImpl());
288     SALOMEDS_Driver_i* aDriver = GetDriver(aSO_impl, _orb);
289     SALOMEDSImpl_SObject aNewSO = _local_impl->Paste(aSO_impl, aDriver);
290     delete aDriver;
291     if(aNewSO.IsNull()) return _PTR(SObject)(aResult);
292     aResult = new SALOMEDS_SObject(aNewSO);
293   }
294   else {
295     SALOMEDS::SObject_ptr aNewSO = _corba_impl->Paste(aSO->GetCORBAImpl());
296     if(CORBA::is_nil(aNewSO)) return _PTR(SObject)(aResult);
297     aResult = new SALOMEDS_SObject(aNewSO);
298   }
299
300   return _PTR(SObject)(aResult);
301 }
302
303
304 void SALOMEDS_StudyManager::init_orb()
305 {
306   ORB_INIT &init = *SINGLETON_<ORB_INIT>::Instance();
307   ASSERT(SINGLETON_<ORB_INIT>::IsAlreadyExisting());
308   _orb = init(0 , 0 );
309 }
310
311 SALOMEDS_Driver_i* GetDriver(const SALOMEDSImpl_SObject& theObject, CORBA::ORB_ptr orb)
312 {
313   SALOMEDS_Driver_i* driver = NULL;
314   
315   SALOMEDSImpl_SComponent aSCO = theObject.GetFatherComponent();
316   if(!aSCO.IsNull()) {
317     string IOREngine = aSCO.GetIOR();
318     if(!IOREngine.empty()) {
319       CORBA::Object_var obj = orb->string_to_object(IOREngine.c_str());
320       SALOMEDS::Driver_var Engine = SALOMEDS::Driver::_narrow(obj) ;
321       driver = new SALOMEDS_Driver_i(Engine, orb);
322     }
323   }
324
325   return driver;
326 }