InputPort.cxx

Go to the documentation of this file.

// Copyright (C) 2006-2026  CEA, EDF
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
 
#include "InputPort.hxx"
#include "OutPort.hxx"
#include "ComposedNode.hxx"
 
#include <sstream>
#include <iostream>
#include <cassert>
 
//#define _DEVDEBUG_
#include "YacsTrace.hxx"
 
using namespace YACS::ENGINE;
using namespace std;
 
const char InputPort::NAME[]="InputPort";
 
InputPort::InputPort(const InputPort& other, Node *newHelder)
  : DataFlowPort(other, newHelder),
    InPort(other, newHelder),
    DataPort(other, newHelder),
    Port(other, newHelder),
    _initValue(0),
    _canBeNull(other._canBeNull)
{
  if(other._initValue)
    _initValue=other._initValue->clone();
}
 
InputPort::InputPort(const std::string& name, Node *node, TypeCode* type, bool canBeNull)
  : DataFlowPort(name, node, type),
    InPort(name, node, type),
    DataPort(name, node, type),
    Port(node),
    _initValue(0),
    _canBeNull(canBeNull)
{
}
 
string InputPort::getNameOfTypeOfCurrentInstance() const
{
  return NAME;
}
 
void InputPort::exInit(bool start)
{
  checkBasicConsistency();
  if(start)
    exRestoreInit();
}
 
bool InputPort::isEmpty()
{
  return get()==0;
}
 
bool InputPort::edIsManuallyInitialized() const
{
  return _initValue!=0;
}
 
bool InputPort::edIsInitialized() const
{
  return (edIsManuallyInitialized() || _backLinks.size()!=0 );
}
 
InputPort::~InputPort()
{
  if(_initValue)
    _initValue->decrRef();
}
 
void InputPort::edInit(Any *value)
{
  InputPort *manuallySet=getRuntime()->adapt(this,
                                             Runtime::RUNTIME_ENGINE_INTERACTION_IMPL_NAME,_type,true);
  try
    {
      manuallySet->put((const void *) value);
      if(manuallySet!=this)
        delete manuallySet;
    }
  catch(ConversionException&)
    {
      if(manuallySet!=this)
        delete manuallySet;
      throw;
    }
  exSaveInit();
  modified();
}
 
 
void InputPort::edInit(const std::string& impl,const void* value)
{
  InputPort *manuallySet=getRuntime()->adapt(this,impl,_type,true);
  try
    {
      manuallySet->put(value);
      if(manuallySet!=this)
        delete manuallySet;
    }
  catch(ConversionException&)
    {
      if(manuallySet!=this)
        delete manuallySet;
      throw;
    }
  exSaveInit();
  modified();
}
 
void InputPort::edRemoveManInit()
{
  if(_initValue)
    _initValue->decrRef();
  _initValue=0;
}
 
void InputPort::checkBasicConsistency() const
{
  if(!_canBeNull && !edIsManuallyInitialized() && _backLinks.size()==0 )
    {
      ostringstream stream;
      stream << "InputPort::checkBasicConsistency : Port " << _name << " of node with name " << _node->getName() << " neither initialized nor linked back";
      throw Exception(stream.str());
    }
}
 
std::string InputPort::dump()
{
  string xmldump = "<value><error> NO_SERIALISATION_AVAILABLE </error></value>";
  return xmldump;
}
 
std::string InputPort::getHumanRepr()
{
  return dump();
}
 
void InputPort::setStringRef(std::string strRef)
{
  _stringRef = strRef;
}
 
bool InputPort::canBeNull() const
{
  return _canBeNull;
}
 
ProxyPort::ProxyPort(InputPort* p):InputPort("Convertor", p->getNode(), p->edGetType()),DataPort("Convertor", p->getNode(), p->edGetType()),
                                   Port( p->getNode())
{
  _port = p;
}
 
ProxyPort::~ProxyPort()
{
  //For the moment, there is no case in YACS we have a proxy port in a proxy port
  //So don't test that. _port may be already deleted. The test is not sure.
  /*
  if(_port->isIntermediate())
    delete _port;
    */
}
 
void ProxyPort::edRemoveAllLinksLinkedWithMe()
{
  _port->edRemoveAllLinksLinkedWithMe();
}
 
InputPort *ProxyPort::clone(Node *newHelder) const
{
  throw Exception("ProxyPort::clone : internal error - should never happened");
}
 
void ProxyPort::edNotifyReferencedBy(OutPort *fromPort, bool isLoopProof)
{
  _port->edNotifyReferencedBy(fromPort,isLoopProof);
}
 
void ProxyPort::edNotifyDereferencedBy(OutPort *fromPort)
{
  _port->edNotifyDereferencedBy(fromPort);
}
 
std::set<OutPort *> ProxyPort::edSetOutPort() const
{
  return _port->edSetOutPort();
}
 
int ProxyPort::edGetNumberOfLinks() const
{
  return _port->edGetNumberOfLinks();
}
 
void ProxyPort::exRestoreInit()
{
  _port->exRestoreInit();
}
 
void ProxyPort::exSaveInit()
{
  _port->exSaveInit();
}
 
#ifdef NOCOVARIANT
InPort *ProxyPort::getPublicRepresentant()
#else
InputPort *ProxyPort::getPublicRepresentant()
#endif
{ 
  return _port->getPublicRepresentant();
}
 
void *ProxyPort::get() const
{
  return _port->get();
}
 
void ProxyPort::releaseData()
{
  _port->releaseData();
}
 
void ProxyPort::put(const void *data)
{
  _port->put(data);
}
 
void ProxyPort::getAllRepresentants(std::set<InPort *>& repr) const
{
  DEBTRACE("ProxyPort::getAllRepresentants");
  _port->getAllRepresentants(repr);
}