SALOME documentation central

src/DSC/DSC_User/Superv_Component_i.hxx

00001 //  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
00002 //
00003 //  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
00004 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
00005 //
00006 //  This library is free software; you can redistribute it and/or
00007 //  modify it under the terms of the GNU Lesser General Public
00008 //  License as published by the Free Software Foundation; either
00009 //  version 2.1 of the License.
00010 //
00011 //  This library is distributed in the hope that it will be useful,
00012 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014 //  Lesser General Public License for more details.
00015 //
00016 //  You should have received a copy of the GNU Lesser General Public
00017 //  License along with this library; if not, write to the Free Software
00018 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
00019 //
00020 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
00021 //
00022 //  File   : Superv_Component_i.hxx
00023 //  Author : André RIBES (EDF), Eric Fayolle (EDF)
00024 //  Module : KERNEL
00025 //
00026 #ifndef _SUPERV_COMPONENT_I_HXX_
00027 #define _SUPERV_COMPONENT_I_HXX_
00028 
00029 #include "DSC_i.hxx"
00030 #include "base_port.hxx"
00031 #include "uses_port.hxx"
00032 #include "provides_port.hxx"
00033 #include "port_factory.hxx"
00034 
00035 #include "DSC_Exception.hxx"
00036 #include <vector>
00037 
00038 //#define MYDEBUG
00039 
00052 class Superv_Component_i :
00053   public Engines_DSC_i,
00054   virtual public POA_Engines::Superv_Component
00055 {
00056 public:
00057   Superv_Component_i(CORBA::ORB_ptr orb,
00058                PortableServer::POA_ptr poa,
00059                PortableServer::ObjectId * contId,
00060                const char *instanceName,
00061                const char *interfaceName,
00062                bool notif = false);
00063   Superv_Component_i(CORBA::ORB_ptr orb,
00064                PortableServer::POA_ptr poa,
00065                Engines::Container_ptr container, 
00066                const char *instanceName,
00067                const char *interfaceName,
00068                bool notif = false,
00069          bool regist = true );
00070   virtual ~Superv_Component_i();
00071 
00072   // Exceptions declarations.
00073   // There are defined on the Superv_Component_i.cxx to avoid problems
00074   // from dlopen.
00075   DSC_EXCEPTION(BadFabType);
00076   DSC_EXCEPTION(BadType);
00077   DSC_EXCEPTION(BadCast);
00078   DSC_EXCEPTION(UnexpectedState);
00079   DSC_EXCEPTION(PortAlreadyDefined);
00080   DSC_EXCEPTION(PortNotDefined);
00081   DSC_EXCEPTION(PortNotConnected);
00082   DSC_EXCEPTION(NilPort);
00083   DSC_EXCEPTION(BadProperty);
00084   
00088   virtual provides_port * create_provides_control_port() 
00089   {return NULL;}
00090 
00094   virtual provides_port * create_provides_data_and_control_port(const char* port_type) 
00095   {return NULL;}
00096 
00100   virtual uses_port * create_uses_control_port()
00101   {return NULL;}
00102 
00106   virtual uses_port * create_uses_data_and_control_port(const char* port_type)
00107   {return NULL;}
00108 
00119   virtual provides_port * create_provides_data_port(const std::string& port_fab_type)
00120     throw (BadFabType);
00121 
00122 
00133   virtual uses_port * create_uses_data_port(const std::string& port_fab_type)
00134     throw (BadFabType); 
00135 
00144   virtual void add_port(const char * port_fab_type,
00145                const char * port_type,
00146                const char * port_name)
00147     throw (PortAlreadyDefined, BadFabType, BadType, BadProperty);
00148 
00158   template < typename SpecificPortType >  
00159   SpecificPortType * add_port(const char * port_fab_type,
00160                      const char * port_type,
00161                      const char * port_name)
00162     throw (PortAlreadyDefined, BadFabType, BadType, BadCast, BadProperty);
00163 
00170   virtual void add_port(provides_port * port, 
00171                const char* provides_port_name)
00172     throw (PortAlreadyDefined, NilPort, BadProperty);
00173 
00180   virtual void add_port(uses_port * port, 
00181                const char* uses_port_name)
00182     throw (PortAlreadyDefined, NilPort, BadProperty);
00183 
00190   virtual void get_port(provides_port *& port, 
00191                const char* provides_port_name)
00192     throw (PortNotDefined, PortNotConnected);
00193   
00200   virtual void get_port(uses_port *& port, 
00201                const char* uses_port_name)
00202     throw (PortNotDefined, PortNotConnected);
00203 
00212   virtual void get_uses_port_names(std::vector<std::string> & port_names,
00213                        const std::string servicename="") const;
00214 
00221   template <typename SpecificPortType > 
00222   SpecificPortType * get_port( const char * port_name)
00223     throw (PortNotDefined, PortNotConnected, BadCast, UnexpectedState);
00224  
00228   virtual void provides_port_changed(const char* provides_port_name,
00229                          int connection_nbr,
00230                          const Engines::DSC::Message message);
00231 
00235   virtual void uses_port_changed(const char* uses_port_name,
00236                      Engines::DSC::uses_port * new_uses_port,
00237                      const Engines::DSC::Message message);
00238 
00239 
00248   static void register_factory(const std::string & factory_name,
00249                     port_factory * factory_ptr);
00250 
00257   virtual port_factory * get_factory(const std::string & factory_name);
00258 
00261   static long dscTimeOut;
00262   static void setTimeOut();
00263   void beginService(const char *serviceName);
00264 
00265 private:   
00266   // Factory map
00267   typedef std::map<std::string, port_factory*> factory_map_t;
00268   static factory_map_t _factory_map;
00269 
00270   /*-------------------------------------------------*/
00271   // A Superv_Component port.
00272   struct superv_port_t {
00273     superv_port_t():u_ref(NULL),p_ref(NULL){};
00274     ~superv_port_t()
00275     {
00276       if(u_ref)delete u_ref;
00277       if(p_ref)
00278         {
00279           // do not delete CORBA servant : deactivate it and then call _remove_ref or delete
00280           PortableServer::ServantBase* servant=dynamic_cast<PortableServer::ServantBase*>(p_ref);
00281           if(servant)
00282             {
00283               PortableServer::POA_var poa =servant->_default_POA();
00284               PortableServer::ObjectId_var oid = poa->servant_to_id(servant);
00285               poa->deactivate_object(oid);
00286               servant->_remove_ref();
00287             }
00288         }
00289     };
00290     // For uses ports.
00291     uses_port * u_ref;
00292     // For provides ports.
00293     provides_port * p_ref;
00294   };
00295 
00296   typedef std::map<std::string, superv_port_t *> superv_ports;
00297 
00298   /*-------------------------------------------------*/
00299   /*-------------------------------------------------*/
00300 
00301   superv_ports my_superv_ports;
00302   superv_ports::iterator my_superv_ports_it;
00303 };
00304 
00305 
00306 
00307 template < typename SpecificPortType >  SpecificPortType * 
00308 Superv_Component_i::add_port(const char * port_fab_type,
00309                     const char * port_type,
00310                     const char * port_name)
00311   throw (PortAlreadyDefined, BadFabType, BadType, BadCast, BadProperty)
00312 {
00313   assert(port_fab_type);
00314   assert(port_type);
00315   assert(port_name);
00316   SpecificPortType * retPort; 
00317 
00318 #ifdef MYDEBUG
00319   std::cout << "---- Superv_Component_i::add_port :  Mark 0 ----  " << port_name << "----" << std::endl;
00320 #endif
00321     
00322   std::string s_port_type(port_type);
00323   if (s_port_type == "provides") {
00324     provides_port * port = create_provides_data_port(port_fab_type);
00325     add_port(port, port_name);
00326     retPort = dynamic_cast<SpecificPortType *>(port);
00327     if ( retPort == NULL ) { delete port;  
00328       throw BadCast( LOC("Can't cast to asked port type " ));
00329     }
00330   }
00331   else if (s_port_type == "uses") {
00332     uses_port * port = create_uses_data_port(port_fab_type);
00333     add_port(port, port_name);
00334 #ifdef MYDEBUG
00335     std::cout << "---- Superv_Component_i::add_port :  Mark 1 ----  " << port << "----" << std::endl;
00336     std::cout << "---- Superv_Component_i::add_port :  Mark 1 ----   get_repository_id()" << port->get_repository_id() << std::endl;
00337 #endif
00338     retPort = dynamic_cast<SpecificPortType *>(port);
00339 #ifdef MYDEBUG
00340     std::cout << "---- Superv_Component_i::add_port :  Mark 2 ----  " << retPort << "----" << std::endl;
00341 #endif
00342     if ( retPort == NULL ) { delete port;  
00343       throw BadCast( LOC("Can't cast to asked port type " ));
00344     }
00345   }
00346   else
00347     throw BadType(LOC(OSS()<< "port_type must be either 'provides' either 'uses' not "
00348                 << port_type));
00349   
00350   return retPort;
00351 };
00352 
00353 
00354 template <typename SpecificPortType > SpecificPortType * 
00355 Superv_Component_i::get_port( const char * port_name)
00356   throw (PortNotDefined, PortNotConnected, BadCast, UnexpectedState)
00357 {
00358   assert(port_name);
00359     
00360   SpecificPortType * retPort;
00361   base_port        * port;
00362 
00363   my_superv_ports_it = my_superv_ports.find(port_name);
00364   if (my_superv_ports_it == my_superv_ports.end())
00365   {
00366     throw PortNotDefined( LOC(OSS()<< "Port " << port_name <<" does not exist"));
00367   }
00368 
00369   superv_port_t * superv_port =  my_superv_ports[port_name];
00370   try {
00371     if ( superv_port->p_ref != NULL ) {
00372       port = superv_port->p_ref;
00373       Ports::Port_var portref=Engines_DSC_interface::get_provides_port(port_name, false); 
00374     } 
00375     else if ( superv_port->u_ref != NULL ) {
00376       port = superv_port->u_ref;
00377       Engines::DSC::uses_port * portseq=Engines_DSC_i::get_uses_port(port_name);
00378       delete portseq;
00379     } else {
00380       throw UnexpectedState( LOC(OSS()<< "Internal Error superv_port struct is inconsistent "));
00381     
00382     }
00383   } catch (const Engines::DSC::PortNotDefined&) {
00384     throw PortNotDefined( LOC(OSS()<< "port "
00385                      << port_name <<" does not exist."));
00386   } catch (const Engines::DSC::PortNotConnected&) {
00387     throw PortNotConnected( LOC(OSS()<< "port " << port_name 
00388                     << " is not connected."));
00389   }
00390   
00391   retPort = dynamic_cast<SpecificPortType *>(port);
00392   if ( retPort == NULL ) {
00393     throw BadCast( LOC("Can't cast to required port type " ));
00394   }
00395 
00396   return retPort;
00397 };
00398 
00399 
00400 #endif