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 long Superv_Component_i::dscTimeOut=0;
  40
  41
  42 Superv_Component_i::Superv_Component_i(CORBA::ORB_ptr orb,
  43                                        PortableServer::POA_ptr poa,
  44                                        PortableServer::ObjectId * contId,
  45                                        const char *instanceName,
  46                                        const char *interfaceName,
  47                                        bool notif) :
  48   Engines_DSC_i(orb, poa, contId, instanceName, interfaceName)
  49 {
  50 #ifdef MYDEBUG
  51   std::cerr << "--Superv_Component_i : MARK 1 ----  " << instanceName << "----" << std::endl;
  52 #endif
  53   setTimeOut();
  54 }
  55 Superv_Component_i::Superv_Component_i(CORBA::ORB_ptr orb,
  56                                        PortableServer::POA_ptr poa,
  57                                        Engines::Container_ptr container,
  58                                        const char *instanceName,
  59                                        const char *interfaceName,
  60                                        bool notif,
  61                                        bool regist) :
  62   Engines_DSC_i(orb, poa, container, instanceName, interfaceName,notif,regist)
  63 {
  64 #ifdef MYDEBUG
  65   std::cerr << "--Superv_Component_i : MARK 1 ----  " << instanceName << "----" << std::endl;
  66 #endif
  67   setTimeOut();
  68 }
  69
  70
  71 Superv_Component_i::~Superv_Component_i()
  72 {
  73   my_superv_ports_it = my_superv_ports.begin();
  74   for(;my_superv_ports_it != my_superv_ports.end();my_superv_ports_it++)
  75     delete my_superv_ports_it->second;
  76 }
  77
  78 void
  79 Superv_Component_i::register_factory(const std::string & factory_name,
  80                                      port_factory * factory_ptr)
  81 {
  82   factory_map_t::iterator it = _factory_map.find(factory_name);
  83
  84   if (it == _factory_map.end() )
  85   {
  86     _factory_map[factory_name] = factory_ptr;
  87   }
  88 }
  89
  90 port_factory *
  91 Superv_Component_i::get_factory(const std::string & factory_name)
  92 {
  93   port_factory * rtn_factory = NULL;
  94   factory_map_t::iterator it = _factory_map.find(factory_name);
  95
  96   if (it != _factory_map.end() )
  97   {
  98     rtn_factory = _factory_map[factory_name];
  99   }
 100
 101   return rtn_factory;
 102 }
 103
 104 provides_port *
 105 Superv_Component_i::create_provides_data_port(const std::string& port_fab_type)
 106   throw (BadFabType)
 107 {
 108   provides_port * rtn_port = NULL;
 109   std::string factory_name;
 110   std::string type_name;
 111   int search_result;
 112
 113   search_result = port_fab_type.find("_");
 114   factory_name = port_fab_type.substr(0,search_result);
 115   type_name = port_fab_type.substr(search_result+1, port_fab_type.length());
 116
 117   port_factory * factory = get_factory(factory_name);
 118   if (factory) {
 119     rtn_port = factory->create_data_servant(type_name);
 120   }
 121
 122   if (rtn_port == NULL)
 123     throw  BadFabType( LOC(OSS()<< "No way to get the port factory "
 124                            <<port_fab_type));
 125
 126   return rtn_port;
 127 }
 128
 129 uses_port *
 130 Superv_Component_i::create_uses_data_port(const std::string& port_fab_type)
 131 throw (BadFabType)
 132 {
 133   uses_port * rtn_proxy = NULL;
 134   std::string factory_name;
 135   std::string type_name;
 136   int search_result;
 137
 138   search_result = port_fab_type.find("_");
 139   factory_name = port_fab_type.substr(0,search_result);
 140   type_name = port_fab_type.substr(search_result+1, port_fab_type.length());
 141
 142   port_factory * factory = get_factory(factory_name);
 143   if (factory) {
 144     rtn_proxy = factory->create_data_proxy(type_name);
 145   }
 146
 147   if (rtn_proxy == NULL)
 148    throw BadFabType( LOC(OSS()<< "No way to get the port factory "
 149                           <<port_fab_type));
 150
 151   return rtn_proxy;
 152 }
 153
 154 void
 155 Superv_Component_i::add_port(const char * port_fab_type,
 156                              const char * port_type,
 157                              const char * port_name)
 158   throw (PortAlreadyDefined, BadFabType, BadType, BadProperty)
 159 {
 160   assert(port_fab_type);
 161   assert(port_type);
 162   assert(port_name);
 163
 164   std::string s_port_type(port_type);
 165   if (s_port_type == "provides") {
 166     provides_port * port = create_provides_data_port(port_fab_type);
 167     add_port(port, port_name);
 168   }
 169   else if (s_port_type == "uses") {
 170 #ifdef MYDEBUG
 171     std::cerr << "---- Superv_Component_i::add_port : MARK 1 ---- "  << std::endl;
 172 #endif
 173     uses_port * port = create_uses_data_port(port_fab_type);
 174 #ifdef MYDEBUG
 175     std::cerr << "---- Superv_Component_i::add_port : MARK 2 ---- "  << std::endl;
 176 #endif
 177     add_port(port, port_name);
 178   }
 179   else
 180     throw BadType( LOC(OSS()<< "port_type must be either 'provides' either 'uses' not "
 181                        << port_type));
 182
 183 }
 184
 185 void
 186 Superv_Component_i::add_port(provides_port * port,
 187                              const char* provides_port_name)
 188   throw (PortAlreadyDefined, NilPort, BadProperty)
 189 {
 190   assert(port);
 191   assert(provides_port_name);
 192
 193   try {
 194
 195     Ports::PortProperties_var portproperties=port->get_port_properties();
 196     Ports::Port_var portref=port->get_port_ref();
 197     Engines_DSC_interface::add_provides_port(portref,
 198                                              provides_port_name,
 199                                              portproperties);
 200
 201     superv_port_t * new_superv_port = new superv_port_t();
 202     new_superv_port->p_ref = port;
 203     my_superv_ports[provides_port_name] = new_superv_port;
 204
 205   }
 206   catch (const Engines::DSC::PortAlreadyDefined&) {
 207     throw PortAlreadyDefined( LOC(OSS()<< "provides port "
 208                                   << provides_port_name <<" already exist."));
 209   }
 210   catch (const Engines::DSC::NilPort&) {
 211     throw NilPort( LOC(OSS()<< "provides port pointer is nul."));
 212   }
 213   catch (const Engines::DSC::BadProperty&) {
 214     throw BadProperty( LOC(OSS()<< "Property is not well defined"));
 215   }
 216 }
 217
 218 void
 219 Superv_Component_i::add_port(uses_port * port,
 220                              const char* uses_port_name)
 221   throw (PortAlreadyDefined, NilPort, BadProperty)
 222 {
 223   assert(port);
 224   assert(uses_port_name);
 225
 226   try {
 227     Ports::PortProperties_var portproperties=port->get_port_properties();
 228     Engines_DSC_interface::add_uses_port(port->get_repository_id(),
 229                                          uses_port_name,
 230                                          portproperties);
 231     superv_port_t * new_superv_port = new superv_port_t();
 232     new_superv_port->u_ref = port;
 233     my_superv_ports[uses_port_name] = new_superv_port;
 234   }
 235   catch (const Engines::DSC::PortAlreadyDefined&) {
 236     throw PortAlreadyDefined( LOC(OSS()<< "uses port "
 237                                   << uses_port_name <<" already exists."));
 238   }
 239   catch (const Engines::DSC::NilPort&) {
 240     throw NilPort( LOC(OSS()<< "uses port pointer is nul."));
 241   }
 242   catch (const Engines::DSC::BadProperty&) {
 243     throw BadProperty( LOC(OSS()<< "Property is not well defined"));
 244   }
 245 }
 246
 247 void
 248 Superv_Component_i::get_port(provides_port *& port,
 249                              const char * provides_port_name)
 250   throw (PortNotDefined,PortNotConnected)
 251 {
 252   assert(provides_port_name);
 253
 254   try {
 255     Ports::Port_var portref=Engines_DSC_interface::get_provides_port(provides_port_name, false);
 256     port = my_superv_ports[provides_port_name]->p_ref;
 257   } catch (const Engines::DSC::PortNotDefined&) {
 258     throw PortNotDefined( LOC(OSS()<< "provides  port "
 259                               << provides_port_name <<" does not exist."));
 260   } catch (const Engines::DSC::PortNotConnected&) {
 261     throw PortNotConnected( LOC(OSS()<< "provides port " << provides_port_name
 262                                 << " is not connected."));
 263   }
 264 }
 265
 266 void
 267 Superv_Component_i::get_port(uses_port *& port,
 268                              const char * uses_port_name)
 269   throw (PortNotDefined, PortNotConnected)
 270 {
 271   assert(uses_port_name);
 272
 273   try {
 274     Engines::DSC::uses_port * portseq=Engines_DSC_i::get_uses_port(uses_port_name);
 275     delete portseq;
 276     port = my_superv_ports[uses_port_name]->u_ref;
 277   } catch (const Engines::DSC::PortNotDefined&) {
 278     throw PortNotDefined( LOC(OSS()<< "uses port "
 279                               << uses_port_name <<" does not exist."));
 280   } catch (const Engines::DSC::PortNotConnected&) {
 281     throw PortNotConnected( LOC(OSS()<< "uses port " << uses_port_name
 282                                 << " is not connected."));
 283   }
 284 }
 285
 286
 287
 288 void
 289 Superv_Component_i::provides_port_changed(const char* provides_port_name,
 290                                           int connection_nbr,
 291                                           const Engines::DSC::Message message)
 292 {
 293   my_superv_ports_it = my_superv_ports.find(provides_port_name);
 294   if (my_superv_ports_it !=  my_superv_ports.end())
 295     my_superv_ports[provides_port_name]->p_ref->provides_port_changed(connection_nbr,
 296                                                                       message);
 297 }
 298
 299 void
 300 Superv_Component_i::uses_port_changed(const char* uses_port_name,
 301                                       Engines::DSC::uses_port * new_uses_port,
 302                                       const Engines::DSC::Message message)
 303 {
 304   my_superv_ports_it = my_superv_ports.find(uses_port_name);
 305   if (my_superv_ports_it !=  my_superv_ports.end())
 306     my_superv_ports[uses_port_name]->u_ref->uses_port_changed(new Engines::DSC::uses_port(*new_uses_port),
 307                                                               message);
 308   //delete the copy made by the caller
 309   delete new_uses_port;
 310 }
 311
 312
 313
 314 void
 315 Superv_Component_i::get_uses_port_names(std::vector<std::string> & port_names,
 316                                         const std::string servicename) const {
 317
 318   port_names.reserve(my_superv_ports.size());
 319
 320   superv_ports::const_iterator it;
 321
 322   for (it=my_superv_ports.begin(); it!=my_superv_ports.end();++it)
 323     if( (*it).second->p_ref == NULL ) port_names.push_back((*it).first);
 324 }
 325
 326 void Superv_Component_i::setTimeOut()
 327 {
 328   char* valenv=getenv("DSC_TIMEOUT");
 329   if(valenv)
 330     {
 331       std::istringstream iss(valenv);
 332       long temp;
 333       if (iss >> temp)
 334         if(temp >=0)
 335           Superv_Component_i::dscTimeOut=temp;
 336     }
 337 }
 338
 339 void Superv_Component_i::beginService(const char *serviceName)
 340 {
 341   Engines_DSC_i::beginService(serviceName);
 342   setTimeOut();
 343 }