src/DSC/DSC_User/Superv_Component_i.cxx

   1 //  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 //  Copyright (C) 2003-2007  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.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 //  File   : Superv_Component_i.cxx
  23 //  Author : André RIBES (EDF), Eric Fayolle (EDF)
  24 //  Module : KERNEL
  25 //
  26 #include "Superv_Component_i.hxx"
  27
  28 DSC_EXCEPTION_CXX(Superv_Component_i,BadFabType);
  29 DSC_EXCEPTION_CXX(Superv_Component_i,BadType);
  30 DSC_EXCEPTION_CXX(Superv_Component_i,BadCast);
  31 DSC_EXCEPTION_CXX(Superv_Component_i,UnexpectedState);
  32 DSC_EXCEPTION_CXX(Superv_Component_i,PortAlreadyDefined);
  33 DSC_EXCEPTION_CXX(Superv_Component_i,PortNotDefined);
  34 DSC_EXCEPTION_CXX(Superv_Component_i,PortNotConnected);
  35 DSC_EXCEPTION_CXX(Superv_Component_i,NilPort);
  36 DSC_EXCEPTION_CXX(Superv_Component_i,BadProperty);
  37
  38 std::map<std::string, port_factory*> Superv_Component_i::_factory_map;
  39
  40 Superv_Component_i::Superv_Component_i(CORBA::ORB_ptr orb,
  41                                        PortableServer::POA_ptr poa,
  42                                        PortableServer::ObjectId * contId,
  43                                        const char *instanceName,
  44                                        const char *interfaceName,
  45                                        bool notif) :
  46   Engines_DSC_i(orb, poa, contId, instanceName, interfaceName)
  47 {
  48 #ifdef _DEBUG_
  49   std::cerr << "--Superv_Component_i : MARK 1 ----  " << instanceName << "----" << std::endl;
  50 #endif
  51 }
  52 Superv_Component_i::Superv_Component_i(CORBA::ORB_ptr orb,
  53                                        PortableServer::POA_ptr poa,
  54                                        Engines::Container_ptr container,
  55                                        const char *instanceName,
  56                                        const char *interfaceName,
  57                                        bool notif,
  58                                        bool regist) :
  59   Engines_DSC_i(orb, poa, container, instanceName, interfaceName,notif,regist)
  60 {
  61 #ifdef _DEBUG_
  62   std::cerr << "--Superv_Component_i : MARK 1 ----  " << instanceName << "----" << std::endl;
  63 #endif
  64 }
  65
  66
  67 Superv_Component_i::~Superv_Component_i()
  68 {
  69   my_superv_ports_it = my_superv_ports.begin();
  70   for(;my_superv_ports_it != my_superv_ports.end();my_superv_ports_it++)
  71     delete my_superv_ports_it->second;
  72 }
  73
  74 void
  75 Superv_Component_i::register_factory(const std::string & factory_name,
  76                                      port_factory * factory_ptr)
  77 {
  78   factory_map_t::iterator it = _factory_map.find(factory_name);
  79
  80   if (it == _factory_map.end() )
  81   {
  82     _factory_map[factory_name] = factory_ptr;
  83   }
  84 }
  85
  86 port_factory *
  87 Superv_Component_i::get_factory(const std::string & factory_name)
  88 {
  89   port_factory * rtn_factory = NULL;
  90   factory_map_t::iterator it = _factory_map.find(factory_name);
  91
  92   if (it != _factory_map.end() )
  93   {
  94     rtn_factory = _factory_map[factory_name];
  95   }
  96
  97   return rtn_factory;
  98 }
  99
 100 provides_port *
 101 Superv_Component_i::create_provides_data_port(const std::string& port_fab_type)
 102   throw (BadFabType)
 103 {
 104   provides_port * rtn_port = NULL;
 105   std::string factory_name;
 106   std::string type_name;
 107   int search_result;
 108
 109   search_result = port_fab_type.find("_");
 110   factory_name = port_fab_type.substr(0,search_result);
 111   type_name = port_fab_type.substr(search_result+1, port_fab_type.length());
 112
 113   port_factory * factory = get_factory(factory_name);
 114   if (factory) {
 115     rtn_port = factory->create_data_servant(type_name);
 116   }
 117
 118   if (rtn_port == NULL)
 119     throw  BadFabType( LOC(OSS()<< "Impossible d'accéder à la fabrique "
 120                            <<port_fab_type));
 121
 122   return rtn_port;
 123 }
 124
 125 uses_port *
 126 Superv_Component_i::create_uses_data_port(const std::string& port_fab_type)
 127 throw (BadFabType)
 128 {
 129   uses_port * rtn_proxy = NULL;
 130   std::string factory_name;
 131   std::string type_name;
 132   int search_result;
 133
 134   search_result = port_fab_type.find("_");
 135   factory_name = port_fab_type.substr(0,search_result);
 136   type_name = port_fab_type.substr(search_result+1, port_fab_type.length());
 137
 138   port_factory * factory = get_factory(factory_name);
 139   if (factory) {
 140     rtn_proxy = factory->create_data_proxy(type_name);
 141   }
 142
 143   if (rtn_proxy == NULL)
 144    throw BadFabType( LOC(OSS()<< "Impossible d'accéder à la fabrique "
 145                           <<port_fab_type));
 146
 147   return rtn_proxy;
 148 }
 149
 150 void
 151 Superv_Component_i::add_port(const char * port_fab_type,
 152                              const char * port_type,
 153                              const char * port_name)
 154   throw (PortAlreadyDefined, BadFabType, BadType, BadProperty)
 155 {
 156   assert(port_fab_type);
 157   assert(port_type);
 158   assert(port_name);
 159
 160   std::string s_port_type(port_type);
 161   if (s_port_type == "provides") {
 162     provides_port * port = create_provides_data_port(port_fab_type);
 163     add_port(port, port_name);
 164   }
 165   else if (s_port_type == "uses") {
 166 #ifdef _DEBUG_
 167     std::cerr << "---- Superv_Component_i::add_port : MARK 1 ---- "  << std::endl;
 168 #endif
 169     uses_port * port = create_uses_data_port(port_fab_type);
 170 #ifdef _DEBUG_
 171     std::cerr << "---- Superv_Component_i::add_port : MARK 2 ---- "  << std::endl;
 172 #endif
 173     add_port(port, port_name);
 174   }
 175   else
 176     throw BadType( LOC(OSS()<< "Le port_type doit être soit 'provides' soit 'uses' not "
 177                        << port_type));
 178
 179 }
 180
 181 void
 182 Superv_Component_i::add_port(provides_port * port,
 183                              const char* provides_port_name)
 184   throw (PortAlreadyDefined, NilPort, BadProperty)
 185 {
 186   assert(port);
 187   assert(provides_port_name);
 188
 189   try {
 190
 191     Ports::PortProperties_var portproperties=port->get_port_properties();
 192     Ports::Port_var portref=port->get_port_ref();
 193     Engines_DSC_interface::add_provides_port(portref,
 194                                              provides_port_name,
 195                                              portproperties);
 196
 197     superv_port_t * new_superv_port = new superv_port_t();
 198     new_superv_port->p_ref = port;
 199     my_superv_ports[provides_port_name] = new_superv_port;
 200
 201   }
 202   catch (const Engines::DSC::PortAlreadyDefined&) {
 203     throw PortAlreadyDefined( LOC(OSS()<< "Le port provides "
 204                                   << provides_port_name <<" existe déjà."));
 205   }
 206   catch (const Engines::DSC::NilPort&) {
 207     throw NilPort( LOC(OSS()<< "Le pointeur sur port provides est nul."));
 208   }
 209   catch (const Engines::DSC::BadProperty&) {
 210     throw BadProperty( LOC(OSS()<< "La propriété est mal définie"));
 211   }
 212 }
 213
 214 void
 215 Superv_Component_i::add_port(uses_port * port,
 216                              const char* uses_port_name)
 217   throw (PortAlreadyDefined, NilPort, BadProperty)
 218 {
 219   assert(port);
 220   assert(uses_port_name);
 221
 222   try {
 223     Ports::PortProperties_var portproperties=port->get_port_properties();
 224     Engines_DSC_interface::add_uses_port(port->get_repository_id(),
 225                                          uses_port_name,
 226                                          portproperties);
 227     superv_port_t * new_superv_port = new superv_port_t();
 228     new_superv_port->u_ref = port;
 229     my_superv_ports[uses_port_name] = new_superv_port;
 230   }
 231   catch (const Engines::DSC::PortAlreadyDefined&) {
 232     throw PortAlreadyDefined( LOC(OSS()<< "Le port uses "
 233                                   << uses_port_name <<" existe déjà."));
 234   }
 235   catch (const Engines::DSC::NilPort&) {
 236     throw NilPort( LOC(OSS()<< "Le pointeur sur port uses est nul."));
 237   }
 238   catch (const Engines::DSC::BadProperty&) {
 239     throw BadProperty( LOC(OSS()<< "La propriété est mal définie"));
 240   }
 241 }
 242
 243 void
 244 Superv_Component_i::get_port(provides_port *& port,
 245                              const char * provides_port_name)
 246   throw (PortNotDefined,PortNotConnected)
 247 {
 248   assert(provides_port_name);
 249
 250   try {
 251     Ports::Port_var portref=Engines_DSC_interface::get_provides_port(provides_port_name, false);
 252     port = my_superv_ports[provides_port_name]->p_ref;
 253   } catch (const Engines::DSC::PortNotDefined&) {
 254     throw PortNotDefined( LOC(OSS()<< "Le port provides  "
 255                               << provides_port_name <<" n'existe pas."));
 256   } catch (const Engines::DSC::PortNotConnected&) {
 257     throw PortNotConnected( LOC(OSS()<< "Le port provides " << provides_port_name
 258                                 << " n'est pas connecté."));
 259   }
 260 }
 261
 262 void
 263 Superv_Component_i::get_port(uses_port *& port,
 264                              const char * uses_port_name)
 265   throw (PortNotDefined, PortNotConnected)
 266 {
 267   assert(uses_port_name);
 268
 269   try {
 270     Engines::DSC::uses_port * portseq=Engines_DSC_i::get_uses_port(uses_port_name);
 271     delete portseq;
 272     port = my_superv_ports[uses_port_name]->u_ref;
 273   } catch (const Engines::DSC::PortNotDefined&) {
 274     throw PortNotDefined( LOC(OSS()<< "Le port uses  "
 275                               << uses_port_name <<" n'existe pas."));
 276   } catch (const Engines::DSC::PortNotConnected&) {
 277     throw PortNotConnected( LOC(OSS()<< "Le port uses " << uses_port_name
 278                                 << " n'est pas connecté."));
 279   }
 280 }
 281
 282
 283
 284 void
 285 Superv_Component_i::provides_port_changed(const char* provides_port_name,
 286                                           int connection_nbr,
 287                                           const Engines::DSC::Message message)
 288 {
 289   my_superv_ports_it = my_superv_ports.find(provides_port_name);
 290   if (my_superv_ports_it !=  my_superv_ports.end())
 291     my_superv_ports[provides_port_name]->p_ref->provides_port_changed(connection_nbr,
 292                                                                       message);
 293 }
 294
 295 void
 296 Superv_Component_i::uses_port_changed(const char* uses_port_name,
 297                                       Engines::DSC::uses_port * new_uses_port,
 298                                       const Engines::DSC::Message message)
 299 {
 300   my_superv_ports_it = my_superv_ports.find(uses_port_name);
 301   if (my_superv_ports_it !=  my_superv_ports.end())
 302     my_superv_ports[uses_port_name]->u_ref->uses_port_changed(new Engines::DSC::uses_port(*new_uses_port),
 303                                                               message);
 304   //delete the copy made by the caller
 305   delete new_uses_port;
 306 }
 307
 308
 309
 310 void
 311 Superv_Component_i::get_uses_port_names(std::vector<std::string> & port_names,
 312                                         const std::string servicename) const {
 313
 314   port_names.reserve(my_superv_ports.size());
 315
 316   superv_ports::const_iterator it;
 317
 318   for (it=my_superv_ports.begin(); it!=my_superv_ports.end();++it)
 319     if( (*it).second->p_ref == NULL ) port_names.push_back((*it).first);
 320 }