X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModuleCatalog%2FSALOME_ModuleCatalog_Handler.cxx;h=7298101b4c0824f83035ecbfd90fa4a9cfdd099a;hb=e379646b647cf817ef93f995cbd123458eae0c52;hp=8788283581dc5ad9ede769c8dffcc4850db7e793;hpb=6dd1af68fb168b4df7558ebf8e7ffe6c4abbfc5b;p=modules%2Fkernel.git diff --git a/src/ModuleCatalog/SALOME_ModuleCatalog_Handler.cxx b/src/ModuleCatalog/SALOME_ModuleCatalog_Handler.cxx index 878828358..7298101b4 100644 --- a/src/ModuleCatalog/SALOME_ModuleCatalog_Handler.cxx +++ b/src/ModuleCatalog/SALOME_ModuleCatalog_Handler.cxx @@ -1,76 +1,115 @@ -// SALOME ModuleCatalog : implementation of ModuleCatalog server which parsers xml description of modules +// Copyright (C) 2007-2008 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 // -// 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 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.salome-platform.org/ or email : webmaster.salome@opencascade.com +// +// SALOME ModuleCatalog : implementation of ModuleCatalog server which parsers xml description of modules // File : SALOME_ModuleCatalog_Handler.cxx // Author : Estelle Deville // Module : SALOME -// $Header$ - +// $Header$ +// #define WRITE_CATA_COMPONENT + #include "SALOME_ModuleCatalog_Handler.hxx" +#include "SALOME_ModuleCatalog_Parser_IO.hxx" +#include "utilities.h" + +#include using namespace std; +#ifdef _DEBUG_ +static int MYDEBUG = 0; +#else +static int MYDEBUG = 0; +#endif + //---------------------------------------------------------------------- // Function : SALOME_ModuleCatalog_Handler // Purpose : Constructor //---------------------------------------------------------------------- -SALOME_ModuleCatalog_Handler::SALOME_ModuleCatalog_Handler() +SALOME_ModuleCatalog_Handler::SALOME_ModuleCatalog_Handler(ParserPathPrefixes& pathList, + ParserComponents& moduleList, + ParserTypes& typeMap, + TypeList& typeList):_typeMap(typeMap),_typeList(typeList), + _pathList(pathList),_moduleList(moduleList) + { - MESSAGE("SALOME_ModuleCatalog_Handler creation") + if(MYDEBUG) BEGIN_OF("SALOME_ModuleCatalog_Handler"); + // XML Tags initialisation // Used in the function endElement - test_path_prefix_name = "path-prefix-name"; - test_computer_name = "computer-name" ; - test_path_prefix = "path-prefix" ; + test_path_prefix_name = "path-prefix-name"; + test_computer_name = "computer-name" ; + test_computer_list = "computer-list" ; + test_path_prefix = "path-prefix" ; + test_path_prefix_list = "path-prefix-list" ; + + test_component_name = "component-name"; + test_component_username = "component-username"; + test_component_type = "component-type" ; + test_component_multistudy = "component-multistudy"; + test_component_icon = "component-icone" ; + test_component_impltype = "component-impltype"; + test_component_implname = "component-implname"; + test_component_version = "component-version"; + test_component_comment = "component-comment"; + + test_interface_name = "component-interface-name" ; + + test_service_name = "service-name"; + test_defaultservice = "service-by-default"; - test_component_name = "component-name"; - test_component_username = "component-username"; - test_component_type = "component-type" ; - test_component_multistudy="component-multistudy"; - test_component_icone="component-icone" ; + test_typeofnode = "type-of-node"; - test_interface_name = "component-interface-name" ; - - test_service_name = "service-name"; - test_defaultservice = "service-by-default"; + test_inParameter_type = "inParameter-type"; + test_inParameter_name = "inParameter-name"; + test_inParameter = "inParameter"; + test_inParameter_list = "inParameter-list"; - test_inParameter_type="inParameter-type"; - test_inParameter_name="inParameter-name"; - test_inParameter="inParameter"; - test_inParameter_list="inParameter-list"; + test_outParameter_type = "outParameter-type"; + test_outParameter_name = "outParameter-name"; + test_outParameter = "outParameter"; + test_outParameter_list = "outParameter-list"; - test_outParameter_type="outParameter-type"; - test_outParameter_name="outParameter-name"; - test_outParameter="outParameter"; - test_outParameter_list="outParameter-list"; + test_inDataStreamParameter_type = "inParameter-type"; + test_inDataStreamParameter_name = "inParameter-name"; + test_inDataStreamParameter_dependency = "inParameter-dependency"; + test_inDataStreamParameter = "inParameter"; + test_inDataStreamParameter_list = "DataStream-list"; - test_service= "component-service"; - test_service_list="component-service-list"; - test_interface_list="component-interface-list"; + test_outDataStreamParameter_type = "outParameter-type"; + test_outDataStreamParameter_name = "outParameter-name"; + test_outDataStreamParameter_dependency = "outParameter-dependency"; + test_outDataStreamParameter = "outParameter"; + test_outDataStreamParameter_list = "DataStream-list"; - test_constraint="constraint"; + test_service = "component-service"; + test_service_list = "component-service-list"; + test_interface_list = "component-interface-list"; + test_constraint = "constraint"; + + test_component_list = "component-list"; test_component="component"; + + if(MYDEBUG) END_OF("SALOME_ModuleCatalog_Handler"); } //---------------------------------------------------------------------- @@ -79,315 +118,674 @@ SALOME_ModuleCatalog_Handler::SALOME_ModuleCatalog_Handler() //---------------------------------------------------------------------- SALOME_ModuleCatalog_Handler::~SALOME_ModuleCatalog_Handler() { - MESSAGE("SALOME_ModuleCatalog_Handler destruction") + if(MYDEBUG) BEGIN_OF("~SALOME_ModuleCatalog_Handler()") + if(MYDEBUG) END_OF("~SALOME_ModuleCatalog_Handler()") } -//---------------------------------------------------------------------- -// Function : startDocument -// Purpose : overload handler function -//---------------------------------------------------------------------- -bool SALOME_ModuleCatalog_Handler::startDocument() -{ - MESSAGE("Begin parse document") - // Empty the private elements - _pathlist.resize(0); - _path_prefix.ListOfComputer.resize(0); - _servicelist.resize(0); - _interfacelist.resize(0); - _modulelist.resize(0); - _inparamlist.resize(0); - _outparamlist.resize(0); - return true; -} -//---------------------------------------------------------------------- -// Function : startElement -// Purpose : overload handler function -//---------------------------------------------------------------------- -bool SALOME_ModuleCatalog_Handler::startElement(const QString&, - const QString &, - const QString& qName, - const QXmlAttributes& atts) -{ - return true; -} +//============================================================================= +/*! + * Processes XML document and fills the list of modules + */ +//============================================================================= -//---------------------------------------------------------------------- -// Function : endElement -// Purpose : overload handler function -//---------------------------------------------------------------------- -bool SALOME_ModuleCatalog_Handler::endElement(const QString&, - const QString &, - const QString& qName) +void SALOME_ModuleCatalog_Handler::ProcessXmlDocument(xmlDocPtr theDoc) { - // Path prefix - - // tag test_path_prefix_name - if((qName.compare(QString(test_path_prefix_name))==0)) - _path_prefix.path = content; - // tag test_computer_name - if((qName.compare(QString(test_computer_name))==0)) - _path_prefix.ListOfComputer.push_back(content); - - // tag test_path_prefix - if((qName.compare(QString(test_path_prefix))==0)) - { - _pathlist.push_back(_path_prefix); - _path_prefix.ListOfComputer.resize(0); - } - - // Component identification - - // tag test_component_name - if((qName.compare(QString(test_component_name))==0)) - _amodule.Parsercomponentname = content ; - // tag test_component_username - if((qName.compare(QString(test_component_username))==0)) - _amodule.Parsercomponentusername = content ; - // tag test_component_type - if((qName.compare(QString(test_component_type))==0)) - { - if ((content.compare("MESH") == 0) || - (content.compare("Mesh") == 0) || - (content.compare("mesh") == 0)) - _amodule.Parsercomponenttype = MESH ; - else if((content.compare("MED") == 0) || - (content.compare("Med") == 0) || - (content.compare("med") == 0)) - _amodule.Parsercomponenttype = Med ; - else if((content.compare("GEOM") == 0) || - (content.compare("Geom") == 0) || - (content.compare("geom") == 0)) - _amodule.Parsercomponenttype = GEOM ; - else if((content.compare("SOLVER") == 0) || - (content.compare("Solver") == 0) || - (content.compare("solver") == 0)) - _amodule.Parsercomponenttype = SOLVER ; - else if((content.compare("SUPERV") == 0) || - (content.compare("Superv") == 0) || - (content.compare("Supervision") == 0) || - (content.compare("superv") == 0)) - _amodule.Parsercomponenttype = SUPERV ; - else if((content.compare("DATA") == 0) || - (content.compare("Data") == 0) || - (content.compare("data") == 0)) - _amodule.Parsercomponenttype = DATA ; - else if((content.compare("VISU") == 0) || - (content.compare("Visu") == 0) || - (content.compare("visu") == 0)) - _amodule.Parsercomponenttype = VISU ; - else if((content.compare("OTHER") == 0) || - (content.compare("Other") == 0) || - (content.compare("other") == 0)) - _amodule.Parsercomponenttype = OTHER ; - else - // If it'not in all theses cases, the type is affected to OTHER - _amodule.Parsercomponenttype = OTHER ; - } - - // tag test_component_multistudy - if((qName.compare(QString(test_component_multistudy))==0)) - _amodule.Parsercomponentmultistudy = atoi(content.c_str()) ; - - // tag test_component_icone - if((qName.compare(QString(test_component_icone))==0)) - _amodule.Parsercomponenticone = content ; - - // interface identification - - // tag test_interface_name - if((qName.compare(QString(test_interface_name))==0)) - _aInterface.Parserinterfacename = content ; - - // Service identification - - // tag test_service_name - if((qName.compare(QString(test_service_name))==0)) - _aService.ParserServiceName = content ; - - //tag test_defaultservice - if((qName.compare(QString(test_defaultservice))==0)) - _aService.ParserServicebydefault = atoi(content.c_str()) ; - - // Parameter in - - // tag test_inParameter_type - if((qName.compare(QString(test_inParameter_type))==0)) - _inparam.ParserParamtype = content ; - //tag test_inParameter_name - if((qName.compare(QString(test_inParameter_name))==0)) - _inparam.ParserParamname = content ; - - //tag test_inParameter - if((qName.compare(QString(test_inParameter))==0)) - { - _inparamlist.push_back(_inparam) ; - - // Empty temporary structures - _inparam.ParserParamtype = ""; - _inparam.ParserParamname = ""; - } + if(MYDEBUG) MESSAGE("Begin parse document"); + // Empty the private elements + _pathList.resize(0); + _pathPrefix.listOfComputer.resize(0); + _serviceList.resize(0); + _interfaceList.resize(0); + _moduleList.resize(0); + _inDataStreamParamList.resize(0); + _outDataStreamParamList.resize(0); + _inParamList.resize(0); + _outParamList.resize(0); + + // Get the document root node + xmlNodePtr aCurNode = xmlDocGetRootElement(theDoc); + aCurNode = aCurNode->xmlChildrenNode; - //tag test_inParameter_list - if((qName.compare(QString(test_inParameter_list))==0)) - { - _aService.ParserServiceinParameter = _inparamlist; - _inparamlist.resize(0); - } - - // Parameter out - - // tag test_outParameter_type - if((qName.compare(QString(test_outParameter_type))==0)) - _outparam.ParserParamtype = content ; - //tag test_outParameter_name - if((qName.compare(QString(test_outParameter_name))==0)) - _outparam.ParserParamname = content ; - - //tag test_outParameter - if((qName.compare(QString(test_outParameter))==0)) + // Processing the document nodes + while(aCurNode != NULL) + { + // Part 1: Process path prefix list (tag test_path_prefix_list) + if ( !xmlStrcmp(aCurNode->name,(const xmlChar*)test_path_prefix_list) ) { - _outparamlist.push_back(_outparam) ; - - // Empty temporary structures - _outparam.ParserParamtype = ""; - _outparam.ParserParamname = ""; + xmlNodePtr aCurSubNode = aCurNode->xmlChildrenNode; + while(aCurSubNode != NULL) + { + // Forming a PathPrefix structure (tag test_path_prefix) + if ( xmlStrcmp(aCurSubNode->name, (const xmlChar*)test_path_prefix) ) { + aCurSubNode = aCurSubNode->next; + continue; + } + + xmlNodePtr aCurSubSubNode = aCurSubNode->xmlChildrenNode; + while(aCurSubSubNode != NULL) + { + // Tag test_path_prefix_name + if ( !xmlStrcmp(aCurSubSubNode->name, (const xmlChar*)test_path_prefix_name) ) { + xmlChar* aPath = xmlNodeGetContent(aCurSubSubNode); + if (aPath != NULL) { + _pathPrefix.path = (const char*)aPath; + xmlFree(aPath); + } + } + + // Tag test_computer_list + if ( !xmlStrcmp(aCurSubSubNode->name, (const xmlChar*)test_computer_list) ) { + xmlNodePtr aComputerNode = aCurSubSubNode->xmlChildrenNode; + while (aComputerNode != NULL) { + // Tag test_computer_name + if ( !xmlStrcmp(aComputerNode->name, (const xmlChar*) test_computer_name) ) { + xmlChar* aCompName = xmlNodeGetContent(aComputerNode); + if (aCompName != NULL) { + _pathPrefix.listOfComputer.push_back((const char*)aCompName); + xmlFree(aCompName); + } + } + + aComputerNode = aComputerNode->next; + } + } + + aCurSubSubNode = aCurSubSubNode->next; + } + + _pathList.push_back(_pathPrefix); + _pathPrefix.listOfComputer.resize(0); + + aCurSubNode = aCurSubNode->next; + } } - //tag test_outParameter_list - if((qName.compare(QString(test_outParameter_list))==0)) - { - _aService.ParserServiceoutParameter=_outparamlist; - _outparamlist.resize(0); - } - - - // tag test_service - if((qName.compare(QString(test_service))==0)) - { - _servicelist.push_back(_aService); - - // Empty temporary structures - _aService.ParserServiceName = ""; - _aService.ParserServiceinParameter.resize(0); - _aService.ParserServiceoutParameter.resize(0); - } - - // tag test_service_list - if((qName.compare(QString(test_service_list))==0)) - { - _aInterface.Parserinterfaceservicelist = _servicelist ; - - // Empty temporary structures - _servicelist.resize(0); - _interfacelist.push_back(_aInterface); - _aInterface.Parserinterfacename =""; - _aInterface.Parserinterfaceservicelist.resize(0); - - } - - //tag test_interface_list - if((qName.compare(QString(test_interface_list))==0)) - { - _amodule.ParserListInterface = _interfacelist ; - _interfacelist.resize(0); - } - - //tag test_constraint - if((qName.compare(QString(test_constraint))==0)) - _amodule.Parserconstraint = content ; - - // tag test_component - if((qName.compare(QString(test_component))==0)) - { - _modulelist.push_back(_amodule) ; - - // Empty temporary structures - _amodule.Parsercomponentname = ""; - _amodule.Parserconstraint = ""; - _amodule.Parsercomponenticone=""; - _amodule.ParserListInterface.resize(0); - } - - return true; -} - -//---------------------------------------------------------------------- -// Function : characters -// Purpose : overload handler function -//---------------------------------------------------------------------- -bool SALOME_ModuleCatalog_Handler::characters(const QString& chars) -{ - content = (const char*)chars ; - return true; -} -//---------------------------------------------------------------------- -// Function : endDocument -// Purpose : overload handler function -// Print all informations find in the catalog -// (only in DEBUG mode!!) -//---------------------------------------------------------------------- -bool SALOME_ModuleCatalog_Handler::endDocument() -{ - //_pathlist - for (unsigned int ind = 0; ind < _pathlist.size(); ind++) + //Part 2: Process list of types + if ( !xmlStrcmp(aCurNode->name,(const xmlChar*)"type-list") ) + { + xmlNodePtr aTypeNode = aCurNode->xmlChildrenNode; + while (aTypeNode != NULL) + { + // match "type" + if ( !xmlStrcmp(aTypeNode->name, (const xmlChar*)"type" )) + { + // Here is a basic type description + ParserType aType; + xmlChar * name=xmlGetProp(aTypeNode,(const xmlChar*)"name"); + if(name) + { + aType.name = (const char*)name; + xmlFree(name); + } + xmlChar *kind=xmlGetProp(aTypeNode,(const xmlChar*)"kind"); + if(kind) + { + aType.kind = (const char*)kind; + xmlFree(kind); + } + if(aType.kind == "double" || + aType.kind == "int" || + aType.kind == "bool" || + aType.kind == "string") + { + if ( _typeMap.find(aType.name) == _typeMap.end() ) + { + MESSAGE("Registered basic type: " << aType.name << " " << aType.kind ); + _typeMap[aType.name]=aType; + _typeList.push_back(aType); + } + else + std::cerr << "Warning: this type (" << aType.name << "," << aType.kind << ") already exists, it will be ignored." << std::endl; + } + else + std::cerr << "Warning: this type (" << aType.name << "," << aType.kind << ") has incorrect kind, it will be ignored." << std::endl; + } + else if ( !xmlStrcmp(aTypeNode->name, (const xmlChar*)"sequence" )) + { + // Here is a sequence type description + ParserSequence aType; + xmlChar * name=xmlGetProp(aTypeNode,(const xmlChar*)"name"); + if(name) + { + aType.name = (const char*)name; + xmlFree(name); + } + xmlChar *content=xmlGetProp(aTypeNode,(const xmlChar*)"content"); + if(content) + { + aType.content = (const char*)content; + xmlFree(content); + } + if ( _typeMap.find(aType.content) != _typeMap.end() ) + { + if ( _typeMap.find(aType.name) == _typeMap.end() ) + { + MESSAGE("Registered sequence type: " << aType.name << " " << aType.content ); + _typeMap[aType.name]=aType; + _typeList.push_back(aType); + } + else + std::cerr << "Warning: this type (" << aType.name << "," << aType.kind << ") already exists, it will be ignored." << std::endl; + } + else + { + std::cerr << "Warning: this sequence type (" << aType.name << "," << aType.content << ") has unknown content type, it will be ignored." << std::endl; + } + } + else if ( !xmlStrcmp(aTypeNode->name, (const xmlChar*)"objref" )) + { + // Here is an objref type description + ParserObjref aType; + int error=0; + xmlChar * name=xmlGetProp(aTypeNode,(const xmlChar*)"name"); + if(name) + { + aType.name = (const char*)name; + xmlFree(name); + } + xmlChar *id=xmlGetProp(aTypeNode,(const xmlChar*)"id"); + if(id) + { + aType.id = (const char*)id; + xmlFree(id); + } + + xmlNodePtr aTypeSubNode = aTypeNode->xmlChildrenNode; + while (aTypeSubNode != NULL) + { + if ( !xmlStrcmp(aTypeSubNode->name, (const xmlChar*)"base" )) + { + //a base type + xmlChar* content = xmlNodeGetContent(aTypeSubNode); + if(content) + { + std::string base=(const char*)content; + xmlFree(content); + if ( _typeMap.find(base) != _typeMap.end() && _typeMap[base].kind == "objref") + { + aType.bases.push_back(base); + } + else + { + std::cerr << "Warning: this objref type (" << aType.name << ") has unknown base type (" << base << "), it will be ignored." << std::endl; + error=1; + break; + } + } + } + aTypeSubNode = aTypeSubNode->next; + } + if(!error) + { + if ( _typeMap.find(aType.name) == _typeMap.end() ) + { + MESSAGE("Registered objref type: " << aType.name << " " << aType.id ); + _typeMap[aType.name]=aType; + _typeList.push_back(aType); + } + else + std::cerr << "Warning: this type (" << aType.name << "," << aType.kind << ") already exists, it will be ignored." << std::endl; + } + } + else if ( !xmlStrcmp(aTypeNode->name, (const xmlChar*)"struct" )) + { + // Here is a struct type description + ParserStruct aType; + int error=0; + xmlChar * name=xmlGetProp(aTypeNode,(const xmlChar*)"name"); + if(name) + { + aType.name = (const char*)name; + xmlFree(name); + } + xmlChar *id=xmlGetProp(aTypeNode,(const xmlChar*)"id"); + if(id) + { + aType.id = (const char*)id; + xmlFree(id); + } + + xmlNodePtr aTypeSubNode = aTypeNode->xmlChildrenNode; + while (aTypeSubNode != NULL) + { + if ( !xmlStrcmp(aTypeSubNode->name, (const xmlChar*)"member" )) + { + std::pair member; + xmlChar * m_name=xmlGetProp(aTypeSubNode,(const xmlChar*)"name"); + if(m_name) + { + member.first=(const char*)m_name; + xmlFree(m_name); + } + xmlChar * m_type=xmlGetProp(aTypeSubNode,(const xmlChar*)"type"); + if(m_type) + { + member.second=(const char*)m_type; + xmlFree(m_type); + } + if ( _typeMap.find(member.second) != _typeMap.end() ) + { + aType.members.push_back(member); + } + else + { + std::cerr << "Warning: this struct type (" << aType.name << ") has unknown member type (" << member.first << "," << member.second << "), it will be ignored." << std::endl; + error=1; + break; + } + } + aTypeSubNode = aTypeSubNode->next; + } + if(!error) + { + if ( _typeMap.find(aType.name) == _typeMap.end() ) + { + MESSAGE("Registered struct type: " << aType.name << " " << aType.id ); + _typeMap[aType.name]=aType; + _typeList.push_back(aType); + } + else + std::cerr << "Warning: this type (" << aType.name << "," << aType.kind << ") already exists, it will be ignored." << std::endl; + } + } // end of struct + aTypeNode = aTypeNode->next; + } + } + + //Part 3: Process list of components (tag test_component_list) + if ( !xmlStrcmp(aCurNode->name,(const xmlChar*)test_component_list) ) { - MESSAGE("Path :"<<_pathlist[ind].path) - for (unsigned int i = 0; i < _pathlist[ind].ListOfComputer.size(); i++) - MESSAGE("Computer name :" << _pathlist[ind].ListOfComputer[i]) + xmlNodePtr aComponentNode = aCurNode->xmlChildrenNode; + while (aComponentNode != NULL) + { + // Do not process tags differ from test_component here + if ( xmlStrcmp(aComponentNode->name, (const xmlChar*)test_component) ) { + aComponentNode = aComponentNode->next; + continue; + } + + // Component identification + + // Empty temporary structures + _aModule.name = ""; + _aModule.constraint = ""; + _aModule.icon=""; + _aModule.interfaces.resize(0); + _aModule.implementationType =""; + _aModule.implementationName =""; + + xmlNodePtr aComponentSubNode = aComponentNode->xmlChildrenNode; + while(aComponentSubNode != NULL) + { + xmlChar* aNodeContent = xmlNodeGetContent(aComponentSubNode); + + if (aNodeContent == NULL) { + aComponentSubNode = aComponentSubNode->next; + continue; + } + + std::string aContent = (const char*)aNodeContent; + + // Tag test_component_name + if ( !xmlStrcmp(aComponentSubNode->name, (const xmlChar*)test_component_name) ) + _aModule.name = aContent; + + // Tag test_component_username + if ( !xmlStrcmp(aComponentSubNode->name, (const xmlChar*)test_component_username) ) + _aModule.username = aContent; + + // Tag test_component_type + if ( !xmlStrcmp(aComponentSubNode->name, (const xmlChar*)test_component_type) ) { + std::string aType = aContent; + + if ((aType.compare("MESH") == 0) || + (aType.compare("Mesh") == 0) || + (aType.compare("mesh") == 0)) + _aModule.type = MESH ; + else if((aType.compare("MED") == 0) || + (aType.compare("Med") == 0) || + (aType.compare("med") == 0)) + _aModule.type = Med ; + else if((aType.compare("GEOM") == 0) || + (aType.compare("Geom") == 0) || + (aType.compare("geom") == 0)) + _aModule.type = GEOM ; + else if((aType.compare("SOLVER") == 0) || + (aType.compare("Solver") == 0) || + (aType.compare("solver") == 0)) + _aModule.type = SOLVER ; + else if((aType.compare("SUPERV") == 0) || + (aType.compare("Superv") == 0) || + (aType.compare("Supervision") == 0) || + (aType.compare("superv") == 0)) + _aModule.type = SUPERV ; + else if((aType.compare("DATA") == 0) || + (aType.compare("Data") == 0) || + (aType.compare("data") == 0)) + _aModule.type = DATA ; + else if((aType.compare("VISU") == 0) || + (aType.compare("Visu") == 0) || + (aType.compare("visu") == 0)) + _aModule.type = VISU ; + else if((aType.compare("OTHER") == 0) || + (aType.compare("Other") == 0) || + (aType.compare("other") == 0)) + _aModule.type = OTHER ; + else + // If it'not in all theses cases, the type is affected to OTHER + _aModule.type = OTHER ; + } + + // Tag test_component_multistudy + if ( !xmlStrcmp(aComponentSubNode->name, (const xmlChar*)test_component_multistudy) ) + _aModule.multistudy = atoi( aContent.c_str() ); + + // Tag test_component_impltype + if ( !xmlStrcmp(aComponentSubNode->name, (const xmlChar*)test_component_impltype) ) + _aModule.implementationType = aContent; + + // Tag test_component_implname + if ( !xmlStrcmp(aComponentSubNode->name, (const xmlChar*)test_component_implname) ) + _aModule.implementationName = aContent; + + // Tag test_component_icon + if ( !xmlStrcmp(aComponentSubNode->name, (const xmlChar*)test_component_icon) ) + _aModule.icon = aContent; + + // Tag test_component_version + if ( !xmlStrcmp(aComponentSubNode->name, (const xmlChar*)test_component_version) ) + _aModule.version = aContent; + + // Tag test_component_comment + if ( !xmlStrcmp(aComponentSubNode->name, (const xmlChar*)test_component_comment) ) + _aModule.comment = aContent; + + // Tag test_constraint + if ( !xmlStrcmp(aComponentSubNode->name, (const xmlChar*)test_constraint) ) + _aModule.constraint = aContent; + + xmlFree(aNodeContent); + + // Process tag test_interface_list: + if ( !xmlStrcmp(aComponentSubNode->name, (const xmlChar*)test_interface_list) ) { + + // Form an interface list for the component + xmlNodePtr aSubNode = aComponentSubNode->xmlChildrenNode; + while(aSubNode != NULL) { + // Tag test_interface_name + if ( !xmlStrcmp(aSubNode->name, (const xmlChar*)test_interface_name) ) { + xmlChar* anInterfaceName = xmlNodeGetContent(aSubNode); + if (anInterfaceName != NULL) { + _aInterface.name = (const char*)anInterfaceName; + xmlFree(anInterfaceName); + } + } + + // Tag test_service_list + if ( !xmlStrcmp(aSubNode->name, (const xmlChar*)test_service_list) ) { + // Form a service list for the interface + xmlNodePtr aCompServiceNode = aSubNode->xmlChildrenNode; + while(aCompServiceNode != NULL) { + // Tag test_service + if ( !xmlStrcmp(aCompServiceNode->name, (const xmlChar*)"component-service") ) { + xmlNodePtr aCompServiceSubNode = aCompServiceNode->xmlChildrenNode; + while(aCompServiceSubNode != NULL) + { + xmlChar* aCompServiceData = xmlNodeGetContent(aCompServiceSubNode); + + if ( aCompServiceData != NULL) + { + // Tag test_service_name + if ( !xmlStrcmp(aCompServiceSubNode->name, (const xmlChar*)test_service_name) ) + _aService.name = (const char*)aCompServiceData; + + // Tag test_defaultservice + if ( !xmlStrcmp(aCompServiceSubNode->name, (const xmlChar*)test_defaultservice) ) + _aService.byDefault = (const char*)aCompServiceData; + + // Tag test_typeofnode + if ( !xmlStrcmp(aCompServiceSubNode->name, (const xmlChar*)test_typeofnode) ) + _aService.typeOfNode = (const char*)aCompServiceData; + + xmlFree(aCompServiceData); + } + + // Tag test_inParameter_list + if ( !xmlStrcmp(aCompServiceSubNode->name, (const xmlChar*)test_inParameter_list) ) { + xmlNodePtr aParamNode = aCompServiceSubNode->xmlChildrenNode; + while (aParamNode != NULL) + { + // Tag test_inParameter + if (xmlStrcmp(aParamNode->name, (const xmlChar*)test_inParameter)) { + aParamNode = aParamNode->next; + continue; + } + + xmlNodePtr aParamItemNode = aParamNode->xmlChildrenNode; + while (aParamItemNode != NULL) + { + xmlChar* aParamData = xmlNodeGetContent(aParamItemNode); + + if (aParamData != NULL) + { + // Tag test_inParameter_name + if ( !xmlStrcmp(aParamItemNode->name, (const xmlChar*)test_inParameter_name) ) + _inParam.name = (const char*)aParamData; + + // Tag test_inParameter_type + if ( !xmlStrcmp(aParamItemNode->name, (const xmlChar*)test_inParameter_type) ) + _inParam.type = (const char*)aParamData; + + xmlFree(aParamData); + } + + aParamItemNode = aParamItemNode->next; + } + + _inParamList.push_back(_inParam) ; + + // Empty temporary structures + _inParam.type = ""; + _inParam.name = ""; + + aParamNode = aParamNode->next; + } + + _aService.inParameters = _inParamList; + _inParamList.resize(0); + } + + // Tag test_outParameter_list + if ( !xmlStrcmp(aCompServiceSubNode->name, (const xmlChar*)test_outParameter_list) ) { + xmlNodePtr aParamNode = aCompServiceSubNode->xmlChildrenNode; + while (aParamNode != NULL) + { + // Tag test_outParameter + if (xmlStrcmp(aParamNode->name, (const xmlChar*)test_outParameter)) { + aParamNode = aParamNode->next; + continue; + } + + xmlNodePtr aParamItemNode = aParamNode->xmlChildrenNode; + while (aParamItemNode != NULL) + { + xmlChar* anOutParamData = xmlNodeGetContent(aParamItemNode); + + if (anOutParamData != NULL) + { + // Tag test_outParameter_name + if ( !xmlStrcmp(aParamItemNode->name, (const xmlChar*)test_outParameter_name) ) + _outParam.name = (const char*)anOutParamData; + + // Tag test_outParameter_type + if ( !xmlStrcmp(aParamItemNode->name, (const xmlChar*)test_outParameter_type) ) + _outParam.type = (const char*)anOutParamData; + + xmlFree(anOutParamData); + } + + aParamItemNode = aParamItemNode->next; + } + + _outParamList.push_back(_outParam) ; + + // Empty temporary structures + _outParam.type = ""; + _outParam.name = ""; + + aParamNode = aParamNode->next; + } + + _aService.outParameters = _outParamList; + _outParamList.resize(0); + } + + //@ Tag test_inDataStreamParameter_list + if ( !xmlStrcmp(aCompServiceSubNode->name, (const xmlChar*)test_inDataStreamParameter_list) ) + { + xmlNodePtr aParamNode = aCompServiceSubNode->xmlChildrenNode; + while (aParamNode != NULL) + { + // Tag test_inDataStreamParameter + if (xmlStrcmp(aParamNode->name, (const xmlChar*)test_inDataStreamParameter)) { + aParamNode = aParamNode->next; + continue; + } + + xmlNodePtr aParamItemNode = aParamNode->xmlChildrenNode; + while (aParamItemNode != NULL) + { + xmlChar* inDataStreamParamData = xmlNodeGetContent(aParamItemNode); + + if (inDataStreamParamData != NULL) + { + // Tag test_inDataStreamParameter_name + if ( !xmlStrcmp(aParamItemNode->name, (const xmlChar*)test_inDataStreamParameter_name) ) + _inDataStreamParam.name = (const char*)inDataStreamParamData; + + // Tag test_inDataStreamParameter_type + if ( !xmlStrcmp(aParamItemNode->name, (const xmlChar*)test_inDataStreamParameter_type) ) + _inDataStreamParam.type = (const char*)inDataStreamParamData; + + // Tag test_inDataStreamParameter_dependency + if ( !xmlStrcmp(aParamItemNode->name, (const xmlChar*)test_inDataStreamParameter_dependency) ) + _inDataStreamParam.dependency = (const char*)inDataStreamParamData; + + xmlFree(inDataStreamParamData); + } + + aParamItemNode = aParamItemNode->next; + } + + _inDataStreamParamList.push_back(_inDataStreamParam) ; + + // Empty temporary structures + _inDataStreamParam.type = ""; + _inDataStreamParam.name = ""; + _inDataStreamParam.dependency = ""; + + aParamNode = aParamNode->next; + } + + _aService.inDataStreamParameters = _inDataStreamParamList; + _inDataStreamParamList.resize(0); + } + + // Tag test_outDataStreamParameter_list + if ( !xmlStrcmp(aCompServiceSubNode->name, (const xmlChar*)test_outDataStreamParameter_list) ) + { + xmlNodePtr aParamNode = aCompServiceSubNode->xmlChildrenNode; + while (aParamNode != NULL) + { + // Tag test_outDataStreamParameter + if (xmlStrcmp(aParamNode->name, (const xmlChar*)test_outDataStreamParameter)) { + aParamNode = aParamNode->next; + continue; + } + + xmlNodePtr aParamItemNode = aParamNode->xmlChildrenNode; + while (aParamItemNode != NULL) + { + xmlChar* outDataStreamParamData = xmlNodeGetContent(aParamItemNode); + + if (outDataStreamParamData != NULL) + { + // Tag test_outDataStreamParameter_name + if ( !xmlStrcmp(aParamItemNode->name, (const xmlChar*)test_outDataStreamParameter_name) ) + _outDataStreamParam.name = (const char*)outDataStreamParamData; + + // Tag test_outDataStreamParameter_type + if ( !xmlStrcmp(aParamItemNode->name, (const xmlChar*)test_outDataStreamParameter_type) ) + _outDataStreamParam.type = (const char*)outDataStreamParamData; + + // Tag test_outDataStreamParameter_dependency + if ( !xmlStrcmp(aParamItemNode->name, (const xmlChar*)test_outDataStreamParameter_dependency) ) + _outDataStreamParam.dependency = (const char*)outDataStreamParamData; + + xmlFree(outDataStreamParamData); + } + + aParamItemNode = aParamItemNode->next; + } + + _outDataStreamParamList.push_back(_outDataStreamParam) ; + + // Empty temporary structures + _outDataStreamParam.type = ""; + _outDataStreamParam.name = ""; + _outDataStreamParam.dependency = ""; + + aParamNode = aParamNode->next; + } + + _aService.outDataStreamParameters = _outDataStreamParamList; + _outDataStreamParamList.resize(0); + } + + aCompServiceSubNode = aCompServiceSubNode->next; + } + + // Put formed service into the list + _serviceList.push_back(_aService); + + // Empty temporary structures + _aService.name = ""; + _aService.typeOfNode = 1; + _aService.inParameters.resize(0); + _aService.outParameters.resize(0); + _aService.inDataStreamParameters.resize(0); + _aService.outDataStreamParameters.resize(0); + } + + aCompServiceNode = aCompServiceNode->next; + } + + _aInterface.services = _serviceList ; + + // Empty temporary structures + _serviceList.resize(0); + _interfaceList.push_back(_aInterface); + _aInterface.name =""; + _aInterface.services.resize(0); + } + + aSubNode = aSubNode->next; + } + + _aModule.interfaces = _interfaceList ; + _interfaceList.resize(0); + } + + aComponentSubNode = aComponentSubNode->next; + } + + _moduleList.push_back(_aModule); + + aComponentNode = aComponentNode->next; + } } - // _modulelist - for (unsigned int ind = 0; ind < _modulelist.size(); ind++) - { - MESSAGE("Component name : " << _modulelist[ind].Parsercomponentname); - // MESSAGE("Component type : " <<_modulelist[ind].Parsercomponenttype); -// MESSAGE("Component constraint : " << _modulelist[ind].Parserconstraint); -// MESSAGE("Component icone : " << _modulelist[ind].Parsercomponenticone); -// for (unsigned int i = 0; i < _modulelist[ind].ParserListInterface.size(); i++) -// { -// MESSAGE("Component interface name : " << _modulelist[ind].ParserListInterface[i].Parserinterfacename); -// for (unsigned int j=0; j< _modulelist[ind].ParserListInterface[i].Parserinterfaceservicelist.size(); j++) -// { -// MESSAGE("Service name : " << _modulelist[ind].ParserListInterface[i].Parserinterfaceservicelist[j].ParserServiceName); -// MESSAGE("Service default : " << _modulelist[ind].ParserListInterface[i].Parserinterfaceservicelist[j].ParserServicebydefault); -// for (unsigned int k=0; k< _modulelist[ind].ParserListInterface[i].Parserinterfaceservicelist[j].ParserServiceinParameter.size() ; k++) -// { -// MESSAGE("Service Parameter in name : " <<_modulelist[ind].ParserListInterface[i].Parserinterfaceservicelist[j].ParserServiceinParameter[k].ParserParamname); -// MESSAGE("Service Parameter in type : " << _modulelist[ind].ParserListInterface[i].Parserinterfaceservicelist[j].ParserServiceinParameter[k].ParserParamtype); -// } -// for (unsigned int k=0; k< _modulelist[ind].ParserListInterface[i].Parserinterfaceservicelist[j].ParserServiceoutParameter.size() ; k++) -// { -// MESSAGE("Service Parameter out name : " << _modulelist[ind].ParserListInterface[i].Parserinterfaceservicelist[j].ParserServiceoutParameter[k].ParserParamname); -// MESSAGE("Service Parameter out type : " << _modulelist[ind].ParserListInterface[i].Parserinterfaceservicelist[j].ParserServiceoutParameter[k].ParserParamtype); -// } -// } - } -// } - //MESSAGE("Document parsed"); - return true; -} - -//---------------------------------------------------------------------- -// Function : errorProtocol -// Purpose : overload handler function -//---------------------------------------------------------------------- -QString SALOME_ModuleCatalog_Handler::errorProtocol() -{ - return errorProt ; -} - - -//---------------------------------------------------------------------- -// Function : fatalError -// Purpose : overload handler function -//---------------------------------------------------------------------- -bool SALOME_ModuleCatalog_Handler::fatalError(const QXmlParseException& exception) -{ - errorProt += QString( "fatal parsing error: %1 in line %2, column %3\n" ) - .arg( exception.message() ) - .arg( exception.lineNumber() ) - .arg( exception.columnNumber() ); - - return QXmlDefaultHandler::fatalError( exception ); + aCurNode = aCurNode->next; + } }