YACS::ENGINE::SessionCataLoader Class Reference

#include <SessionCataLoader.hxx>

Inheritance diagram for YACS::ENGINE::SessionCataLoader:

Collaboration diagram for YACS::ENGINE::SessionCataLoader:

Public Member Functions
	SessionCataLoader ()
	SessionCataLoader (const std::string &path)
virtual	~SessionCataLoader ()
virtual void	loadCata (Catalog *cata)
virtual void	loadTypesOld (Catalog *cata)
virtual void	loadTypes (Catalog *cata, SALOME_ModuleCatalog::ModuleCatalog_ptr catalog)
virtual CatalogLoader *	newLoader (const std::string &path)
virtual void	importComponent (Catalog *cata, SALOME_ModuleCatalog::Acomponent_ptr compo)
	import a SALOME component definition in a YACS catalog More...
Public Member Functions inherited from YACS::ENGINE::CatalogLoader
	CatalogLoader ()
	CatalogLoader (const std::string &path)
virtual	~CatalogLoader ()
virtual CatalogLoader *	newLoader (const std::string &path)=0
virtual void	loadCata (Catalog *cata)=0
virtual void	load (Catalog *cata, const std::string &path)

Protected Attributes
std::string	_errors
Protected Attributes inherited from YACS::ENGINE::CatalogLoader
std::string	_path

Detailed Description

Definition at line 34 of file SessionCataLoader.hxx.

Constructor & Destructor Documentation

SessionCataLoader() [1/2]

YACS::ENGINE::SessionCataLoader::SessionCataLoader ( )

inline

Definition at line 37 of file SessionCataLoader.hxx.

:CatalogLoader(){};

Referenced by newLoader().

SessionCataLoader() [2/2]

SessionCataLoader::SessionCataLoader

(

const std::string &

path

)

Definition at line 36 of file SessionCataLoader.cxx.

                                                         :CatalogLoader(path)
{
  //path should be a CORBA URI like that : corbaname::machine:port/NameService#Kernel.dir/ModulCatalog.object
  //or equivalent corbaname
}

~SessionCataLoader()

SessionCataLoader::~SessionCataLoader ( )

virtual

Definition at line 223 of file SessionCataLoader.cxx.

{
  DEBTRACE ("SessionCataLoader::~SessionCataLoader");
}

References DEBTRACE.

Member Function Documentation

importComponent()

void SessionCataLoader::importComponent ( Catalog *  cata, SALOME_ModuleCatalog::Acomponent_ptr  compo  )

virtual

import a SALOME component definition in a YACS catalog

SALOME components can have several interfaces. YACS for the moment allows only one interface by component, so if there is only one interface we import it. If we have more than one interface, we import the one with the same name as the component or the first one.

Parameters

cata	: a YACS catalog
compo	: a CORBA reference on a component in a SALOME_ModuleCatalog

Definition at line 66 of file SessionCataLoader.cxx.

{
  CORBA::String_var componame = compo->componentname();
 
  DEBTRACE("Implementation type : " << compo->implementation_type());
#ifdef NEW_KERNEL
  SALOME_ModuleCatalog::ImplType imptyp=compo->implementation_type();
  if(imptyp == SALOME_ModuleCatalog::SO)DEBTRACE("Dyn lib");
  if(imptyp == SALOME_ModuleCatalog::PY)DEBTRACE("Python module");
  if(imptyp == SALOME_ModuleCatalog::EXE)DEBTRACE("Executable");
  DEBTRACE("Implementation name : " << compo->implementation_name());
#endif
 
  SALOME_ModuleCatalog::ListOfInterfaces_var interfacename_list = compo->GetInterfaceList();
  if(interfacename_list->length() == 0)
    return;
  int found=0;
  for (int j = 0; j < interfacename_list->length();j++) 
    {
      DEBTRACE ("Interface : " << interfacename_list[j]);
      if(strcmp(componame,interfacename_list[j]) == 0)
         {
           found=j;
           break;
         }
    }
  DEBTRACE ("Interface found : " << interfacename_list[found]);
  ComponentDefinition* compodef=new ComponentDefinition((const char*)componame);
 
  SALOME_ModuleCatalog::DefinitionInterface_var interface;
  interface= compo->GetInterface(interfacename_list[found]);
  SALOME_ModuleCatalog::ListOfInterfaceService services = interface->interfaceservicelist;
  for (int k = 0; k < services.length(); k++)
    {
      DEBTRACE("Service : " << services[k].ServiceName);
      const char* s=services[k].ServiceName;
      //create a new service node (prototype)
      ServiceNode* node=getRuntime()->createCompoNode("Salome",s);
      node->setRef((const char*)componame);
      node->setMethod(s);
      for (int kk=0;kk< services[k].ServiceinParameter.length();kk++)
        {
          DEBTRACE("Parameter : " <<  services[k].ServiceinParameter[kk].Parametername);
          DEBTRACE("Type : " <<  services[k].ServiceinParameter[kk].Parametertype);
          const char* ty=services[k].ServiceinParameter[kk].Parametertype;
          if(cata->_typeMap.count(ty)==0)
            {
              std::stringstream msg; 
              msg << "Type " <<ty <<" does not exist. Service " << s << " of component " << componame << " is not available";
              _errors=_errors+"\n"+msg.str();
              std::cerr << msg.str() << std::endl;
              compodef->_serviceMap[s+std::string("_IS_INVALID")]=0;
              delete node;
              node=0;
              break;
            }
          const char* name=services[k].ServiceinParameter[kk].Parametername;
          node->edAddInputPort(name,cata->_typeMap[ty]);
        }
      if(node == 0)continue;
 
      for (int kk=0;kk< services[k].ServiceoutParameter.length();kk++)
        {
          DEBTRACE("Parameter : " <<  services[k].ServiceoutParameter[kk].Parametername);
          DEBTRACE("Type : " <<  services[k].ServiceoutParameter[kk].Parametertype);
          const char* ty=services[k].ServiceoutParameter[kk].Parametertype;
          if(cata->_typeMap.count(ty)==0)
            {
              std::stringstream msg; 
              msg << "Type " <<ty <<" does not exist. Service " << s << " of component " << componame << " is not available";
              _errors=_errors+"\n"+msg.str();
              std::cerr << msg.str() << std::endl;
              compodef->_serviceMap[s+std::string("_IS_INVALID")]=0;
              delete node;
              node=0;
              break;
            }
          const char* name=services[k].ServiceoutParameter[kk].Parametername;
          node->edAddOutputPort(name,cata->_typeMap[ty]);
        }
      if(node == 0)continue;
 
      for (int kk=0;kk< services[k].ServiceinDataStreamParameter.length();kk++)
        {
          DEBTRACE("Parameter : " <<  services[k].ServiceinDataStreamParameter[kk].Parametername);
          DEBTRACE("Type : " <<  services[k].ServiceinDataStreamParameter[kk].Parametertype);
          DEBTRACE("Dependency : " <<  services[k].ServiceinDataStreamParameter[kk].Parameterdependency);
#ifdef NEW_KERNEL
          const char* ty=services[k].ServiceinDataStreamParameter[kk].Parametertype;
#else
          std::string ty=datastreamMap[services[k].ServiceinDataStreamParameter[kk].Parametertype];
#endif
          if(cata->_typeMap.count(ty)==0)
            {
              std::stringstream msg; 
              msg << "Type " <<ty <<" does not exist. Service " << s << " of component " << componame << " is not available";
              _errors=_errors+"\n"+msg.str();
              std::cerr << msg.str() << std::endl;
              compodef->_serviceMap[s+std::string("_IS_INVALID")]=0;
              delete node;
              node=0;
              break;
            }
          const char* name=services[k].ServiceinDataStreamParameter[kk].Parametername;
          InputDataStreamPort* port;
          port=node->edAddInputDataStreamPort(name,cata->_typeMap[ty]);
        }
      if(node == 0)continue;
 
      for (int kk=0;kk< services[k].ServiceoutDataStreamParameter.length();kk++)
        {
          DEBTRACE("Parameter : " <<  services[k].ServiceoutDataStreamParameter[kk].Parametername);
          DEBTRACE("Type : " <<  services[k].ServiceoutDataStreamParameter[kk].Parametertype);
          DEBTRACE("Dependency : " <<  services[k].ServiceoutDataStreamParameter[kk].Parameterdependency);
#ifdef NEW_KERNEL
          const char* ty=services[k].ServiceoutDataStreamParameter[kk].Parametertype;
#else
          std::string ty=datastreamMap[services[k].ServiceoutDataStreamParameter[kk].Parametertype];
#endif
          if(cata->_typeMap.count(ty)==0)
            {
              std::stringstream msg; 
              msg << "Type " <<ty <<" does not exist. Service " << s << " of component " << componame << " is not available";
              _errors=_errors+"\n"+msg.str();
              std::cerr << msg.str() << std::endl;
              compodef->_serviceMap[s+std::string("_IS_INVALID")]=0;
              delete node;
              node=0;
              break;
            }
          const char* name=services[k].ServiceoutDataStreamParameter[kk].Parametername;
          OutputDataStreamPort* port;
          port=node->edAddOutputDataStreamPort(name,cata->_typeMap[ty]);
          // Set all properties for this port
          /*
          std::map<std::string, std::string>::const_iterator pt;
          for(pt=p._props.begin();pt!=p._props.end();pt++)
            port->setProperty((*pt).first,(*pt).second);
            */
        }
      if(node == 0)continue;
      compodef->_serviceMap[s]=node;
    }
 
  /* Even if a component has no service, put it in the catalog
  if(compodef->_serviceMap.size() > 0)
    {
      cata->_componentMap[(const char*)componame]=compodef;
    }
  else
    {
      delete compodef;
    }
    */
  cata->_componentMap[(const char*)componame]=compodef;
}

References YACS::ENGINE::Catalog::_componentMap, _errors, YACS::ENGINE::ComponentDefinition::_serviceMap, YACS::ENGINE::Catalog::_typeMap, YACS::ENGINE::Runtime::createCompoNode(), DEBTRACE, YACS::ENGINE::ElementaryNode::edAddInputDataStreamPort(), YACS::ENGINE::ElementaryNode::edAddInputPort(), YACS::ENGINE::ElementaryNode::edAddOutputDataStreamPort(), YACS::ENGINE::ElementaryNode::edAddOutputPort(), YACS::ENGINE::getRuntime(), YACS::ENGINE::ServiceNode::setMethod(), and YACS::ENGINE::ServiceNode::setRef().

Referenced by loadCata().

loadCata()

void SessionCataLoader::loadCata ( Catalog *  cata )

virtual

Implements YACS::ENGINE::CatalogLoader.

Definition at line 381 of file SessionCataLoader.cxx.

{
  DEBTRACE("SessionCataLoader::load")
#ifndef NEW_KERNEL
  datastreamMap[SALOME_ModuleCatalog::DATASTREAM_UNKNOWN]="CALCIUM_unknown";
  datastreamMap[SALOME_ModuleCatalog::DATASTREAM_INTEGER]="CALCIUM_integer";
  datastreamMap[SALOME_ModuleCatalog::DATASTREAM_FLOAT]="CALCIUM_real";
  datastreamMap[SALOME_ModuleCatalog::DATASTREAM_DOUBLE]="CALCIUM_double";
  datastreamMap[SALOME_ModuleCatalog::DATASTREAM_BOOLEAN]="CALCIUM_boolean";
  datastreamMap[SALOME_ModuleCatalog::DATASTREAM_STRING]="CALCIUM_string";
#endif
 
  CORBA::ORB_ptr orb = getSALOMERuntime()->getOrb();
  CORBA::Object_var obj;
  SALOME_ModuleCatalog::ModuleCatalog_var catalog;
  obj=orb->string_to_object(_path.c_str());
  catalog= SALOME_ModuleCatalog::ModuleCatalog::_narrow(obj);
  _errors="";
 
  // Get types in catalog
  loadTypes(cata,catalog);
  // Get old types 
  loadTypesOld(cata);
 
  // Get component list
  SALOME_ModuleCatalog::ListOfComponents_var componentname_list;
  componentname_list  = catalog->GetComponentList();
  for (int i=0; i<componentname_list->length(); i++)
    {
      DEBTRACE ("Component : " << componentname_list[i]);
      SALOME_ModuleCatalog::Acomponent_var component = catalog->GetComponent(componentname_list[i]);
      importComponent(cata,component);
    }
  cata->setErrors(_errors);
}

References _errors, YACS::ENGINE::CatalogLoader::_path, DEBTRACE, YACS::ENGINE::RuntimeSALOME::getOrb(), YACS::ENGINE::getSALOMERuntime(), yacsorb.CORBAEngineTest::i, importComponent(), loadTypes(), loadTypesOld(), orb, and YACS::ENGINE::Catalog::setErrors().

loadTypes()

void SessionCataLoader::loadTypes ( Catalog *  cata, SALOME_ModuleCatalog::ModuleCatalog_ptr  catalog  )

virtual

Definition at line 228 of file SessionCataLoader.cxx.

{
  Runtime* r=getRuntime();
  std::map<std::string,TypeCode*>& typeMap=cata->_typeMap;
  // Get types list
  SALOME_ModuleCatalog::ListOfTypeDefinition_var types_list=catalog->GetTypes();
  for (int i=0; i< types_list->length(); i++)
    {
      const char* name=types_list[i].name;
      DEBTRACE ("type : " << types_list[i].name << " " << types_list[i].kind);
      if(types_list[i].kind == SALOME_ModuleCatalog::Dble)
        {
          r->_tc_double->incrRef();
          typeMap[name]=r->_tc_double;
        }
      else if(types_list[i].kind == SALOME_ModuleCatalog::Int)
        {
          r->_tc_int->incrRef();
          typeMap[name]=r->_tc_int;
        }
      else if(types_list[i].kind == SALOME_ModuleCatalog::Bool)
        {
          r->_tc_bool->incrRef();
          typeMap[name]=r->_tc_bool;
        }
      else if(types_list[i].kind == SALOME_ModuleCatalog::Str)
        {
          r->_tc_string->incrRef();
          typeMap[name]=r->_tc_string;
        }
      else if(types_list[i].kind == SALOME_ModuleCatalog::Seq)
        {
          const char* content=types_list[i].content;
          if ( typeMap.find(content) != typeMap.end() )
            typeMap[name]=r->createSequenceTc(name,name,typeMap[content]);
          //else ignored !!
        }
      else if(types_list[i].kind == SALOME_ModuleCatalog::Array)
        {
          //ignored, for the moment !!
        }
      else if(types_list[i].kind == SALOME_ModuleCatalog::Objref)
        {
          std::list<TypeCodeObjref *> ltc;
          const char* id=types_list[i].id;
          for (int m=0; m< types_list[i].bases.length(); m++)
            {
              const char* b_name=types_list[i].bases[m];
              if(typeMap.find(b_name) != typeMap.end())
                ltc.push_back((TypeCodeObjref *)typeMap[b_name]);
              //else ignored !!!
            }
          typeMap[name]=r->createInterfaceTc(id,name,ltc);
        }
      else if(types_list[i].kind == SALOME_ModuleCatalog::Struc)
        {
          TypeCodeStruct* t=r->createStructTc("",name);
          for (int m=0; m< types_list[i].members.length(); m++)
            {
              const char* m_name=types_list[i].members[m].name;
              const char* m_type=types_list[i].members[m].type;
              if(typeMap.find(m_type) != typeMap.end())
                t->addMember(m_name,typeMap[m_type]);
              //else ignored !!!
            }
          typeMap[name]=t;
        }
      else
        {
          std::cerr << "Unknown kind: " << types_list[i].kind << std::endl;
        }
    }
}

References YACS::ENGINE::Catalog::_typeMap, YACS::ENGINE::Array, YACS::ENGINE::Bool, DEBTRACE, YACS::ENGINE::getRuntime(), yacsorb.CORBAEngineTest::i, YACS::ENGINE::Int, gui.GraphViewer::m, YACS::ENGINE::Objref, testCppPluginInvokation::r, and gui.Appli::t.

Referenced by loadCata().

loadTypesOld()

void SessionCataLoader::loadTypesOld ( Catalog *  cata )

virtual

Definition at line 302 of file SessionCataLoader.cxx.

{
  // Fill the types map with built in types
  Runtime* r=getRuntime();
  std::map<std::string,TypeCode*>& typeMap=cata->_typeMap;
 
#ifdef NEW_KERNEL
  //Add old Calcium data types for KERNEL
  if(typeMap.count("CALCIUM_double")!=0)
    {
      typeMap["DOUBLE"]=typeMap["CALCIUM_double"];
      typeMap["DOUBLE"]->incrRef();
    }
  if(typeMap.count("CALCIUM_real")!=0)
    {
      typeMap["FLOAT"]=typeMap["CALCIUM_real"];
      typeMap["FLOAT"]->incrRef();
    }
  if(typeMap.count("CALCIUM_integer")!=0)
    {
      typeMap["INTEGER"]=typeMap["CALCIUM_integer"];
      typeMap["INTEGER"]->incrRef();
    }
  if(typeMap.count("CALCIUM_boolean")!=0)
    {
      typeMap["BOOLEAN"]=typeMap["CALCIUM_boolean"];
      typeMap["BOOLEAN"]->incrRef();
    }
  if(typeMap.count("CALCIUM_string")!=0)
    {
      typeMap["STRING"]=typeMap["CALCIUM_string"];
      typeMap["STRING"]->incrRef();
    }
#endif
 
  //GEOM
  /*
  typeMap["GEOM_Object"]=TypeCode::interfaceTc("IDL:GEOM/GEOM_Object:1.0","GEOM_Object");
  typeMap["ListOfLong"]=TypeCode::sequenceTc("ListOfLong","ListOfLong",r->_tc_int);
  typeMap["GEOM_List"]=TypeCode::interfaceTc("IDL:GEOM/GEOM_List:1.0","GEOM_List");
  typeMap["GEOM_Superv"]=TypeCode::interfaceTc("IDL:GEOM/GEOM_Superv:1.0","GEOM_Superv");
  typeMap["ListOfGO"]=TypeCode::sequenceTc("ListOfGO","ListOfGO",cata->_typeMap["GEOM_Object"]);
  typeMap["string_array"]=TypeCode::sequenceTc("string_array","string_array",r->_tc_string);
  r->_tc_int->incrRef();
  typeMap["BCErrorType"]=r->_tc_int;
  typeMap["BCError"]=TypeCode::structTc("","BCError");
  ((TypeCodeStruct*)typeMap["BCError"])->addMember("incriminated",typeMap["ListOfLong"]);
  typeMap["BCErrors"]=TypeCode::sequenceTc("BCErrors","BCErrors",typeMap["BCError"]);
  typeMap["GEOM_Gen"]=TypeCode::interfaceTc("IDL:GEOM/GEOM_Gen:1.0","GEOM_Gen");
  typeMap["GEOM_Object"]->incrRef();
  typeMap["GEOM_Shape"]=typeMap["GEOM_Object"];
  */
 
  //SMESH
  /*
  typeMap["SMESH_Mesh"]=TypeCode::interfaceTc("IDL:Mesh/SMESH_Mesh:1.0","SMESH_Mesh");
  typeMap["SMESH_Hypothesis"]=TypeCode::interfaceTc("IDL:SMESH/SMESH_Hypothesis:1.0","SMESH_Hypothesis");
  */
 
  //MED
  /*
  typeMap["MED"]=TypeCode::interfaceTc("IDL:SALOME_MED/MED:1.0","MED");
  typeMap["FIELD"]=TypeCode::interfaceTc("IDL:SALOME_MED/FIELD:1.0","FIELD");
  // TODO : FIELDDOUBLE inherits FIELD
  typeMap["FIELDDOUBLE"]=TypeCode::interfaceTc("IDL:SALOME_MED/FIELDDOUBLE:1.0","FIELDDOUBLE");
  */
 
  //COMPONENT
  /*
  typeMap["AddComponent"]=TypeCode::interfaceTc("IDL:SuperVisionTest/AddComponent:1.0","AddComponent");
  typeMap["AddComponent"]->incrRef();
  typeMap["AddInterface"]=typeMap["AddComponent"];
  typeMap["SuperVisionTest/Adder"]=TypeCode::interfaceTc("IDL:SuperVisionTest/Adder:1.0","SuperVisionTest/Adder");
  typeMap["AdditionComponent/Adder"]=TypeCode::interfaceTc("IDL:AdditionComponent/Adder:1.0","AdditionComponent/Adder");
  typeMap["Syr"]=TypeCode::interfaceTc("IDL:SuperVisionTest/Syr:1.0","Syr");
  typeMap["ListOfSyr"]=TypeCode::interfaceTc("IDL:SuperVisionTest/ListOfSyr:1.0","ListOfSyr");
  */
}

References YACS::ENGINE::Catalog::_typeMap, YACS::ENGINE::getRuntime(), and testCppPluginInvokation::r.

Referenced by loadCata().

newLoader()

virtual CatalogLoader * YACS::ENGINE::SessionCataLoader::newLoader ( const std::string &  path )

inlinevirtual

Implements YACS::ENGINE::CatalogLoader.

Definition at line 43 of file SessionCataLoader.hxx.

{return new SessionCataLoader(path);}

References SessionCataLoader().

Member Data Documentation

_errors

std::string YACS::ENGINE::SessionCataLoader::_errors

protected

Definition at line 46 of file SessionCataLoader.hxx.

Referenced by importComponent(), and loadCata().

---

The documentation for this class was generated from the following files:

• src/runtime/SessionCataLoader.hxx
• src/runtime/SessionCataLoader.cxx