src/engine/InputPort.hxx

   1 // Copyright (C) 2006-2016  CEA/DEN, EDF R&D
   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 #ifndef __INPUTPORT_HXX__
  21 #define __INPUTPORT_HXX__
  22
  23 #include "YACSlibEngineExport.hxx"
  24 #include "Any.hxx"
  25 #include "InPort.hxx"
  26 #include "Runtime.hxx"
  27 #include "DataFlowPort.hxx"
  28 #include "ConversionException.hxx"
  29 #include "yacsconfig.h"
  30
  31 #include <string>
  32
  33 namespace YACS
  34 {
  35   namespace ENGINE
  36   {
  37     class OutPort;
  38 /*! \brief Base class for Input Ports
  39  *
  40  * \ingroup Ports
  41  *
  42  */
  43     class YACSLIBENGINE_EXPORT InputPort : public DataFlowPort, public InPort
  44     {
  45       friend class Runtime; // for port creation
  46       friend class OutPort;
  47     public:
  48       static const char NAME[];
  49     public:
  50       virtual ~InputPort();
  51
  52       std::string getNameOfTypeOfCurrentInstance() const;
  53       //! returns the final physical port behind 'this'.
  54 #ifdef NOCOVARIANT
  55       virtual InPort *getPublicRepresentant() { return this; }
  56 #else
  57       virtual InputPort *getPublicRepresentant() { return this; }
  58 #endif
  59       virtual bool isIntermediate() const { return false; }
  60       virtual bool edIsManuallyInitialized() const;
  61       //!soon deprecated
  62       bool edIsInitialized() const;
  63
  64       template<class T>
  65       void edInit(T value);
  66       void edInit(Any *value);
  67       void edInit(const std::string& impl,const void* value);
  68       virtual void edRemoveManInit();
  69       virtual void checkBasicConsistency() const throw(Exception);
  70       virtual void exInit(bool start);
  71       virtual void exSaveInit() = 0;
  72       virtual void exRestoreInit() = 0;
  73       virtual InputPort *clone(Node *newHelder) const = 0;
  74       virtual bool isEmpty();
  75
  76       virtual void *get() const = 0;
  77       virtual void put(const void *data) throw(ConversionException) = 0;
  78       virtual std::string dump();
  79       virtual std::string getHumanRepr();
  80       virtual void setStringRef(std::string strRef);
  81       virtual std::string typeName() {return "YACS__ENGINE__InputPort";}
  82       bool canBeNull() const;
  83     protected:
  84       InputPort(const InputPort& other, Node *newHelder);
  85       InputPort(const std::string& name, Node *node, TypeCode* type, bool canBeNull = false);
  86     protected:
  87       Any *_initValue;
  88       std::string _stringRef;
  89       bool _canBeNull;
  90     };
  91
  92 /*! \brief Base class for Proxy Input Ports
  93  *
  94  * \ingroup Ports
  95  *
  96  */
  97     class YACSLIBENGINE_EXPORT ProxyPort : public InputPort
  98     {
  99     public:
 100       ProxyPort(InputPort* p);
 101       ~ProxyPort();
 102
 103       void edRemoveAllLinksLinkedWithMe() throw(Exception);
 104       InputPort *clone(Node *newHelder) const;
 105       void edNotifyReferencedBy(OutPort *fromPort);
 106       void edNotifyDereferencedBy(OutPort *fromPort);
 107       std::set<OutPort *> edSetOutPort() const;
 108 #ifdef NOCOVARIANT
 109       InPort *getPublicRepresentant();
 110 #else
 111       InputPort *getPublicRepresentant();
 112 #endif
 113       void *get() const;
 114       virtual void put(const void *data) throw(ConversionException) ;
 115       int edGetNumberOfLinks() const;
 116       bool isIntermediate() const { return true; }
 117       void exRestoreInit();
 118       void exSaveInit();
 119       void getAllRepresentants(std::set<InPort *>& repr) const;
 120       virtual std::string typeName() {return "YACS__ENGINE__ProxyPort";}
 121     protected:
 122       InputPort* _port;
 123     };
 124
 125     template<class T>
 126     void InputPort::edInit(T value)
 127     {
 128       Any* any=AtomAny::New(value);
 129       try
 130       {
 131         edInit(any);
 132         any->decrRef();
 133       }
 134       catch(ConversionException&)
 135       {
 136         any->decrRef();
 137         throw;
 138       }
 139     }
 140   }
 141 }
 142
 143 #endif