X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModuleCatalog%2FSALOME_ModuleCatalog_impl.cxx;h=326dddc149563c369915f88389202849dc3c66b5;hb=77773aa5efd0d400ad59025b9c4ec050d593c0dd;hp=b6def6a59e20e95c81f827f6a31af45655768a89;hpb=36b4d0d5e82155abafd70bd5e61660744da41a4d;p=modules%2Fkernel.git diff --git a/src/ModuleCatalog/SALOME_ModuleCatalog_impl.cxx b/src/ModuleCatalog/SALOME_ModuleCatalog_impl.cxx index b6def6a59..326dddc14 100644 --- a/src/ModuleCatalog/SALOME_ModuleCatalog_impl.cxx +++ b/src/ModuleCatalog/SALOME_ModuleCatalog_impl.cxx @@ -1,26 +1,26 @@ -// SALOME ModuleCatalog : implementation of ModuleCatalog server which parsers xml description of modules +// Copyright (C) 2007-2020 CEA/DEN, EDF R&D, OPEN CASCADE +// +// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. // -// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, -// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS -// -// This library is free software; you can redistribute it and/or -// modify it under the terms of the GNU Lesser General Public -// License as published by the Free Software Foundation; either -// version 2.1 of the License. -// -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -// Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public -// License along with this library; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -// -// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. // +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // + +// SALOME ModuleCatalog : implementation of ModuleCatalog server which parsers xml description of modules // File : SALOME_ModuleCatalog_impl.cxx // Author : Estelle Deville // Module : SALOME @@ -28,22 +28,162 @@ // #include "SALOME_ModuleCatalog_impl.hxx" #include "SALOME_ModuleCatalog_Acomponent_impl.hxx" +#include "SALOME_ModuleCatalog_Handler.hxx" +#include #include #include - -#include -#include -using namespace std; - #include "utilities.h" +#include + +#ifdef WIN32 +# include +# include +#include +#include +#include +#include +#include +#include +#include +#include +#else +# include +#endif + #ifdef _DEBUG_ -static int MYDEBUG = 1; +static int MYDEBUG = 0; #else -static int MYDEBUG = 1; +static int MYDEBUG = 0; #endif -static const char* SEPARATOR = ":"; +static const char* SEPARATOR = "::"; +static const char* OLD_SEPARATOR = ":"; + + +std::list splitStringToList(const std::string& theString, const std::string& theSeparator) +{ + std::list aList; + + size_t sepLen = theSeparator.length(); + size_t startPos = 0, sepPos = theString.find(theSeparator, startPos); + + while (1) + { + std::string anItem ; + if(sepPos != std::string::npos) + anItem = theString.substr(startPos, sepPos - startPos); + else + anItem = theString.substr(startPos); + if (anItem.length() > 0) + aList.push_back(anItem); + if(sepPos == std::string::npos) + break; + startPos = sepPos + sepLen; + sepPos = theString.find(theSeparator, startPos); + } + + return aList; +} + +class SALOME_ModuleCatalogImpl::Private +{ + friend class SALOME_ModuleCatalogImpl; +public: + //! method to parse one module catalog + /*! + \param file const char* arguments + \param modulelist ParserComponents arguments + \param pathlist ParserPathPrefixes arguments + \param typeMap ParserTypes arguments + */ + void _parse_xml_file(const char* file, + ParserComponents & modulelist, + ParserPathPrefixes & pathlist, + ParserTypes& typeMap, + TypeList& typeList); + + //! method to find component in the parser list + /*! + \param name string argument + \return pointer on a component, NULL if not found + */ + ParserComponent *findComponent(const std::string & name); + + //! method to create a CORBA component description from parser + /*! + \param C_corba Component argument + \param C_parser const ParserComponent argument + */ + void duplicate(SALOME_ModuleCatalog::ComponentDef & C_corba, + const ParserComponent & C_parser); + + //! method to create a CORBA interface description from parser + /*! + \param I_corba DefinitionInterface argument + \param I_parser const ParserInterface argument + */ + void duplicate(SALOME_ModuleCatalog::DefinitionInterface & I_corba, + const ParserInterface & I_parser); + + //! method to create a CORBA service description from parser + /*! + \param S_corba Service argument + \param S_parser const ParserService argument + */ + void duplicate(SALOME_ModuleCatalog::Service & S_corba, + const ParserService & service); + + //! method to create a CORBA parameter description from parser + /*! + \param P_corba ServicesParameter argument + \param P_parser const ParserParameter argument + */ + void duplicate(SALOME_ModuleCatalog::ServicesParameter & P_corba, + const ParserParameter & P_parser); + + //! method to create a CORBA datastream parameter description from parser + /*! + \param P_corba ServicesDataStreamParameter argument + \param P_parser const ParserDataStreamParameter argument + */ + void duplicate(SALOME_ModuleCatalog::ServicesDataStreamParameter & P_corba, + const ParserDataStreamParameter & P_parser); + + //! method to create the path prefix structures from the catalog parsing + /*! + \param paths ParserPathPrefixes arguments + \return the paths + */ + void duplicate(ParserPathPrefixes & p_out, const ParserPathPrefixes & P_in); + + //! method to verify path prefix content + /*! + \param pathlist ListOfParserPathPrefix arguments + \return true if verification is OK + */ + bool _verify_path_prefix(ParserPathPrefixes & pathlist); + + // Theses variables will contain the path to the general and personal catalogs + char* _general_path; + char* _personal_path; + + // These variables will contain the information on the general common catalog + ParserComponents _general_module_list ; + ParserPathPrefixes _general_path_list ; + ParserTypes _typeMap; + TypeList _typeList; + + // These variables will contain the information on the personal catalog + ParserComponents _personal_module_list ; + ParserPathPrefixes _personal_path_list ; + + std::map + DataStreamDepConvert; + + std::map + ComponentTypeConvert; +}; //---------------------------------------------------------------------- // Function : SALOME_ModuleCatalogImpl @@ -51,105 +191,117 @@ static const char* SEPARATOR = ":"; //---------------------------------------------------------------------- SALOME_ModuleCatalogImpl::SALOME_ModuleCatalogImpl(int argc, char** argv, CORBA::ORB_ptr orb) : _orb(orb) { + myPrivate = new Private; if(MYDEBUG) MESSAGE("Catalog creation"); + /* Init libxml */ + xmlInitParser(); // Conversion rules for component types - ComponentTypeConvert[GEOM] + myPrivate->ComponentTypeConvert[GEOM] = SALOME_ModuleCatalog::GEOM; - ComponentTypeConvert[MESH] + myPrivate->ComponentTypeConvert[MESH] = SALOME_ModuleCatalog::MESH; - ComponentTypeConvert[Med] + myPrivate->ComponentTypeConvert[Med] = SALOME_ModuleCatalog::Med; - ComponentTypeConvert[SOLVER] + myPrivate->ComponentTypeConvert[SOLVER] = SALOME_ModuleCatalog::SOLVER; - ComponentTypeConvert[DATA] + myPrivate->ComponentTypeConvert[DATA] = SALOME_ModuleCatalog::DATA; - ComponentTypeConvert[VISU] + myPrivate->ComponentTypeConvert[VISU] = SALOME_ModuleCatalog::VISU; - ComponentTypeConvert[SUPERV] + myPrivate->ComponentTypeConvert[SUPERV] = SALOME_ModuleCatalog::SUPERV; - ComponentTypeConvert[OTHER] + myPrivate->ComponentTypeConvert[OTHER] = SALOME_ModuleCatalog::OTHER; - // Conversion rules for datastream parameters type and dependency - DataStreamTypeConvert["UNKNOWN"] - = SALOME_ModuleCatalog::DATASTREAM_UNKNOWN; - DataStreamTypeConvert["INTEGER"] - = SALOME_ModuleCatalog::DATASTREAM_INTEGER; - DataStreamTypeConvert["FLOAT"] - = SALOME_ModuleCatalog::DATASTREAM_FLOAT; - DataStreamTypeConvert["DOUBLE"] - = SALOME_ModuleCatalog::DATASTREAM_DOUBLE; - DataStreamTypeConvert["STRING"] - = SALOME_ModuleCatalog::DATASTREAM_STRING; - DataStreamTypeConvert["BOOLEAN"] - = SALOME_ModuleCatalog::DATASTREAM_BOOLEAN; - - DataStreamDepConvert["UNDEFINED"] + // Conversion rules for datastream parameters dependency + myPrivate->DataStreamDepConvert["UNDEFINED"] = SALOME_ModuleCatalog::DATASTREAM_UNDEFINED; - DataStreamDepConvert["T"] + myPrivate->DataStreamDepConvert["T"] = SALOME_ModuleCatalog::DATASTREAM_TEMPORAL; - DataStreamDepConvert["I"] + myPrivate->DataStreamDepConvert["I"] = SALOME_ModuleCatalog::DATASTREAM_ITERATIVE; // Empty used variables - _general_module_list.resize(0); - _general_path_list.resize(0); - - _personal_module_list.resize(0); - _personal_path_list.resize(0); + myPrivate->_general_module_list.resize(0); + myPrivate->_general_path_list.resize(0); + myPrivate->_personal_module_list.resize(0); + myPrivate->_personal_path_list.resize(0); + // Parse the arguments given at server run - if (!_parseArguments(argc, argv,&_general_path,&_personal_path)) + if (!_parseArguments(argc, argv,&myPrivate->_general_path,&myPrivate->_personal_path)) if(MYDEBUG) MESSAGE( "Error while argument parsing" ); // Test existency of files - if (_general_path == NULL){ + if (myPrivate->_general_path == NULL) + { if(MYDEBUG) MESSAGE( "Error the general catalog should be indicated" ); - }else{ + } + else + { // Affect the _general_module_list and _general_path_list members // with the common catalog - - QStringList dirList - = QStringList::split( SEPARATOR, _general_path, - false ); // skip empty entries - - for ( int i = 0; i < dirList.count(); i++ ) { - QFileInfo fileInfo( dirList[ i ] ); - if ( fileInfo.isFile() && fileInfo.exists() ) { - _parse_xml_file(fileInfo.filePath(), - _general_module_list, - _general_path_list); - } + + std::list dirList; + +#ifdef WIN32 + dirList = splitStringToList(myPrivate->_general_path, SEPARATOR); +#else + //check for new format + bool isNew = (std::string( myPrivate->_general_path ).find(SEPARATOR) != std::string::npos); + if ( isNew ) { + //using new format + dirList = splitStringToList(myPrivate->_general_path, SEPARATOR); + } else { + //support old format + dirList = splitStringToList(myPrivate->_general_path, OLD_SEPARATOR); } - +#endif + + for (std::list::iterator iter = dirList.begin(); iter != dirList.end(); iter++) + { + std::string aPath = (*iter); + //remove inverted commas from filename + while (aPath.find('\"') != std::string::npos) + aPath.erase(aPath.find('\"'), 1); + + myPrivate->_parse_xml_file(aPath.c_str(), + myPrivate->_general_module_list, + myPrivate->_general_path_list, + myPrivate->_typeMap, + myPrivate->_typeList); + } + // Verification of _general_path_list content - if(!_verify_path_prefix(_general_path_list)){ + if (!myPrivate->_verify_path_prefix(myPrivate->_general_path_list)) { if(MYDEBUG) MESSAGE( "Error while parsing the general path list, " - "differents paths are associated to the same computer," - "the first one will be choosen"); - }else{ + "different paths are associated to the same computer," + "the first one will be chosen"); + } else { if(MYDEBUG) MESSAGE("General path list OK"); } - - if(_personal_path != NULL){ + + if (myPrivate->_personal_path != NULL) { // Initialize the _personal_module_list and // _personal_path_list members with the personal catalog files - _parse_xml_file(_personal_path, - _personal_module_list, - _personal_path_list); + myPrivate->_parse_xml_file(myPrivate->_personal_path, + myPrivate->_personal_module_list, + myPrivate->_personal_path_list, + myPrivate->_typeMap, + myPrivate->_typeList); // Verification of _general_path_list content - if(!_verify_path_prefix(_personal_path_list)){ - if(MYDEBUG) MESSAGE("Error while parsing the personal path list, " - "differents paths are associated to the same computer, " - "the first one will be choosen" ); + if(!myPrivate->_verify_path_prefix(myPrivate->_personal_path_list)){ + if(MYDEBUG) MESSAGE("Error while parsing the personal path list, " + "different paths are associated to the same computer, " + "the first one will be chosen" ); }else { - if(MYDEBUG) MESSAGE("Personal path list OK"); + if(MYDEBUG) MESSAGE("Personal path list OK"); } }else if(MYDEBUG) MESSAGE("No personal catalog indicated or error while " - "opening the personal catalog"); + "opening the personal catalog"); } } @@ -160,9 +312,79 @@ SALOME_ModuleCatalogImpl::SALOME_ModuleCatalogImpl(int argc, char** argv, CORBA: SALOME_ModuleCatalogImpl::~SALOME_ModuleCatalogImpl() { if(MYDEBUG) MESSAGE("Catalog Destruction"); + delete myPrivate; } +//! Get the list of all types of the catalog +/*! + * \return the list of types + */ +SALOME_ModuleCatalog::ListOfTypeDefinition* SALOME_ModuleCatalogImpl::GetTypes() +{ + SALOME_ModuleCatalog::ListOfTypeDefinition_var type_list = new SALOME_ModuleCatalog::ListOfTypeDefinition(); + type_list->length((CORBA::ULong)myPrivate->_typeList.size()); + + for (unsigned int ind = 0 ; ind < myPrivate->_typeList.size() ; ind++) + { + //no real need to call string_dup, omniorb calls it on operator= (const char *) but it is safer + type_list[ind].name=CORBA::string_dup(myPrivate->_typeList[ind].name.c_str()); + type_list[ind].kind=SALOME_ModuleCatalog::NONE; + if(myPrivate->_typeList[ind].kind=="double") + type_list[ind].kind=SALOME_ModuleCatalog::Dble; + else if(myPrivate->_typeList[ind].kind=="int") + type_list[ind].kind=SALOME_ModuleCatalog::Int; + else if(myPrivate->_typeList[ind].kind=="bool") + type_list[ind].kind=SALOME_ModuleCatalog::Bool; + else if(myPrivate->_typeList[ind].kind=="string") + type_list[ind].kind=SALOME_ModuleCatalog::Str; + else if(myPrivate->_typeList[ind].kind=="objref") + { + type_list[ind].kind=SALOME_ModuleCatalog::Objref; + type_list[ind].id=CORBA::string_dup(myPrivate->_typeList[ind].id.c_str()); + //bases + type_list[ind].bases.length((CORBA::ULong)myPrivate->_typeList[ind].bases.size()); + std::vector::const_iterator miter; + miter=myPrivate->_typeList[ind].bases.begin(); + int n_memb=0; + while(miter != myPrivate->_typeList[ind].bases.end()) + { + type_list[ind].bases[n_memb]=CORBA::string_dup(miter->c_str()); + miter++; + n_memb++; + } + } + else if(myPrivate->_typeList[ind].kind=="sequence") + { + type_list[ind].kind=SALOME_ModuleCatalog::Seq; + type_list[ind].content=CORBA::string_dup(myPrivate->_typeList[ind].content.c_str()); + } + else if(myPrivate->_typeList[ind].kind=="array") + { + type_list[ind].kind=SALOME_ModuleCatalog::Array; + type_list[ind].content=CORBA::string_dup(myPrivate->_typeList[ind].content.c_str()); + } + else if(myPrivate->_typeList[ind].kind=="struct") + { + type_list[ind].kind=SALOME_ModuleCatalog::Struc; + //members + type_list[ind].members.length((CORBA::ULong)myPrivate->_typeList[ind].members.size()); + + std::vector< std::pair >::const_iterator miter; + miter=myPrivate->_typeList[ind].members.begin(); + int n_memb=0; + while(miter != myPrivate->_typeList[ind].members.end()) + { + type_list[ind].members[n_memb].name=CORBA::string_dup(miter->first.c_str()); + type_list[ind].members[n_memb].type=CORBA::string_dup(miter->second.c_str()); + n_memb++; + miter++; + } + } + } + return type_list._retn(); +} + //---------------------------------------------------------------------- // Function : GetComputerList // Purpose : get a computer list @@ -179,51 +401,43 @@ SALOME_ModuleCatalogImpl::GetComputerList() // Function : GetPathPrefix // Purpose : get the PathPrefix of a computer //---------------------------------------------------------------------- -char * +char* SALOME_ModuleCatalogImpl::GetPathPrefix(const char* machinename) { if(MYDEBUG) MESSAGE("Begin of GetPathPrefix"); // Variables initialisation - char* _path = NULL; - bool _find = false ; + std::string _path; + bool _find = false; // Parse all the path prefixes // looking for the wanted computer - for (unsigned int ind = 0 ; ind < _personal_path_list.size() ; ind++) + for (unsigned int ind = 0; ind < myPrivate->_personal_path_list.size() && !_find; ind++) + { + for (unsigned int ind1 = 0; ind1 < myPrivate->_personal_path_list[ind].listOfComputer.size() && !_find; ind1++) { - for (unsigned int ind1 = 0 ; ind1 < _personal_path_list[ind].listOfComputer.size() ; ind1++) - { - if (strcmp(machinename, _personal_path_list[ind].listOfComputer[ind1].c_str()) == 0) - { - _find = true ; - // Wanted computer - // affect the path to be returned - const char* _temp = _personal_path_list[ind].path.c_str() ; - _path = new char[strlen(_temp)+1]; - strcpy(_path,_temp); - } - } + if ( myPrivate->_personal_path_list[ind].listOfComputer[ind1] == machinename ) + { + _find = true; + // Wanted computer + // affect the path to be returned + _path = myPrivate->_personal_path_list[ind].path; + } } + } - if (!_find) + for (unsigned int ind = 0; ind < myPrivate->_general_path_list.size() && !_find; ind++) + { + for (unsigned int ind1 = 0; ind1 < myPrivate->_general_path_list[ind].listOfComputer.size() && !_find; ind1++) { - for (unsigned int ind = 0 ; ind < _general_path_list.size() ; ind++) + if (myPrivate->_general_path_list[ind].listOfComputer[ind1] == machinename) { - for (unsigned int ind1 = 0 ; ind1 < _general_path_list[ind].listOfComputer.size() ; ind1++) - { - if (strcmp(machinename, _general_path_list[ind].listOfComputer[ind1].c_str()) == 0) - { - _find = true ; - // Wanted computer - // affect the path to be returned - const char* _temp = _general_path_list[ind].path.c_str() ; - _path = new char[strlen(_temp)+1]; - strcpy(_path,_temp); - } - } + _find = true; + // Wanted computer + // affect the path to be returned + _path = myPrivate->_general_path_list[ind].path; } } - - return _path; + } + return CORBA::string_dup(_path.c_str()) ; } //---------------------------------------------------------------------- @@ -240,43 +454,39 @@ SALOME_ModuleCatalogImpl::GetComponentList() SALOME_ModuleCatalog::ListOfComponents_var _list_components = new SALOME_ModuleCatalog::ListOfComponents; - _list_components->length(_personal_module_list.size()); + _list_components->length((CORBA::ULong)myPrivate->_personal_module_list.size()); // All the components defined in the personal catalog are taken - for(unsigned int ind=0; ind < _personal_module_list.size();ind++){ - _list_components[ind]=(_personal_module_list[ind].name).c_str(); + for(unsigned int ind=0; ind < myPrivate->_personal_module_list.size();ind++){ + _list_components[ind]=(myPrivate->_personal_module_list[ind].name).c_str(); if(MYDEBUG) SCRUTE(_list_components[ind]) ; } - int indice = _personal_module_list.size() ; + size_t indice = myPrivate->_personal_module_list.size(); bool _find = false; // The components in the general catalog are taken only if they're // not defined in the personal catalog -#ifndef WNT - for(unsigned int ind=0; ind < _general_module_list.size();ind++){ -#else - for(ind=0; ind < _general_module_list.size();ind++){ -#endif + for(unsigned int ind=0; ind < myPrivate->_general_module_list.size();ind++){ _find = false; - for(unsigned int ind1=0; ind1 < _personal_module_list.size();ind1++){ + for(unsigned int ind1=0; ind1 < myPrivate->_personal_module_list.size();ind1++){ // searching if the component is already defined in // the personal catalog - if ((_general_module_list[ind].name.compare(_personal_module_list[ind1].name)) == 0) - _find = true; + if ((myPrivate->_general_module_list[ind].name.compare(myPrivate->_personal_module_list[ind1].name)) == 0) + _find = true; } if(!_find){ - if(MYDEBUG) MESSAGE("A new component " << _general_module_list[ind].name - << " has to be to added in the list"); - _list_components->length(indice+1); + if(MYDEBUG) MESSAGE("A new component " << myPrivate->_general_module_list[ind].name + << " has to be to added in the list"); + _list_components->length((CORBA::ULong)indice+1); // The component is not already defined => has to be taken - _list_components[indice]=(_general_module_list[ind].name).c_str(); - if(MYDEBUG) SCRUTE(_list_components[indice]) ; + _list_components[(CORBA::ULong)indice]=(myPrivate->_general_module_list[ind].name).c_str(); + if(MYDEBUG) SCRUTE(_list_components[(CORBA::ULong)indice]) ; indice++; }else{ - if(MYDEBUG) MESSAGE("The component " <<_general_module_list[ind].name - << " was already defined in the personal catalog") ; + if(MYDEBUG) MESSAGE("The component " <_general_module_list[ind].name + << " was already defined in the personal catalog") ; } } @@ -300,47 +510,43 @@ SALOME_ModuleCatalogImpl::GetComponentIconeList() SALOME_ModuleCatalog::ListOfIAPP_Affich_var _list_components_icone = new SALOME_ModuleCatalog::ListOfIAPP_Affich; - _list_components_icone->length(_personal_module_list.size()); + _list_components_icone->length((CORBA::ULong)myPrivate->_personal_module_list.size()); // All the components defined in the personal catalog are taken - for(unsigned int ind=0; ind < _personal_module_list.size();ind++){ - _list_components_icone[ind].modulename=(_personal_module_list[ind].name).c_str(); - _list_components_icone[ind].moduleusername=(_personal_module_list[ind].username).c_str(); - _list_components_icone[ind].moduleicone=(_personal_module_list[ind].icon).c_str(); - _list_components_icone[ind].moduleversion=(_personal_module_list[ind].version).c_str(); - _list_components_icone[ind].modulecomment=(_personal_module_list[ind].comment).c_str(); + for(unsigned int ind=0; ind < myPrivate->_personal_module_list.size();ind++){ + _list_components_icone[ind].modulename=(myPrivate->_personal_module_list[ind].name).c_str(); + _list_components_icone[ind].moduleusername=(myPrivate->_personal_module_list[ind].username).c_str(); + _list_components_icone[ind].moduleicone=(myPrivate->_personal_module_list[ind].icon).c_str(); + _list_components_icone[ind].moduleversion=(myPrivate->_personal_module_list[ind].version).c_str(); + _list_components_icone[ind].modulecomment=(myPrivate->_personal_module_list[ind].comment).c_str(); //if(MYDEBUG) SCRUTE(_list_components_icone[ind].modulename); //if(MYDEBUG) SCRUTE(_list_components_icone[ind].moduleicone); } - int indice = _personal_module_list.size() ; + size_t indice = myPrivate->_personal_module_list.size(); bool _find = false; // The components in the general catalog are taken only if they're // not defined in the personal catalog -#ifndef WNT - for(unsigned int ind=0; ind < _general_module_list.size();ind++){ -#else - for(ind=0; ind < _general_module_list.size();ind++){ -#endif + for(unsigned int ind=0; ind < myPrivate->_general_module_list.size();ind++){ _find = false; - for(unsigned int ind1=0; ind1 < _personal_module_list.size();ind1++){ + for(unsigned int ind1=0; ind1 < myPrivate->_personal_module_list.size();ind1++){ // searching if the component is aleready defined in // the personal catalog - if((_general_module_list[ind].name.compare(_personal_module_list[ind1].name)) == 0) - _find = true; + if((myPrivate->_general_module_list[ind].name.compare(myPrivate->_personal_module_list[ind1].name)) == 0) + _find = true; } if(!_find){ - // if(MYDEBUG) MESSAGE("A new component " << _general_module_list[ind].name << " has to be to added in the list"); - _list_components_icone->length(indice+1); + // if(MYDEBUG) MESSAGE("A new component " << _general_module_list[ind].name << " has to be to added in the list"); + _list_components_icone->length((CORBA::ULong)indice+1); // The component is not already defined => has to be taken - _list_components_icone[indice].modulename=_general_module_list[ind].name.c_str(); - _list_components_icone[indice].moduleusername=_general_module_list[ind].username.c_str(); - _list_components_icone[indice].moduleicone=_general_module_list[ind].icon.c_str(); - _list_components_icone[indice].moduleversion=_general_module_list[ind].version.c_str(); - _list_components_icone[indice].modulecomment=_general_module_list[ind].comment.c_str(); - //if(MYDEBUG) SCRUTE(_list_components_icone[indice].modulename) ; - //if(MYDEBUG) SCRUTE(_list_components_icone[indice].moduleicone); + _list_components_icone[(CORBA::ULong)indice].modulename=myPrivate->_general_module_list[ind].name.c_str(); + _list_components_icone[(CORBA::ULong)indice].moduleusername=myPrivate->_general_module_list[ind].username.c_str(); + _list_components_icone[(CORBA::ULong)indice].moduleicone=myPrivate->_general_module_list[ind].icon.c_str(); + _list_components_icone[(CORBA::ULong)indice].moduleversion=myPrivate->_general_module_list[ind].version.c_str(); + _list_components_icone[(CORBA::ULong)indice].modulecomment=myPrivate->_general_module_list[ind].comment.c_str(); + //if(MYDEBUG) SCRUTE(_list_components_icone[(CORBA::ULong)indice].modulename) ; + //if(MYDEBUG) SCRUTE(_list_components_icone[(CORBA::ULong)indice].moduleicone); indice++; } @@ -368,7 +574,7 @@ SALOME_ModuleCatalogImpl::GetTypedComponentList(SALOME_ModuleCatalog::ComponentT _list_typed_component->length(0); // Transform SALOME_ModuleCatalog::ComponentType in ParserComponentType - ParserComponentType _temp_component_type; + ParserComponentType _temp_component_type = OTHER; switch(component_type){ case SALOME_ModuleCatalog::GEOM: _temp_component_type = GEOM ; @@ -397,15 +603,15 @@ SALOME_ModuleCatalogImpl::GetTypedComponentList(SALOME_ModuleCatalog::ComponentT } // All the components in the personal catalog are taken - for (unsigned int ind=0; ind < _personal_module_list.size();ind++) + for (unsigned int ind=0; ind < myPrivate->_personal_module_list.size();ind++) { - if (_personal_module_list[ind].type == _temp_component_type) - { - _list_typed_component->length(_j + 1); - _list_typed_component[_j] = (_moduleList[ind].name).c_str(); - //if(MYDEBUG) SCRUTE(_list_typed_component[_j]); - _j++; - } + if (myPrivate->_personal_module_list[ind].type == _temp_component_type) + { + _list_typed_component->length(_j + 1); + _list_typed_component[_j] = myPrivate->_personal_module_list[ind].name.c_str(); + //if(MYDEBUG) SCRUTE(_list_typed_component[_j]); + _j++; + } } int indice = _list_typed_component->length() ; @@ -413,35 +619,31 @@ SALOME_ModuleCatalogImpl::GetTypedComponentList(SALOME_ModuleCatalog::ComponentT // The components in the general catalog are taken only if they're // not defined in the personal catalog -#ifndef WNT - for (unsigned int ind=0; ind < _general_module_list.size();ind++) -#else - for (ind=0; ind < _general_module_list.size();ind++) -#endif + for (unsigned int ind=0; ind < myPrivate->_general_module_list.size();ind++) { _find = false; - if(_general_module_list[ind].type == _temp_component_type) - { - for (unsigned int ind1=0; ind1 < _personal_module_list.size();ind1++) - { - // searching if the component is aleready defined in - // the personal catalog - if ((_general_module_list[ind].name.compare(_personal_module_list[ind1].name)) == 0) - _find = true; - } - if (!_find) - { - //if(MYDEBUG) MESSAGE("A new component " << _general_module_list[ind].name << " has to be to added in the list"); + if(myPrivate->_general_module_list[ind].type == _temp_component_type) + { + for (unsigned int ind1=0; ind1 < myPrivate->_personal_module_list.size();ind1++) + { + // searching if the component is aleready defined in + // the personal catalog + if ((myPrivate->_general_module_list[ind].name.compare(myPrivate->_personal_module_list[ind1].name)) == 0) + _find = true; + } + if (!_find) + { + //if(MYDEBUG) MESSAGE("A new component " << _general_module_list[ind].name << " has to be to added in the list"); _list_typed_component->length(indice+1); - // The component is not already defined => has to be taken - _list_typed_component[indice]=(_general_module_list[ind].name).c_str(); - //if(MYDEBUG) SCRUTE(_list_typed_component[indice]) ; - - indice++; - } - //else - //if(MYDEBUG) MESSAGE("The component " <<_general_module_list[ind].name << " was already defined in the personal catalog") ; + // The component is not already defined => has to be taken + _list_typed_component[indice]=(myPrivate->_general_module_list[ind].name).c_str(); + //if(MYDEBUG) SCRUTE(_list_typed_component[indice]) ; + + indice++; + } + //else + //if(MYDEBUG) MESSAGE("The component " <<_general_module_list[ind].name << " was already defined in the personal catalog") ; } } @@ -468,17 +670,17 @@ SALOME_ModuleCatalogImpl::GetComponent(const char* name) std::string s(name); ParserComponent *C_parser = NULL; - ParserPathPrefixes *pp = NULL; + //ParserPathPrefixes *pp = NULL; SALOME_ModuleCatalog::Acomponent_ptr compo = SALOME_ModuleCatalog::Acomponent::_nil(); - C_parser = findComponent(s); + C_parser = myPrivate->findComponent(s); if (C_parser) { // DebugParserComponent(*C_parser); - SALOME_ModuleCatalog::Component C_corba; - duplicate(C_corba, *C_parser); + SALOME_ModuleCatalog::ComponentDef C_corba; + myPrivate->duplicate(C_corba, *C_parser); SALOME_ModuleCatalog_AcomponentImpl * aComponentImpl = @@ -490,57 +692,127 @@ SALOME_ModuleCatalogImpl::GetComponent(const char* name) // Not found in the personal catalog and in the general catalog // return NULL object if(MYDEBUG) MESSAGE("Component with name " << name - << " not found in catalog"); + << " not found in catalog"); } return compo; } -SALOME_ModuleCatalog::Component * +SALOME_ModuleCatalog::ComponentDef * SALOME_ModuleCatalogImpl::GetComponentInfo(const char *name) { std::string s(name); - ParserComponent * C_parser = findComponent(s); + ParserComponent * C_parser = myPrivate->findComponent(s); if (C_parser) { - SALOME_ModuleCatalog::Component * C_corba - = new SALOME_ModuleCatalog::Component; - duplicate(*C_corba, *C_parser); + SALOME_ModuleCatalog::ComponentDef * C_corba + = new SALOME_ModuleCatalog::ComponentDef; + myPrivate->duplicate(*C_corba, *C_parser); return C_corba; } return NULL; } +void SALOME_ModuleCatalogImpl::ping() +{ +} + +CORBA::Long SALOME_ModuleCatalogImpl::getPID() +{ + return +#ifndef WIN32 + (CORBA::Long)getpid(); +#else + (CORBA::Long)_getpid(); +#endif +} + +void SALOME_ModuleCatalogImpl::ShutdownWithExit() +{ + exit( EXIT_SUCCESS ); +} + +void SALOME_ModuleCatalogImpl::shutdown() +{ + if (!CORBA::is_nil(_orb)) _orb->shutdown(0); +} + + + +//---------------------------------------------------------------------- +// Function : _parseArguments +// Purpose : parse arguments to get general and personal catalog files +//---------------------------------------------------------------------- +bool +SALOME_ModuleCatalogImpl::_parseArguments(int argc, char **argv, + char **_general, + char** _personal) +{ + bool _return_value = true; + *_general = NULL; + *_personal = NULL ; + for (int ind = 0; ind < argc ; ind++) + { + + if (strcmp(argv[ind],"-help") == 0) + { + INFOS( "Usage: " << argv[0] + << " -common 'path to general catalog' " + " -personal 'path to personal catalog' " + " -ORBInitRef NameService=corbaname::localhost"); + _return_value = false ; + } + + if (strcmp(argv[ind],"-common") == 0) + { + if (ind + 1 < argc) + { + // General catalog file + *_general = argv[ind + 1] ; + } + } + else if (strcmp(argv[ind],"-personal") == 0) + { + if (ind + 1 < argc) + { + // Personal catalog file + *_personal = argv[ind + 1] ; + } + } + } + return _return_value; +} + ParserComponent * -SALOME_ModuleCatalogImpl::findComponent(const string & name) +SALOME_ModuleCatalogImpl::Private::findComponent(const std::string & name) { ParserComponent * C_parser = NULL; if (!C_parser) for (unsigned int ind=0; ind < _personal_module_list.size();ind++) { - if (name.compare(_personal_module_list[ind].name) == 0) - { - if(MYDEBUG) MESSAGE("Component named " << name - << " found in the personal catalog"); - C_parser = &(_personal_module_list[ind]); - break; - } + if (name.compare(_personal_module_list[ind].name) == 0) + { + if(MYDEBUG) MESSAGE("Component named " << name + << " found in the personal catalog"); + C_parser = &(_personal_module_list[ind]); + break; + } } if (!C_parser) for (unsigned int ind=0; ind < _general_module_list.size();ind++) { - if (name.compare(_general_module_list[ind].name) == 0) - { - // if(MYDEBUG) MESSAGE("Component named " << name - // << " found in the general catalog"); - C_parser = &(_general_module_list[ind]); - break; - } + if (name.compare(_general_module_list[ind].name) == 0) + { + // if(MYDEBUG) MESSAGE("Component named " << name + // << " found in the general catalog"); + C_parser = &(_general_module_list[ind]); + break; + } } return C_parser; @@ -551,30 +823,50 @@ SALOME_ModuleCatalogImpl::findComponent(const string & name) // Purpose : parse one module catalog //---------------------------------------------------------------------- void -SALOME_ModuleCatalogImpl::_parse_xml_file(const char* file, - ParserComponents& modulelist, - ParserPathPrefixes& pathList) +SALOME_ModuleCatalogImpl::Private::_parse_xml_file(const char* file, + ParserComponents& modulelist, + ParserPathPrefixes& pathList, + ParserTypes& typeMap, + TypeList& typeList) { if(MYDEBUG) BEGIN_OF("_parse_xml_file"); if(MYDEBUG) SCRUTE(file); - SALOME_ModuleCatalog_Handler* handler = new SALOME_ModuleCatalog_Handler(); - QFile xmlFile(file); - - QXmlInputSource source(xmlFile); - - QXmlSimpleReader reader; - reader.setContentHandler( handler ); - reader.setErrorHandler( handler ); - reader.parse( source ); - xmlFile.close(); + //Local path and module list for the file to parse + ParserPathPrefixes _pathList; + ParserComponents _moduleList; + + SALOME_ModuleCatalog_Handler* handler = new SALOME_ModuleCatalog_Handler(_pathList,_moduleList,typeMap,typeList); +#if defined(WIN32) + const wchar_t* w_file = Kernel_Utils::utf8_decode(file); + FILE* aFile = _wfopen(w_file, L"r"); +#else + FILE* aFile = fopen(file, "r"); +#endif + + if (aFile != NULL) + { + xmlDocPtr aDoc = xmlReadFile(file, NULL, 0); + + if (aDoc != NULL) + handler->ProcessXmlDocument(aDoc); + else + MESSAGE("ModuleCatalog: could not parse file "<_parse_xml_file(file, myPrivate->_personal_module_list, myPrivate->_personal_path_list,myPrivate->_typeMap,myPrivate->_typeList); } @@ -606,19 +898,26 @@ SALOME_ModuleCatalogImpl::ImportXmlCatalogFile(const char* file) // Function : duplicate // Purpose : create a component from the catalog parsing //---------------------------------------------------------------------- -void SALOME_ModuleCatalogImpl::duplicate -(SALOME_ModuleCatalog::Component & C_corba, +void SALOME_ModuleCatalogImpl::Private::duplicate +(SALOME_ModuleCatalog::ComponentDef & C_corba, const ParserComponent & C_parser) { C_corba.name = CORBA::string_dup(C_parser.name.c_str()); C_corba.username = CORBA::string_dup(C_parser.username.c_str()); - C_corba.multistudy = C_parser.multistudy; C_corba.icon = CORBA::string_dup(C_parser.icon.c_str()); C_corba.type = ComponentTypeConvert[C_parser.type]; - C_corba.implementationType = C_parser.implementationType; - - unsigned int _length = C_parser.interfaces.size(); - C_corba.interfaces.length(_length); + if(C_parser.implementationType == "EXE") + C_corba.implementationType=SALOME_ModuleCatalog::EXE; + else if(C_parser.implementationType == "CEXE") + C_corba.implementationType=SALOME_ModuleCatalog::CEXE; + else if(C_parser.implementationType == "PY") + C_corba.implementationType=SALOME_ModuleCatalog::PY; + else + C_corba.implementationType=SALOME_ModuleCatalog::SO; + C_corba.implname = CORBA::string_dup(C_parser.implementationName.c_str()); + + size_t _length = C_parser.interfaces.size(); + C_corba.interfaces.length((CORBA::ULong)_length); for (unsigned int ind = 0; ind < _length; ind++) duplicate(C_corba.interfaces[ind], C_parser.interfaces[ind]); @@ -629,7 +928,7 @@ void SALOME_ModuleCatalogImpl::duplicate // Function : duplicate // Purpose : create an interface from the catalog parsing //---------------------------------------------------------------------- -void SALOME_ModuleCatalogImpl::duplicate +void SALOME_ModuleCatalogImpl::Private::duplicate (SALOME_ModuleCatalog::DefinitionInterface & I_corba, const ParserInterface & I_parser) { @@ -637,22 +936,22 @@ void SALOME_ModuleCatalogImpl::duplicate I_corba.interfacename = CORBA::string_dup(I_parser.name.c_str()); // duplicate service list - unsigned int _length = I_parser.services.size(); + size_t _length = I_parser.services.size(); // if(MYDEBUG) SCRUTE(_length); // I_corba.interfaceservicelist // = new SALOME_ModuleCatalog::ListOfInterfaceService; - I_corba.interfaceservicelist.length(_length); + I_corba.interfaceservicelist.length((CORBA::ULong)_length); for (unsigned int ind1 = 0; ind1 < _length ; ind1 ++) duplicate(I_corba.interfaceservicelist[ind1], - I_parser.services[ind1]); + I_parser.services[ind1]); } //---------------------------------------------------------------------- // Function : duplicate // Purpose : create a service from the catalog parsing //---------------------------------------------------------------------- -void SALOME_ModuleCatalogImpl::duplicate +void SALOME_ModuleCatalogImpl::Private::duplicate (SALOME_ModuleCatalog::Service & S_corba, const ParserService & S_parser) { @@ -664,59 +963,47 @@ void SALOME_ModuleCatalogImpl::duplicate S_corba.TypeOfNode = S_parser.typeOfNode; - unsigned int _length; + size_t _length; // duplicate in Parameters _length = S_parser.inParameters.size(); - S_corba.ServiceinParameter.length(_length); + S_corba.ServiceinParameter.length((CORBA::ULong)_length); for (unsigned int ind2 = 0; ind2 < _length ; ind2 ++) duplicate(S_corba.ServiceinParameter[ind2], - S_parser.inParameters[ind2]); + S_parser.inParameters[ind2]); // duplicate out Parameters _length = S_parser.outParameters.size(); - S_corba.ServiceoutParameter.length(_length); + S_corba.ServiceoutParameter.length((CORBA::ULong)_length); -#ifndef WNT for (unsigned int ind2 = 0; ind2 < _length ; ind2 ++) -#else - for (ind2 = 0; ind2 < _length ; ind2 ++) -#endif duplicate(S_corba.ServiceoutParameter[ind2], - S_parser.outParameters[ind2]); + S_parser.outParameters[ind2]); // duplicate in DataStreamParameters _length = S_parser.inDataStreamParameters.size(); - S_corba.ServiceinDataStreamParameter.length(_length); + S_corba.ServiceinDataStreamParameter.length((CORBA::ULong)_length); -#ifndef WNT for (unsigned int ind2 = 0; ind2 < _length ; ind2 ++) -#else - for (ind2 = 0; ind2 < _length ; ind2 ++) -#endif duplicate(S_corba.ServiceinDataStreamParameter[ind2], - S_parser.inDataStreamParameters[ind2]); + S_parser.inDataStreamParameters[ind2]); // duplicate out DataStreamParameters _length = S_parser.outDataStreamParameters.size(); // if(MYDEBUG) SCRUTE(_length); - S_corba.ServiceoutDataStreamParameter.length(_length); + S_corba.ServiceoutDataStreamParameter.length((CORBA::ULong)_length); -#ifndef WNT for (unsigned int ind2 = 0; ind2 < _length ; ind2 ++) -#else - for (ind2 = 0; ind2 < _length ; ind2 ++) -#endif duplicate(S_corba.ServiceoutDataStreamParameter[ind2], - S_parser.outDataStreamParameters[ind2]); + S_parser.outDataStreamParameters[ind2]); } //---------------------------------------------------------------------- // Function : duplicate // Purpose : create a service parameter from the catalog parsing //---------------------------------------------------------------------- -void SALOME_ModuleCatalogImpl::duplicate +void SALOME_ModuleCatalogImpl::Private::duplicate (SALOME_ModuleCatalog::ServicesParameter & P_corba, const ParserParameter & P_parser) { @@ -732,36 +1019,16 @@ void SALOME_ModuleCatalogImpl::duplicate // Function : duplicate // Purpose : create a service datastream parameter from the catalog parsing //---------------------------------------------------------------------- -void SALOME_ModuleCatalogImpl::duplicate +void SALOME_ModuleCatalogImpl::Private::duplicate (SALOME_ModuleCatalog::ServicesDataStreamParameter & P_corba, const ParserDataStreamParameter & P_parser) { - std::map < std::string, - SALOME_ModuleCatalog::DataStreamType >::const_iterator it_type; - std::map < std::string, SALOME_ModuleCatalog::DataStreamDependency >::const_iterator it_dep; // duplicate parameter name P_corba.Parametername = CORBA::string_dup(P_parser.name.c_str()); - // doesn't work ??? - // it_type = DataStreamTypeConvert.find(P_parser.type); - // P_corba.Parametertype - // = (it_type == DataStreamTypeConvert.end()) - // ? it_type->second : SALOME_ModuleCatalog::DATASTREAM_UNKNOWN; - - if(MYDEBUG) SCRUTE(P_parser.type); - P_corba.Parametertype = SALOME_ModuleCatalog::DATASTREAM_UNKNOWN; - for (it_type = DataStreamTypeConvert.begin(); - it_type != DataStreamTypeConvert.end(); - it_type++) - if (P_parser.type.compare(it_type->first) == 0) { - P_corba.Parametertype = it_type->second; - break; - } - if(MYDEBUG) SCRUTE(P_corba.Parametertype); - // duplicate parameter type // doesn't work ??? @@ -769,6 +1036,10 @@ void SALOME_ModuleCatalogImpl::duplicate // P_corba.Parametertype // = (it_type == DataStreamTypeConvert.end()) // ? it_type->second : SALOME_ModuleCatalog::DATASTREAM_UNKNOWN; + + P_corba.Parametertype = CORBA::string_dup(P_parser.type.c_str()); + + // duplicate parameter dependency if(MYDEBUG) SCRUTE(P_parser.dependency); P_corba.Parameterdependency = SALOME_ModuleCatalog::DATASTREAM_UNDEFINED; @@ -788,8 +1059,8 @@ void SALOME_ModuleCatalogImpl::duplicate // Purpose : create the path prefix structures from the catalog parsing //---------------------------------------------------------------------- void -SALOME_ModuleCatalogImpl::duplicate(ParserPathPrefixes &L_out, - const ParserPathPrefixes &L_in) +SALOME_ModuleCatalogImpl::Private::duplicate(ParserPathPrefixes &L_out, + const ParserPathPrefixes &L_in) { L_out = L_in; } @@ -802,82 +1073,31 @@ SALOME_ModuleCatalogImpl::duplicate(ParserPathPrefixes &L_out, // particular computer //---------------------------------------------------------------------- bool -SALOME_ModuleCatalogImpl::_verify_path_prefix(ParserPathPrefixes & pathList) +SALOME_ModuleCatalogImpl::Private::_verify_path_prefix(ParserPathPrefixes & pathList) { bool _return_value = true; - vector _machine_list; + std::vector _machine_list; // Fill a list of all computers indicated in the path list for (unsigned int ind = 0; ind < pathList.size(); ind++) { for (unsigned int ind1 = 0 ; ind1 < pathList[ind].listOfComputer.size(); ind1++) - { - _machine_list.push_back(pathList[ind].listOfComputer[ind1]); - } + { + _machine_list.push_back(pathList[ind].listOfComputer[ind1]); + } } // Parse if a computer name is twice in the list of computers -#ifndef WNT for (unsigned int ind = 0; ind < _machine_list.size(); ind++) -#else - for (ind = 0; ind < _machine_list.size(); ind++) -#endif { for (unsigned int ind1 = ind+1 ; ind1 < _machine_list.size(); ind1++) { - if(_machine_list[ind].compare(_machine_list[ind1]) == 0) - { - if(MYDEBUG) MESSAGE( "The computer " << _machine_list[ind] << " is indicated more than once in the path list"); - _return_value = false; - } + if(_machine_list[ind].compare(_machine_list[ind1]) == 0) + { + if(MYDEBUG) MESSAGE( "The computer " << _machine_list[ind] << " is indicated more than once in the path list"); + _return_value = false; + } } } return _return_value; } - - -//---------------------------------------------------------------------- -// Function : _parseArguments -// Purpose : parse arguments to get general and personal catalog files -//---------------------------------------------------------------------- -bool -SALOME_ModuleCatalogImpl::_parseArguments(int argc, char **argv, - char **_general, - char** _personal) -{ - bool _return_value = true; - *_general = NULL; - *_personal = NULL ; - for (int ind = 0; ind < argc ; ind++) - { - - if (strcmp(argv[ind],"-help") == 0) - { - INFOS( "Usage: " << argv[0] - << " -common 'path to general catalog' " - " -personal 'path to personal catalog' " - " -ORBInitRef NameService=corbaname::localhost"); - _return_value = false ; - } - - if (strcmp(argv[ind],"-common") == 0) - { - if (ind + 1 < argc) - { - // General catalog file - *_general = argv[ind + 1] ; - } - } - else if (strcmp(argv[ind],"-personal") == 0) - { - if (ind + 1 < argc) - { - // Personal catalog file - *_personal = argv[ind + 1] ; - } - } - } - return _return_value; -} - -