src/DSC/DSC_Basic/DSC_interface.hxx

   1 // Copyright (C) 2007-2023  CEA, EDF, 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   : DSC_interface.hxx
  24 //  Author : André RIBES (EDF)
  25 //  Module : KERNEL
  26 //
  27 #ifndef _DSC_INTERFACE_HXX_
  28 #define _DSC_INTERFACE_HXX_
  29
  30 #include <iostream>
  31 #include <map>
  32 #include <string.h>
  33 #include <assert.h>
  34
  35 #include "DSC_Callbacks.hxx"
  36
  37 /*! \class Engines_DSC_interface
  38  *  \brief This class implements the interface Engines::DSC
  39  *
  40  *  This class is used by the sequential DSC implementation
  41  *  and the parallel DSC implementation.
  42  */
  43 class Engines_DSC_interface:
  44   public DSC_Callbacks
  45 {
  46 public:
  47   Engines_DSC_interface();
  48   virtual ~Engines_DSC_interface();
  49
  50   /*!
  51    * \see Engines::DSC::add_provides_port
  52    */
  53   virtual void add_provides_port(Ports::Port_ptr ref,
  54                                  const char* provides_port_name,
  55                                  Ports::PortProperties_ptr port_prop);
  56
  57   /*!
  58    * \see Engines::DSC::add_uses_port
  59    */
  60   virtual void add_uses_port(const char* repository_id,
  61                              const char* uses_port_name,
  62                              Ports::PortProperties_ptr port_prop);
  63
  64   /*!
  65    * \see Engines::DSC::get_provides_port
  66    */
  67   virtual Ports::Port_ptr get_provides_port(const char* provides_port_name,
  68                                             const CORBA::Boolean connection_error);
  69
  70   /*!
  71    * \see Engines::DSC::get_uses_port
  72    */
  73   virtual Engines::DSC::uses_port * get_uses_port(const char* uses_port_name);
  74
  75   /*!
  76    * \see Engines::DSC::connect_provides_port
  77    *
  78    * \note This method uses Callbacks mechanism to inform the provides
  79    * port how much uses ports are connected with. Currently, the provides
  80    * port doesn't know its uses ports references. It's framework or application role
  81    * to manage connections between ports.
  82    */
  83   virtual void connect_provides_port(const char* provides_port_name);
  84
  85   /*!
  86    * \see Engines::DSC::connect_uses_port
  87    *
  88    * \note This method uses Callbacks mechanism to inform the uses
  89    * port how much provides ports are connected with.
  90    */
  91   virtual void connect_uses_port(const char* uses_port_name,
  92                                  Ports::Port_ptr provides_port_ref);
  93
  94   /*!
  95    * \see Engines::DSC::is_connected
  96    */
  97   virtual CORBA::Boolean is_connected(const char* port_name);
  98
  99    /*!
 100    * \see Engines::DSC::disconnect_provides_port
 101    *
 102    * \note This method uses Callbacks mechanism to inform the provides
 103    * port how much uses ports are connected with. Currently, the provides
 104    * port doesn't know its uses ports references. It's framework or application role
 105    * to manage connections between ports.
 106    */
 107   virtual void disconnect_provides_port(const char* provides_port_name,
 108                                         const Engines::DSC::Message message);
 109
 110    /*!
 111    * \see Engines::DSC::disconnect_uses_port
 112    *
 113    *
 114    * \note This method uses Callbacks mechanism to inform the uses
 115    * port how much provides ports are connected with.
 116    *
 117    * \warning The new sequence of the uses port is sended by the callback.
 118    * The old sequence is not destoyed. Is uses port user's role to destroy
 119    * the sequence.
 120    */
 121   virtual void disconnect_uses_port(const char* uses_port_name,
 122                                     Ports::Port_ptr provides_port_ref,
 123                                     const Engines::DSC::Message message);
 124
 125   /*!
 126    * \see Engines::DSC::get_port_properties
 127    */
 128   virtual Ports::PortProperties_ptr get_port_properties(const char* port_name);
 129
 130   static void writeEvent(const char* request,const std::string& containerName, const char* instance_name,
 131                          const char* port_name, const char* error, const char* message);
 132
 133 protected:
 134
 135   /*-------------------------------------------------*/
 136   /* Definition des types pour le stockage des ports */
 137
 138   enum port_type {uses, provides, none};
 139
 140   struct port_t {
 141     port_type type;
 142     int connection_nbr;
 143
 144     // Specifique aux uses port
 145     Engines::DSC::uses_port uses_port_refs;
 146     std::string repository_id;
 147
 148     // Specifique aux provides port;
 149     Ports::Port_var provides_port_ref;
 150
 151     Ports::PortProperties_var port_prop;
 152   };
 153
 154   typedef std::map<std::string, port_t *> ports;
 155
 156   /*-------------------------------------------------*/
 157   /*-------------------------------------------------*/
 158
 159   ports my_ports;
 160   ports::iterator my_ports_it;
 161 };
 162
 163 #endif