src/DSC/ParallelDSC/ParallelDSC_i.hxx

   1 // Copyright (C) 2007-2023  CEA, EDF, OPEN CASCADE
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 //  File   : ParallelDSC_i.hxx
  21 //  Author : André RIBES (EDF)
  22 //  Module : KERNEL
  23 //
  24 #ifndef _PARALLEL_DSC_COMPONENT_I_HXX_
  25 #define _PARALLEL_DSC_COMPONENT_I_HXX_
  26
  27 #include <iostream>
  28 #include <map>
  29
  30 #include "DSC_interface.hxx"
  31 #include "SALOME_ParallelComponent_i.hxx"
  32
  33 #include "SALOME_PACOExtensionPaCO_Engines_Parallel_DSC_server.hxx"
  34 #include "SALOME_PortsPaCO.hxx"
  35
  36 class Engines_ParallelDSC_i:
  37   public virtual Engines_Parallel_Component_i,
  38   public virtual Engines::Parallel_DSC_serv,
  39   public virtual Engines_DSC_interface
  40 {
  41 public:
  42   Engines_ParallelDSC_i(CORBA::ORB_ptr orb,
  43                         char * ior,
  44                         int rank,
  45                         PortableServer::POA_ptr poa,
  46                         PortableServer::ObjectId * contId,
  47                         const char *instanceName,
  48                         const char *interfaceName,
  49                         bool notif = false);
  50
  51   virtual ~Engines_ParallelDSC_i();
  52
  53
  54   /*!
  55    * \see Engines::DSC::add_provides_port
  56    */
  57   virtual void add_provides_port(Ports::Port_ptr ref,
  58                                  const char* provides_port_name,
  59                                  Ports::PortProperties_ptr port_prop)
  60     {
  61       Engines_DSC_interface::add_provides_port(ref,
  62                                                provides_port_name,
  63                                                port_prop);
  64     }
  65
  66   /*!
  67    * \see Engines::DSC::add_uses_port
  68    */
  69   virtual void add_uses_port(const char* repository_id,
  70                              const char* uses_port_name,
  71                              Ports::PortProperties_ptr port_prop)
  72     {
  73       Engines_DSC_interface::add_uses_port(repository_id,
  74                                            uses_port_name,
  75                                            port_prop);
  76     }
  77
  78   /*!
  79    * \see Engines::DSC::get_provides_port
  80    */
  81   virtual Ports::Port_ptr get_provides_port(const char* provides_port_name,
  82                                             const CORBA::Boolean connection_error)
  83     {
  84       return Engines_DSC_interface::get_provides_port(provides_port_name,
  85                                                       connection_error);
  86     }
  87
  88   /*!
  89    * \see Engines::DSC::get_uses_port
  90    */
  91   virtual Engines::DSC::uses_port * get_uses_port(const char* uses_port_name)
  92     {
  93       return Engines_DSC_interface::get_uses_port(uses_port_name);
  94     }
  95
  96   /*!
  97    * \see Engines::DSC::connect_provides_port
  98    */
  99   virtual void connect_provides_port(const char* provides_port_name)
 100     {
 101       Engines_DSC_interface::connect_provides_port(provides_port_name);
 102     }
 103
 104   /*!
 105    * \see Engines::DSC::connect_uses_port
 106    */
 107   virtual void connect_uses_port(const char* uses_port_name,
 108                                  Ports::Port_ptr provides_port_ref)
 109     {
 110       Engines_DSC_interface::connect_uses_port(uses_port_name,
 111                                                provides_port_ref);
 112     }
 113
 114   /*!
 115    * \see Engines::DSC::is_connected
 116    */
 117   virtual CORBA::Boolean is_connected(const char* port_name)
 118     {
 119       return Engines_DSC_interface::is_connected(port_name);
 120     }
 121
 122    /*!
 123    * \see Engines::DSC::disconnect_provides_port
 124    */
 125   virtual void disconnect_provides_port(const char* provides_port_name,
 126                                         const Engines::DSC::Message message)
 127     {
 128       Engines_DSC_interface::disconnect_provides_port(provides_port_name,
 129                                                       message);
 130     }
 131
 132    /*!
 133    * \see Engines::DSC::disconnect_uses_port
 134    */
 135   virtual void disconnect_uses_port(const char* uses_port_name,
 136                                     Ports::Port_ptr provides_port_ref,
 137                                     const Engines::DSC::Message message)
 138     {
 139       Engines_DSC_interface::disconnect_uses_port(uses_port_name,
 140                                                   provides_port_ref,
 141                                                   message);
 142     }
 143
 144   virtual Ports::PortProperties_ptr get_port_properties(const char* port_name)
 145     {
 146       return Engines_DSC_interface::get_port_properties(port_name);
 147     }
 148
 149   /*!
 150    * This method is used to register the proxy of the parallel port into
 151    * all the nodes of the parallel component.
 152    *
 153    * \param ref CORBA proxy reference.
 154    * \param provides_port_name provides port associated with the proxy.
 155    * \param port_prop port properties.
 156    */
 157   virtual void set_paco_proxy(CORBA::Object_ptr ref,
 158                               const char* provides_port_name,
 159                               Ports::PortProperties_ptr port_prop);
 160
 161   /*!
 162    * This method is used by the node that want to add the parallel proxy port.
 163    *
 164    * \param ref CORBA proxy reference.
 165    * \param provides_port_name provides port associated with the proxy.
 166    *
 167    * \return true if the proxy is correctly added.
 168    */
 169   virtual CORBA::Boolean add_parallel_provides_proxy_port(const CORBA::Object_ptr ref,
 170                                                           const char * provides_port_name,
 171                                                           Ports::PortProperties_ptr port_prop);
 172
 173   /*!
 174    * This method by the nodes that do not add the proxy to wait is reference.
 175    *
 176    * \param provides_port_name provides port associated with the proxy.
 177    *
 178    * \return true if the proxy is correctly added.
 179    */
 180   virtual CORBA::Boolean add_parallel_provides_proxy_wait(const char * provides_port_name);
 181
 182   /*!
 183    * Permits to add a parallel node of a parallel provides port.
 184    *
 185    * \param ref CORBA node reference.
 186    * \param provides_port_name provides port associated with the node.
 187    *
 188    * \return true if the node is correctly added.
 189    */
 190   virtual CORBA::Boolean add_parallel_provides_node_port(Ports::Port_PaCO_ptr ref,
 191                                                          const char* provides_port_name);
 192
 193   /*!
 194    * Used to get the proxy of the parallel port.
 195    *
 196    * \param provides_port_name name of the parallel provides port.
 197    *
 198    * \return IOR of the proxy.
 199    */
 200   virtual const char * get_proxy(const char* provides_port_name);
 201
 202 };
 203
 204 #endif