src/ModuleCatalog/SALOME_ModuleCatalog_impl.cxx

   1 //  SALOME ModuleCatalog : implementation of ModuleCatalog server which parsers xml description of modules
   2 //
   3 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 //  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
  21 //
  22 //
  23 //
  24 //  File   : SALOME_ModuleCatalog_impl.cxx
  25 //  Author : Estelle Deville
  26 //  Module : SALOME
  27 //  $Header$
  28 //
  29 #include "SALOME_ModuleCatalog_impl.hxx"
  30 #include "SALOME_ModuleCatalog_Acomponent_impl.hxx"
  31 #include <fstream>
  32 #include <map>
  33
  34 #include <qstringlist.h>
  35 #include <qfileinfo.h>
  36 using namespace std;
  37
  38 #ifdef _DEBUG_
  39 static int MYDEBUG = 0;
  40 #else
  41 static int MYDEBUG = 0;
  42 #endif
  43
  44 static const char* SEPARATOR    = ":";
  45
  46 //----------------------------------------------------------------------
  47 // Function : SALOME_ModuleCatalogImpl
  48 // Purpose  : Constructor
  49 //----------------------------------------------------------------------
  50 SALOME_ModuleCatalogImpl::SALOME_ModuleCatalogImpl(int argc, char** argv, CORBA::ORB_ptr orb) : _orb(orb)
  51 {
  52   if(MYDEBUG) MESSAGE("Catalog creation");
  53
  54   // Conversion rules for component types
  55   ComponentTypeConvert[GEOM]
  56     = SALOME_ModuleCatalog::GEOM;
  57   ComponentTypeConvert[MESH]
  58     = SALOME_ModuleCatalog::MESH;
  59   ComponentTypeConvert[Med]
  60     = SALOME_ModuleCatalog::Med;
  61   ComponentTypeConvert[SOLVER]
  62     = SALOME_ModuleCatalog::SOLVER;
  63   ComponentTypeConvert[DATA]
  64     = SALOME_ModuleCatalog::DATA;
  65   ComponentTypeConvert[VISU]
  66     = SALOME_ModuleCatalog::VISU;
  67   ComponentTypeConvert[SUPERV]
  68     = SALOME_ModuleCatalog::SUPERV;
  69   ComponentTypeConvert[OTHER]
  70     = SALOME_ModuleCatalog::OTHER;
  71
  72   // Conversion rules for datastream parameters type and dependency
  73   DataStreamTypeConvert["UNKNOWN"]
  74     = SALOME_ModuleCatalog::DATASTREAM_UNKNOWN;
  75   DataStreamTypeConvert["INTEGER"]
  76     = SALOME_ModuleCatalog::DATASTREAM_INTEGER;
  77   DataStreamTypeConvert["FLOAT"]
  78     = SALOME_ModuleCatalog::DATASTREAM_FLOAT;
  79   DataStreamTypeConvert["DOUBLE"]
  80     = SALOME_ModuleCatalog::DATASTREAM_DOUBLE;
  81   DataStreamTypeConvert["STRING"]
  82     = SALOME_ModuleCatalog::DATASTREAM_STRING;
  83   DataStreamTypeConvert["BOOLEAN"]
  84     = SALOME_ModuleCatalog::DATASTREAM_BOOLEAN;
  85
  86   DataStreamDepConvert["UNDEFINED"]
  87     = SALOME_ModuleCatalog::DATASTREAM_UNDEFINED;
  88   DataStreamDepConvert["T"]
  89     = SALOME_ModuleCatalog::DATASTREAM_TEMPORAL;
  90   DataStreamDepConvert["I"]
  91     = SALOME_ModuleCatalog::DATASTREAM_ITERATIVE;
  92
  93   // Empty used variables
  94   _general_module_list.resize(0);
  95   _general_path_list.resize(0);
  96
  97   _personal_module_list.resize(0);
  98   _personal_path_list.resize(0);
  99
 100   // Parse the arguments given at server run
 101   if (!_parseArguments(argc, argv,&_general_path,&_personal_path))
 102     if(MYDEBUG) MESSAGE( "Error while argument parsing" );
 103
 104   // Test existency of files
 105   if (_general_path == NULL){
 106     if(MYDEBUG) MESSAGE( "Error the general catalog should be indicated" );
 107   }else{
 108     // Affect the _general_module_list and _general_path_list members
 109     // with the common catalog
 110
 111     QStringList dirList
 112       = QStringList::split( SEPARATOR, _general_path,
 113                             false ); // skip empty entries
 114
 115     for ( int i = 0; i < dirList.count(); i++ ) {
 116       QFileInfo fileInfo( dirList[ i ] );
 117       if ( fileInfo.isFile() && fileInfo.exists() ) {
 118         _parse_xml_file(fileInfo.filePath(),
 119                         _general_module_list,
 120                         _general_path_list);
 121       }
 122     }
 123
 124     // Verification of _general_path_list content
 125     if(!_verify_path_prefix(_general_path_list)){
 126       if(MYDEBUG) MESSAGE( "Error while parsing the general path list, "
 127                            "differents paths are associated to the same computer,"
 128                            "the first one will be choosen");
 129     }else{
 130       if(MYDEBUG) MESSAGE("General path list OK");
 131     }
 132
 133     if(_personal_path != NULL){
 134       // Initialize the _personal_module_list and
 135       // _personal_path_list members with the personal catalog files
 136       _parse_xml_file(_personal_path,
 137                       _personal_module_list,
 138                       _personal_path_list);
 139
 140       // Verification of _general_path_list content
 141       if(!_verify_path_prefix(_personal_path_list)){
 142         if(MYDEBUG) MESSAGE("Error while parsing the personal path list, "
 143                             "differents paths are associated to the same computer, "
 144                             "the first one will be choosen" );
 145       }else {
 146         if(MYDEBUG) MESSAGE("Personal path list OK");
 147       }
 148     }else
 149       if(MYDEBUG) MESSAGE("No personal catalog indicated or error while "
 150                           "opening the personal catalog");
 151   }
 152 }
 153
 154 //----------------------------------------------------------------------
 155 // Function : ~SALOME_ModuleCatalogImpl
 156 // Purpose  : Destructor
 157 //----------------------------------------------------------------------
 158 SALOME_ModuleCatalogImpl::~SALOME_ModuleCatalogImpl()
 159 {
 160   if(MYDEBUG) MESSAGE("Catalog Destruction");
 161 }
 162
 163
 164 //----------------------------------------------------------------------
 165 // Function : GetComputerList
 166 // Purpose  : get a computer list
 167 //----------------------------------------------------------------------
 168 SALOME_ModuleCatalog::ListOfComputers*
 169 SALOME_ModuleCatalogImpl::GetComputerList()
 170 {
 171   SALOME_ModuleCatalog::ListOfComputers_var _list_computers =
 172     new SALOME_ModuleCatalog::ListOfComputers;
 173   return _list_computers._retn();
 174 }
 175
 176 //----------------------------------------------------------------------
 177 // Function : GetPathPrefix
 178 // Purpose  : get the PathPrefix of a computer
 179 //----------------------------------------------------------------------
 180 char *
 181 SALOME_ModuleCatalogImpl::GetPathPrefix(const char* machinename) {
 182   if(MYDEBUG) MESSAGE("Begin of GetPathPrefix");
 183   // Variables initialisation
 184   char* _path = NULL;
 185   bool _find = false ;
 186
 187   // Parse all the path prefixes
 188   // looking for the wanted computer
 189   for (unsigned int ind = 0 ; ind < _personal_path_list.size() ; ind++)
 190     {
 191       for (unsigned int ind1 = 0 ; ind1 < _personal_path_list[ind].listOfComputer.size() ; ind1++)
 192         {
 193           if (strcmp(machinename, _personal_path_list[ind].listOfComputer[ind1].c_str()) == 0)
 194             {
 195               _find = true ;
 196               // Wanted computer
 197               // affect the path to be returned
 198                 const char* _temp = _personal_path_list[ind].path.c_str() ;
 199                   _path = new char[strlen(_temp)+1];
 200               strcpy(_path,_temp);
 201             }
 202         }
 203     }
 204
 205   if (!_find)
 206     {
 207     for (unsigned int ind = 0 ; ind < _general_path_list.size() ; ind++)
 208       {
 209         for (unsigned int ind1 = 0 ; ind1 < _general_path_list[ind].listOfComputer.size() ; ind1++)
 210           {
 211             if (strcmp(machinename, _general_path_list[ind].listOfComputer[ind1].c_str()) == 0)
 212               {
 213                 _find = true ;
 214                 // Wanted computer
 215                 // affect the path to be returned
 216                   const char* _temp = _general_path_list[ind].path.c_str() ;
 217                     _path = new char[strlen(_temp)+1];
 218                 strcpy(_path,_temp);
 219               }
 220           }
 221       }
 222     }
 223
 224   return _path;
 225 }
 226
 227 //----------------------------------------------------------------------
 228 // Function : GetComponentList
 229 // Purpose  : get a component list
 230 //            If a component is defined in the personal catalog and
 231 //            in the general catalog (same name), the component defined
 232 //            in the personal catalog is used
 233 //----------------------------------------------------------------------
 234 SALOME_ModuleCatalog::ListOfComponents*
 235 SALOME_ModuleCatalogImpl::GetComponentList()
 236 {
 237   if(MYDEBUG) MESSAGE("Begin of GetComponentList");
 238   SALOME_ModuleCatalog::ListOfComponents_var _list_components =
 239     new SALOME_ModuleCatalog::ListOfComponents;
 240
 241   _list_components->length(_personal_module_list.size());
 242
 243   // All the components defined in the personal catalog are taken
 244   for(unsigned int ind=0; ind < _personal_module_list.size();ind++){
 245     _list_components[ind]=(_personal_module_list[ind].name).c_str();
 246     if(MYDEBUG) SCRUTE(_list_components[ind]) ;
 247   }
 248
 249   int indice = _personal_module_list.size() ;
 250   bool _find = false;
 251
 252   // The components in the general catalog are taken only if they're
 253   // not defined in the personal catalog
 254   for(unsigned int ind=0; ind < _general_module_list.size();ind++){
 255     _find = false;
 256     for(unsigned int ind1=0; ind1 < _personal_module_list.size();ind1++){
 257       // searching if the component is already defined in
 258       // the personal catalog
 259       if ((_general_module_list[ind].name.compare(_personal_module_list[ind1].name)) == 0)
 260         _find = true;
 261     }
 262     if(!_find){
 263       if(MYDEBUG) MESSAGE("A new component " << _general_module_list[ind].name
 264                           << " has to be to added in the list");
 265       _list_components->length(indice+1);
 266       // The component is not already defined => has to be taken
 267       _list_components[indice]=(_general_module_list[ind].name).c_str();
 268       if(MYDEBUG) SCRUTE(_list_components[indice]) ;
 269
 270       indice++;
 271     }else{
 272       if(MYDEBUG) MESSAGE("The component " <<_general_module_list[ind].name
 273                           << " was already defined in the personal catalog") ;
 274     }
 275   }
 276
 277   if(MYDEBUG) MESSAGE ( "End of GetComponentList" );
 278   return _list_components._retn();
 279 }
 280
 281
 282 //----------------------------------------------------------------------
 283 // Function : GetComponentIconeList
 284 // Purpose  : get a component list of component name and component icone
 285 //            If a component is defined in the personal catalog and
 286 //            in the general catalog (same name), the component defined
 287 //            in the personal catalog is used
 288 //----------------------------------------------------------------------
 289 SALOME_ModuleCatalog::ListOfIAPP_Affich*
 290 SALOME_ModuleCatalogImpl::GetComponentIconeList()
 291 {
 292   if(MYDEBUG) MESSAGE("Begin of GetComponentIconeList");
 293
 294   SALOME_ModuleCatalog::ListOfIAPP_Affich_var _list_components_icone =
 295     new SALOME_ModuleCatalog::ListOfIAPP_Affich;
 296
 297   _list_components_icone->length(_personal_module_list.size());
 298
 299   // All the components defined in the personal catalog are taken
 300   for(unsigned int ind=0; ind < _personal_module_list.size();ind++){
 301     _list_components_icone[ind].modulename=(_personal_module_list[ind].name).c_str();
 302     _list_components_icone[ind].moduleusername=(_personal_module_list[ind].username).c_str();
 303     _list_components_icone[ind].moduleicone=(_personal_module_list[ind].icon).c_str();
 304     _list_components_icone[ind].moduleversion=(_personal_module_list[ind].version).c_str();
 305     _list_components_icone[ind].modulecomment=(_personal_module_list[ind].comment).c_str();
 306     //if(MYDEBUG) SCRUTE(_list_components_icone[ind].modulename);
 307     //if(MYDEBUG) SCRUTE(_list_components_icone[ind].moduleicone);
 308   }
 309
 310   int indice = _personal_module_list.size() ;
 311   bool _find = false;
 312
 313   // The components in the general catalog are taken only if they're
 314   // not defined in the personal catalog
 315   for(unsigned int ind=0; ind < _general_module_list.size();ind++){
 316     _find = false;
 317     for(unsigned int ind1=0; ind1 < _personal_module_list.size();ind1++){
 318       // searching if the component is aleready defined in
 319       // the personal catalog
 320       if((_general_module_list[ind].name.compare(_personal_module_list[ind1].name)) == 0)
 321         _find = true;
 322     }
 323     if(!_find){
 324       //          if(MYDEBUG) MESSAGE("A new component " << _general_module_list[ind].name << " has to be to added in the list");
 325       _list_components_icone->length(indice+1);
 326       // The component is not already defined => has to be taken
 327       _list_components_icone[indice].modulename=_general_module_list[ind].name.c_str();
 328       _list_components_icone[indice].moduleusername=_general_module_list[ind].username.c_str();
 329       _list_components_icone[indice].moduleicone=_general_module_list[ind].icon.c_str();
 330       _list_components_icone[indice].moduleversion=_general_module_list[ind].version.c_str();
 331       _list_components_icone[indice].modulecomment=_general_module_list[ind].comment.c_str();
 332       //if(MYDEBUG) SCRUTE(_list_components_icone[indice].modulename) ;
 333       //if(MYDEBUG) SCRUTE(_list_components_icone[indice].moduleicone);
 334
 335       indice++;
 336     }
 337     // else
 338     //if(MYDEBUG) MESSAGE("The component " <<_general_module_list[ind].name << " was already defined in the personal catalog");
 339   }
 340
 341   return _list_components_icone._retn() ;
 342 }
 343
 344 //----------------------------------------------------------------------
 345 // Function : GetTypedComponentList
 346 // Purpose  : get a component list of a wanted type
 347 //            If a component is defined in the personal catalog and
 348 //            in the general catalog (same name), the component defined
 349 //            in the personal catalog is used
 350 //----------------------------------------------------------------------
 351 SALOME_ModuleCatalog::ListOfComponents*
 352 SALOME_ModuleCatalogImpl::GetTypedComponentList(SALOME_ModuleCatalog::ComponentType component_type)
 353 {
 354   if(MYDEBUG) MESSAGE("Begin of GetTypedComponentList");
 355   SALOME_ModuleCatalog::ListOfComponents_var _list_typed_component =
 356     new SALOME_ModuleCatalog::ListOfComponents;
 357   int _j = 0;
 358
 359   _list_typed_component->length(0);
 360   // Transform SALOME_ModuleCatalog::ComponentType in ParserComponentType
 361   ParserComponentType _temp_component_type;
 362   switch(component_type){
 363   case SALOME_ModuleCatalog::GEOM:
 364     _temp_component_type = GEOM ;
 365     break;
 366   case SALOME_ModuleCatalog::MESH:
 367     _temp_component_type = MESH;
 368     break;
 369   case SALOME_ModuleCatalog::Med:
 370     _temp_component_type = Med;
 371     break;
 372   case SALOME_ModuleCatalog::SOLVER:
 373     _temp_component_type = SOLVER;
 374     break;
 375   case SALOME_ModuleCatalog::DATA:
 376     _temp_component_type = DATA;
 377     break;
 378   case SALOME_ModuleCatalog::VISU:
 379     _temp_component_type = VISU;
 380     break;
 381   case SALOME_ModuleCatalog::SUPERV:
 382     _temp_component_type = SUPERV;
 383     break;
 384   case SALOME_ModuleCatalog::OTHER:
 385     _temp_component_type = OTHER;
 386     break;
 387   }
 388
 389   // All the components in the personal catalog are taken
 390   for (unsigned int ind=0; ind < _personal_module_list.size();ind++)
 391     {
 392       if  (_personal_module_list[ind].type == _temp_component_type)
 393         {
 394           _list_typed_component->length(_j + 1);
 395           _list_typed_component[_j] = (_moduleList[ind].name).c_str();
 396           //if(MYDEBUG) SCRUTE(_list_typed_component[_j]);
 397           _j++;
 398         }
 399     }
 400
 401   int indice = _list_typed_component->length() ;
 402   bool _find = false;
 403
 404   // The components in the general catalog are taken only if they're
 405   // not defined in the personal catalog
 406   for (unsigned int ind=0; ind < _general_module_list.size();ind++)
 407     {
 408       _find = false;
 409
 410       if(_general_module_list[ind].type == _temp_component_type)
 411         {
 412           for (unsigned int ind1=0; ind1 < _personal_module_list.size();ind1++)
 413             {
 414               // searching if the component is aleready defined in
 415               // the personal catalog
 416               if ((_general_module_list[ind].name.compare(_personal_module_list[ind1].name)) == 0)
 417                 _find = true;
 418             }
 419           if (!_find)
 420             {
 421               //if(MYDEBUG) MESSAGE("A new component " << _general_module_list[ind].name << " has to be to added in the list");
 422               _list_typed_component->length(indice+1);
 423               // The component is not already defined => has to be taken
 424               _list_typed_component[indice]=(_general_module_list[ind].name).c_str();
 425               //if(MYDEBUG) SCRUTE(_list_typed_component[indice]) ;
 426
 427               indice++;
 428             }
 429           //else
 430             //if(MYDEBUG) MESSAGE("The component " <<_general_module_list[ind].name << " was already defined in the personal catalog") ;
 431         }
 432     }
 433
 434
 435   return _list_typed_component._retn();
 436 }
 437
 438 //----------------------------------------------------------------------
 439 // Function : GetComponent
 440 // Purpose  : get a component
 441 //            If a component is defined in the personal catalog and
 442 //            in the general catalog (same name), the component defined
 443 //            in the personal catalog is used
 444 //----------------------------------------------------------------------
 445 SALOME_ModuleCatalog::Acomponent_ptr
 446 SALOME_ModuleCatalogImpl::GetComponent(const char* name)
 447 {
 448   // Looking for component named "componentname" in the personal catalog
 449   // If found, get name, interfaces and constraint
 450   // If not found, looking for component named "componentname" in
 451   // the general catalog
 452   // If found, get name, interfaces and constraint
 453   // If not found, NULL pointer is returned
 454
 455   std::string s(name);
 456   ParserComponent *C_parser = NULL;
 457   ParserPathPrefixes *pp = NULL;
 458
 459   SALOME_ModuleCatalog::Acomponent_ptr compo = NULL;
 460
 461   C_parser = findComponent(s);
 462   if (C_parser) {
 463
 464 //    DebugParserComponent(*C_parser);
 465
 466     SALOME_ModuleCatalog::Component C_corba;
 467     duplicate(C_corba, *C_parser);
 468
 469
 470     SALOME_ModuleCatalog_AcomponentImpl * aComponentImpl =
 471       new SALOME_ModuleCatalog_AcomponentImpl(C_corba);
 472
 473     compo = aComponentImpl->_this();
 474   }
 475   else {
 476     // Not found in the personal catalog and in the general catalog
 477     // return NULL object
 478     if(MYDEBUG) MESSAGE("Component with name  " << name
 479                         << " not found in catalog");
 480     compo = NULL;
 481   }
 482
 483   return compo;
 484 }
 485
 486 SALOME_ModuleCatalog::Component *
 487 SALOME_ModuleCatalogImpl::GetComponentInfo(const char *name)
 488 {
 489   std::string s(name);
 490
 491   ParserComponent * C_parser = findComponent(s);
 492
 493   if (C_parser) {
 494
 495     SALOME_ModuleCatalog::Component * C_corba
 496       = new SALOME_ModuleCatalog::Component;
 497     duplicate(*C_corba, *C_parser);
 498     return C_corba;
 499   }
 500
 501   return NULL;
 502 }
 503
 504 ParserComponent *
 505 SALOME_ModuleCatalogImpl::findComponent(const string & name)
 506 {
 507   ParserComponent * C_parser = NULL;
 508
 509   if (!C_parser)
 510     for (unsigned int ind=0; ind < _personal_module_list.size();ind++)
 511       if (name.compare(_personal_module_list[ind].name) == 0)
 512         {
 513           if(MYDEBUG) MESSAGE("Component named " << name
 514                               << " found in the personal catalog");
 515           C_parser = &(_personal_module_list[ind]);
 516           break;
 517         }
 518
 519   if (!C_parser)
 520     for (unsigned int ind=0; ind < _general_module_list.size();ind++)
 521       {
 522         if (name.compare(_general_module_list[ind].name) == 0)
 523           {
 524             if(MYDEBUG) MESSAGE("Component named " << name
 525                                 << " found in the general catalog");
 526             C_parser = &(_general_module_list[ind]);
 527             break;
 528           }
 529       }
 530
 531   return C_parser;
 532 }
 533
 534 //----------------------------------------------------------------------
 535 // Function : _parse_xml_file
 536 // Purpose  : parse one module catalog
 537 //----------------------------------------------------------------------
 538 void
 539 SALOME_ModuleCatalogImpl::_parse_xml_file(const char* file,
 540                                           ParserComponents& modulelist,
 541                                           ParserPathPrefixes& pathList)
 542 {
 543   if(MYDEBUG) BEGIN_OF("_parse_xml_file");
 544   if(MYDEBUG) SCRUTE(file);
 545
 546   SALOME_ModuleCatalog_Handler* handler = new SALOME_ModuleCatalog_Handler();
 547   QFile xmlFile(file);
 548
 549   QXmlInputSource source(xmlFile);
 550
 551   QXmlSimpleReader reader;
 552   reader.setContentHandler( handler );
 553   reader.setErrorHandler( handler );
 554   reader.parse( source );
 555   xmlFile.close();
 556
 557   unsigned int i, j;
 558
 559   for ( i = 0; i < _moduleList.size(); i++) {
 560     for (j=0; j<modulelist.size(); j++) {
 561       if (modulelist[j].name == _moduleList[i].name)
 562         break;
 563     }
 564     if (j < modulelist.size())
 565       modulelist[j] = _moduleList[i];
 566     else
 567       modulelist.push_back(_moduleList[i]);
 568   }
 569
 570   for ( i=0; i < _pathList.size(); i++)
 571     pathList.push_back(_pathList[i]) ;
 572
 573   for (j=0; j<modulelist.size(); j++)
 574     modulelist[j].prefixes = pathList;
 575 }
 576
 577 void
 578 SALOME_ModuleCatalogImpl::ImportXmlCatalogFile(const char* file)
 579 {
 580   _parse_xml_file(file, _personal_module_list, _personal_path_list);
 581 }
 582
 583
 584 //
 585 //  Duplicate functions create a Corba structure (component,
 586 //  interface, service, parameter) from the corresponding C++
 587 //  parser structure
 588 //
 589
 590 //----------------------------------------------------------------------
 591 // Function : duplicate
 592 // Purpose  : create a component from the catalog parsing
 593 //----------------------------------------------------------------------
 594 void SALOME_ModuleCatalogImpl::duplicate
 595 (SALOME_ModuleCatalog::Component & C_corba,
 596  const ParserComponent & C_parser)
 597 {
 598   C_corba.name = CORBA::string_dup(C_parser.name.c_str());
 599   C_corba.username = CORBA::string_dup(C_parser.username.c_str());
 600   C_corba.multistudy = C_parser.multistudy;
 601   C_corba.icon = CORBA::string_dup(C_parser.icon.c_str());
 602   C_corba.type = ComponentTypeConvert[C_parser.type];
 603   C_corba.implementationType = C_parser.implementationType;
 604
 605   unsigned int _length = C_parser.interfaces.size();
 606   C_corba.interfaces.length(_length);
 607
 608   for (unsigned int ind = 0; ind < _length; ind++)
 609     duplicate(C_corba.interfaces[ind], C_parser.interfaces[ind]);
 610 }
 611
 612
 613 //----------------------------------------------------------------------
 614 // Function : duplicate
 615 // Purpose  : create an interface from the catalog parsing
 616 //----------------------------------------------------------------------
 617 void SALOME_ModuleCatalogImpl::duplicate
 618 (SALOME_ModuleCatalog::DefinitionInterface & I_corba,
 619  const ParserInterface & I_parser)
 620 {
 621   //duplicate interface name
 622   I_corba.interfacename = CORBA::string_dup(I_parser.name.c_str());
 623
 624   // duplicate service list
 625   unsigned int _length = I_parser.services.size();
 626   if(MYDEBUG) SCRUTE(_length);
 627   //  I_corba.interfaceservicelist
 628   //  = new SALOME_ModuleCatalog::ListOfInterfaceService;
 629   I_corba.interfaceservicelist.length(_length);
 630
 631   for (unsigned int ind1 = 0; ind1 < _length ; ind1 ++)
 632     duplicate(I_corba.interfaceservicelist[ind1],
 633               I_parser.services[ind1]);
 634 }
 635
 636 //----------------------------------------------------------------------
 637 // Function : duplicate
 638 // Purpose  : create a service from the catalog parsing
 639 //----------------------------------------------------------------------
 640 void SALOME_ModuleCatalogImpl::duplicate
 641 (SALOME_ModuleCatalog::Service & S_corba,
 642  const ParserService & S_parser)
 643 {
 644   // duplicate service name
 645   S_corba.ServiceName = CORBA::string_dup(S_parser.name.c_str());
 646
 647   // duplicate service by default
 648   S_corba.Servicebydefault = S_parser.byDefault;
 649
 650   S_corba.TypeOfNode = S_parser.typeOfNode;
 651
 652   unsigned int _length;
 653
 654   // duplicate in Parameters
 655   _length = S_parser.inParameters.size();
 656   S_corba.ServiceinParameter.length(_length);
 657
 658   for (unsigned int ind2 = 0; ind2 < _length ; ind2 ++)
 659     duplicate(S_corba.ServiceinParameter[ind2],
 660               S_parser.inParameters[ind2]);
 661
 662   // duplicate out Parameters
 663   _length = S_parser.outParameters.size();
 664   S_corba.ServiceoutParameter.length(_length);
 665
 666   for (unsigned int ind2 = 0; ind2 < _length ; ind2 ++)
 667     duplicate(S_corba.ServiceoutParameter[ind2],
 668               S_parser.outParameters[ind2]);
 669
 670   // duplicate in DataStreamParameters
 671   _length = S_parser.inDataStreamParameters.size();
 672   S_corba.ServiceinDataStreamParameter.length(_length);
 673
 674   for (unsigned int ind2 = 0; ind2 < _length ; ind2 ++)
 675     duplicate(S_corba.ServiceinDataStreamParameter[ind2],
 676               S_parser.inDataStreamParameters[ind2]);
 677
 678   // duplicate out DataStreamParameters
 679   _length = S_parser.outDataStreamParameters.size();
 680   if(MYDEBUG) SCRUTE(_length);
 681   S_corba.ServiceoutDataStreamParameter.length(_length);
 682
 683   for (unsigned int ind2 = 0; ind2 < _length ; ind2 ++)
 684     duplicate(S_corba.ServiceoutDataStreamParameter[ind2],
 685               S_parser.outDataStreamParameters[ind2]);
 686 }
 687
 688 //----------------------------------------------------------------------
 689 // Function : duplicate
 690 // Purpose  : create a service parameter from the catalog parsing
 691 //----------------------------------------------------------------------
 692 void SALOME_ModuleCatalogImpl::duplicate
 693 (SALOME_ModuleCatalog::ServicesParameter & P_corba,
 694  const ParserParameter & P_parser)
 695 {
 696   // duplicate parameter name
 697   P_corba.Parametername = CORBA::string_dup(P_parser.name.c_str());
 698
 699   // duplicate parameter type
 700   P_corba.Parametertype = CORBA::string_dup(P_parser.type.c_str());
 701 }
 702
 703
 704 //----------------------------------------------------------------------
 705 // Function : duplicate
 706 // Purpose  : create a service datastream parameter from the catalog parsing
 707 //----------------------------------------------------------------------
 708 void SALOME_ModuleCatalogImpl::duplicate
 709 (SALOME_ModuleCatalog::ServicesDataStreamParameter & P_corba,
 710  const ParserDataStreamParameter & P_parser)
 711 {
 712   std::map < std::string,
 713     SALOME_ModuleCatalog::DataStreamType >::const_iterator it_type;
 714
 715   std::map < std::string,
 716     SALOME_ModuleCatalog::DataStreamDependency >::const_iterator it_dep;
 717
 718   // duplicate parameter name
 719   P_corba.Parametername = CORBA::string_dup(P_parser.name.c_str());
 720
 721   // doesn't work ???
 722   //   it_type = DataStreamTypeConvert.find(P_parser.type);
 723   //   P_corba.Parametertype
 724   //     = (it_type == DataStreamTypeConvert.end())
 725   //     ? it_type->second : SALOME_ModuleCatalog::DATASTREAM_UNKNOWN;
 726
 727   if(MYDEBUG) SCRUTE(P_parser.type);
 728   P_corba.Parametertype = SALOME_ModuleCatalog::DATASTREAM_UNKNOWN;
 729   for (it_type = DataStreamTypeConvert.begin();
 730        it_type != DataStreamTypeConvert.end();
 731        it_type++)
 732     if (P_parser.type.compare(it_type->first) == 0) {
 733       P_corba.Parametertype = it_type->second;
 734       break;
 735     }
 736   if(MYDEBUG) SCRUTE(P_corba.Parametertype);
 737
 738   // duplicate parameter type
 739
 740   // doesn't work ???
 741   //   it_type = DataStreamTypeConvert.find(P_parser.type);
 742   //   P_corba.Parametertype
 743   //     = (it_type == DataStreamTypeConvert.end())
 744   //     ? it_type->second : SALOME_ModuleCatalog::DATASTREAM_UNKNOWN;
 745
 746   if(MYDEBUG) SCRUTE(P_parser.dependency);
 747   P_corba.Parameterdependency = SALOME_ModuleCatalog::DATASTREAM_UNDEFINED;
 748   for (it_dep = DataStreamDepConvert.begin();
 749        it_dep != DataStreamDepConvert.end();
 750        it_dep++)
 751     if (P_parser.dependency.compare(it_dep->first) == 0) {
 752       P_corba.Parameterdependency = it_dep->second;
 753       break;
 754     }
 755
 756   if(MYDEBUG) SCRUTE(P_corba.Parameterdependency);
 757 }
 758
 759 //----------------------------------------------------------------------
 760 // Function : duplicate
 761 // Purpose  : create the path prefix structures from the catalog parsing
 762 //----------------------------------------------------------------------
 763 void
 764 SALOME_ModuleCatalogImpl::duplicate(ParserPathPrefixes &L_out,
 765                                     const ParserPathPrefixes &L_in)
 766 {
 767   L_out = L_in;
 768 }
 769
 770
 771 //----------------------------------------------------------------------
 772 // Function : _verify_path_prefix
 773 // Purpose  : verify the path prefix structures from the catalog parsing
 774 //            Verify that there only one path prefix associated to a
 775 //            particular computer
 776 //----------------------------------------------------------------------
 777 bool
 778 SALOME_ModuleCatalogImpl::_verify_path_prefix(ParserPathPrefixes & pathList)
 779 {
 780   bool _return_value = true;
 781   vector<string> _machine_list;
 782
 783   // Fill a list of all computers indicated in the path list
 784   for (unsigned int ind = 0; ind < pathList.size(); ind++)
 785     {
 786       for (unsigned int ind1 = 0 ; ind1 < pathList[ind].listOfComputer.size(); ind1++)
 787         {
 788           _machine_list.push_back(pathList[ind].listOfComputer[ind1]);
 789         }
 790     }
 791
 792   // Parse if a computer name is twice in the list of computers
 793   for (unsigned int ind = 0; ind < _machine_list.size(); ind++)
 794     {
 795      for (unsigned int ind1 = ind+1 ; ind1 < _machine_list.size(); ind1++)
 796        {
 797          if(_machine_list[ind].compare(_machine_list[ind1]) == 0)
 798            {
 799              if(MYDEBUG) MESSAGE( "The computer " << _machine_list[ind] << " is indicated more than once in the path list");
 800              _return_value = false;
 801            }
 802        }
 803     }
 804   return _return_value;
 805 }
 806
 807
 808 //----------------------------------------------------------------------
 809 // Function : _parseArguments
 810 // Purpose  : parse arguments to get general and personal catalog files
 811 //----------------------------------------------------------------------
 812 bool
 813 SALOME_ModuleCatalogImpl::_parseArguments(int argc, char **argv,
 814                                           char **_general,
 815                                           char** _personal)
 816 {
 817   bool _return_value = true;
 818   *_general = NULL;
 819   *_personal = NULL ;
 820   for (int ind = 0; ind < argc ; ind++)
 821     {
 822
 823       if (strcmp(argv[ind],"-help") == 0)
 824         {
 825           INFOS( "Usage: " << argv[0]
 826                  << " -common 'path to general catalog' "
 827                  " -personal 'path to personal catalog' "
 828                  " -ORBInitRef NameService=corbaname::localhost");
 829             _return_value = false ;
 830         }
 831
 832       if (strcmp(argv[ind],"-common") == 0)
 833         {
 834           if (ind + 1 < argc)
 835             {
 836               // General catalog file
 837               *_general = argv[ind + 1] ;
 838             }
 839         }
 840       else if (strcmp(argv[ind],"-personal") == 0)
 841         {
 842           if (ind + 1 < argc)
 843             {
 844               // Personal catalog file
 845               *_personal = argv[ind + 1] ;
 846             }
 847         }
 848     }
 849   return _return_value;
 850 }
 851
 852