Version: 7.8.0
Superv_Component_i.hxx
Go to the documentation of this file.
1 // Copyright (C) 2007-2016 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, or (at your option) any later version.
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 
23 // File : Superv_Component_i.hxx
24 // Author : André RIBES (EDF), Eric Fayolle (EDF)
25 // Module : KERNEL
26 //
27 #ifndef _SUPERV_COMPONENT_I_HXX_
28 #define _SUPERV_COMPONENT_I_HXX_
29 
30 #include "DSC_i.hxx"
31 #include "base_port.hxx"
32 #include "uses_port.hxx"
33 #include "provides_port.hxx"
34 #include "port_factory.hxx"
35 
36 #include "DSC_Exception.hxx"
37 #include <vector>
38 
39 //#define MYDEBUG
40 
54  public Engines_DSC_i,
55  virtual public POA_Engines::Superv_Component
56 {
57 public:
58  Superv_Component_i(CORBA::ORB_ptr orb,
59  PortableServer::POA_ptr poa,
60  PortableServer::ObjectId * contId,
61  const char *instanceName,
62  const char *interfaceName,
63  bool notif = false);
64  Superv_Component_i(CORBA::ORB_ptr orb,
65  PortableServer::POA_ptr poa,
66  Engines::Container_ptr container,
67  const char *instanceName,
68  const char *interfaceName,
69  bool notif = false,
70  bool regist = true );
71  virtual ~Superv_Component_i();
72 
73  // Exceptions declarations.
74  // There are defined on the Superv_Component_i.cxx to avoid problems
75  // from dlopen.
85 
90  {return NULL;}
91 
96  {return NULL;}
97 
102  {return NULL;}
103 
108  {return NULL;}
109 
120  virtual provides_port * create_provides_data_port(const std::string& port_fab_type)
121  throw (BadFabType);
122 
123 
134  virtual uses_port * create_uses_data_port(const std::string& port_fab_type)
135  throw (BadFabType);
136 
145  virtual void add_port(const char * port_fab_type,
146  const char * port_type,
147  const char * port_name)
148  throw (PortAlreadyDefined, BadFabType, BadType, BadProperty);
149 
159  template < typename SpecificPortType >
160  SpecificPortType * add_port(const char * port_fab_type,
161  const char * port_type,
162  const char * port_name)
163  throw (PortAlreadyDefined, BadFabType, BadType, BadCast, BadProperty);
164 
171  virtual void add_port(provides_port * port,
172  const char* provides_port_name)
173  throw (PortAlreadyDefined, NilPort, BadProperty);
174 
181  virtual void add_port(uses_port * port,
182  const char* uses_port_name)
183  throw (PortAlreadyDefined, NilPort, BadProperty);
184 
191  virtual void get_port(provides_port *& port,
192  const char* provides_port_name)
193  throw (PortNotDefined, PortNotConnected);
194 
201  virtual void get_port(uses_port *& port,
202  const char* uses_port_name)
203  throw (PortNotDefined, PortNotConnected);
204 
213  virtual void get_uses_port_names(std::vector<std::string> & port_names,
214  const std::string servicename="") const;
215 
222  template <typename SpecificPortType >
223  SpecificPortType * get_port( const char * port_name)
224  throw (PortNotDefined, PortNotConnected, BadCast, UnexpectedState);
225 
229  virtual void provides_port_changed(const char* provides_port_name,
230  int connection_nbr,
231  const Engines::DSC::Message message);
232 
236  virtual void uses_port_changed(const char* uses_port_name,
237  Engines::DSC::uses_port * new_uses_port,
238  const Engines::DSC::Message message);
239 
240 
249  static void register_factory(const std::string & factory_name,
250  port_factory * factory_ptr);
251 
258  virtual port_factory * get_factory(const std::string & factory_name);
259 
262  static long dscTimeOut;
263  static void setTimeOut();
264  void beginService(const char *serviceName);
265 
266 
267  // This method is implemented by default since it is a very specific usage.
268  // It also permits to not break compatibility with older components.
269  virtual CORBA::Boolean init_service_with_multiple(const char* service_name,
271  {
272  return true;
273  }
274 
275 private:
276  // Factory map
277  typedef std::map<std::string, port_factory*> factory_map_t;
279 
280  /*-------------------------------------------------*/
281  // A Superv_Component port.
282  struct superv_port_t {
283  superv_port_t():u_ref(NULL),p_ref(NULL){};
285  {
286  if(u_ref)delete u_ref;
287  if(p_ref)
288  {
289  // do not delete CORBA servant : deactivate it and then call _remove_ref or delete
290  PortableServer::ServantBase* servant=dynamic_cast<PortableServer::ServantBase*>(p_ref);
291  if(servant)
292  {
293  PortableServer::POA_var poa =servant->_default_POA();
294  PortableServer::ObjectId_var oid = poa->servant_to_id(servant);
295  poa->deactivate_object(oid);
296  servant->_remove_ref();
297  }
298  }
299  };
300  // For uses ports.
301  uses_port * u_ref;
302  // For provides ports.
304  };
305 
306  typedef std::map<std::string, superv_port_t *> superv_ports;
307 
308  /*-------------------------------------------------*/
309  /*-------------------------------------------------*/
310 
312  superv_ports::iterator my_superv_ports_it;
313 };
314 
315 
316 
317 template < typename SpecificPortType > SpecificPortType *
318 Superv_Component_i::add_port(const char * port_fab_type,
319  const char * port_type,
320  const char * port_name)
321  throw (PortAlreadyDefined, BadFabType, BadType, BadCast, BadProperty)
322 {
323  assert(port_fab_type);
324  assert(port_type);
325  assert(port_name);
326  SpecificPortType * retPort;
327 
328 #ifdef MYDEBUG
329  std::cout << "---- Superv_Component_i::add_port : Mark 0 ---- " << port_name << "----" << std::endl;
330 #endif
331 
332  std::string s_port_type(port_type);
333  if (s_port_type == "provides") {
334  provides_port * port = create_provides_data_port(port_fab_type);
335  add_port(port, port_name);
336  retPort = dynamic_cast<SpecificPortType *>(port);
337  if ( retPort == NULL ) { delete port;
338  throw BadCast( LOC("Can't cast to asked port type " ));
339  }
340  }
341  else if (s_port_type == "uses") {
342  uses_port * port = create_uses_data_port(port_fab_type);
343  add_port(port, port_name);
344 #ifdef MYDEBUG
345  std::cout << "---- Superv_Component_i::add_port : Mark 1 ---- " << port << "----" << std::endl;
346  std::cout << "---- Superv_Component_i::add_port : Mark 1 ---- get_repository_id()" << port->get_repository_id() << std::endl;
347 #endif
348  retPort = dynamic_cast<SpecificPortType *>(port);
349 #ifdef MYDEBUG
350  std::cout << "---- Superv_Component_i::add_port : Mark 2 ---- " << retPort << "----" << std::endl;
351 #endif
352  if ( retPort == NULL ) { delete port;
353  throw BadCast( LOC("Can't cast to asked port type " ));
354  }
355  }
356  else
357  throw BadType(LOC(OSS()<< "port_type must be either 'provides' either 'uses' not "
358  << port_type));
359 
360  return retPort;
361 };
362 
363 
364 template <typename SpecificPortType > SpecificPortType *
365 Superv_Component_i::get_port( const char * port_name)
367 {
368  assert(port_name);
369 
370  SpecificPortType * retPort;
371  base_port * port;
372 
373  my_superv_ports_it = my_superv_ports.find(port_name);
374  if (my_superv_ports_it == my_superv_ports.end())
375  {
376  throw PortNotDefined( LOC(OSS()<< "Port " << port_name <<" does not exist"));
377  }
378 
379  superv_port_t * superv_port = my_superv_ports[port_name];
380  try {
381  if ( superv_port->p_ref != NULL ) {
382  port = superv_port->p_ref;
383  Ports::Port_var portref=Engines_DSC_interface::get_provides_port(port_name, false);
384  }
385  else if ( superv_port->u_ref != NULL ) {
386  port = superv_port->u_ref;
388  delete portseq;
389  } else {
390  throw UnexpectedState( LOC(OSS()<< "Internal Error superv_port struct is inconsistent "));
391 
392  }
393  } catch (const Engines::DSC::PortNotDefined&) {
394  throw PortNotDefined( LOC(OSS()<< "port "
395  << port_name <<" does not exist."));
396  } catch (const Engines::DSC::PortNotConnected&) {
397  throw PortNotConnected( LOC(OSS()<< "port " << port_name
398  << " is not connected."));
399  }
400 
401  retPort = dynamic_cast<SpecificPortType *>(port);
402  if ( retPort == NULL ) {
403  throw BadCast( LOC("Can't cast to required port type " ));
404  }
405 
406  return retPort;
407 };
408 
409 
410 #endif