src/engine/InputPort.cxx

   1 // Copyright (C) 2006-2024  CEA, EDF
   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 #include "InputPort.hxx"
  21 #include "OutPort.hxx"
  22 #include "ComposedNode.hxx"
  23
  24 #include <sstream>
  25 #include <iostream>
  26 #include <cassert>
  27
  28 //#define _DEVDEBUG_
  29 #include "YacsTrace.hxx"
  30
  31 using namespace YACS::ENGINE;
  32 using namespace std;
  33
  34 const char InputPort::NAME[]="InputPort";
  35
  36 InputPort::InputPort(const InputPort& other, Node *newHelder)
  37   : DataFlowPort(other, newHelder),
  38     InPort(other, newHelder),
  39     DataPort(other, newHelder),
  40     Port(other, newHelder),
  41     _initValue(0),
  42     _canBeNull(other._canBeNull)
  43 {
  44   if(other._initValue)
  45     _initValue=other._initValue->clone();
  46 }
  47
  48 InputPort::InputPort(const std::string& name, Node *node, TypeCode* type, bool canBeNull)
  49   : DataFlowPort(name, node, type),
  50     InPort(name, node, type),
  51     DataPort(name, node, type),
  52     Port(node),
  53     _initValue(0),
  54     _canBeNull(canBeNull)
  55 {
  56 }
  57
  58 string InputPort::getNameOfTypeOfCurrentInstance() const
  59 {
  60   return NAME;
  61 }
  62
  63 void InputPort::exInit(bool start)
  64 {
  65   checkBasicConsistency();
  66   if(start)
  67     exRestoreInit();
  68 }
  69
  70 bool InputPort::isEmpty()
  71 {
  72   return get()==0;
  73 }
  74
  75 //! Specifies if this port has been \b manually set by the call of InputPort::edInit
  76 bool InputPort::edIsManuallyInitialized() const
  77 {
  78   return _initValue!=0;
  79 }
  80
  81 /*!
  82  * Perform a quick and not complete check. Use ComposedNode::CheckConsistency instead.
  83  */
  84 bool InputPort::edIsInitialized() const
  85 {
  86   return (edIsManuallyInitialized() || _backLinks.size()!=0 );
  87 }
  88
  89 InputPort::~InputPort()
  90 {
  91   if(_initValue)
  92     _initValue->decrRef();
  93 }
  94
  95 void InputPort::edInit(Any *value)
  96 {
  97   InputPort *manuallySet=getRuntime()->adapt(this,
  98                                              Runtime::RUNTIME_ENGINE_INTERACTION_IMPL_NAME,_type,true);
  99   try
 100     {
 101       manuallySet->put((const void *) value);
 102       if(manuallySet!=this)
 103         delete manuallySet;
 104     }
 105   catch(ConversionException&)
 106     {
 107       if(manuallySet!=this)
 108         delete manuallySet;
 109       throw;
 110     }
 111   exSaveInit();
 112   modified();
 113 }
 114
 115 //! Initialize the port with an object (value) coming from a world with implementation impl
 116 /*!
 117  *  You should be careful when using this method : the caller must set the context according to implementation
 118  *  For instance, if implementation is Python, the caller must hold the Global Interpreter Lock (also known as GIL).
 119  */
 120 void InputPort::edInit(const std::string& impl,const void* value)
 121 {
 122   InputPort *manuallySet=getRuntime()->adapt(this,impl,_type,true);
 123   try
 124     {
 125       manuallySet->put(value);
 126       if(manuallySet!=this)
 127         delete manuallySet;
 128     }
 129   catch(ConversionException&)
 130     {
 131       if(manuallySet!=this)
 132         delete manuallySet;
 133       throw;
 134     }
 135   exSaveInit();
 136   modified();
 137 }
 138
 139 //! Removes eventually previous manual initialisation.
 140 void InputPort::edRemoveManInit()
 141 {
 142   if(_initValue)
 143     _initValue->decrRef();
 144   _initValue=0;
 145 }
 146
 147 //! Check basically that this port has one chance to be specified on time. It's a necessary condition \b not \b sufficient at all.
 148 void InputPort::checkBasicConsistency() const
 149 {
 150   if(!_canBeNull && !edIsManuallyInitialized() && _backLinks.size()==0 )
 151     {
 152       ostringstream stream;
 153       stream << "InputPort::checkBasicConsistency : Port " << _name << " of node with name " << _node->getName() << " neither initialized nor linked back";
 154       throw Exception(stream.str());
 155     }
 156 }
 157
 158 std::string InputPort::dump()
 159 {
 160   string xmldump = "<value><error> NO_SERIALISATION_AVAILABLE </error></value>";
 161   return xmldump;
 162 }
 163
 164 std::string InputPort::getHumanRepr()
 165 {
 166   return dump();
 167 }
 168
 169 void InputPort::setStringRef(std::string strRef)
 170 {
 171   _stringRef = strRef;
 172 }
 173
 174 bool InputPort::canBeNull() const
 175 {
 176   return _canBeNull;
 177 }
 178
 179 ProxyPort::ProxyPort(InputPort* p):InputPort("Convertor", p->getNode(), p->edGetType()),DataPort("Convertor", p->getNode(), p->edGetType()),
 180                                    Port( p->getNode())
 181 {
 182   _port = p;
 183 }
 184
 185 ProxyPort::~ProxyPort()
 186 {
 187   //For the moment, there is no case in YACS we have a proxy port in a proxy port
 188   //So don't test that. _port may be already deleted. The test is not sure.
 189   /*
 190   if(_port->isIntermediate())
 191     delete _port;
 192     */
 193 }
 194
 195 void ProxyPort::edRemoveAllLinksLinkedWithMe()
 196 {
 197   _port->edRemoveAllLinksLinkedWithMe();
 198 }
 199
 200 /*!
 201  * \note : Should never been called because Node clone process does not duplicate data attributes relative to links.
 202  *         This part is done afterwards on relink process.
 203  */
 204 InputPort *ProxyPort::clone(Node *newHelder) const
 205 {
 206   throw Exception("ProxyPort::clone : internal error - should never happened");
 207 }
 208
 209 void ProxyPort::edNotifyReferencedBy(OutPort *fromPort, bool isLoopProof)
 210 {
 211   _port->edNotifyReferencedBy(fromPort,isLoopProof);
 212 }
 213
 214 void ProxyPort::edNotifyDereferencedBy(OutPort *fromPort)
 215 {
 216   _port->edNotifyDereferencedBy(fromPort);
 217 }
 218
 219 std::set<OutPort *> ProxyPort::edSetOutPort() const
 220 {
 221   return _port->edSetOutPort();
 222 }
 223
 224 int ProxyPort::edGetNumberOfLinks() const
 225 {
 226   return _port->edGetNumberOfLinks();
 227 }
 228
 229 void ProxyPort::exRestoreInit()
 230 {
 231   _port->exRestoreInit();
 232 }
 233
 234 void ProxyPort::exSaveInit()
 235 {
 236   _port->exSaveInit();
 237 }
 238
 239 #ifdef NOCOVARIANT
 240 InPort *ProxyPort::getPublicRepresentant()
 241 #else
 242 InputPort *ProxyPort::getPublicRepresentant()
 243 #endif
 244 {
 245   return _port->getPublicRepresentant();
 246 }
 247
 248 void *ProxyPort::get() const
 249 {
 250   return _port->get();
 251 }
 252
 253 void ProxyPort::releaseData()
 254 {
 255   _port->releaseData();
 256 }
 257
 258 void ProxyPort::put(const void *data)
 259 {
 260   _port->put(data);
 261 }
 262
 263 void ProxyPort::getAllRepresentants(std::set<InPort *>& repr) const
 264 {
 265   DEBTRACE("ProxyPort::getAllRepresentants");
 266   _port->getAllRepresentants(repr);
 267 }