Version: 8.3.0
SessionCataLoader.cxx
Go to the documentation of this file.
1 // Copyright (C) 2006-2016 CEA/DEN, EDF R&D
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 // Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19 
20 #include "RuntimeSALOME.hxx"
21 #include "SessionCataLoader.hxx"
22 #include "ComponentDefinition.hxx"
23 #include "ServiceNode.hxx"
24 #include "TypeCode.hxx"
25 
26 #include <iostream>
27 #include <sstream>
28 
29 //#define _DEVDEBUG_
30 #include "YacsTrace.hxx"
31 
32 #define NEW_KERNEL
33 
34 using namespace YACS::ENGINE;
35 
36 SessionCataLoader::SessionCataLoader(const std::string& path):CatalogLoader(path)
37 {
38  //path should be a CORBA URI like that : corbaname::machine:port/NameService#Kernel.dir/ModulCatalog.object
39  //or equivalent corbaname
40 }
41 
42 /*
43  In salome catalog, the type names for CALCIUM are : INTEGER, FLOAT,DOUBLE,STRING,BOOLEAN
44  enum DataStreamType {
45  DATASTREAM_UNKNOWN,
46  DATASTREAM_INTEGER,
47  DATASTREAM_FLOAT,
48  DATASTREAM_DOUBLE,
49  DATASTREAM_STRING,
50  DATASTREAM_BOOLEAN
51  } ;
52 */
53 #ifndef NEW_KERNEL
54 std::map<SALOME_ModuleCatalog::DataStreamType,std::string> datastreamMap;
55 #endif
56 
58 
66 void SessionCataLoader::importComponent(Catalog* cata,SALOME_ModuleCatalog::Acomponent_ptr compo)
67 {
68  CORBA::String_var componame = compo->componentname();
69 
70  DEBTRACE("Implementation type : " << compo->implementation_type());
71 #ifdef NEW_KERNEL
72  SALOME_ModuleCatalog::ImplType imptyp=compo->implementation_type();
73  if(imptyp == SALOME_ModuleCatalog::SO)DEBTRACE("Dyn lib");
74  if(imptyp == SALOME_ModuleCatalog::PY)DEBTRACE("Python module");
75  if(imptyp == SALOME_ModuleCatalog::EXE)DEBTRACE("Executable");
76  DEBTRACE("Implementation name : " << compo->implementation_name());
77 #endif
78 
79  SALOME_ModuleCatalog::ListOfInterfaces_var interfacename_list = compo->GetInterfaceList();
80  if(interfacename_list->length() == 0)
81  return;
82  int found=0;
83  for (int j = 0; j < interfacename_list->length();j++)
84  {
85  DEBTRACE ("Interface : " << interfacename_list[j]);
86  if(strcmp(componame,interfacename_list[j]) == 0)
87  {
88  found=j;
89  break;
90  }
91  }
92  DEBTRACE ("Interface found : " << interfacename_list[found]);
93  ComponentDefinition* compodef=new ComponentDefinition((const char*)componame);
94 
95  SALOME_ModuleCatalog::DefinitionInterface_var interface;
96  interface= compo->GetInterface(interfacename_list[found]);
97  SALOME_ModuleCatalog::ListOfInterfaceService services = interface->interfaceservicelist;
98  for (int k = 0; k < services.length(); k++)
99  {
100  DEBTRACE("Service : " << services[k].ServiceName);
101  const char* s=services[k].ServiceName;
102  //create a new service node (prototype)
103  ServiceNode* node=getRuntime()->createCompoNode("Salome",s);
104  node->setRef((const char*)componame);
105  node->setMethod(s);
106  for (int kk=0;kk< services[k].ServiceinParameter.length();kk++)
107  {
108  DEBTRACE("Parameter : " << services[k].ServiceinParameter[kk].Parametername);
109  DEBTRACE("Type : " << services[k].ServiceinParameter[kk].Parametertype);
110  const char* ty=services[k].ServiceinParameter[kk].Parametertype;
111  if(cata->_typeMap.count(ty)==0)
112  {
113  std::stringstream msg;
114  msg << "Type " <<ty <<" does not exist. Service " << s << " of component " << componame << " is not available";
115  _errors=_errors+"\n"+msg.str();
116  std::cerr << msg.str() << std::endl;
117  compodef->_serviceMap[s+std::string("_IS_INVALID")]=0;
118  delete node;
119  node=0;
120  break;
121  }
122  const char* name=services[k].ServiceinParameter[kk].Parametername;
123  node->edAddInputPort(name,cata->_typeMap[ty]);
124  }
125  if(node == 0)continue;
126 
127  for (int kk=0;kk< services[k].ServiceoutParameter.length();kk++)
128  {
129  DEBTRACE("Parameter : " << services[k].ServiceoutParameter[kk].Parametername);
130  DEBTRACE("Type : " << services[k].ServiceoutParameter[kk].Parametertype);
131  const char* ty=services[k].ServiceoutParameter[kk].Parametertype;
132  if(cata->_typeMap.count(ty)==0)
133  {
134  std::stringstream msg;
135  msg << "Type " <<ty <<" does not exist. Service " << s << " of component " << componame << " is not available";
136  _errors=_errors+"\n"+msg.str();
137  std::cerr << msg.str() << std::endl;
138  compodef->_serviceMap[s+std::string("_IS_INVALID")]=0;
139  delete node;
140  node=0;
141  break;
142  }
143  const char* name=services[k].ServiceoutParameter[kk].Parametername;
144  node->edAddOutputPort(name,cata->_typeMap[ty]);
145  }
146  if(node == 0)continue;
147 
148  for (int kk=0;kk< services[k].ServiceinDataStreamParameter.length();kk++)
149  {
150  DEBTRACE("Parameter : " << services[k].ServiceinDataStreamParameter[kk].Parametername);
151  DEBTRACE("Type : " << services[k].ServiceinDataStreamParameter[kk].Parametertype);
152  DEBTRACE("Dependency : " << services[k].ServiceinDataStreamParameter[kk].Parameterdependency);
153 #ifdef NEW_KERNEL
154  const char* ty=services[k].ServiceinDataStreamParameter[kk].Parametertype;
155 #else
156  std::string ty=datastreamMap[services[k].ServiceinDataStreamParameter[kk].Parametertype];
157 #endif
158  if(cata->_typeMap.count(ty)==0)
159  {
160  std::stringstream msg;
161  msg << "Type " <<ty <<" does not exist. Service " << s << " of component " << componame << " is not available";
162  _errors=_errors+"\n"+msg.str();
163  std::cerr << msg.str() << std::endl;
164  compodef->_serviceMap[s+std::string("_IS_INVALID")]=0;
165  delete node;
166  node=0;
167  break;
168  }
169  const char* name=services[k].ServiceinDataStreamParameter[kk].Parametername;
170  InputDataStreamPort* port;
171  port=node->edAddInputDataStreamPort(name,cata->_typeMap[ty]);
172  }
173  if(node == 0)continue;
174 
175  for (int kk=0;kk< services[k].ServiceoutDataStreamParameter.length();kk++)
176  {
177  DEBTRACE("Parameter : " << services[k].ServiceoutDataStreamParameter[kk].Parametername);
178  DEBTRACE("Type : " << services[k].ServiceoutDataStreamParameter[kk].Parametertype);
179  DEBTRACE("Dependency : " << services[k].ServiceoutDataStreamParameter[kk].Parameterdependency);
180 #ifdef NEW_KERNEL
181  const char* ty=services[k].ServiceoutDataStreamParameter[kk].Parametertype;
182 #else
183  std::string ty=datastreamMap[services[k].ServiceoutDataStreamParameter[kk].Parametertype];
184 #endif
185  if(cata->_typeMap.count(ty)==0)
186  {
187  std::stringstream msg;
188  msg << "Type " <<ty <<" does not exist. Service " << s << " of component " << componame << " is not available";
189  _errors=_errors+"\n"+msg.str();
190  std::cerr << msg.str() << std::endl;
191  compodef->_serviceMap[s+std::string("_IS_INVALID")]=0;
192  delete node;
193  node=0;
194  break;
195  }
196  const char* name=services[k].ServiceoutDataStreamParameter[kk].Parametername;
197  OutputDataStreamPort* port;
198  port=node->edAddOutputDataStreamPort(name,cata->_typeMap[ty]);
199  // Set all properties for this port
200  /*
201  std::map<std::string, std::string>::const_iterator pt;
202  for(pt=p._props.begin();pt!=p._props.end();pt++)
203  port->setProperty((*pt).first,(*pt).second);
204  */
205  }
206  if(node == 0)continue;
207  compodef->_serviceMap[s]=node;
208  }
209 
210  /* Even if a component has no service, put it in the catalog
211  if(compodef->_serviceMap.size() > 0)
212  {
213  cata->_componentMap[(const char*)componame]=compodef;
214  }
215  else
216  {
217  delete compodef;
218  }
219  */
220  cata->_componentMap[(const char*)componame]=compodef;
221 }
222 
223 SessionCataLoader::~SessionCataLoader()
224 {
225  DEBTRACE ("SessionCataLoader::~SessionCataLoader");
226 }
227 
228 void SessionCataLoader::loadTypes(Catalog* cata,SALOME_ModuleCatalog::ModuleCatalog_ptr catalog)
229 {
230  Runtime* r=getRuntime();
231  std::map<std::string,TypeCode*>& typeMap=cata->_typeMap;
232  // Get types list
233  SALOME_ModuleCatalog::ListOfTypeDefinition_var types_list=catalog->GetTypes();
234  for (int i=0; i< types_list->length(); i++)
235  {
236  const char* name=types_list[i].name;
237  DEBTRACE ("type : " << types_list[i].name << " " << types_list[i].kind);
238  if(types_list[i].kind == SALOME_ModuleCatalog::Dble)
239  {
240  r->_tc_double->incrRef();
241  typeMap[name]=r->_tc_double;
242  }
243  else if(types_list[i].kind == SALOME_ModuleCatalog::Int)
244  {
245  r->_tc_int->incrRef();
246  typeMap[name]=r->_tc_int;
247  }
248  else if(types_list[i].kind == SALOME_ModuleCatalog::Bool)
249  {
250  r->_tc_bool->incrRef();
251  typeMap[name]=r->_tc_bool;
252  }
253  else if(types_list[i].kind == SALOME_ModuleCatalog::Str)
254  {
255  r->_tc_string->incrRef();
256  typeMap[name]=r->_tc_string;
257  }
258  else if(types_list[i].kind == SALOME_ModuleCatalog::Seq)
259  {
260  const char* content=types_list[i].content;
261  if ( typeMap.find(content) != typeMap.end() )
262  typeMap[name]=r->createSequenceTc(name,name,typeMap[content]);
263  //else ignored !!
264  }
265  else if(types_list[i].kind == SALOME_ModuleCatalog::Array)
266  {
267  //ignored, for the moment !!
268  }
269  else if(types_list[i].kind == SALOME_ModuleCatalog::Objref)
270  {
271  std::list<TypeCodeObjref *> ltc;
272  const char* id=types_list[i].id;
273  for (int m=0; m< types_list[i].bases.length(); m++)
274  {
275  const char* b_name=types_list[i].bases[m];
276  if(typeMap.find(b_name) != typeMap.end())
277  ltc.push_back((TypeCodeObjref *)typeMap[b_name]);
278  //else ignored !!!
279  }
280  typeMap[name]=r->createInterfaceTc(id,name,ltc);
281  }
282  else if(types_list[i].kind == SALOME_ModuleCatalog::Struc)
283  {
284  TypeCodeStruct* t=r->createStructTc("",name);
285  for (int m=0; m< types_list[i].members.length(); m++)
286  {
287  const char* m_name=types_list[i].members[m].name;
288  const char* m_type=types_list[i].members[m].type;
289  if(typeMap.find(m_type) != typeMap.end())
290  t->addMember(m_name,typeMap[m_type]);
291  //else ignored !!!
292  }
293  typeMap[name]=t;
294  }
295  else
296  {
297  std::cerr << "Unknown kind: " << types_list[i].kind << std::endl;
298  }
299  }
300 }
301 
302 void SessionCataLoader::loadTypesOld(Catalog* cata)
303 {
304  // Fill the types map with built in types
305  Runtime* r=getRuntime();
306  std::map<std::string,TypeCode*>& typeMap=cata->_typeMap;
307 
308 #ifdef NEW_KERNEL
309  //Add old Calcium data types for KERNEL
310  if(typeMap.count("CALCIUM_double")!=0)
311  {
312  typeMap["DOUBLE"]=typeMap["CALCIUM_double"];
313  typeMap["DOUBLE"]->incrRef();
314  }
315  if(typeMap.count("CALCIUM_real")!=0)
316  {
317  typeMap["FLOAT"]=typeMap["CALCIUM_real"];
318  typeMap["FLOAT"]->incrRef();
319  }
320  if(typeMap.count("CALCIUM_integer")!=0)
321  {
322  typeMap["INTEGER"]=typeMap["CALCIUM_integer"];
323  typeMap["INTEGER"]->incrRef();
324  }
325  if(typeMap.count("CALCIUM_boolean")!=0)
326  {
327  typeMap["BOOLEAN"]=typeMap["CALCIUM_boolean"];
328  typeMap["BOOLEAN"]->incrRef();
329  }
330  if(typeMap.count("CALCIUM_string")!=0)
331  {
332  typeMap["STRING"]=typeMap["CALCIUM_string"];
333  typeMap["STRING"]->incrRef();
334  }
335 #endif
336 
337  //GEOM
338  /*
339  typeMap["GEOM_Object"]=TypeCode::interfaceTc("IDL:GEOM/GEOM_Object:1.0","GEOM_Object");
340  typeMap["ListOfLong"]=TypeCode::sequenceTc("ListOfLong","ListOfLong",r->_tc_int);
341  typeMap["GEOM_List"]=TypeCode::interfaceTc("IDL:GEOM/GEOM_List:1.0","GEOM_List");
342  typeMap["GEOM_Superv"]=TypeCode::interfaceTc("IDL:GEOM/GEOM_Superv:1.0","GEOM_Superv");
343  typeMap["ListOfGO"]=TypeCode::sequenceTc("ListOfGO","ListOfGO",cata->_typeMap["GEOM_Object"]);
344  typeMap["string_array"]=TypeCode::sequenceTc("string_array","string_array",r->_tc_string);
345  r->_tc_int->incrRef();
346  typeMap["BCErrorType"]=r->_tc_int;
347  typeMap["BCError"]=TypeCode::structTc("","BCError");
348  ((TypeCodeStruct*)typeMap["BCError"])->addMember("incriminated",typeMap["ListOfLong"]);
349  typeMap["BCErrors"]=TypeCode::sequenceTc("BCErrors","BCErrors",typeMap["BCError"]);
350  typeMap["GEOM_Gen"]=TypeCode::interfaceTc("IDL:GEOM/GEOM_Gen:1.0","GEOM_Gen");
351  typeMap["GEOM_Object"]->incrRef();
352  typeMap["GEOM_Shape"]=typeMap["GEOM_Object"];
353  */
354 
355  //SMESH
356  /*
357  typeMap["SMESH_Mesh"]=TypeCode::interfaceTc("IDL:Mesh/SMESH_Mesh:1.0","SMESH_Mesh");
358  typeMap["SMESH_Hypothesis"]=TypeCode::interfaceTc("IDL:SMESH/SMESH_Hypothesis:1.0","SMESH_Hypothesis");
359  */
360 
361  //MED
362  /*
363  typeMap["MED"]=TypeCode::interfaceTc("IDL:SALOME_MED/MED:1.0","MED");
364  typeMap["FIELD"]=TypeCode::interfaceTc("IDL:SALOME_MED/FIELD:1.0","FIELD");
365  // TODO : FIELDDOUBLE inherits FIELD
366  typeMap["FIELDDOUBLE"]=TypeCode::interfaceTc("IDL:SALOME_MED/FIELDDOUBLE:1.0","FIELDDOUBLE");
367  */
368 
369  //COMPONENT
370  /*
371  typeMap["AddComponent"]=TypeCode::interfaceTc("IDL:SuperVisionTest/AddComponent:1.0","AddComponent");
372  typeMap["AddComponent"]->incrRef();
373  typeMap["AddInterface"]=typeMap["AddComponent"];
374  typeMap["SuperVisionTest/Adder"]=TypeCode::interfaceTc("IDL:SuperVisionTest/Adder:1.0","SuperVisionTest/Adder");
375  typeMap["AdditionComponent/Adder"]=TypeCode::interfaceTc("IDL:AdditionComponent/Adder:1.0","AdditionComponent/Adder");
376  typeMap["Syr"]=TypeCode::interfaceTc("IDL:SuperVisionTest/Syr:1.0","Syr");
377  typeMap["ListOfSyr"]=TypeCode::interfaceTc("IDL:SuperVisionTest/ListOfSyr:1.0","ListOfSyr");
378  */
379 }
380 
381 void SessionCataLoader::loadCata(Catalog* cata)
382 {
383  DEBTRACE("SessionCataLoader::load")
384 #ifndef NEW_KERNEL
385  datastreamMap[SALOME_ModuleCatalog::DATASTREAM_UNKNOWN]="CALCIUM_unknown";
386  datastreamMap[SALOME_ModuleCatalog::DATASTREAM_INTEGER]="CALCIUM_integer";
387  datastreamMap[SALOME_ModuleCatalog::DATASTREAM_FLOAT]="CALCIUM_real";
388  datastreamMap[SALOME_ModuleCatalog::DATASTREAM_DOUBLE]="CALCIUM_double";
389  datastreamMap[SALOME_ModuleCatalog::DATASTREAM_BOOLEAN]="CALCIUM_boolean";
390  datastreamMap[SALOME_ModuleCatalog::DATASTREAM_STRING]="CALCIUM_string";
391 #endif
392 
393  CORBA::ORB_ptr orb = getSALOMERuntime()->getOrb();
394  CORBA::Object_var obj;
395  SALOME_ModuleCatalog::ModuleCatalog_var catalog;
396  obj=orb->string_to_object(_path.c_str());
397  catalog= SALOME_ModuleCatalog::ModuleCatalog::_narrow(obj);
398  _errors="";
399 
400  // Get types in catalog
401  loadTypes(cata,catalog);
402  // Get old types
403  loadTypesOld(cata);
404 
405  // Get component list
406  SALOME_ModuleCatalog::ListOfComponents_var componentname_list;
407  componentname_list = catalog->GetComponentList();
408  for (int i=0; i<componentname_list->length(); i++)
409  {
410  DEBTRACE ("Component : " << componentname_list[i]);
411  SALOME_ModuleCatalog::Acomponent_var component = catalog->GetComponent(componentname_list[i]);
412  importComponent(cata,component);
413  }
414  cata->setErrors(_errors);
415 }