inline Echo_i() {}
virtual ~Echo_i() {}
virtual char* echoString(const char* mesg);
- CORBA::Long echoLong(CORBA::Long i) throw(eo::SALOME_Exception);
+ CORBA::Long echoLong(CORBA::Long i);
void echoDouble(CORBA::Double i,CORBA::Double& j) ;
void echoDoubleVec(const eo::DoubleVec& i,eo::DoubleVec_out j) ;
void echoDoubleVecVec(const eo::DoubleVecVec&, eo::DoubleVecVec_out);
out=new eo::DoubleVecVec(in);
}
-CORBA::Long Echo_i::echoLong(CORBA::Long i ) throw(eo::SALOME_Exception)
+CORBA::Long Echo_i::echoLong(CORBA::Long i )
{
DEBTRACE("Echo_i::echoLong " << i);
CORBA::Long j=i;
return new AtomAny(val,type);
}
-AnyPtr AtomAny::operator[](int i) const throw(YACS::Exception)
+AnyPtr AtomAny::operator[](int i) const
{
throw InvalidExtractionException(_type->kind(),Sequence);
}
-AnyPtr AtomAny::operator[](const char *key) const throw(YACS::Exception)
+AnyPtr AtomAny::operator[](const char *key) const
{
throw Exception("AtomAny::operator[] : try to get a part of a partitionned data whereas atomical.");
}
return false;
}
-int AtomAny::getIntValue() const throw(YACS::Exception)
+int AtomAny::getIntValue() const
{
if(_type->isA(Runtime::_tc_int))
return _value._i;
throw Exception("Value is not an int");
}
-bool AtomAny::getBoolValue() const throw(YACS::Exception)
+bool AtomAny::getBoolValue() const
{
if(_type->isA(Runtime::_tc_bool))
return _value._b;
throw Exception("Value is not a bool");
}
-double AtomAny::getDoubleValue() const throw(YACS::Exception)
+double AtomAny::getDoubleValue() const
{
if(_type->isA(Runtime::_tc_double))
return _value._d;
throw Exception("Value is not a double");
}
-std::string AtomAny::getStringValue() const throw(YACS::Exception)
+std::string AtomAny::getStringValue() const
{
if(_type->isA(Runtime::_tc_string) || _type->kind()==YACS::ENGINE::Objref)
{
_type->decrRef();
}
-AnyPtr ComposedAny::operator[](const char *key) const throw(YACS::Exception)
+AnyPtr ComposedAny::operator[](const char *key) const
{
throw Exception("AtomAny::operator[] : try to get a part of a partitionned data not localizable by a string.");
}
-void ComposedAny::checkTypeOf(const Any *elem) const throw(YACS::Exception)
+void ComposedAny::checkTypeOf(const Any *elem) const
{
if(!elem->getType()->isA(_type->contentType()))
throw Exception("ComposedAny::checkTypeOf : invalid type.");
}
-int ComposedAny::getIntValue() const throw(YACS::Exception)
+int ComposedAny::getIntValue() const
{
throw InvalidExtractionException(_type->kind(),Runtime::_tc_int->kind());
}
-bool ComposedAny::getBoolValue() const throw(YACS::Exception)
+bool ComposedAny::getBoolValue() const
{
throw InvalidExtractionException(_type->kind(),Runtime::_tc_bool->kind());
}
-double ComposedAny::getDoubleValue() const throw(YACS::Exception)
+double ComposedAny::getDoubleValue() const
{
throw InvalidExtractionException(_type->kind(),Runtime::_tc_double->kind());
}
-std::string ComposedAny::getStringValue() const throw(YACS::Exception)
+std::string ComposedAny::getStringValue() const
{
throw InvalidExtractionException(_type->kind(),Runtime::_tc_string->kind());
}
return true;
}
-void SequenceAny::setEltAtRank(int i, const Any *elem) throw(YACS::Exception)
+void SequenceAny::setEltAtRank(int i, const Any *elem)
{
checkTypeOf(elem);
_alloc.destroy(_alloc._start+i*_alloc._sizeOf1Elm,_type->contentType());
_alloc.construct(_alloc._start+i*_alloc._sizeOf1Elm,elem);
}
-AnyPtr SequenceAny::operator[](int i) const throw(YACS::Exception)
+AnyPtr SequenceAny::operator[](int i) const
{
return _type->contentType()->getOrBuildAnyFromZippedData(_alloc._start+i*_alloc._sizeOf1Elm);
}
}
}
-void ArrayAny::setEltAtRank(int i, const Any *elem) throw(YACS::Exception)
+void ArrayAny::setEltAtRank(int i, const Any *elem)
{
checkTypeOf(elem);
const TypeCode *subType=_type->contentType();
return true;
}
-AnyPtr ArrayAny::operator[](int i) const throw(YACS::Exception)
+AnyPtr ArrayAny::operator[](int i) const
{
const TypeCode *subType=_type->contentType();
unsigned sizePerContent=subType->getSizeInByteOfAnyReprInSeq();
return true;
}
-AnyPtr StructAny::operator[](int i) const throw(YACS::Exception)
+AnyPtr StructAny::operator[](int i) const
{
const char what[]="StructAny::operator[](int i) : Struct key are strings not integers.";
throw Exception(what);
}
-AnyPtr StructAny::operator[](const char *key) const throw(YACS::Exception)
+AnyPtr StructAny::operator[](const char *key) const
{
const TypeCodeStruct *typeC=(const TypeCodeStruct *)_type;
char *whereToGet=_data;
return (*iter).second->getOrBuildAnyFromZippedData(whereToGet);
}
-void StructAny::setEltAtRank(int i, const Any *elem) throw(YACS::Exception)
+void StructAny::setEltAtRank(int i, const Any *elem)
{
const char what[]="Struct key are strings not integers.";
throw Exception(what);
}
-void StructAny::setEltAtRank(const char *key, const Any *elem) throw(YACS::Exception)
+void StructAny::setEltAtRank(const char *key, const Any *elem)
{
const TypeCodeStruct *typeC=(const TypeCodeStruct *)_type;
unsigned offset;
const TypeCode *getType() const { return _type; }
//for convenience methods
virtual Any *clone() const = 0;
- virtual AnyPtr operator[](int i) const throw(Exception) = 0;
- virtual AnyPtr operator[](const char *key) const throw(Exception) = 0;
+ virtual AnyPtr operator[](int i) const = 0;
+ virtual AnyPtr operator[](const char *key) const = 0;
virtual bool operator ==(const Any& other) const = 0;
- virtual int getIntValue() const throw(Exception) = 0;
- virtual bool getBoolValue() const throw(Exception) = 0;
- virtual double getDoubleValue() const throw(Exception) = 0;
- virtual std::string getStringValue() const throw(Exception) = 0;
+ virtual int getIntValue() const = 0;
+ virtual bool getBoolValue() const = 0;
+ virtual double getDoubleValue() const = 0;
+ virtual std::string getStringValue() const = 0;
//
protected:
#ifndef SWIG
static AtomAny *New(T val) { return new AtomAny(val); }
static AtomAny *New(char *val, Deallocator dealloc);
static AtomAny *New(const std::string& val, TypeCode *type);
- AnyPtr operator[](int i) const throw(Exception);
- AnyPtr operator[](const char *key) const throw(Exception);
+ AnyPtr operator[](int i) const;
+ AnyPtr operator[](const char *key) const;
bool operator ==(const Any& other) const;
- int getIntValue() const throw(Exception);
- bool getBoolValue() const throw(Exception);
- double getDoubleValue() const throw(Exception);
- std::string getStringValue() const throw(Exception);
+ int getIntValue() const;
+ bool getBoolValue() const;
+ double getDoubleValue() const;
+ std::string getStringValue() const;
const char *getBytesValue(std::size_t& len) const;
protected:
void putMyReprAtPlace(char *data) const;
class YACSLIBENGINE_EXPORT ComposedAny : public Any
{
public:
- virtual void setEltAtRank(int i, const Any *elem) throw(Exception) = 0;
- AnyPtr operator[](const char *key) const throw(Exception);
+ virtual void setEltAtRank(int i, const Any *elem) = 0;
+ AnyPtr operator[](const char *key) const;
protected:
ComposedAny(const ComposedAny& other);
ComposedAny(TypeCode* type, bool isNew=true);
protected:
- void checkTypeOf(const Any *elem) const throw(Exception);
+ void checkTypeOf(const Any *elem) const;
private://error methods called during incorrect runtime extraction
- int getIntValue() const throw(Exception);
- bool getBoolValue() const throw(Exception);
- double getDoubleValue() const throw(Exception);
- std::string getStringValue() const throw(Exception);
+ int getIntValue() const;
+ bool getBoolValue() const;
+ double getDoubleValue() const;
+ std::string getStringValue() const;
};
typedef SharedPtr<SequenceAny> SequenceAnyPtr;
unsigned int size() const { return _alloc.size(); }
void pushBack(const Any *elem);
bool operator ==(const Any& other) const;
- void setEltAtRank(int i, const Any *elem) throw(Exception);
- AnyPtr operator[](int i) const throw(Exception);
+ void setEltAtRank(int i, const Any *elem);
+ AnyPtr operator[](int i) const;
Any *clone() const;
template<class T>
static SequenceAny *New(const std::vector<T>& vec);
{
friend class TypeCodeArray;
public:
- void setEltAtRank(int i, const Any *elem) throw(Exception);
+ void setEltAtRank(int i, const Any *elem);
bool operator ==(const Any& other) const;
- AnyPtr operator[](int i) const throw(Exception);
+ AnyPtr operator[](int i) const;
unsigned int size() const;
Any *clone() const;
template<class T>
Any *clone() const;
bool operator ==(const Any& other) const;
static StructAny *New(TypeCodeStruct *type);
- AnyPtr operator[](int i) const throw(Exception);
- AnyPtr operator[](const char *key) const throw(Exception);
- void setEltAtRank(int i, const Any *elem) throw(Exception);
- void setEltAtRank(const char *key, const Any *elem) throw(Exception);
+ AnyPtr operator[](int i) const;
+ AnyPtr operator[](const char *key) const;
+ void setEltAtRank(int i, const Any *elem);
+ void setEltAtRank(const char *key, const Any *elem);
protected:
void putMyReprAtPlace(char *data) const;
static void putReprAtPlace(char *data, const char *src, const TypeCodeStruct *type, bool deepCpy);
return getRuntime()->convertNeutralAsString(edGetType(),_value);
}
-void AnyInputPort::put(const void *data) throw(ConversionException)
+void AnyInputPort::put(const void *data)
{
put((Any *)data);
}
void *get() const;
virtual std::string getAsString();
virtual bool isEmpty();
- void put(const void *data) throw(ConversionException);
+ void put(const void *data);
InputPort *clone(Node *newHelder) const;
std::string dump();
virtual std::string typeName() {return "YACS__ENGINE__AnyInputPort";}
return new AnyOutputPort(*this,newHelder);
}
-void AnyOutputPort::put(const void *data) throw(ConversionException)
+void AnyOutputPort::put(const void *data)
{
put((YACS::ENGINE::Any *)data);
}
-void AnyOutputPort::put(YACS::ENGINE::Any *data) throw(ConversionException)
+void AnyOutputPort::put(YACS::ENGINE::Any *data)
{
setValue(data);
OutputPort::put(data);
AnyOutputPort(const AnyOutputPort& other, Node *newHelder);
virtual ~AnyOutputPort();
virtual void setValue(Any *data);
- virtual void put(const void *data) throw(ConversionException);
- void put(Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(Any *data);
//! get the current dispatched value for update port value
Any* getValue() const { return _data; }
virtual std::string getAsString();
* If node name already used in bloc, throw exception.
* Publish inputPorts in current bloc and ancestors.
*/
-bool Bloc::edAddChild(Node *node) throw(YACS::Exception)
+bool Bloc::edAddChild(Node *node)
{
if(isNodeAlreadyAggregated(node))
{
* @exception If 'node' is NOT the son of 'this'.
*/
-void Bloc::edRemoveChild(Node *node) throw(YACS::Exception)
+void Bloc::edRemoveChild(Node *node)
{
StaticDefinedComposedNode::edRemoveChild(node);
list<Node *>::iterator iter=find(_setOfNode.begin(),_setOfNode.end(),node);
return ret;
}
-Node *Bloc::getChildByShortName(const std::string& name) const throw(YACS::Exception)
+Node *Bloc::getChildByShortName(const std::string& name) const
{
for (list<Node *>::const_iterator iter = _setOfNode.begin(); iter != _setOfNode.end(); iter++)
if ((*iter)->getName() == name)
* \b WARNING : When using this method 'node' has to be checked in order to be part of direct children of 'this'.
*
*/
-void Bloc::checkNoCyclePassingThrough(Node *node) throw(YACS::Exception)
+void Bloc::checkNoCyclePassingThrough(Node *node)
{
set<Node *> currentNodesToTest;
//don't insert node to test in set.
void getReadyTasks(std::vector<Task *>& tasks);
void exUpdateState();
//Node* DISOWNnode is a SWIG notation to indicate that the ownership of the node is transfered to C++
- bool edAddChild(Node *DISOWNnode) throw(Exception);
- void edRemoveChild(Node *node) throw(Exception);
+ bool edAddChild(Node *DISOWNnode) ;
+ void edRemoveChild(Node *node) ;
std::list<Node *> getChildren() const { return _setOfNode; }
std::list<Node *> edGetDirectDescendants() const { return _setOfNode; }
std::vector< std::list<Node *> > splitIntoIndependantGraph() const;
- Node *getChildByShortName(const std::string& name) const throw(Exception);
+ Node *getChildByShortName(const std::string& name) const ;
virtual void writeDot(std::ostream &os) const;
void accept(Visitor *visitor);
template<bool direction>
bool areAllSubNodesFinished() const;
bool areAllSubNodesDone() const;
bool isNameAlreadyUsed(const std::string& name) const;
- void checkNoCyclePassingThrough(Node *node) throw(Exception);
+ void checkNoCyclePassingThrough(Node *node) ;
std::vector< std::pair<OutGate *, InGate *> > getSetOfInternalCFLinks() const;
YACS::Event updateStateOnFinishedEventFrom(Node *node);
YACS::Event updateStateOnFailedEventFrom(Node *node, const Executor *execInst);
/*!
* \param deep if \b true a deep check is perfomed. Typically has to be called by an executor before any attempt to launch an execution.
*/
-DeploymentTree ComposedNode::checkDeploymentTree(bool deep) const throw(YACS::Exception)
+DeploymentTree ComposedNode::checkDeploymentTree(bool deep) const
{
DeploymentTree ret;
list< ElementaryNode * > tasks=getRecursiveConstituents();
* \return true if a new link has been created, false otherwise.
*/
-bool ComposedNode::edAddLink(OutPort *start, InPort *end) throw(YACS::Exception)
+bool ComposedNode::edAddLink(OutPort *start, InPort *end)
{
DEBTRACE("ComposedNode::edAddLink");
set<OutPort *> represented;
* \param end : the InPort to connect
* \return true if a new link has been created, false otherwise.
*/
-bool ComposedNode::edAddDFLink(OutPort *start, InPort *end) throw(YACS::Exception)
+bool ComposedNode::edAddDFLink(OutPort *start, InPort *end)
{
Node* n1=start->getNode();
Node* n2=end->getNode();
* supporting it.
* \return true if a new link has been created, false otherwise.
*/
-bool ComposedNode::edAddLink(OutGate *start, InGate *end) throw(YACS::Exception)
+bool ComposedNode::edAddLink(OutGate *start, InGate *end)
{
Node* n1=start->getNode();
Node* n2=end->getNode();
/*!
* Add a controlflow link between two nodes by calling edAddLink on their control ports
*/
-bool ComposedNode::edAddCFLink(Node *nodeS, Node *nodeE) throw(YACS::Exception)
+bool ComposedNode::edAddCFLink(Node *nodeS, Node *nodeE)
{
return edAddLink(nodeS->getOutGate(),nodeE->getInGate());
}
//! Remove a controlflow link.
-void ComposedNode::edRemoveCFLink(Node *nodeS, Node *nodeE) throw(YACS::Exception)
+void ComposedNode::edRemoveCFLink(Node *nodeS, Node *nodeE)
{
edRemoveLink(nodeS->getOutGate(),nodeE->getInGate());
}
* implies DF/DS gateway.
*/
-void ComposedNode::edRemoveLink(OutPort *start, InPort *end) throw(YACS::Exception)
+void ComposedNode::edRemoveLink(OutPort *start, InPort *end)
{
if(!start->isAlreadyLinkedWith(end))
throw Exception("ComposedNode::edRemoveLink : unexisting link");
}
//! Remove a controlflow link.
-void ComposedNode::edRemoveLink(OutGate *start, InGate *end) throw(YACS::Exception)
+void ComposedNode::edRemoveLink(OutGate *start, InGate *end)
{
ComposedNode* father=checkHavingCommonFather(start->getNode(),end->getNode());
if(father!=this)
start->edRemoveInGate(end);
}
-bool ComposedNode::edAddChild(Node *DISOWNnode) throw(YACS::Exception)
+bool ComposedNode::edAddChild(Node *DISOWNnode)
{
return false; // --- reimplemented in derived classes
}
//! Remove a child node.
-void ComposedNode::edRemoveChild(Node *node) throw(YACS::Exception)
+void ComposedNode::edRemoveChild(Node *node)
{
if(!node)
return;
* separator was not found).
*/
bool ComposedNode::splitNamesBySep(const std::string& globalName, const char separator[],
- std::string& firstPart, std::string& lastPart, bool priority) throw(YACS::Exception)
+ std::string& firstPart, std::string& lastPart, bool priority)
{
const string delims(separator);
string portName, nodeName;
return ret;
}
-void ComposedNode::checkConsistency(LinkInfo& info) const throw(YACS::Exception)
+void ComposedNode::checkConsistency(LinkInfo& info) const
{
info.clearAll();
info.setPointOfView((ComposedNode *)this);
* This method check that G1 <- G2 <- G3 <- G1 does not happened.
* Typically called by methods that set a hierarchy (Bloc::edAddChild, Loop::edSetNode, ...).
*/
-void ComposedNode::checkNoCrossHierachyWith(Node *node) const throw(YACS::Exception)
+void ComposedNode::checkNoCrossHierachyWith(Node *node) const
{
ComposedNode *nodeC=dynamic_cast<ComposedNode *>(node);
if(!nodeC)
/*!
* call it only for 'starts' to 'end' links \b DEALED by 'this'.
*/
-void ComposedNode::checkLinksCoherenceRegardingControl(const std::vector<OutPort *>& starts, InputPort *end, LinkInfo& info) const throw(YACS::Exception)
+void ComposedNode::checkLinksCoherenceRegardingControl(const std::vector<OutPort *>& starts, InputPort *end, LinkInfo& info) const
{
map < ComposedNode *, list<OutPort *>, SortHierarc > outputs;//forward link classical
vector<OutPort *> outputsCross;//forward link cross
}
}
-ComposedNode *ComposedNode::getRootNode() const throw(YACS::Exception)
+ComposedNode *ComposedNode::getRootNode() const
{
if(!_father)
return (ComposedNode *)this;
return 0;
}
-string ComposedNode::getChildName(const Node* node) const throw(YACS::Exception)
+string ComposedNode::getChildName(const Node* node) const
{
string nodeName=node->getQualifiedName();
if (!isNodeAlreadyAggregated(node))
return directSon->getName();
}
-Node *ComposedNode::getChildByName(const std::string& name) const throw(YACS::Exception)
+Node *ComposedNode::getChildByName(const std::string& name) const
{
string potentiallyDirectSonName, remainsPath;
bool forwardNeeded=ComposedNode::splitNamesBySep(name, SEP_CHAR_BTW_LEVEL,
* \exception Exception : If 'nodeToTest' is NOT in descendance of 'this' AND not equal to 'this'
* \param nodeToTest : the node to check
*/
-void ComposedNode::checkInMyDescendance(Node *nodeToTest) const throw(YACS::Exception)
+void ComposedNode::checkInMyDescendance(Node *nodeToTest) const
{
const char whatC[]=" is not the descendance of node ";
if(nodeToTest==0)
* \return The lowest common ancestor if it exists.
*
*/
-ComposedNode *ComposedNode::getLowestCommonAncestor(Node *node1, Node *node2) throw(YACS::Exception)
+ComposedNode *ComposedNode::getLowestCommonAncestor(Node *node1, Node *node2)
{
const char what[]="The two nodes do not share the same genealogy";
if(node1==0 || node2==0)
* get the input port name used by the current node, recursively built with children names.
*/
-string ComposedNode::getInPortName(const InPort * inPort) const throw(YACS::Exception)
+string ComposedNode::getInPortName(const InPort * inPort) const
{
return getPortName<InPort>(inPort);
}
-string ComposedNode::getOutPortName(const OutPort *outPort) const throw(YACS::Exception)
+string ComposedNode::getOutPortName(const OutPort *outPort) const
{
return getPortName<OutPort>(outPort);
}
return ret;
}
-OutPort *ComposedNode::getOutPort(const std::string& name) const throw(YACS::Exception)
+OutPort *ComposedNode::getOutPort(const std::string& name) const
{
string portName, nodeName;
if(splitNamesBySep(name,Node::SEP_CHAR_IN_PORT,nodeName,portName,false))
* and so the leaf of type ElementaryNode aggregating
* this InputPort is directly invoked.
*/
-InputPort * ComposedNode::getInputPort(const std::string& name) const throw(YACS::Exception)
+InputPort * ComposedNode::getInputPort(const std::string& name) const
{
try {
return Node::getInputPort(name);
* Contrary to YACS::ENGINE::ComposedNode::getInputPort, this method is recursive and go
* down hierarchy step by step to complete its work.
*/
-OutputPort * ComposedNode::getOutputPort(const std::string& name) const throw(YACS::Exception)
+OutputPort * ComposedNode::getOutputPort(const std::string& name) const
{
string portName, nodeName;
if(splitNamesBySep(name,Node::SEP_CHAR_IN_PORT,nodeName,portName,false))
}
}
-InputDataStreamPort *ComposedNode::getInputDataStreamPort(const std::string& name) const throw(YACS::Exception)
+InputDataStreamPort *ComposedNode::getInputDataStreamPort(const std::string& name) const
{
string portName, nodeName;
if(splitNamesBySep(name,Node::SEP_CHAR_IN_PORT,nodeName,portName,true))
}
}
-OutputDataStreamPort *ComposedNode::getOutputDataStreamPort(const std::string& name) const throw(YACS::Exception)
+OutputDataStreamPort *ComposedNode::getOutputDataStreamPort(const std::string& name) const
{
string portName, nodeName;
if(splitNamesBySep(name,Node::SEP_CHAR_IN_PORT,nodeName,portName,true))
}
void ComposedNode::checkLinkPossibility(OutPort *start, const std::list<ComposedNode *>& pointsOfViewStart,
- InPort *end, const std::list<ComposedNode *>& pointsOfViewEnd) throw(YACS::Exception)
+ InPort *end, const std::list<ComposedNode *>& pointsOfViewEnd)
{
if((dynamic_cast<DataFlowPort *>(start) || dynamic_cast<DataFlowPort *>(end))
&& (dynamic_cast<DataStreamPort *>(start) || dynamic_cast<DataStreamPort *>(end)))
{
}
-void ComposedNode::getDelegateOf(InPort * & port, OutPort *initialStart, const std::list<ComposedNode *>& pointsOfView) throw(YACS::Exception)
+void ComposedNode::getDelegateOf(InPort * & port, OutPort *initialStart, const std::list<ComposedNode *>& pointsOfView)
{
}
-void ComposedNode::getDelegateOf(std::pair<OutPort *, OutPort *>& port, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView) throw(YACS::Exception)
+void ComposedNode::getDelegateOf(std::pair<OutPort *, OutPort *>& port, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView)
{
}
-void ComposedNode::releaseDelegateOf(InPort * & port, OutPort *initialStart, const std::list<ComposedNode *>& pointsOfView) throw(YACS::Exception)
+void ComposedNode::releaseDelegateOf(InPort * & port, OutPort *initialStart, const std::list<ComposedNode *>& pointsOfView)
{
}
-void ComposedNode::releaseDelegateOf(OutPort *portDwn, OutPort *portUp, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView) throw(YACS::Exception)
+void ComposedNode::releaseDelegateOf(OutPort *portDwn, OutPort *portUp, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView)
{
}
-void ComposedNode::checkBasicConsistency() const throw(YACS::Exception)
+void ComposedNode::checkBasicConsistency() const
{
DEBTRACE("ComposedNode::checkBasicConsistency");
std::list<InputPort *>::const_iterator iter;
std::string getName() const;
std::string getTaskName(Task *task) const;
DeploymentTree getDeploymentTree() const;
- DeploymentTree checkDeploymentTree(bool deep) const throw(Exception);
+ DeploymentTree checkDeploymentTree(bool deep) const ;
std::vector<Task *> getNextTasks(bool& isMore);
virtual bool isPlacementPredictableB4Run() const = 0;
void notifyFrom(const Task *sender, YACS::Event event, const Executor *execInst);
- bool edAddLink(OutPort *start, InPort *end) throw(Exception);
- virtual bool edAddDFLink(OutPort *start, InPort *end) throw(Exception);
+ bool edAddLink(OutPort *start, InPort *end) ;
+ virtual bool edAddDFLink(OutPort *start, InPort *end) ;
//Node* DISOWNnode is a SWIG notation to indicate that the ownership of the node is transfered to C++
- virtual bool edAddChild(Node *DISOWNnode) throw(Exception);
- virtual void edRemoveChild(Node *node) throw(Exception);
- bool edAddLink(OutGate *start, InGate *end) throw(Exception);
- bool edAddCFLink(Node *nodeS, Node *nodeE) throw(Exception);
- void edRemoveCFLink(Node *nodeS, Node *nodeE) throw(Exception);
- void edRemoveLink(OutPort *start, InPort *end) throw(Exception);
- void edRemoveLink(OutGate *start, InGate *end) throw(Exception);
+ virtual bool edAddChild(Node *DISOWNnode) ;
+ virtual void edRemoveChild(Node *node) ;
+ bool edAddLink(OutGate *start, InGate *end) ;
+ bool edAddCFLink(Node *nodeS, Node *nodeE) ;
+ void edRemoveCFLink(Node *nodeS, Node *nodeE) ;
+ void edRemoveLink(OutPort *start, InPort *end) ;
+ void edRemoveLink(OutGate *start, InGate *end) ;
virtual bool isRepeatedUnpredictablySeveralTimes() const { return false; }
virtual bool isLoop() const { return false; }
virtual std::list<Node *> edGetDirectDescendants() const = 0;
std::list<Node *> getAllRecursiveNodes();
virtual std::list<Node *> getAllRecursiveConstituents(); // first implementation
std::list<ProgressWeight> getProgressWeight() const;
- std::string getInPortName(const InPort *) const throw (Exception);
- std::string getOutPortName(const OutPort *) const throw (Exception);
+ std::string getInPortName(const InPort *) const ;
+ std::string getOutPortName(const OutPort *) const ;
//
int getNumberOfInputPorts() const;
int getNumberOfOutputPorts() const;
std::set<InPort *> getAllInPortsComingFromOutsideOfCurrentScope() const;
std::list<InputDataStreamPort *> getSetOfInputDataStreamPort() const;
std::list<OutputDataStreamPort *> getSetOfOutputDataStreamPort() const;
- OutPort *getOutPort(const std::string& name) const throw(Exception);
- InputPort *getInputPort(const std::string& name) const throw(Exception);
- OutputPort *getOutputPort(const std::string& name) const throw(Exception);
- InputDataStreamPort *getInputDataStreamPort(const std::string& name) const throw(Exception);
- OutputDataStreamPort *getOutputDataStreamPort(const std::string& name) const throw(Exception);
+ OutPort *getOutPort(const std::string& name) const ;
+ InputPort *getInputPort(const std::string& name) const ;
+ OutputPort *getOutputPort(const std::string& name) const ;
+ InputDataStreamPort *getInputDataStreamPort(const std::string& name) const ;
+ OutputDataStreamPort *getOutputDataStreamPort(const std::string& name) const ;
std::vector< std::pair<OutPort *, InPort *> > getSetOfInternalLinks() const;
virtual std::vector< std::pair<OutPort *, InPort *> > getSetOfLinksLeavingCurrentScope() const;
- void checkConsistency(LinkInfo& info) const throw(Exception);
+ void checkConsistency(LinkInfo& info) const ;
virtual std::vector< std::pair<InPort *, OutPort *> > getSetOfLinksComingInCurrentScope() const;
virtual std::string typeName() {return "YACS__ENGINE__ComposedNode";}
virtual void edUpdateState();
- virtual void checkBasicConsistency() const throw(Exception);
+ virtual void checkBasicConsistency() const ;
virtual std::string getErrorReport();
//
- ComposedNode *getRootNode() const throw(Exception);
+ ComposedNode *getRootNode() const ;
bool isNodeAlreadyAggregated(const Node *node) const;
virtual bool isNameAlreadyUsed(const std::string& name) const;
Node *isInMyDescendance(Node *nodeToTest) const;
- std::string getChildName(const Node* node) const throw(Exception);
+ std::string getChildName(const Node* node) const ;
virtual std::string getMyQualifiedName(const Node *directSon) const;
- Node *getChildByName(const std::string& name) const throw(Exception);
- static ComposedNode *getLowestCommonAncestor(Node *node1, Node *node2) throw(Exception);
+ Node *getChildByName(const std::string& name) const ;
+ static ComposedNode *getLowestCommonAncestor(Node *node1, Node *node2) ;
static std::string getLowestCommonAncestorStr(const std::string& node1, const std::string& node2);
void loaded();
void connected();
protected:
void edDisconnectAllLinksWithMe();
static bool splitNamesBySep(const std::string& globalName, const char separator[],
- std::string& firstPart, std::string& lastPart, bool priority) throw(Exception);
- virtual Node *getChildByShortName(const std::string& name) const throw(Exception) = 0;
+ std::string& firstPart, std::string& lastPart, bool priority) ;
+ virtual Node *getChildByShortName(const std::string& name) const = 0;
YACS::Event updateStateFrom(Node *node, YACS::Event event, const Executor *execInst);//update the state of this. Precondition : node->_father == this
virtual YACS::Event updateStateOnStartEventFrom(Node *node);//transition 3 doc P.R
virtual YACS::Event updateStateOnFinishedEventFrom(Node *node) = 0;//transition 9 doc P.R.
virtual YACS::Event updateStateOnFailedEventFrom(Node *node, const Executor *execInst);//transition 9 doc P.R.
virtual void checkLinkPossibility(OutPort *start, const std::list<ComposedNode *>& pointsOfViewStart,
- InPort *end, const std::list<ComposedNode *>& pointsOfViewEnd) throw(Exception);
+ InPort *end, const std::list<ComposedNode *>& pointsOfViewEnd) ;
virtual void buildDelegateOf(InPort * & port, OutPort *initialStart, const std::list<ComposedNode *>& pointsOfView);
virtual void buildDelegateOf(std::pair<OutPort *, OutPort *>& port, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView);
- virtual void getDelegateOf(InPort * & port, OutPort *initialStart, const std::list<ComposedNode *>& pointsOfView) throw(Exception);
- virtual void getDelegateOf(std::pair<OutPort *, OutPort *>& port, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView) throw(Exception);
- virtual void releaseDelegateOf(InPort * & port, OutPort *initialStart, const std::list<ComposedNode *>& pointsOfView) throw(Exception);
- virtual void releaseDelegateOf(OutPort *portDwn, OutPort *portUp, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView) throw(Exception);
- virtual void checkNoCyclePassingThrough(Node *node) throw(Exception) = 0;
- void checkInMyDescendance(Node *nodeToTest) const throw(Exception);
+ virtual void getDelegateOf(InPort * & port, OutPort *initialStart, const std::list<ComposedNode *>& pointsOfView) ;
+ virtual void getDelegateOf(std::pair<OutPort *, OutPort *>& port, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView) ;
+ virtual void releaseDelegateOf(InPort * & port, OutPort *initialStart, const std::list<ComposedNode *>& pointsOfView) ;
+ virtual void releaseDelegateOf(OutPort *portDwn, OutPort *portUp, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView) ;
+ virtual void checkNoCyclePassingThrough(Node *node) = 0;
+ void checkInMyDescendance(Node *nodeToTest) const ;
template <class PORT>
- std::string getPortName(const PORT * port) const throw (Exception);
+ std::string getPortName(const PORT * port) const ;
//For CF Computations
- void checkNoCrossHierachyWith(Node *node) const throw (Exception);
+ void checkNoCrossHierachyWith(Node *node) const ;
virtual void performCFComputations(LinkInfo& info) const;
virtual void destructCFComputations(LinkInfo& info) const;
Node *getLowestNodeDealingAll(const std::list<OutPort *>& ports) const;
void checkLinksCoherenceRegardingControl(const std::vector<OutPort *>& starts,
- InputPort *end, LinkInfo& info) const throw(Exception);
+ InputPort *end, LinkInfo& info) const ;
virtual void checkControlDependancy(OutPort *start, InPort *end, bool cross,
std::map < ComposedNode *, std::list < OutPort * >, SortHierarc >& fw,
std::vector<OutPort *>& fwCross,
};
template <class PORT>
- std::string ComposedNode::getPortName(const PORT * port) const throw (Exception)
+ std::string ComposedNode::getPortName(const PORT * port) const
{
Node *node = port->getNode();
std::string portName = port->getName();
return (void *)_value;
}
-void ConditionInputPort::put(const void *data) throw(ConversionException)
+void ConditionInputPort::put(const void *data)
{
put((Any*)data);
}
_value=nullptr;
}
-void ConditionInputPort::put(Any *data) throw(ConversionException)
+void ConditionInputPort::put(Any *data)
{
ConditionInputPort::releaseData();
_value=data;
void edNotifyReferencedBy(OutPort *fromPort, bool isLoopProof) override;
void edNotifyDereferencedBy(OutPort *fromPort);
void *get() const;
- virtual void put(const void *data) throw(ConversionException);
- void put(Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(Any *data);
void releaseData() override;
std::string dump();
virtual std::string getAsString();
//Execution only methods
virtual std::string getDiscreminantStrOfThis(const Task *askingNode) const;
virtual bool isAlreadyStarted(const Task *askingNode) const = 0;
- virtual void start(const Task *askingNode) throw(Exception) = 0;
+ virtual void start(const Task *askingNode) = 0;
virtual std::string getPlacementId(const Task *askingNode) const = 0;
virtual std::string getFullPlacementId(const Task *askingNode) const = 0;
//Edition only methods
virtual Container *clone() const = 0;
virtual Container *cloneAlways() const = 0;
virtual bool isSupportingRTODefNbOfComp() const;
- virtual void checkCapabilityToDealWith(const ComponentInstance *inst) const throw(Exception) = 0;
+ virtual void checkCapabilityToDealWith(const ComponentInstance *inst) const = 0;
virtual void setProperty(const std::string& name,const std::string& value) = 0;
virtual std::string getProperty(const std::string& name) const = 0;
virtual void clearProperties() = 0;
//! returns type of channel the port will use for data exchange on runtime : DATAFLOW or DATASTREAM.
virtual TypeOfChannel getTypeOfChannel() const = 0;
bool isDifferentTypeOf(const DataPort *other) const;
- virtual void edRemoveAllLinksLinkedWithMe() throw(Exception) = 0;
+ virtual void edRemoveAllLinksLinkedWithMe() = 0;
virtual std::string typeName() {return "YACS__ENGINE__DataPort";}
virtual std::string getAsString();
public:
* \param end : the InPort to connect
* \return true if a new link has been created, false otherwise.
*/
-bool DynParaLoop::edAddDFLink(OutPort *start, InPort *end) throw(YACS::Exception)
+bool DynParaLoop::edAddDFLink(OutPort *start, InPort *end)
{
return edAddLink(start,end);
}
return ret;
}
-OutPort *DynParaLoop::getOutPort(const std::string& name) const throw(YACS::Exception)
+OutPort *DynParaLoop::getOutPort(const std::string& name) const
{
if (name == NAME_OF_SPLITTED_SEQ_OUT || name == OLD_NAME_OF_SPLITTED_SEQ_OUT)
return (OutPort *)&_splittedPort;
}
-OutputPort *DynParaLoop::getOutputPort(const std::string& name) const throw(YACS::Exception)
+OutputPort *DynParaLoop::getOutputPort(const std::string& name) const
{
if (name == NAME_OF_SPLITTED_SEQ_OUT || name == OLD_NAME_OF_SPLITTED_SEQ_OUT)
return (OutputPort *)&_splittedPort;
return removeNode(_finalizeNode);
}
-void DynParaLoop::edRemoveChild(Node *node) throw(YACS::Exception)
+void DynParaLoop::edRemoveChild(Node *node)
{
ComposedNode::edRemoveChild(node);
if(node==_node)
modified();
}
-bool DynParaLoop::edAddChild(Node *DISOWNnode) throw(YACS::Exception)
+bool DynParaLoop::edAddChild(Node *DISOWNnode)
{
return edSetNode(DISOWNnode);
}
return ret;
}
-InputPort *DynParaLoop::getInputPort(const std::string& name) const throw(YACS::Exception)
+InputPort *DynParaLoop::getInputPort(const std::string& name) const
{
if(_nbOfBranches->isMyName(name))
return _nbOfBranches->getPort();
return ret;
}
-unsigned DynParaLoop::getNumberOfBranchesCreatedDyn() const throw(YACS::Exception)
+unsigned DynParaLoop::getNumberOfBranchesCreatedDyn() const
{
if(_execNodes.empty())
throw Exception("ForEachLoop::getNumberOfBranches : No branches created dynamically ! - ForEachLoop needs to run or to be runned to call getNumberOfBranches");
return _execNodes.size();
}
-Node *DynParaLoop::getChildByShortName(const std::string& name) const throw(YACS::Exception)
+Node *DynParaLoop::getChildByShortName(const std::string& name) const
{
if (_node && name == _node->getName())
return _node;
throw Exception(what);
}
-Node *DynParaLoop::getChildByNameExec(const std::string& name, unsigned id) const throw(YACS::Exception)
+Node *DynParaLoop::getChildByNameExec(const std::string& name, unsigned id) const
{
if(id>=getNumberOfBranchesCreatedDyn())
throw Exception("ForEachLoop::getChildByNameExec : invalid id - too large compared with dynamically created branches.");
}
void DynParaLoop::checkLinkPossibility(OutPort *start, const std::list<ComposedNode *>& pointsOfViewStart,
- InPort *end, const std::list<ComposedNode *>& pointsOfViewEnd) throw(YACS::Exception)
+ InPort *end, const std::list<ComposedNode *>& pointsOfViewEnd)
{
ComposedNode::checkLinkPossibility(start, pointsOfViewStart, end, pointsOfViewEnd);
Node * startNode = isInMyDescendance(start->getNode());
return 0;
}
-void DynParaLoop::checkBasicConsistency() const throw(YACS::Exception)
+void DynParaLoop::checkBasicConsistency() const
{
DEBTRACE("DynParaLoop::checkBasicConsistency");
ComposedNode::checkBasicConsistency();
Node *edSetNode(Node *DISOWNnode);
Node *edSetInitNode(Node *DISOWNnode);
Node *edSetFinalizeNode(Node *DISOWNnode);
- virtual bool edAddDFLink(OutPort *start, InPort *end) throw(Exception);
+ virtual bool edAddDFLink(OutPort *start, InPort *end) ;
void init(bool start=true);
InputPort *edGetNbOfBranchesPort() { return _nbOfBranches->getPort(); }
int getNumberOfInputPorts() const;
std::list<OutputPort *> getSetOfOutputPort() const;
std::list<OutputPort *> getLocalOutputPorts() const;
OutputPort *edGetSamplePort() { return &_splittedPort; }
- OutPort *getOutPort(const std::string& name) const throw(Exception);
- InputPort *getInputPort(const std::string& name) const throw(Exception);
- OutputPort *getOutputPort(const std::string& name) const throw(Exception);
+ OutPort *getOutPort(const std::string& name) const ;
+ InputPort *getInputPort(const std::string& name) const ;
+ OutputPort *getOutputPort(const std::string& name) const ;
//! For the moment false is returned : impovement about it coming soon.
bool isPlacementPredictableB4Run() const;
- void edRemoveChild(Node *node) throw(Exception);
+ void edRemoveChild(Node *node) ;
bool isLoop() const override { return true; }
- virtual bool edAddChild(Node *DISOWNnode) throw(Exception);
+ virtual bool edAddChild(Node *DISOWNnode) ;
std::list<Node *> edGetDirectDescendants() const;
std::list<InputPort *> getSetOfInputPort() const;
std::list<InputPort *> getLocalInputPorts() const;
- unsigned getNumberOfBranchesCreatedDyn() const throw(Exception);
- Node *getChildByShortName(const std::string& name) const throw(Exception);
- Node *getChildByNameExec(const std::string& name, unsigned id) const throw(Exception);
+ unsigned getNumberOfBranchesCreatedDyn() const ;
+ Node *getChildByShortName(const std::string& name) const ;
+ Node *getChildByNameExec(const std::string& name, unsigned id) const ;
std::vector<Node *> getNodes() const { return _execNodes; } // need to use in GUI part for adding observers for clone nodes
ComplexWeight * getWeight();
void setWeight(double loopWeight);
void getWeightRegardingDPL(ComplexWeight *weight) {weight->addWeight(getWeight());}
bool isMultiplicitySpecified(unsigned& value) const;
void forceMultiplicity(unsigned value);
- virtual void checkBasicConsistency() const throw(Exception);
+ virtual void checkBasicConsistency() const ;
virtual std::string getErrorReport();
void accept(Visitor *visitor);
Node * getInitNode();
std::map< ComposedNode *, std::list < OutPort *>, SortHierarc >& bw,
LinkInfo& info) const;
virtual void checkLinkPossibility(OutPort *start, const std::list<ComposedNode *>& pointsOfViewStart,
- InPort *end, const std::list<ComposedNode *>& pointsOfViewEnd) throw(Exception);
+ InPort *end, const std::list<ComposedNode *>& pointsOfViewEnd) ;
protected:
void prepareInputsFromOutOfScope(int branchNb);
void putValueOnBranch(Any *val, unsigned branchId, bool first);
return _setOfOutputPort.size();
}
-InputPort *ElementaryNode::getInputPort(const std::string& name) const throw(YACS::Exception)
+InputPort *ElementaryNode::getInputPort(const std::string& name) const
{
try {
return Node::getInputPort(name);
return getPort<InputPort>(name,_setOfInputPort);
}
-OutputPort *ElementaryNode::getOutputPort(const std::string& name) const throw(YACS::Exception)
+OutputPort *ElementaryNode::getOutputPort(const std::string& name) const
{
return getPort<OutputPort>(name,_setOfOutputPort);
}
return ret;
}
-InputDataStreamPort *ElementaryNode::getInputDataStreamPort(const std::string& name) const throw(YACS::Exception)
+InputDataStreamPort *ElementaryNode::getInputDataStreamPort(const std::string& name) const
{
return getPort<InputDataStreamPort>(name,_setOfInputDataStreamPort);
}
-OutputDataStreamPort *ElementaryNode::getOutputDataStreamPort(const std::string& name) const throw(YACS::Exception)
+OutputDataStreamPort *ElementaryNode::getOutputDataStreamPort(const std::string& name) const
{
return getPort<OutputDataStreamPort>(name,_setOfOutputDataStreamPort);
}
* remove port from node at edition. Ports are typed.
*/
-void ElementaryNode::edRemovePort(Port *port) throw(YACS::Exception)
+void ElementaryNode::edRemovePort(Port *port)
{
DEBTRACE("ElementaryNode::edRemovePort ");
if(port->getNode()!=this)
return ret;
}
-Node *ElementaryNode::getChildByName(const std::string& name) const throw(YACS::Exception)
+Node *ElementaryNode::getChildByName(const std::string& name) const
{
string what("ElementaryNode does not agregate any nodes particullary node with name "); what+=name;
throw Exception(what);
}
-void ElementaryNode::checkBasicConsistency() const throw(YACS::Exception)
+void ElementaryNode::checkBasicConsistency() const
{
DEBTRACE("ElementaryNode::checkBasicConsistency");
list<InputPort *>::const_iterator iter;
* WARNING: CHECK CASE OF BLOC: ONLY INPUT PORTS NOT INTERNALLY CONNECTED MUST BE VISIBLE.
*/
-InputPort *ElementaryNode::edAddInputPort(const std::string& inputPortName, TypeCode* type) throw(YACS::Exception)
+InputPort *ElementaryNode::edAddInputPort(const std::string& inputPortName, TypeCode* type)
{
// Cannot create an InputPort defined with InPropertyPort name.
* for now, publication is done the same way as input ports
*/
-OutputPort *ElementaryNode::edAddOutputPort(const std::string& outputPortName, TypeCode* type) throw(YACS::Exception)
+OutputPort *ElementaryNode::edAddOutputPort(const std::string& outputPortName, TypeCode* type)
{
OutputPort *ret =0;
if (edCheckAddPort<OutputPort, TypeCode*>(outputPortName,_setOfOutputPort,type))
return getRuntime()->createInputDataStreamPort(inputPortDSName, this, type);
}
-InputDataStreamPort *ElementaryNode::edAddInputDataStreamPort(const std::string& inputPortDSName, TypeCode* type) throw(YACS::Exception)
+InputDataStreamPort *ElementaryNode::edAddInputDataStreamPort(const std::string& inputPortDSName, TypeCode* type)
{
InputDataStreamPort *ret = 0;
if (edCheckAddPort<InputDataStreamPort, TypeCode*>(inputPortDSName,_setOfInputDataStreamPort,type))
return getRuntime()->createOutputDataStreamPort(outputPortDSName, this, type);
}
-OutputDataStreamPort *ElementaryNode::edAddOutputDataStreamPort(const std::string& outputPortDSName, TypeCode* type) throw(YACS::Exception)
+OutputDataStreamPort *ElementaryNode::edAddOutputDataStreamPort(const std::string& outputPortDSName, TypeCode* type)
{
OutputDataStreamPort *ret = 0;
if (edCheckAddPort<OutputDataStreamPort, TypeCode*>(outputPortDSName,_setOfOutputDataStreamPort,type))
* get the input port name used by the current node (see composed nodes)
*/
-string ElementaryNode::getInPortName(const InPort * inPort) const throw(YACS::Exception)
+string ElementaryNode::getInPortName(const InPort * inPort) const
{
Node *node = inPort->getNode();
if ( node != this )
return inPort->getName();
}
-string ElementaryNode::getOutPortName(const OutPort *outPort) const throw(YACS::Exception)
+string ElementaryNode::getOutPortName(const OutPort *outPort) const
{
Node *node = outPort->getNode();
if ( node != this )
Container *getContainer();
YACS::StatesForNode getState() const;
void getReadyTasks(std::vector<Task *>& tasks);
- void edRemovePort(Port *port) throw(Exception);
+ void edRemovePort(Port *port) ;
std::list<ElementaryNode *> getRecursiveConstituents() const;
std::list<ProgressWeight> getProgressWeight() const;
- Node *getChildByName(const std::string& name) const throw(Exception);
- virtual void checkBasicConsistency() const throw(Exception);
+ Node *getChildByName(const std::string& name) const ;
+ virtual void checkBasicConsistency() const ;
ComposedNode *getDynClonerIfExists(const ComposedNode *levelToStop) const;
int getNumberOfInputPorts() const;
int getNumberOfOutputPorts() const;
- std::string getInPortName(const InPort *) const throw (Exception);
- std::string getOutPortName(const OutPort *) const throw (Exception);
- InputPort *getInputPort(const std::string& name) const throw(Exception);
- OutputPort *getOutputPort(const std::string& name) const throw(Exception);
+ std::string getInPortName(const InPort *) const ;
+ std::string getOutPortName(const OutPort *) const ;
+ InputPort *getInputPort(const std::string& name) const ;
+ OutputPort *getOutputPort(const std::string& name) const ;
std::list<InputPort *> getSetOfInputPort() const { return _setOfInputPort; }
std::list<OutputPort *> getSetOfOutputPort() const { return _setOfOutputPort; }
std::list<InputPort *> getLocalInputPorts() const { return _setOfInputPort; }
virtual std::vector< std::pair<InPort *, OutPort *> > getSetOfLinksComingInCurrentScope() const;
std::list<InputDataStreamPort *> getSetOfInputDataStreamPort() const { return _setOfInputDataStreamPort; }
std::list<OutputDataStreamPort *> getSetOfOutputDataStreamPort() const { return _setOfOutputDataStreamPort; }
- InputDataStreamPort *getInputDataStreamPort(const std::string& name) const throw(Exception);
- OutputDataStreamPort *getOutputDataStreamPort(const std::string& name) const throw(Exception);
+ InputDataStreamPort *getInputDataStreamPort(const std::string& name) const ;
+ OutputDataStreamPort *getOutputDataStreamPort(const std::string& name) const ;
virtual InputPort *createInputPort(const std::string& inputPortName, TypeCode* type);
virtual OutputPort *createOutputPort(const std::string& outputPortName, TypeCode* type);
virtual InputDataStreamPort *createInputDataStreamPort(const std::string& inputPortDSName, TypeCode* type);
virtual OutputDataStreamPort *createOutputDataStreamPort(const std::string& outputPortDSName, TypeCode* type);
- virtual InputPort *edAddInputPort(const std::string& inputPortName, TypeCode* type) throw(Exception);
- virtual OutputPort *edAddOutputPort(const std::string& outputPortName, TypeCode* type) throw(Exception);
- virtual InputDataStreamPort *edAddInputDataStreamPort(const std::string& inputPortDSName, TypeCode* type) throw(Exception);
- virtual OutputDataStreamPort *edAddOutputDataStreamPort(const std::string& outputPortDSName, TypeCode* type) throw(Exception);
+ virtual InputPort *edAddInputPort(const std::string& inputPortName, TypeCode* type) ;
+ virtual OutputPort *edAddOutputPort(const std::string& outputPortName, TypeCode* type) ;
+ virtual InputDataStreamPort *edAddInputDataStreamPort(const std::string& inputPortDSName, TypeCode* type) ;
+ virtual OutputDataStreamPort *edAddOutputDataStreamPort(const std::string& outputPortDSName, TypeCode* type) ;
virtual void edOrderInputPorts(const std::list<InputPort*>& ports);
virtual void edOrderOutputPorts(const std::list<OutputPort*>& ports);
void edDisconnectAllLinksWithMe();
bool areAllInputPortsValid() const;
template<class PORT>
- PORT *getPort(const std::string& name, const std::list<PORT *>& setOfPorts) const throw(Exception);
+ PORT *getPort(const std::string& name, const std::list<PORT *>& setOfPorts) const ;
template<class PORT, class ENUMTYPE>
- PORT *edAddPort(const std::string& portName, std::list<PORT *>& setOfPorts, ENUMTYPE type) throw(Exception);
+ PORT *edAddPort(const std::string& portName, std::list<PORT *>& setOfPorts, ENUMTYPE type) ;
template<class PORT, class ENUMTYPE>
- bool edCheckAddPort(const std::string& portName, std::list<PORT *>& setOfPorts, ENUMTYPE type) throw(Exception);
+ bool edCheckAddPort(const std::string& portName, std::list<PORT *>& setOfPorts, ENUMTYPE type) ;
template<class PORT>
- static void edRemovePortTypedFromSet(PORT *port, std::list<PORT *>& setOfPorts) throw(Exception);
+ static void edRemovePortTypedFromSet(PORT *port, std::list<PORT *>& setOfPorts) ;
template<class PORT>
static bool isPortNameAlreadyExist(const std::string& portName, const std::list<PORT *>& setOfPorts);
};
*/
template<class PORT>
- PORT *ElementaryNode::getPort(const std::string& name, const std::list<PORT *>& setOfPorts) const throw(Exception)
+ PORT *ElementaryNode::getPort(const std::string& name, const std::list<PORT *>& setOfPorts) const
{
for(typename std::list<PORT *>::const_iterator iter=setOfPorts.begin();iter!=setOfPorts.end();iter++)
{
*/
template<class PORT, class ENUMTYPE>
- PORT *ElementaryNode::edAddPort(const std::string& portName, std::list<PORT *>& setOfPorts, ENUMTYPE type) throw(Exception)
+ PORT *ElementaryNode::edAddPort(const std::string& portName, std::list<PORT *>& setOfPorts, ENUMTYPE type)
{
checkValidityOfPortName(portName);
if(isPortNameAlreadyExist<PORT>(portName, setOfPorts))
}
template<class PORT, class ENUMTYPE>
- bool ElementaryNode::edCheckAddPort(const std::string& portName, std::list<PORT *>& setOfPorts, ENUMTYPE type) throw(Exception)
+ bool ElementaryNode::edCheckAddPort(const std::string& portName, std::list<PORT *>& setOfPorts, ENUMTYPE type)
{
checkValidityOfPortName(portName);
if(isPortNameAlreadyExist<PORT>(portName, setOfPorts))
*/
template<class PORT>
- void ElementaryNode::edRemovePortTypedFromSet(PORT *port, std::list<PORT *>& setOfPorts) throw(Exception)
+ void ElementaryNode::edRemovePortTypedFromSet(PORT *port, std::list<PORT *>& setOfPorts)
{
if(!isPortNameAlreadyExist<PORT>(port->getName(), setOfPorts))
throw Exception("Port is not part of the list : unable to remove it");
{
}
-bool AnySplitOutputPort::addInPort(InPort *inPort) throw(YACS::Exception)
+bool AnySplitOutputPort::addInPort(InPort *inPort)
{
bool ret=OutputPort::addInPort(inPort);
if(_repr)
_repr->getAllRepresented(represented);
}
-int AnySplitOutputPort::removeInPort(InPort *inPort, bool forward) throw(YACS::Exception)
+int AnySplitOutputPort::removeInPort(InPort *inPort, bool forward)
{
bool ret=OutputPort::removeInPort(inPort,forward);
if(_repr)
{
}
-InputPort *SplitterNode::getInputPort(const std::string& name) const throw(YACS::Exception)
+InputPort *SplitterNode::getInputPort(const std::string& name) const
{
if(name==NAME_OF_SEQUENCE_INPUT)
return (InputPort *)&_dataPortToDispatch;
return DynParaLoop::getNumberOfInputPorts()+1;
}
-void ForEachLoopGen::checkNoCyclePassingThrough(Node *node) throw(YACS::Exception)
+void ForEachLoopGen::checkNoCyclePassingThrough(Node *node)
{
//TO DO
}
return ret;
}
-InputPort *ForEachLoopGen::getInputPort(const std::string& name) const throw(YACS::Exception)
+InputPort *ForEachLoopGen::getInputPort(const std::string& name) const
{
if(name==SplitterNode::NAME_OF_SEQUENCE_INPUT)
return (InputPort *)&_splitterNode._dataPortToDispatch;
return DynParaLoop::getInputPort(name);
}
-OutputPort *ForEachLoopGen::getOutputPort(const std::string& name) const throw(YACS::Exception)
+OutputPort *ForEachLoopGen::getOutputPort(const std::string& name) const
{
for(vector<AnySplitOutputPort *>::const_iterator iter=_outGoingPorts.begin();iter!=_outGoingPorts.end();iter++)
{
return DynParaLoop::getOutputPort(name);
}
-OutPort *ForEachLoopGen::getOutPort(const std::string& name) const throw(YACS::Exception)
+OutPort *ForEachLoopGen::getOutPort(const std::string& name) const
{
for(vector<AnySplitOutputPort *>::const_iterator iter=_outGoingPorts.begin();iter!=_outGoingPorts.end();iter++)
{
return DynParaLoop::getOutPort(name);
}
-Node *ForEachLoopGen::getChildByShortName(const std::string& name) const throw(YACS::Exception)
+Node *ForEachLoopGen::getChildByShortName(const std::string& name) const
{
if(name==NAME_OF_SPLITTERNODE)
return (Node *)&_splitterNode;
throw Exception("ForEachLoopGen::buildDelegateOf : not implemented for DS because not specified");
}
-void ForEachLoopGen::getDelegateOf(std::pair<OutPort *, OutPort *>& port, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView) throw(YACS::Exception)
+void ForEachLoopGen::getDelegateOf(std::pair<OutPort *, OutPort *>& port, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView)
{
string typeOfPortInstance=(port.first)->getNameOfTypeOfCurrentInstance();
if(typeOfPortInstance==OutputPort::NAME)
throw Exception("ForEachLoopGen::getDelegateOf : not implemented because not specified");
}
-void ForEachLoopGen::releaseDelegateOf(OutPort *portDwn, OutPort *portUp, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView) throw(YACS::Exception)
+void ForEachLoopGen::releaseDelegateOf(OutPort *portDwn, OutPort *portUp, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView)
{
string typeOfPortInstance=portDwn->getNameOfTypeOfCurrentInstance();
if(typeOfPortInstance==OutputPort::NAME)
}
void ForEachLoopGen::checkLinkPossibility(OutPort *start, const std::list<ComposedNode *>& pointsOfViewStart,
- InPort *end, const std::list<ComposedNode *>& pointsOfViewEnd) throw(YACS::Exception)
+ InPort *end, const std::list<ComposedNode *>& pointsOfViewEnd)
{
DynParaLoop::checkLinkPossibility(start, pointsOfViewStart, end, pointsOfViewEnd);
if(end->getNode() == &_splitterNode)
void incrRef() const;
AnySplitOutputPort(const std::string& name, Node *node, TypeCode *type);
AnySplitOutputPort(const AnySplitOutputPort& other, Node *newHelder);
- bool addInPort(InPort *inPort) throw(Exception);
+ bool addInPort(InPort *inPort) ;
void getAllRepresented(std::set<OutPort *>& represented) const;
- int removeInPort(InPort *inPort, bool forward) throw(Exception);
+ int removeInPort(InPort *inPort, bool forward) ;
void addRepr(OutPort *repr, InterceptorInputPort *intercptr);
OutPort *getRepr() const { return _repr; }
OutputPort *clone(Node *newHelder) const;
private:
SplitterNode(const std::string& name, TypeCode *typeOfData, ForEachLoopGen *father);
SplitterNode(const SplitterNode& other, ForEachLoopGen *father);
- InputPort *getInputPort(const std::string& name) const throw(Exception);
+ InputPort *getInputPort(const std::string& name) const ;
Node *simpleClone(ComposedNode *father, bool editionOnly) const;
unsigned getNumberOfElements() const;
void execute();
void getReadyTasks(std::vector<Task *>& tasks);
int getNumberOfInputPorts() const;
//
- void checkNoCyclePassingThrough(Node *node) throw(Exception);
+ void checkNoCyclePassingThrough(Node *node) ;
void selectRunnableTasks(std::vector<Task *>& tasks);
//
unsigned getExecCurrentId() const { return _execCurrentId; } // for update progress bar on GUI part
std::list<InputPort *> getSetOfInputPort() const;
std::list<InputPort *> getLocalInputPorts() const;
InputPort *edGetSeqOfSamplesPort() { return &_splitterNode._dataPortToDispatch; }
- InputPort *getInputPort(const std::string& name) const throw(Exception);
- OutPort *getOutPort(const std::string& name) const throw(Exception);
- OutputPort *getOutputPort(const std::string& name) const throw(Exception);
- Node *getChildByShortName(const std::string& name) const throw(Exception);
+ InputPort *getInputPort(const std::string& name) const ;
+ OutPort *getOutPort(const std::string& name) const ;
+ OutputPort *getOutputPort(const std::string& name) const ;
+ Node *getChildByShortName(const std::string& name) const ;
std::list<OutputPort *> getLocalOutputPorts() const;
void writeDot(std::ostream &os) const;
virtual std::string typeName() {return "YACS__ENGINE__ForEachLoop";}
void cleanDynGraph() override;
protected:
void checkLinkPossibility(OutPort *start, const std::list<ComposedNode *>& pointsOfViewStart,
- InPort *end, const std::list<ComposedNode *>& pointsOfViewEnd) throw(Exception);
+ InPort *end, const std::list<ComposedNode *>& pointsOfViewEnd) ;
YACS::Event updateStateOnFinishedEventFrom(Node *node);
YACS::Event updateStateForInitNodeOnFinishedEventFrom(Node *node, unsigned int id);
YACS::Event updateStateForWorkNodeOnFinishedEventFrom(Node *node, unsigned int id, bool isNormalFinish);
YACS::Event updateStateForFinalizeNodeOnFinishedEventFrom(Node *node, unsigned int id);
YACS::Event updateStateOnFailedEventFrom(Node *node, const Executor *execInst);
void buildDelegateOf(std::pair<OutPort *, OutPort *>& port, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView);
- void getDelegateOf(std::pair<OutPort *, OutPort *>& port, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView) throw(Exception);
- void releaseDelegateOf(OutPort *portDwn, OutPort *portUp, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView) throw(Exception);
+ void getDelegateOf(std::pair<OutPort *, OutPort *>& port, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView) ;
+ void releaseDelegateOf(OutPort *portDwn, OutPort *portUp, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView) ;
protected:
void pushAllSequenceValues();
void createOutputOutOfScopeInterceptors(int branchNb);
return new ForLoop(*this,father,editionOnly);
}
-InputPort* ForLoop::getInputPort(const std::string& name) const throw(YACS::Exception)
+InputPort* ForLoop::getInputPort(const std::string& name) const
{
if(name == NAME_OF_NSTEPS_NUMBER)return (InputPort*)&_nbOfTimesPort;
return Loop::getInputPort(name);
return ret;
}
-OutPort *ForLoop::getOutPort(const std::string& name) const throw(YACS::Exception)
+OutPort *ForLoop::getOutPort(const std::string& name) const
{
if(name==NAME_OF_INDEX)
return (OutPort *)&_indexPort;
return Loop::getOutPort(name);
}
-OutputPort *ForLoop::getOutputPort(const std::string& name) const throw(YACS::Exception)
+OutputPort *ForLoop::getOutputPort(const std::string& name) const
{
if(name==NAME_OF_INDEX)
return (OutputPort *)&_indexPort;
void init(bool start=true);
InputPort *edGetNbOfTimesInputPort() { return &_nbOfTimesPort; }
Node *simpleClone(ComposedNode *father, bool editionOnly=true) const;
- InputPort* getInputPort(const std::string& name) const throw(Exception);
- OutPort *getOutPort(const std::string& name) const throw(Exception);
- OutputPort *getOutputPort(const std::string& name) const throw(Exception);
+ InputPort* getInputPort(const std::string& name) const ;
+ OutPort *getOutPort(const std::string& name) const ;
+ OutputPort *getOutputPort(const std::string& name) const ;
std::list<InputPort *> getLocalInputPorts() const;
std::list<OutputPort *> getLocalOutputPorts() const;
std::list<OutputPort *> getSetOfOutputPort() const;
return _backLinks.size();
}
-void InPort::edRemoveAllLinksLinkedWithMe() throw(YACS::Exception)
+void InPort::edRemoveAllLinksLinkedWithMe()
{
set< std::pair<OutPort *,bool> > temp(_backLinks);//edRemoveLink called after causes invalidation of set iterator.
for(auto iter : temp)
protected:
InPort(const InPort& other, Node *newHelder);
InPort(const std::string& name, Node *node, TypeCode* type);
- void edRemoveAllLinksLinkedWithMe() throw(Exception);
+ void edRemoveAllLinksLinkedWithMe() ;
virtual void edNotifyReferencedBy(OutPort *fromPort, bool isLoopProof = true);
virtual void edNotifyDereferencedBy(OutPort *fromPort);
virtual void getAllRepresentants(std::set<InPort *>& repr) const;
}
void
-InPropertyPort::put(const void *data) throw(ConversionException)
+InPropertyPort::put(const void *data)
{
put((YACS::ENGINE::Any *)data);
}
virtual void exRestoreInit();
virtual InPropertyPort *clone(Node *newHelder) const;
virtual void *get() const;
- virtual void put(const void *data) throw(ConversionException);
+ virtual void put(const void *data);
virtual void put(YACS::ENGINE::Any *data);
void releaseData() override;
protected:
modified();
}
-void InlineFuncNode::checkBasicConsistency() const throw(YACS::Exception)
+void InlineFuncNode::checkBasicConsistency() const
{
InlineNode::checkBasicConsistency();
if(_fname.empty() )
void accept(Visitor *visitor);
virtual ~InlineFuncNode();
virtual std::string typeName() { return "YACS__ENGINE__InlineFuncNode"; }
- virtual void checkBasicConsistency() const throw(Exception);
+ virtual void checkBasicConsistency() const ;
protected:
std::string _fname;
};
}
//! Check basically that this port has one chance to be specified on time. It's a necessary condition \b not \b sufficient at all.
-void InputPort::checkBasicConsistency() const throw(YACS::Exception)
+void InputPort::checkBasicConsistency() const
{
if(!_canBeNull && !edIsManuallyInitialized() && _backLinks.size()==0 )
{
*/
}
-void ProxyPort::edRemoveAllLinksLinkedWithMe() throw(YACS::Exception)
+void ProxyPort::edRemoveAllLinksLinkedWithMe()
{
_port->edRemoveAllLinksLinkedWithMe();
}
_port->releaseData();
}
-void ProxyPort::put(const void *data) throw(ConversionException)
+void ProxyPort::put(const void *data)
{
_port->put(data);
}
void edInit(Any *value);
void edInit(const std::string& impl,const void* value);
virtual void edRemoveManInit();
- virtual void checkBasicConsistency() const throw(Exception);
+ virtual void checkBasicConsistency() const ;
virtual void exInit(bool start);
virtual void exSaveInit() = 0;
virtual void exRestoreInit() = 0;
virtual void *get() const = 0;
virtual void releaseData() = 0;
- virtual void put(const void *data) throw(ConversionException) = 0;
+ virtual void put(const void *data) = 0;
virtual std::string dump();
virtual std::string getHumanRepr();
virtual void setStringRef(std::string strRef);
ProxyPort(InputPort* p);
~ProxyPort();
- void edRemoveAllLinksLinkedWithMe() throw(Exception);
+ void edRemoveAllLinksLinkedWithMe() ;
InputPort *clone(Node *newHelder) const;
void edNotifyReferencedBy(OutPort *fromPort, bool isLoopProof = true) override;
void edNotifyDereferencedBy(OutPort *fromPort);
InputPort *getPublicRepresentant();
#endif
void *get() const;
- virtual void put(const void *data) throw(ConversionException) ;
+ virtual void put(const void *data) ;
void releaseData() override;
int edGetNumberOfLinks() const;
bool isIntermediate() const { return true; }
_level++;
}
-void LinkInfo::endCollapseTransac() throw(YACS::Exception)
+void LinkInfo::endCollapseTransac()
{
if(--_level==0)
{
_collapse[reason].back().push_back(pair<OutPort *,InPort *>(semStart,end));
}
-void LinkInfo::pushErrLink(OutPort *semStart, InPort *end, ErrReason reason) throw(YACS::Exception)
+void LinkInfo::pushErrLink(OutPort *semStart, InPort *end, ErrReason reason)
{
if(reason==E_NEVER_SET_INPUTPORT)
_unsetInPort.push_back(end);
throw Exception(getErrRepr());
}
-void LinkInfo::pushErrSwitch(CollectorSwOutPort *collector) throw(YACS::Exception)
+void LinkInfo::pushErrSwitch(CollectorSwOutPort *collector)
{
_errorsOnSwitchCases.push_back(collector);
if(_level==0)
_uselessLinks.insert(pair<Node *,Node *>(start,end));
}
-void LinkInfo::takeDecision() const throw(YACS::Exception)
+void LinkInfo::takeDecision() const
{
if(!_errors.empty())
throw Exception(getErrRepr());
LinkInfo(unsigned char level);
void clearAll();
void startCollapseTransac();
- void endCollapseTransac() throw(Exception);
+ void endCollapseTransac();
void setPointOfView(ComposedNode *pov);
void pushInfoLink(OutPort *semStart, InPort *end, InfoReason reason);
void pushWarnLink(OutPort *semStart, InPort *end, WarnReason reason);
- void pushErrLink(OutPort *semStart, InPort *end, ErrReason reason) throw(Exception);
- void pushErrSwitch(CollectorSwOutPort *collector) throw(Exception);
+ void pushErrLink(OutPort *semStart, InPort *end, ErrReason reason);
+ void pushErrSwitch(CollectorSwOutPort *collector);
void pushUselessCFLink(Node *start, Node *end);
- void takeDecision() const throw(Exception);
+ void takeDecision() const;
//Typically methods for high level use.
std::string getGlobalRepr() const;
std::string getInfoRepr() const;
repr.insert(s.begin(),s.end());
}
-void *InputPort4DF2DS::get() const throw(YACS::Exception)
+void *InputPort4DF2DS::get() const
{
if(!_data)
{
_initValue->incrRef();
}
-void InputPort4DF2DS::put(const void *data) throw(ConversionException)
+void InputPort4DF2DS::put(const void *data)
{
put((Any *)data);
}
{
}
-InputPort *DFToDSForLoop::getInputPort(const std::string& name) const throw(YACS::Exception)
+InputPort *DFToDSForLoop::getInputPort(const std::string& name) const
{
try {
return Node::getInputPort(name);
return (*it);
}
-OutputDataStreamPort *DFToDSForLoop::getOutputDataStreamPort(const std::string& name) const throw(YACS::Exception)
+OutputDataStreamPort *DFToDSForLoop::getOutputDataStreamPort(const std::string& name) const
{
list<OutputDataStreamPort *>::const_iterator it =_setOfOutputDataStreamPort.begin();
return (*it);
(*iter)->getAllRepresented(represented);
}
-void OutputPort4DS2DF::put(const void *data) throw(ConversionException)
+void OutputPort4DS2DF::put(const void *data)
{
put((Any *)data);
OutputPort::put(data);
{
}
-OutputPort *DSToDFForLoop::getOutputPort(const std::string& name) const throw(YACS::Exception)
+OutputPort *DSToDFForLoop::getOutputPort(const std::string& name) const
{
list<OutputPort *>::const_iterator it = _setOfOutputPort.begin();
return (*it);
}
-InputDataStreamPort *DSToDFForLoop::getInputDataStreamPort(const std::string& name) const throw(YACS::Exception)
+InputDataStreamPort *DSToDFForLoop::getInputDataStreamPort(const std::string& name) const
{
list<InputDataStreamPort *>::const_iterator it = _setOfInputDataStreamPort.begin();
return (*it);
return ret;
}
-bool Loop::edAddChild(Node *node) throw(YACS::Exception)
+bool Loop::edAddChild(Node *node)
{
return edSetNode(node);
}
}
}
-void Loop::edRemoveChild(Node *node) throw(YACS::Exception)
+void Loop::edRemoveChild(Node *node)
{
StaticDefinedComposedNode::edRemoveChild(node);
if(_node==node)
_node->partitionRegardingDPL(pd,zeMap);
}
-Node *Loop::getChildByShortName(const std::string& name) const throw(YACS::Exception)
+Node *Loop::getChildByShortName(const std::string& name) const
{
if (_node)
if(name==_node->getName())
throw Exception(what);
}
-TypeCode* Loop::MappingDF2DS(TypeCode* type) throw(YACS::Exception)
+TypeCode* Loop::MappingDF2DS(TypeCode* type)
{
return type;
}
-TypeCode* Loop::MappingDS2DF(TypeCode* type) throw(YACS::Exception)
+TypeCode* Loop::MappingDS2DF(TypeCode* type)
{
return type;
}
port.first=(*iter)->getOutputDataStreamPort("");
}
-void Loop::getDelegateOf(InPort * & port, OutPort *initialStart, const std::list<ComposedNode *>& pointsOfView) throw(YACS::Exception)
+void Loop::getDelegateOf(InPort * & port, OutPort *initialStart, const std::list<ComposedNode *>& pointsOfView)
{
string typeOfPortInstance=port->getNameOfTypeOfCurrentInstance();
if(typeOfPortInstance!=InputPort::NAME ||
}
void Loop::getDelegateOf(std::pair<OutPort *, OutPort *>& port, InPort *finalTarget,
- const std::list<ComposedNode *>& pointsOfView) throw(YACS::Exception)
+ const std::list<ComposedNode *>& pointsOfView)
{
string typeOfPortInstance=(port.first)->getNameOfTypeOfCurrentInstance();
if(typeOfPortInstance!=OutputPort::NAME ||
port.first=(*iter)->getOutputDataStreamPort("");
}
-void Loop::releaseDelegateOf(InPort * & port, OutPort *initialStart, const std::list<ComposedNode *>& pointsOfView) throw(YACS::Exception)
+void Loop::releaseDelegateOf(InPort * & port, OutPort *initialStart, const std::list<ComposedNode *>& pointsOfView)
{
string typeOfPortInstance=port->getNameOfTypeOfCurrentInstance();
if(typeOfPortInstance!=InputPort::NAME ||
}
}
-void Loop::releaseDelegateOf(OutPort *portDwn, OutPort *portUp, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView) throw(YACS::Exception)
+void Loop::releaseDelegateOf(OutPort *portDwn, OutPort *portUp, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView)
{
if(portDwn==portUp)
return ;
}
}
-void Loop::checkNoCyclePassingThrough(Node *node) throw(YACS::Exception)
+void Loop::checkNoCyclePassingThrough(Node *node)
{
//throw Exception("Loop::checkNoCyclePassingThrough : Internal error occured");
}
* \param end : the InPort to connect
* \return true if a new link has been created, false otherwise.
*/
-bool Loop::edAddDFLink(OutPort *start, InPort *end) throw(YACS::Exception)
+bool Loop::edAddDFLink(OutPort *start, InPort *end)
{
return edAddLink(start,end);
}
fw[(ComposedNode *)this].push_back(start);
}
-void Loop::checkBasicConsistency() const throw(YACS::Exception)
+void Loop::checkBasicConsistency() const
{
DEBTRACE("Loop::checkBasicConsistency");
ComposedNode::checkBasicConsistency();
InputPort4DF2DS(DFToDSForLoop *node, TypeCode* type);
void getAllRepresentants(std::set<InPort *>& repr) const;
void releaseData() override;
- void put(const void *data) throw(ConversionException);
+ void put(const void *data);
InputPort *clone(Node *newHelder) const;
- void *get() const throw(Exception);
+ void *get() const ;
void exRestoreInit();
void exSaveInit();
void put(Any *data);
void loopHasOneMoreRef() { _nbOfTimeUsed++; }
bool loopHasOneLessRef() { return --_nbOfTimeUsed==0; }
void getReadyTasks(std::vector<Task *>& tasks);
- InputPort *getInputPort(const std::string& name) const throw(Exception);
- OutputDataStreamPort *getOutputDataStreamPort(const std::string& name) const throw(Exception);
+ InputPort *getInputPort(const std::string& name) const ;
+ OutputDataStreamPort *getOutputDataStreamPort(const std::string& name) const ;
Node *simpleClone(ComposedNode *father, bool editionOnly=true) const;
//run part
void execute();
public:
OutputPort4DS2DF(DSToDFForLoop *node, TypeCode *type);
void getAllRepresented(std::set<OutPort *>& represented) const;
- void put(const void *data) throw(ConversionException);
+ void put(const void *data);
OutputPort *clone(Node *newHelder) const;
void put(Any *data);
~OutputPort4DS2DF();
void loopHasOneMoreRef() { _nbOfTimeUsed++; }
bool loopHasOneLessRef() { return --_nbOfTimeUsed==0; }
void getReadyTasks(std::vector<Task *>& tasks);
- OutputPort *getOutputPort(const std::string& name) const throw(Exception);
- InputDataStreamPort *getInputDataStreamPort(const std::string& name) const throw(Exception);
+ OutputPort *getOutputPort(const std::string& name) const ;
+ InputDataStreamPort *getInputDataStreamPort(const std::string& name) const ;
//run part
void execute();
void load();
int getNbOfTurns() const { return _nbOfTurns; }
//Node* DISOWNnode is a SWIG notation to indicate that the ownership of the node is transfered to C++
Node *edSetNode(Node *DISOWNnode);
- virtual bool edAddChild(Node *DISOWNnode) throw(Exception);
+ virtual bool edAddChild(Node *DISOWNnode) ;
bool isLoop() const override { return true; }
Node *edRemoveNode();
- virtual void checkBasicConsistency() const throw(Exception);
+ virtual void checkBasicConsistency() const ;
//! Returns the port which value is used to take decision about the continuation of the loop.
virtual InputPort *getDecisionPort() const = 0;
void getReadyTasks(std::vector<Task *>& tasks);
- void edRemoveChild(Node *node) throw(Exception);
+ void edRemoveChild(Node *node) ;
bool isRepeatedUnpredictablySeveralTimes() const { return true; }
std::list<Node *> edGetDirectDescendants() const;
std::list<InputPort *> getSetOfInputPort() const;
int getMaxLevelOfParallelism() const;
void getWeightRegardingDPL(ComplexWeight *weight);
void partitionRegardingDPL(const PartDefinition *pd, std::map<ComposedNode *, YACS::BASES::AutoRefCnt<PartDefinition> >& zeMap);
- Node *getChildByShortName(const std::string& name) const throw(Exception);
- static TypeCode* MappingDF2DS(TypeCode* type) throw(Exception);
- static TypeCode* MappingDS2DF(TypeCode* type) throw(Exception);
- virtual bool edAddDFLink(OutPort *start, InPort *end) throw(Exception);
+ Node *getChildByShortName(const std::string& name) const ;
+ static TypeCode* MappingDF2DS(TypeCode* type) ;
+ static TypeCode* MappingDS2DF(TypeCode* type) ;
+ virtual bool edAddDFLink(OutPort *start, InPort *end) ;
void writeDot(std::ostream &os) const;
virtual void accept(Visitor *visitor);
virtual std::string typeName() {return "YACS__ENGINE__Loop";}
protected:
void buildDelegateOf(InPort * & port, OutPort *initialStart, const std::list<ComposedNode *>& pointsOfView);
void buildDelegateOf(std::pair<OutPort *, OutPort *>& port, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView);
- void getDelegateOf(InPort * & port, OutPort *initialStart, const std::list<ComposedNode *>& pointsOfView) throw(Exception);
- void getDelegateOf(std::pair<OutPort *, OutPort *>& port, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView) throw(Exception);
- void releaseDelegateOf(InPort * & port, OutPort *initialStart, const std::list<ComposedNode *>& pointsOfView) throw(Exception);
- void releaseDelegateOf(OutPort *portDwn, OutPort *portUp, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView) throw(Exception);
- void checkNoCyclePassingThrough(Node *node) throw(Exception);
+ void getDelegateOf(InPort * & port, OutPort *initialStart, const std::list<ComposedNode *>& pointsOfView) ;
+ void getDelegateOf(std::pair<OutPort *, OutPort *>& port, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView) ;
+ void releaseDelegateOf(InPort * & port, OutPort *initialStart, const std::list<ComposedNode *>& pointsOfView) ;
+ void releaseDelegateOf(OutPort *portDwn, OutPort *portUp, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView) ;
+ void checkNoCyclePassingThrough(Node *node) ;
void checkControlDependancy(OutPort *start, InPort *end, bool cross,
std::map < ComposedNode *, std::list < OutPort * >, SortHierarc >& fw,
std::vector<OutPort *>& fwCross,
_outGate.exNotifyDisabled();
}
-InPort *Node::getInPort(const std::string& name) const throw(YACS::Exception)
+InPort *Node::getInPort(const std::string& name) const
{
InPort *ret;
try
}
InPropertyPort *
-Node::getInPropertyPort() const throw(YACS::Exception)
+Node::getInPropertyPort() const
{
return _inPropertyPort;
}
InputPort *
-Node::getInputPort(const std::string& name) const throw(YACS::Exception)
+Node::getInputPort(const std::string& name) const
{
if (name == "__InPropertyPort__Node__YACS_")
return _inPropertyPort;
* \note: Contrary to getOutputPort method, this method returns the output port at highest level, possible.
* That is to say in some ComposedNode, like ForEachLoop or Switch, an outport inside 'this' is seen differently than the true outport.
*/
-OutPort *Node::getOutPort(const std::string& name) const throw(YACS::Exception)
+OutPort *Node::getOutPort(const std::string& name) const
{
OutPort *ret;
try
return NULL;
}
-ComposedNode *Node::getRootNode() const throw(YACS::Exception)
+ComposedNode *Node::getRootNode() const
{
if(!_father)
throw Exception("No root node");
* USAGE NOT CLEAR, not used so far, when are those characters set ?
*/
-void Node::checkValidityOfPortName(const std::string& name) throw(YACS::Exception)
+void Node::checkValidityOfPortName(const std::string& name)
{
if(name.find(SEP_CHAR_IN_PORT, 0 )!=string::npos)
{
* @note : Check that 'node1' and 'node2' have exactly the same father
* @exception : If 'node1' and 'node2' have NOT exactly the same father
*/
-ComposedNode *Node::checkHavingCommonFather(Node *node1, Node *node2) throw(YACS::Exception)
+ComposedNode *Node::checkHavingCommonFather(Node *node1, Node *node2)
{
if(node1!=0 && node2!=0)
{
virtual std::list<OutputPort *> getLocalOutputPorts() const = 0;
virtual std::set<InputPort *> edGetSetOfUnitializedInputPort() const;
virtual bool edAreAllInputPortInitialized() const;
- virtual std::string getInPortName(const InPort *) const throw (Exception) = 0;
- virtual std::string getOutPortName(const OutPort *) const throw (Exception) = 0;
+ virtual std::string getInPortName(const InPort *) const = 0;
+ virtual std::string getOutPortName(const OutPort *) const = 0;
virtual std::list<InputDataStreamPort *> getSetOfInputDataStreamPort() const = 0;
virtual std::list<OutputDataStreamPort *> getSetOfOutputDataStreamPort() const = 0;
- InPort *getInPort(const std::string& name) const throw(Exception);
- InPropertyPort *getInPropertyPort() const throw(Exception);
- virtual OutPort *getOutPort(const std::string& name) const throw(Exception);
+ InPort *getInPort(const std::string& name) const;
+ InPropertyPort *getInPropertyPort() const;
+ virtual OutPort *getOutPort(const std::string& name) const;
virtual std::set<OutPort *> getAllOutPortsLeavingCurrentScope() const = 0;
virtual std::set<InPort *> getAllInPortsComingFromOutsideOfCurrentScope() const = 0;
virtual std::vector< std::pair<OutPort *, InPort *> > getSetOfLinksLeavingCurrentScope() const = 0;
virtual std::vector< std::pair<InPort *, OutPort *> > getSetOfLinksComingInCurrentScope() const =0;
- virtual InputPort *getInputPort(const std::string& name) const throw(Exception);
- virtual OutputPort *getOutputPort(const std::string& name) const throw(Exception) = 0;
- virtual InputDataStreamPort *getInputDataStreamPort(const std::string& name) const throw(Exception) = 0;
- virtual OutputDataStreamPort *getOutputDataStreamPort(const std::string& name) const throw(Exception) = 0;
+ virtual InputPort *getInputPort(const std::string& name) const;
+ virtual OutputPort *getOutputPort(const std::string& name) const = 0;
+ virtual InputDataStreamPort *getInputDataStreamPort(const std::string& name) const = 0;
+ virtual OutputDataStreamPort *getOutputDataStreamPort(const std::string& name) const = 0;
std::list<ComposedNode *> getAllAscendanceOf(ComposedNode *levelToStop = 0) const;
bool operator>(const Node& other) const;
bool operator<(const Node& other) const;
std::string getImplementation() const;
DynParaLoop *getClosestDPLAmongAncestors() const;
- virtual ComposedNode *getRootNode() const throw(Exception);
+ virtual ComposedNode *getRootNode() const;
virtual void setProperty(const std::string& name,const std::string& value);
virtual std::string getProperty(const std::string& name);
std::map<std::string,std::string> getProperties() ;
std::map<std::string,std::string> getPropertyMap() { return _propertyMap; }
virtual void setProperties(std::map<std::string,std::string> properties);
- virtual Node *getChildByName(const std::string& name) const throw(Exception) = 0;
+ virtual Node *getChildByName(const std::string& name) const = 0;
virtual Proc *getProc();
virtual const Proc *getProc() const;
virtual void accept(Visitor *visitor) = 0;
virtual void exForwardFailed();
virtual void exForwardFinished();
virtual void edDisconnectAllLinksWithMe();
- static void checkValidityOfPortName(const std::string& name) throw(Exception);
- static ComposedNode *checkHavingCommonFather(Node *node1, Node *node2) throw(Exception);
+ static void checkValidityOfPortName(const std::string& name);
+ static ComposedNode *checkHavingCommonFather(Node *node1, Node *node2);
public:
static void checkValidityOfNodeName(const std::string& name);
};
{
}
-void OptimizerAlgBase::initialize(const Any *input) throw (YACS::Exception)
+void OptimizerAlgBase::initialize(const Any *input)
{
}
return getTCForAlgoResult();
}
-void OptimizerAlgBase::initializeProxy(const Any *input) throw (YACS::Exception)
+void OptimizerAlgBase::initializeProxy(const Any *input)
{
initialize(input);
}
virtual TypeCode *getTCForAlgoInit() const;
//! returns typecode of type expected as algo result. OwnerShip of returned pointer is held by this.
virtual TypeCode *getTCForAlgoResult() const;
- virtual void initialize(const Any *input) throw (Exception);
+ virtual void initialize(const Any *input) ;
virtual void start() = 0;//! Update _pool attribute before performing anything.
virtual void takeDecision() = 0;//! _pool->getCurrentId gives the \b id at the origin of this call.
//! Perform the job of analysing to know what new jobs to do (_pool->pushInSample)
virtual TypeCode *getTCForOutProxy() const;
virtual TypeCode *getTCForAlgoInitProxy() const;
virtual TypeCode *getTCForAlgoResultProxy() const;
- virtual void initializeProxy(const Any *input) throw (Exception);
+ virtual void initializeProxy(const Any *input) ;
virtual void startProxy();
virtual void takeDecisionProxy();
virtual void finishProxy();
return DynParaLoop::getNumberOfInputPorts()+2;
}
-InputPort *OptimizerLoop::getInputPort(const std::string& name) const throw(YACS::Exception)
+InputPort *OptimizerLoop::getInputPort(const std::string& name) const
{
if (name == NAME_OF_ALGO_INIT_PORT)
return (InputPort *)&_algoInitPort;
return DynParaLoop::updateStateOnFailedEventFrom(node,execInst);
}
-void OptimizerLoop::checkNoCyclePassingThrough(Node *node) throw(YACS::Exception)
+void OptimizerLoop::checkNoCyclePassingThrough(Node *node)
{
}
}
void OptimizerLoop::checkLinkPossibility(OutPort *start, const std::list<ComposedNode *>& pointsOfViewStart,
- InPort *end, const std::list<ComposedNode *>& pointsOfViewEnd) throw(YACS::Exception)
+ InPort *end, const std::list<ComposedNode *>& pointsOfViewEnd)
{
DynParaLoop::checkLinkPossibility(start, pointsOfViewStart, end, pointsOfViewEnd);
std::string linkName("(");
/*!
* Throw an exception if the node is not valid
*/
-void OptimizerLoop::checkBasicConsistency() const throw(YACS::Exception)
+void OptimizerLoop::checkBasicConsistency() const
{
DEBTRACE("OptimizerLoop::checkBasicConsistency");
if (_alglib == "")
return ret;
}
-OutPort * OptimizerLoop::getOutPort(const std::string& name) const throw(YACS::Exception)
+OutPort * OptimizerLoop::getOutPort(const std::string& name) const
{
return (name == NAME_OF_ALGO_RESULT_PORT) ? (OutPort *)&_algoResultPort :
DynParaLoop::getOutPort(name);
}
-OutputPort * OptimizerLoop::getOutputPort(const std::string& name) const throw(YACS::Exception)
+OutputPort * OptimizerLoop::getOutputPort(const std::string& name) const
{
return (name == NAME_OF_ALGO_RESULT_PORT) ? (OutputPort *)&_algoResultPort :
DynParaLoop::getOutputPort(name);
InputPort *edGetPortForOutPool() { return &_retPortForOutPool; }
InputPort *edGetAlgoInitPort() { return &_algoInitPort; }
OutputPort *edGetAlgoResultPort() { return &_algoResultPort; }
- InputPort *getInputPort(const std::string& name) const throw(Exception);
+ InputPort *getInputPort(const std::string& name) const ;
std::list<InputPort *> getSetOfInputPort() const;
std::list<InputPort *> getLocalInputPorts() const;
void selectRunnableTasks(std::vector<Task *>& tasks);
void getReadyTasks(std::vector<Task *>& tasks);
YACS::Event updateStateOnFinishedEventFrom(Node *node);
- void checkNoCyclePassingThrough(Node *node) throw(Exception);
+ void checkNoCyclePassingThrough(Node *node) ;
virtual void accept(Visitor *visitor);
virtual std::string getSymbol() const { return _symbol; }
virtual std::string getAlgLib() const ;
virtual void setAlgorithm(const std::string& alglib,const std::string& symbol,
bool checkLinks=true, Proc * procForTypes = NULL);
- virtual void checkBasicConsistency() const throw(Exception);
+ virtual void checkBasicConsistency() const ;
virtual std::string typeName() {return "YACS__ENGINE__OptimizerLoop";}
int getNumberOfOutputPorts() const;
std::list<OutputPort *> getSetOfOutputPort() const;
std::list<OutputPort *> getLocalOutputPorts() const;
- OutPort *getOutPort(const std::string& name) const throw(Exception);
- OutputPort *getOutputPort(const std::string& name) const throw(Exception);
+ OutPort *getOutPort(const std::string& name) const ;
+ OutputPort *getOutputPort(const std::string& name) const ;
YACS::Event finalize();
protected:
virtual YACS::Event updateStateOnFailedEventFrom(Node *node, const Executor *execInst);
LinkInfo& info) const;
void checkCFLinks(const std::list<OutPort *>& starts, InputPort *end, unsigned char& alreadyFed, bool direction, LinkInfo& info) const;
void checkLinkPossibility(OutPort *start, const std::list<ComposedNode *>& pointsOfViewStart,
- InPort *end, const std::list<ComposedNode *>& pointsOfViewEnd) throw(Exception);
+ InPort *end, const std::list<ComposedNode *>& pointsOfViewEnd) ;
protected:
void cleanInterceptors();
void launchMaxOfSamples(bool first);
return ret;
}
-void OutGate::edRemoveInGate(InGate *inGate, bool coherenceWithInGate) throw(YACS::Exception)
+void OutGate::edRemoveInGate(InGate *inGate, bool coherenceWithInGate)
{
std::list< pair<InGate* , bool> >::iterator iter(std::find_if(_setOfInGate.begin(),_setOfInGate.end(),ItemCmp(inGate)));
if(iter==_setOfInGate.end())
bool edAddInGate(InGate *inGate);
std::list< std::pair< InGate *, bool> >& edMapInGate() { return _setOfInGate; }
std::list<InGate *> edSetInGate() const;
- void edRemoveInGate(InGate *inGate, bool coherenceWithInGate=true) throw(Exception);
+ void edRemoveInGate(InGate *inGate, bool coherenceWithInGate=true);
int getNbOfInGatesConnected() const;
bool isAlreadyInSet(InGate *inGate) const;
virtual std::string typeName() {return "YACS__ENGINE__OutGate";}
virtual std::set<InPort *> edSetInPort() const = 0;
virtual bool isAlreadyLinkedWith(InPort *withp) const = 0;
virtual void getAllRepresented(std::set<OutPort *>& represented) const;
- virtual bool addInPort(InPort *inPort) throw(Exception) = 0;
- virtual int removeInPort(InPort *inPort, bool forward) throw(Exception) = 0;
+ virtual bool addInPort(InPort *inPort) = 0;
+ virtual int removeInPort(InPort *inPort, bool forward) = 0;
virtual ~OutPort();
std::vector<DataPort *> calculateHistoryOfLinkWith(InPort *end);
virtual std::string typeName() {return "YACS__ENGINE__OutPort";}
}
bool OutputDataStreamPort::edAddInputDataStreamPort(InputDataStreamPort *port)
- throw(ConversionException)
+
{
DEBTRACE("OutputDataStreamPort::edAddInputDataStreamPort");
if(!isAlreadyInSet(port))
return false;
}
-int OutputDataStreamPort::edRemoveInputDataStreamPort(InputDataStreamPort *inPort, bool forward) throw(YACS::Exception)
+int OutputDataStreamPort::edRemoveInputDataStreamPort(InputDataStreamPort *inPort, bool forward)
{
if(forward)
{
}
}
-bool OutputDataStreamPort::addInPort(InPort *inPort) throw(YACS::Exception)
+bool OutputDataStreamPort::addInPort(InPort *inPort)
{
DEBTRACE("OutputDataStreamPort::addInPort");
if(inPort->getNameOfTypeOfCurrentInstance()!=InputDataStreamPort::NAME)
return edAddInputDataStreamPort(static_cast<InputDataStreamPort*>(inPort));
}
-void OutputDataStreamPort::edRemoveAllLinksLinkedWithMe() throw(YACS::Exception)
+void OutputDataStreamPort::edRemoveAllLinksLinkedWithMe()
{
set<InputDataStreamPort *>::iterator iter;
set<InputDataStreamPort *> vec(_setOfInputDataStreamPort);
_setOfInputDataStreamPort.clear();
}
-int OutputDataStreamPort::removeInPort(InPort *inPort, bool forward) throw(YACS::Exception)
+int OutputDataStreamPort::removeInPort(InPort *inPort, bool forward)
{
DEBTRACE("OutputDataStreamPort::removeInPort");
if(inPort->getNameOfTypeOfCurrentInstance()!=InputDataStreamPort::NAME && !forward)
std::set<InPort *> edSetInPort() const;
bool isAlreadyLinkedWith(InPort *withp) const;
virtual std::string getNameOfTypeOfCurrentInstance() const;
- virtual bool addInPort(InPort *inPort) throw(Exception);
- virtual bool edAddInputDataStreamPort(InputDataStreamPort *port) throw(ConversionException);
- int edRemoveInputDataStreamPort(InputDataStreamPort *inPort, bool forward) throw(Exception);
- void edRemoveAllLinksLinkedWithMe() throw(Exception);
- int removeInPort(InPort *inPort, bool forward) throw(Exception);
+ virtual bool addInPort(InPort *inPort) ;
+ virtual bool edAddInputDataStreamPort(InputDataStreamPort *port);
+ int edRemoveInputDataStreamPort(InputDataStreamPort *inPort, bool forward) ;
+ void edRemoveAllLinksLinkedWithMe() ;
+ int removeInPort(InPort *inPort, bool forward) ;
virtual std::string typeName() {return "YACS__ENGINE__OutputDataStreamPort";}
private:
bool isAlreadyInSet(InputDataStreamPort *inPort) const;
return NAME;
}
-void OutputPort::edRemoveAllLinksLinkedWithMe() throw(YACS::Exception)
+void OutputPort::edRemoveAllLinksLinkedWithMe()
{
set<InputPort *>::iterator iter;
set<InputPort *> vec(_setOfInputPort);
{
}
-void OutputPort::put(const void *data) throw(ConversionException)
+void OutputPort::put(const void *data)
{
for(set<InputPort *>::iterator iter = _setOfInputPort.begin(); iter != _setOfInputPort.end(); iter++)
(*iter)->put(data);
/**
* check if output type is an input type and if a data converter exists before link
*/
-bool OutputPort::edAddInputPort(InputPort *phyPort) throw(YACS::Exception)
+bool OutputPort::edAddInputPort(InputPort *phyPort)
{
DEBTRACE("OutputPort::edAddInputPort");
if(!isAlreadyInSet(phyPort))
return false;
}
-bool OutputPort::edAddInPropertyPort(InPropertyPort *phyPort) throw(YACS::Exception)
+bool OutputPort::edAddInPropertyPort(InPropertyPort *phyPort)
{
DEBTRACE("OutputPort::edAddInPropertyPort");
if(!isAlreadyInSet(phyPort))
* If 'forward' == true the forward deletion
* If 'forward' == false no forward deletion performed, oneway deletion without update 'inputPort' side.
*/
-int OutputPort::edRemoveInputPort(InputPort *inputPort, bool forward) throw(YACS::Exception)
+int OutputPort::edRemoveInputPort(InputPort *inputPort, bool forward)
{
if(forward)
{
/**
* check compatibility of port class ( an inputPort ) before trying to create the link.
*/
-bool OutputPort::addInPort(InPort *inPort) throw(YACS::Exception)
+bool OutputPort::addInPort(InPort *inPort)
{
DEBTRACE("OutputPort::addInPort");
if(inPort->getNameOfTypeOfCurrentInstance()!=InputPort::NAME &&
/**
* check compatibility of port class ( an inputPort ) before trying to remove link WITHOUT forward.
*/
-int OutputPort::removeInPort(InPort *inPort, bool forward) throw(YACS::Exception)
+int OutputPort::removeInPort(InPort *inPort, bool forward)
{
if(inPort->getNameOfTypeOfCurrentInstance()!=InputPort::NAME && !forward)
{
}
//! Check validity of output port. Nothing on base class
-void OutputPort::checkBasicConsistency() const throw(YACS::Exception)
+void OutputPort::checkBasicConsistency() const
{
}
bool isAlreadyInSet(InputPort *inputPort) const;
bool isConnected() const;
std::string getNameOfTypeOfCurrentInstance() const;
- int removeInPort(InPort *inPort, bool forward) throw(Exception);
- virtual bool edAddInputPort(InputPort *phyPort) throw(Exception);
- virtual bool edAddInPropertyPort(InPropertyPort *phyPort) throw(Exception);
- virtual int edRemoveInputPort(InputPort *inputPort, bool forward) throw(Exception);
- bool addInPort(InPort *inPort) throw(Exception);
- void edRemoveAllLinksLinkedWithMe() throw(Exception);//entry point for forward port deletion
+ int removeInPort(InPort *inPort, bool forward) ;
+ virtual bool edAddInputPort(InputPort *phyPort) ;
+ virtual bool edAddInPropertyPort(InPropertyPort *phyPort) ;
+ virtual int edRemoveInputPort(InputPort *inputPort, bool forward) ;
+ bool addInPort(InPort *inPort) ;
+ void edRemoveAllLinksLinkedWithMe() ;//entry point for forward port deletion
virtual void exInit();
- virtual void checkBasicConsistency() const throw(Exception);
+ virtual void checkBasicConsistency() const ;
virtual OutputPort *clone(Node *newHelder) const = 0;
virtual std::string dump();
- virtual void put(const void *data) throw(ConversionException);
+ virtual void put(const void *data);
virtual std::string typeName() {return "YACS__ENGINE__OutputPort";}
protected:
rien = solv->next();
}
-void PluginSimplex::initialize(const Any *input) throw(YACS::Exception)
+void PluginSimplex::initialize(const Any *input)
{
}
void parseFileToInit(const std::string& fileName);
void start();
void takeDecision();
- void initialize(const Any *input) throw(Exception);
+ void initialize(const Any *input) ;
void finish();
};
}
* corrupted 'this'.
*
*/
-void Pool::checkConsistency() throw(YACS::Exception)
+void Pool::checkConsistency()
{
// First check unicity of ids.
std::set<int> ids;
/*!
* \throw See the \b throw case of pushOutSampleAt method.
*/
-void Pool::setCurrentId(int id) throw(YACS::Exception)
+void Pool::setCurrentId(int id)
{
std::list< std::pair<int, ExpData> >::iterator iter;
for(iter=_container.begin();iter!=_container.end();iter++)
* has destroyed a case id different from its id.
*
*/
-void Pool::putOutSampleAt(int id, Any *outValue) throw(YACS::Exception)
+void Pool::putOutSampleAt(int id, Any *outValue)
{
std::list< std::pair<int, ExpData> >::iterator iter;
for(iter=_container.begin();iter!=_container.end();iter++)
private:
//For OptimizerNode use
void destroyCurrentCase();
- void checkConsistency() throw(Exception);
- void setCurrentId(int id) throw(Exception);
- void putOutSampleAt(int id, Any *outValue) throw(Exception);
+ void checkConsistency() ;
+ void setCurrentId(int id) ;
+ void putOutSampleAt(int id, Any *outValue) ;
Any *getNextSampleWithHighestPriority(int& id, unsigned char& priority) const;
void markIdAsInUse(int id);
bool empty() const;
// singleton creation must be done before by a derived class
-Runtime* YACS::ENGINE::getRuntime() throw(Exception)
+Runtime* YACS::ENGINE::getRuntime()
{
if ( ! Runtime::_singleton )
throw Exception("Runtime is not yet initialized");
namespace ENGINE
{
class Runtime;
- YACSLIBENGINE_EXPORT Runtime* getRuntime() throw(Exception);
+ YACSLIBENGINE_EXPORT Runtime* getRuntime() ;
class Any;
class InputPort;
class YACSLIBENGINE_EXPORT Runtime
{
- friend Runtime* getRuntime() throw(Exception);
+ friend Runtime* getRuntime() ;
public:
virtual void init() { }
virtual void fini() { }
TypeCode * type);
virtual InputPort* adapt(InputPort* source, const std::string& impl, TypeCode * type,
- bool init=false) throw (ConversionException) = 0;
+ bool init=false) = 0;
virtual InputPort* adapt(InPropertyPort* source,
const std::string& impl,
TypeCode * type,
- bool init=false) throw (ConversionException) = 0;
+ bool init=false) = 0;
virtual void* convertNeutral(TypeCode * type, Any *data);
virtual std::string convertNeutralAsString(TypeCode * type, Any *data);
}
//! Associate an existing component instance to this service node \b AND check the consistency regarding the deployment from root node point of view.
-void ServiceNode::setComponent(ComponentInstance* compo) throw(YACS::Exception)
+void ServiceNode::setComponent(ComponentInstance* compo)
{
DEBTRACE("ServiceNode::setComponent " << compo);
if(compo)
public:
virtual void load();
virtual bool isDeployable() const;
- virtual void setComponent(ComponentInstance* compo) throw(Exception);
+ virtual void setComponent(ComponentInstance* compo) ;
virtual ComponentInstance *getComponent();
virtual const ComponentInstance *getComponent() const;
virtual Container *getContainer();
return _className;
}
-void CollectorSwOutPort::edRemoveAllLinksLinkedWithMe() throw(YACS::Exception)
+void CollectorSwOutPort::edRemoveAllLinksLinkedWithMe()
{
map<int, OutPort *>::iterator pt;
if(_consumer)
((*pt).second)->getAllRepresented(represented);
}
-bool CollectorSwOutPort::addInPort(InPort *inPort) throw(YACS::Exception)
+bool CollectorSwOutPort::addInPort(InPort *inPort)
{
if(_currentProducer)
{//a specific link is beeing done
(*iter).second->addInPort(inPort);
}
-int CollectorSwOutPort::removeInPort(InPort *inPort, bool forward) throw(YACS::Exception)
+int CollectorSwOutPort::removeInPort(InPort *inPort, bool forward)
{
if(_currentProducer)
{
return _potentialProducers.empty();
}
-bool CollectorSwOutPort::checkManagementOfPort(OutPort *port) throw(YACS::Exception)
+bool CollectorSwOutPort::checkManagementOfPort(OutPort *port)
{
for(map<int, OutPort *>::iterator iter=_potentialProducers.begin();iter!=_potentialProducers.end();iter++)
if((*iter).second==port)
(*it).second->partitionRegardingDPL(pd,zeMap);
}
-void Switch::edRemoveChild(Node *node) throw(YACS::Exception)
+void Switch::edRemoveChild(Node *node)
{
map< int , Node * >::iterator iter=_mapOfNode.begin();
for(;iter!=_mapOfNode.end();iter++)
ret.push_back((InputPort *)&_condition);
return ret;
}
-OutPort *Switch::getOutPort(const std::string& name) const throw(YACS::Exception)
+OutPort *Switch::getOutPort(const std::string& name) const
{
for(map<InPort *, CollectorSwOutPort * >::const_iterator iter=_outPortsCollector.begin();iter!=_outPortsCollector.end();iter++)
if(name==(*iter).second->getName())
return StaticDefinedComposedNode::getOutPort(name);
}
-InputPort *Switch::getInputPort(const std::string& name) const throw(YACS::Exception)
+InputPort *Switch::getInputPort(const std::string& name) const
{
if(name==SELECTOR_INPUTPORT_NAME)
return (InputPort *)&_condition;
return StaticDefinedComposedNode::getInputPort(name);
}
-Node *Switch::getChildByShortName(const std::string& name) const throw(YACS::Exception)
+Node *Switch::getChildByShortName(const std::string& name) const
{
if(name==DEFAULT_NODE_NAME)
{
return edSetNode(ID_FOR_DEFAULT_NODE,node);
}
-Node *Switch::edReleaseDefaultNode() throw(YACS::Exception)
+Node *Switch::edReleaseDefaultNode()
{
return edReleaseCase(ID_FOR_DEFAULT_NODE);
}
-Node *Switch::edReleaseCase(int caseId) throw(YACS::Exception)
+Node *Switch::edReleaseCase(int caseId)
{
map< int , Node * >::iterator iter=_mapOfNode.find(caseId);
if(iter==_mapOfNode.end())
* 0 is returned if caseId is a new ID.
* \b WARNING : 'node' is held by 'this' after call, whereas returned node is no more held.
*/
-Node *Switch::edSetNode(int caseId, Node *node) throw(YACS::Exception)
+Node *Switch::edSetNode(int caseId, Node *node)
{
if(!node)
throw Exception("Switch::edSetNode : null node cannot be set as a case in switch node");
return ret;
}
-bool Switch::edAddChild(Node *node) throw(YACS::Exception)
+bool Switch::edAddChild(Node *node)
{
int aCase = getMaxCase() + 1;
DEBTRACE(aCase);
throw Exception("Switch::checkControlDependancy : a link was dectected between 2 cases of a switch. Impossible !");
}
-void Switch::checkNoCyclePassingThrough(Node *node) throw(YACS::Exception)
+void Switch::checkNoCyclePassingThrough(Node *node)
{
throw Exception("Switch::checkNoCyclePassingThrough : uncorrect control flow link relative to switch");
}
void Switch::checkLinkPossibility(OutPort *start, const std::list<ComposedNode *>& pointsOfViewStart,
- InPort *end, const std::list<ComposedNode *>& pointsOfViewEnd) throw(YACS::Exception)
+ InPort *end, const std::list<ComposedNode *>& pointsOfViewEnd)
{
throw Exception("Switch::checkLinkPossibility : A link between 2 different cases of a same Switch requested -> Impossible");
}
port.first=newCollector;
}
-void Switch::getDelegateOf(std::pair<OutPort *, OutPort *>& port, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView) throw(YACS::Exception)
+void Switch::getDelegateOf(std::pair<OutPort *, OutPort *>& port, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView)
{
map<InPort *, CollectorSwOutPort * >::iterator iter=_outPortsCollector.find(finalTarget);
if(iter==_outPortsCollector.end())
port.first=(*iter).second;
}
-void Switch::releaseDelegateOf(OutPort *portDwn, OutPort *portUp, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView) throw(YACS::Exception)
+void Switch::releaseDelegateOf(OutPort *portDwn, OutPort *portUp, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView)
{
set<OutPort *> repr;
portDwn->getAllRepresented(repr);
return id;
}
-std::string Switch::getCaseId(const Node *node) const throw(YACS::Exception)
+std::string Switch::getCaseId(const Node *node) const
{
const char sep='_';
map<int, Node*>::const_iterator iter;
std::set<InPort *> edSetInPort() const;
bool isAlreadyLinkedWith(InPort *withp) const;
std::string getNameOfTypeOfCurrentInstance() const;
- void edRemoveAllLinksLinkedWithMe() throw(Exception);
+ void edRemoveAllLinksLinkedWithMe() ;
TypeOfChannel getTypeOfChannel() const;
void getAllRepresented(std::set<OutPort *>& represented) const;
- bool addInPort(InPort *inPort) throw(Exception);
- int removeInPort(InPort *inPort, bool forward) throw(Exception);
+ bool addInPort(InPort *inPort) ;
+ int removeInPort(InPort *inPort, bool forward) ;
public:
void getHumanReprOfIncompleteCases(std::ostream& stream) const;
private://Specific part
CollectorSwOutPort(Switch *master, InPort *port);
CollectorSwOutPort(const CollectorSwOutPort& other, Switch *master);
void addPotentialProducerForMaster(OutPort *port);
- bool checkManagementOfPort(OutPort *port) throw(Exception);
+ bool checkManagementOfPort(OutPort *port) ;
private:
InPort *_consumer;
std::string _className;
void init(bool start=true);
//Node* DISOWNnode is a SWIG notation to indicate that the ownership of the node is transfered to C++
Node *edSetDefaultNode(Node *DISOWNnode);
- Node *edReleaseDefaultNode() throw(Exception);
- Node *edReleaseCase(int caseId) throw(Exception);
+ Node *edReleaseDefaultNode() ;
+ Node *edReleaseCase(int caseId) ;
Node *edGetNode(int caseId);
- Node *edSetNode(int caseId, Node *DISOWNnode) throw(Exception);
+ Node *edSetNode(int caseId, Node *DISOWNnode) ;
void edChangeCase(int oldCase, int newCase);
- virtual bool edAddChild(Node *DISOWNnode) throw(Exception);
+ virtual bool edAddChild(Node *DISOWNnode) ;
int getMaxCase();
void getReadyTasks(std::vector<Task *>& tasks);
std::list<Node *> edGetDirectDescendants() const;
int getMaxLevelOfParallelism() const;
void getWeightRegardingDPL(ComplexWeight *weight);
void partitionRegardingDPL(const PartDefinition *pd, std::map<ComposedNode *, YACS::BASES::AutoRefCnt<PartDefinition> >& zeMap);
- void edRemoveChild(Node *node) throw(Exception);
+ void edRemoveChild(Node *node) ;
std::list<InputPort *> getSetOfInputPort() const;
std::list<InputPort *> getLocalInputPorts() const;
YACS::StatesForNode getEffectiveState() const;
YACS::StatesForNode getEffectiveState(const Node* node) const;
- OutPort *getOutPort(const std::string& name) const throw(Exception);
- InputPort* getInputPort(const std::string& name) const throw(Exception);
- Node *getChildByShortName(const std::string& name) const throw(Exception);
+ OutPort *getOutPort(const std::string& name) const ;
+ InputPort* getInputPort(const std::string& name) const ;
+ Node *getChildByShortName(const std::string& name) const ;
std::string getMyQualifiedName(const Node *directSon) const;
- std::string getCaseId(const Node *node) const throw(Exception);
+ std::string getCaseId(const Node *node) const ;
virtual void accept(Visitor *visitor);
int getRankOfNode(Node *node) const;
virtual std::string typeName() {return "YACS__ENGINE__Switch";}
Node *simpleClone(ComposedNode *father, bool editionOnly=true) const;
std::set<InPort *> getAllInPortsComingFromOutsideOfCurrentScope() const;
void checkLinkPossibility(OutPort *start, const std::list<ComposedNode *>& pointsOfViewStart,
- InPort *end, const std::list<ComposedNode *>& pointsOfViewEnd) throw(Exception);
+ InPort *end, const std::list<ComposedNode *>& pointsOfViewEnd) ;
void buildDelegateOf(std::pair<OutPort *, OutPort *>& port, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView);
- void getDelegateOf(std::pair<OutPort *, OutPort *>& port, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView) throw(Exception);
- void releaseDelegateOf(OutPort *portDwn, OutPort *portUp, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView) throw(Exception);
+ void getDelegateOf(std::pair<OutPort *, OutPort *>& port, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView) ;
+ void releaseDelegateOf(OutPort *portDwn, OutPort *portUp, InPort *finalTarget, const std::list<ComposedNode *>& pointsOfView) ;
void checkCFLinks(const std::list<OutPort *>& starts, InputPort *end, unsigned char& alreadyFed, bool direction, LinkInfo& info) const;
void checkControlDependancy(OutPort *start, InPort *end, bool cross,
std::map < ComposedNode *, std::list < OutPort * > >& fw,
std::vector<OutPort *>& fwCross,
std::map< ComposedNode *, std::list < OutPort *> >& bw,
LinkInfo& info) const;
- void checkNoCyclePassingThrough(Node *node) throw(Exception);
+ void checkNoCyclePassingThrough(Node *node) ;
private:
int getNbOfCases() const;
static std::string getRepresentationOfCase(int i);
return _alreadyStarted;
}
-void ContainerTest::start(const Task *askingNode) throw(YACS::Exception)
+void ContainerTest::start(const Task *askingNode)
{
if(_alreadyStarted)
throw Exception("ContainerTest already started !!!!");
return new ContainerTest;
}
-void ContainerTest::checkCapabilityToDealWith(const ComponentInstance *inst) const throw(YACS::Exception)
+void ContainerTest::checkCapabilityToDealWith(const ComponentInstance *inst) const
{
if(inst->getKind()!=SUPPORTED_COMP_KIND)
throw Exception("ContainerTest not compatible with this type of instance.");
return _alreadyStarted;
}
-void ContainerTest2::start(const Task *askingNode) throw(YACS::Exception)
+void ContainerTest2::start(const Task *askingNode)
{
if(_alreadyStarted)
throw Exception("ContainerTest already started !!!!");
_counter=0;
}
-void ContainerTest2::checkCapabilityToDealWith(const ComponentInstance *inst) const throw(YACS::Exception)
+void ContainerTest2::checkCapabilityToDealWith(const ComponentInstance *inst) const
{
if(inst->getKind()!=SUPPORTED_COMP_KIND)
throw Exception("ContainerTest not compatible with this type of instance.");
std::string getPlacementInfo() const;
// implementation of compulsary methods
bool isAlreadyStarted(const Task *askingNode) const;
- void start(const Task *askingNode) throw(Exception);
+ void start(const Task *askingNode) ;
Container *clone() const;
Container *cloneAlways() const;
//
std::string getFullPlacementId(const Task *askingNode) const { return ""; }
static void initAllContainers();
protected:
- void checkCapabilityToDealWith(const ComponentInstance *inst) const throw(Exception);
+ void checkCapabilityToDealWith(const ComponentInstance *inst) const ;
protected:
bool _alreadyStarted;
unsigned _myCounter;
std::string getKind() const;
// implementation of compulsary methods
bool isAlreadyStarted(const Task *askingNode) const;
- void start(const Task *askingNode) throw(Exception);
+ void start(const Task *askingNode) ;
Container *clone() const;
Container *cloneAlways() const;
//
std::string getFullPlacementId(const Task *askingNode) const { return ""; }
static void initAllContainers();
protected:
- void checkCapabilityToDealWith(const ComponentInstance *inst) const throw(Exception);
+ void checkCapabilityToDealWith(const ComponentInstance *inst) const ;
protected:
bool _alreadyStarted;
unsigned _myCounter;
_idTest++;
}
-void PluginOptEvTest1::initialize(const Any *input) throw(YACS::Exception)
+void PluginOptEvTest1::initialize(const Any *input)
{
}
void parseFileToInit(const std::string& fileName);
void start();
void takeDecision();
- void initialize(const Any *input) throw(Exception);
+ void initialize(const Any *input) ;
void finish();
};
}
// throw Exception("RuntimeForEngineTest::getCatalogOfComputeNodes : not implemented !");
}
-ElementaryNode* RuntimeForEngineIntegrationTest::createNode(const std::string& implementation, const std::string& name) throw (YACS::Exception)
+ElementaryNode* RuntimeForEngineIntegrationTest::createNode(const std::string& implementation, const std::string& name)
{
if (implementation == ToyNode::MY_IMPL_NAME)
return new ToyNode(name);
throw Exception(msg.str());
}
-InputPort* RuntimeForEngineIntegrationTest::adapt(InputPort* source, const std::string& impl,TypeCode * type,bool init) throw (ConversionException)
+InputPort* RuntimeForEngineIntegrationTest::adapt(InputPort* source, const std::string& impl,TypeCode * type,bool init)
{
return new ProxyPort(source);
}
-InputPort* RuntimeForEngineIntegrationTest::adapt(InPropertyPort* source, const std::string& impl, TypeCode * type, bool init) throw (ConversionException)
+InputPort* RuntimeForEngineIntegrationTest::adapt(InPropertyPort* source, const std::string& impl, TypeCode * type, bool init)
{
return adapt((InputPort *)source, impl, type, init);
}
public:
static void setRuntime();
std::vector< std::pair<std::string,int> > getCatalogOfComputeNodes() const;
- ElementaryNode* createNode(const std::string& implementation, const std::string& name) throw(Exception);
+ ElementaryNode* createNode(const std::string& implementation, const std::string& name) ;
InputPort* createInputPort(const std::string& name, const std::string& impl, Node * node, TypeCode * type);
OutputPort* createOutputPort(const std::string& name, const std::string& impl, Node * node, TypeCode * type);
- InputPort* adapt(InputPort* source, const std::string& impl,TypeCode * type,bool init) throw (ConversionException);
- InputPort* adapt(InPropertyPort* source, const std::string& impl, TypeCode * type,bool init) throw (ConversionException);
+ InputPort* adapt(InputPort* source, const std::string& impl,TypeCode * type,bool init);
+ InputPort* adapt(InPropertyPort* source, const std::string& impl, TypeCode * type,bool init);
ComponentInstance* createComponentInstance(const std::string& name, const std::string& kind="");
};
}
throw Exception(msg.str());
}
-void TestElemInputPort::put(const void *data) throw(ConversionException)
+void TestElemInputPort::put(const void *data)
{
cerr << _name << endl;
stringstream msg;
return new TestElemInputPort(*this,newHelder);
}
-void *TestElemInputPort::get() const throw(YACS::Exception)
+void *TestElemInputPort::get() const
{
stringstream msg;
msg << "Not implemented (" << __FILE__ << ":" << __LINE__ << ")";
return new TestElemOutputPort(*this,newHelder);
}
-void TestElemOutputPort::put(const void *data) throw(ConversionException)
+void TestElemOutputPort::put(const void *data)
{
cerr << _name << endl;
stringstream msg;
// throw Exception("RuntimeForEngineTest::getCatalogOfComputeNodes : not implemented !");
}
-ElementaryNode* RuntimeForEngineTest::createNode(const string& implementation, const string& name) throw(YACS::Exception)
+ElementaryNode* RuntimeForEngineTest::createNode(const string& implementation, const string& name)
{
return new TestElemNode(name);
}
return new TestElemOutputPort(name, node, type);
}
-InputPort* RuntimeForEngineTest::adapt(InputPort* source, const string& impl,TypeCode * type,bool init) throw (ConversionException)
+InputPort* RuntimeForEngineTest::adapt(InputPort* source, const string& impl,TypeCode * type,bool init)
{
return new ProxyPort(source);
}
-InputPort* RuntimeForEngineTest::adapt(InPropertyPort* source, const std::string& impl, TypeCode * type, bool init) throw (ConversionException)
+InputPort* RuntimeForEngineTest::adapt(InPropertyPort* source, const std::string& impl, TypeCode * type, bool init)
{
return adapt((InputPort *)source,impl,type,init);
}
TestElemInputPort(const std::string& name, Node *node, TypeCode* type);
TestElemInputPort(const TestElemInputPort& other, Node *newHelder);
void releaseData() override;
- void put(const void *data) throw(ConversionException);
+ void put(const void *data);
InputPort *clone(Node *newHelder) const;
- void *get() const throw(Exception);
+ void *get() const ;
void exRestoreInit();
void exSaveInit();
protected:
public:
TestElemOutputPort(const std::string& name, Node *node, TypeCode* type);
TestElemOutputPort(const TestElemOutputPort& other, Node *newHelder);
- void put(const void *data) throw(ConversionException);
+ void put(const void *data);
OutputPort *clone(Node *newHelder) const;
};
public:
static void setRuntime();
std::vector< std::pair<std::string,int> > getCatalogOfComputeNodes() const;
- ElementaryNode* createNode(const std::string& implementation, const std::string& name) throw(Exception);
+ ElementaryNode* createNode(const std::string& implementation, const std::string& name) ;
InputPort* createInputPort(const std::string& name, const std::string& impl, Node * node, TypeCode * type);
OutputPort* createOutputPort(const std::string& name, const std::string& impl, Node * node, TypeCode * type);
- InputPort* adapt(InputPort* source, const std::string& impl, TypeCode * type,bool init) throw (ConversionException);
- InputPort* adapt(InPropertyPort* source, const std::string& impl, TypeCode * type,bool init) throw (ConversionException);
+ InputPort* adapt(InputPort* source, const std::string& impl, TypeCode * type,bool init);
+ InputPort* adapt(InPropertyPort* source, const std::string& impl, TypeCode * type,bool init);
};
}
}
{
}
-void InputToyPort::put(const void *data) throw(ConversionException)
+void InputToyPort::put(const void *data)
{
put((Any *)data);
}
return _initData!=0;
}
-void *InputToyPort::get() const throw(YACS::Exception)
+void *InputToyPort::get() const
{
return (void *)_data;
}
_data=other._data->clone();
}
-void OutputToyPort::put(const void *data) throw(ConversionException)
+void OutputToyPort::put(const void *data)
{
put((Any *)data);
OutputPort::put(data);
return ElementaryNode::getNumberOfInputPorts()+1;
}
-OutputPort *ToyNode::getOutputPort(const std::string& name) const throw(YACS::Exception)
+OutputPort *ToyNode::getOutputPort(const std::string& name) const
{
if(name==NAME_FOR_NB)
return (OutputPort *)&_nbOfInputsPort;
return ret;
}
-InputPort *SeqToyNode::getInputPort(const std::string& name) const throw(YACS::Exception)
+InputPort *SeqToyNode::getInputPort(const std::string& name) const
{
if(name==NAME_NBOFELTS_INSEQ_INPRT)
return (InputPort *)&_inIntValue;
return ret;
}
-OutputPort *SeqToyNode::getOutputPort(const std::string& name) const throw(YACS::Exception)
+OutputPort *SeqToyNode::getOutputPort(const std::string& name) const
{
if(name==NAME_SEQ_OUTPRT)
return (OutputPort *)&_seqOut;
return ret;
}
-InputPort *Seq2ToyNode::getInputPort(const std::string& name) const throw(YACS::Exception)
+InputPort *Seq2ToyNode::getInputPort(const std::string& name) const
{
if(name==NAME_SEQ_INPRT1)
return (InputPort *)&_inValue1;
return ret;
}
-OutputPort *Seq2ToyNode::getOutputPort(const std::string& name) const throw(YACS::Exception)
+OutputPort *Seq2ToyNode::getOutputPort(const std::string& name) const
{
if(name==NAME_SEQ_OUTPRT)
return (OutputPort *)&_seqOut;
return ret;
}
-InputPort *Seq3ToyNode::getInputPort(const std::string& name) const throw(YACS::Exception)
+InputPort *Seq3ToyNode::getInputPort(const std::string& name) const
{
if(name==NAME_SEQ_INPRT1)
return (InputPort *)&_inValue1;
return ret;
}
-OutputPort *Seq3ToyNode::getOutputPort(const std::string& name) const throw(YACS::Exception)
+OutputPort *Seq3ToyNode::getOutputPort(const std::string& name) const
{
if(name==NAME_SEQ_OUTPRT)
return (OutputPort *)&_seqOut;
{
}
-void InputLimitPort::put(const void *data) throw(ConversionException)
+void InputLimitPort::put(const void *data)
{
put((Any *)data);
}
return _initData!=0;
}
-void *InputLimitPort::get() const throw(YACS::Exception)
+void *InputLimitPort::get() const
{
if(!_data)
{
{
}
-void OutputLimitPort::put(const void *data) throw(ConversionException)
+void OutputLimitPort::put(const void *data)
{
put((Any *)data);
OutputPort::put(data);
return ret;
}
-InputPort *LimitNode::getInputPort(const std::string& name) const throw(YACS::Exception)
+InputPort *LimitNode::getInputPort(const std::string& name) const
{
if(name==NAME_FOR_SWPORT)
return (InputPort *)&_entry;
return ElementaryNode::getInputPort(name);
}
-OutputPort *LimitNode::getOutputPort(const std::string& name) const throw(YACS::Exception)
+OutputPort *LimitNode::getOutputPort(const std::string& name) const
{
if(name==NAME_FOR_SWPORT)
return (OutputPort *)&_switchPort;
InputToyPort(const InputToyPort& other, Node *newHelder);
InputToyPort(const std::string& name, Node *node);
void releaseData() override;
- void put(const void *data) throw(ConversionException);
+ void put(const void *data);
InputPort *clone(Node *newHelder) const;
bool edIsManuallyInitialized() const;
- void *get() const throw(Exception);
+ void *get() const ;
void edRemoveManInit();
void put(Any *data);
~InputToyPort();
public:
OutputToyPort(const std::string& name, Node *node, TypeCode *type);
OutputToyPort(const OutputToyPort& other, Node *newHelder);
- void put(const void *data) throw(ConversionException);
+ void put(const void *data);
OutputPort *clone(Node *newHelder) const;
void put(Any *data);
~OutputToyPort();
OutputPort *edGetNbOfInputsOutputPort() { return &_nbOfInputsPort; }
std::list<OutputPort *> getSetOfOutputPort() const;
int getNumberOfOutputPorts()const;
- OutputPort *getOutputPort(const std::string& name) const throw(Exception);
+ OutputPort *getOutputPort(const std::string& name) const ;
protected:
Node *simpleClone(ComposedNode *father, bool editionOnly) const;
public:
InputPort *edGetInIntValue() const { return (InputPort *)&_inIntValue; }
int getNumberOfInputPorts() const;
std::list<InputPort *> getSetOfInputPort() const;
- InputPort *getInputPort(const std::string& name) const throw(Exception);
+ InputPort *getInputPort(const std::string& name) const ;
int getNumberOfOutputPorts() const;
std::list<OutputPort *> getSetOfOutputPort() const;
- OutputPort *getOutputPort(const std::string& name) const throw(Exception);
+ OutputPort *getOutputPort(const std::string& name) const ;
protected:
Node *simpleClone(ComposedNode *father, bool editionOnly) const;
public:
InputPort *edGetInValue2() const { return (InputPort *)&_inValue2; }
int getNumberOfInputPorts() const;
std::list<InputPort *> getSetOfInputPort() const;
- InputPort *getInputPort(const std::string& name) const throw(Exception);
+ InputPort *getInputPort(const std::string& name) const ;
int getNumberOfOutputPorts() const;
std::list<OutputPort *> getSetOfOutputPort() const;
- OutputPort *getOutputPort(const std::string& name) const throw(Exception);
+ OutputPort *getOutputPort(const std::string& name) const ;
protected:
Node *simpleClone(ComposedNode *father, bool editionOnly) const;
public:
InputPort *edGetInValue2() const { return (InputPort *)&_inValue2; }
int getNumberOfInputPorts() const;
std::list<InputPort *> getSetOfInputPort() const;
- InputPort *getInputPort(const std::string& name) const throw(Exception);
+ InputPort *getInputPort(const std::string& name) const ;
int getNumberOfOutputPorts() const;
std::list<OutputPort *> getSetOfOutputPort() const;
- OutputPort *getOutputPort(const std::string& name) const throw(Exception);
+ OutputPort *getOutputPort(const std::string& name) const ;
protected:
Node *simpleClone(ComposedNode *father, bool editionOnly) const;
public:
{
friend class LimitNode;
public:
- void put(const void *data) throw(ConversionException);
+ void put(const void *data);
InputPort *clone(Node *newHelder) const;
bool edIsManuallyInitialized() const;
- void *get() const throw(Exception);
+ void *get() const ;
void edRemoveManInit();
void releaseData() override;
void put(Any *data);
{
friend class LimitNode;
public:
- void put(const void *data) throw(ConversionException);
+ void put(const void *data);
OutputPort *clone(Node *newHelder) const;
void put(Any *data);
~OutputLimitPort();
OutputPort *getCounterPort() { return &_counterPort; }
std::list<InputPort *> getSetOfInputPort() const;
std::list<OutputPort *> getSetOfOutputPort() const;
- InputPort *getInputPort(const std::string& name) const throw(Exception);
- OutputPort *getOutputPort(const std::string& name) const throw(Exception);
+ InputPort *getInputPort(const std::string& name) const ;
+ OutputPort *getOutputPort(const std::string& name) const ;
LimitNode(const LimitNode& other, ComposedNode *father);
LimitNode(const std::string& name);
protected:
return AtomAny::getOrBuildFromData(data,this);
}
-const char * TypeCode::name() const throw(YACS::Exception)
+const char * TypeCode::name() const
{
return id();
}
return id();
}
-const char * TypeCode::id() const throw(YACS::Exception)
+const char * TypeCode::id() const
{
switch(_kind)
{
}
}
-int TypeCode::isA(const char* id) const throw(YACS::Exception)
+int TypeCode::isA(const char* id) const
{
throw Exception("Not implemented for this type");
}
}
}
-const TypeCode * TypeCode::contentType() const throw(YACS::Exception)
+const TypeCode * TypeCode::contentType() const
{
throw Exception("No content type");
};
return AtomAny::getOrBuildFromData(data,this);
}
-const char * TypeCodeObjref::id() const throw(YACS::Exception)
+const char * TypeCodeObjref::id() const
{
return _repoId.c_str();
};
-const char * TypeCodeObjref::name() const throw(YACS::Exception)
+const char * TypeCodeObjref::name() const
{
return _name.c_str();
}
* \param id : a given id
* \return 1 if true, 0 if false
*/
-int TypeCodeObjref::isA(const char* id) const throw(YACS::Exception)
+int TypeCodeObjref::isA(const char* id) const
{
if(_repoId == id)return 1;
list<TypeCodeObjref *>::const_iterator iter;
return SequenceAny::getOrBuildFromData(data,this);
}
-const char * TypeCodeSeq::id() const throw(YACS::Exception)
+const char * TypeCodeSeq::id() const
{
return _repoId.c_str();
}
-const char * TypeCodeSeq::name() const throw(YACS::Exception)
+const char * TypeCodeSeq::name() const
{
return _name.c_str();
}
return oss.str();
}
-const TypeCode * TypeCodeSeq::contentType() const throw(YACS::Exception)
+const TypeCode * TypeCodeSeq::contentType() const
{
return _content;
}
return ArrayAny::getOrBuildFromData(data,this);
}
-const char * TypeCodeArray::id() const throw(YACS::Exception)
+const char * TypeCodeArray::id() const
{
return _repoId.c_str();
}
-const char * TypeCodeArray::name() const throw(YACS::Exception)
+const char * TypeCodeArray::name() const
{
return _name.c_str();
}
return _staticLgth;
}
-const TypeCode * TypeCodeArray::contentType() const throw(YACS::Exception)
+const TypeCode * TypeCodeArray::contentType() const
{
return _content;
}
return StructAny::getOrBuildFromData(data,this);
}
-const char * TypeCodeStruct::id() const throw(YACS::Exception)
+const char * TypeCodeStruct::id() const
{
return _repoId.c_str();
};
-const char * TypeCodeStruct::name() const throw(YACS::Exception)
+const char * TypeCodeStruct::name() const
{
return _name.c_str();
}
return ret;
}
-const TypeCode *TypeCodeStruct::contentType() const throw(YACS::Exception)
+const TypeCode *TypeCodeStruct::contentType() const
{
const char what[]="Content type is specified by giving a key.";
throw Exception(what);
* \param id : a given id
* \return 1 if true, 0 if false
*/
-int TypeCodeStruct::isA(const char* id) const throw(YACS::Exception)
+int TypeCodeStruct::isA(const char* id) const
{
if(_repoId == id)return 1;
return 0;
virtual void putReprAtPlace(char *pt, const char *val, bool deepCpy) const;
virtual void destroyZippedAny(char *data) const;
virtual AnyPtr getOrBuildAnyFromZippedData(char *data) const;
- virtual const char * name() const throw(Exception);
+ virtual const char * name() const;
virtual const char * shortName() const;
- virtual const char * id() const throw(Exception);
- virtual const TypeCode * contentType() const throw(Exception);
- virtual int isA(const char* repositoryId) const throw(Exception);
+ virtual const char * id() const;
+ virtual const TypeCode * contentType() const;
+ virtual int isA(const char* repositoryId) const;
virtual int isA(const TypeCode* tc) const ;
virtual int isAdaptable(const TypeCode* tc) const;
virtual int isEquivalent(const TypeCode* tc) const;
void putReprAtPlace(char *pt, const char *val, bool deepCpy) const;
void destroyZippedAny(char *data) const;
AnyPtr getOrBuildAnyFromZippedData(char *data) const;
- const char * id() const throw(Exception);
- const char * name() const throw(Exception);
+ const char * id() const;
+ const char * name() const;
const char * shortName() const;
- int isA(const char* repositoryId) const throw(Exception);
+ int isA(const char* repositoryId) const;
virtual int isA(const TypeCode* tc) const ;
virtual int isAdaptable(const TypeCode* tc) const;
virtual int isEquivalent(const TypeCode* tc) const;
void destroyZippedAny(char *data) const;
virtual unsigned getSizeInByteOfAnyReprInSeq() const;
AnyPtr getOrBuildAnyFromZippedData(char *data) const;
- const char * id() const throw(Exception);
- const char * name() const throw(Exception);
+ const char * id() const;
+ const char * name() const;
const char * shortName() const;
virtual std::string getPrintStr() const;
- virtual const TypeCode * contentType() const throw(Exception);
+ virtual const TypeCode * contentType() const;
virtual int isA(const TypeCode* tc) const ;
virtual int isAdaptable(const TypeCode* tc) const;
virtual int isEquivalent(const TypeCode* tc) const;
void putReprAtPlace(char *pt, const char *val, bool deepCpy) const;
void destroyZippedAny(char *data) const;
AnyPtr getOrBuildAnyFromZippedData(char *data) const;
- const char * id() const throw(Exception);
- const char * name() const throw(Exception);
+ const char * id() const;
+ const char * name() const;
const char * shortName() const;
unsigned getStaticLgth() const;
- virtual const TypeCode * contentType() const throw(Exception);
+ virtual const TypeCode * contentType() const;
virtual int isA(const TypeCode* tc) const ;
virtual int isAdaptable(const TypeCode* tc) const;
virtual int isEquivalent(const TypeCode* tc) const;
void putReprAtPlace(char *pt, const char *val, bool deepCpy) const;
void destroyZippedAny(char *data) const;
AnyPtr getOrBuildAnyFromZippedData(char *data) const;
- const char * id() const throw(Exception);
- const char * name() const throw(Exception);
+ const char * id() const;
+ const char * name() const;
const char * shortName() const;
virtual unsigned getSizeInByteOfAnyReprInSeq() const;
- const TypeCode * contentType() const throw(Exception);
- virtual int isA(const char* repositoryId) const throw(Exception);
+ const TypeCode * contentType() const;
+ virtual int isA(const char* repositoryId) const;
virtual int isA(const TypeCode* tc) const ;
virtual int isAdaptable(const TypeCode* tc) const;
virtual int isEquivalent(const TypeCode* tc) const;
}
}
-void VisitorSaveSchema::openFileSchema(std::string xmlSchema) throw(YACS::Exception)
+void VisitorSaveSchema::openFileSchema(std::string xmlSchema)
{
_out.open(xmlSchema.c_str(), ios::out);
if (!_out)
public:
VisitorSaveSchema(ComposedNode *root);
virtual ~VisitorSaveSchema();
- void openFileSchema(std::string xmlDump) throw(Exception);
+ void openFileSchema(std::string xmlDump) ;
void closeFileSchema();
virtual void visitBloc(Bloc *node);
virtual void visitElementaryNode(ElementaryNode *node);
}
}
-void VisitorSaveState::openFileDump(const std::string& xmlDump) throw(YACS::Exception)
+void VisitorSaveState::openFileDump(const std::string& xmlDump)
{
_out.open(xmlDump.c_str(), ios::out);
if (!_out)
public:
VisitorSaveState(ComposedNode *root);
virtual ~VisitorSaveState();
- void openFileDump(const std::string& xmlDump) throw(Exception);
+ void openFileDump(const std::string& xmlDump) ;
void closeFileDump();
virtual void visitBloc(Bloc *node);
virtual void visitElementaryNode(ElementaryNode *node);
return new WhileLoop(*this,father,editionOnly);
}
-InputPort *WhileLoop::getInputPort(const std::string& name) const throw(YACS::Exception)
+InputPort *WhileLoop::getInputPort(const std::string& name) const
{
if(name==NAME_OF_INPUT_CONDITION)
return (InputPort*)&_conditionPort;
void WhileLoop::checkLinkPossibility(OutPort *start,
const std::list<ComposedNode *>& pointsOfViewStart,
InPort *end,
- const std::list<ComposedNode *>& pointsOfViewEnd) throw(YACS::Exception)
+ const std::list<ComposedNode *>& pointsOfViewEnd)
{
DEBTRACE("WhileLoop::checkLinkPossibility");
}
void exUpdateState();
void init(bool start=true);
InputPort *edGetConditionPort() { return &_conditionPort; }
- InputPort* getInputPort(const std::string& name) const throw(Exception);
+ InputPort* getInputPort(const std::string& name) const ;
std::list<InputPort *> getLocalInputPorts() const;
virtual void accept(Visitor *visitor);
InputPort *getDecisionPort() const { return (InputPort *)&_conditionPort; }
protected:
Node *simpleClone(ComposedNode *father, bool editionOnly=true) const;
void checkLinkPossibility(OutPort *start, const std::list<ComposedNode *>& pointsOfViewStart,
- InPort *end, const std::list<ComposedNode *>& pointsOfViewEnd) throw(Exception);
+ InPort *end, const std::list<ComposedNode *>& pointsOfViewEnd) ;
YACS::Event updateStateOnFinishedEventFrom(Node *node);
};
}
* transition method from const void* to CORBA::Any*
* \param data : const void * data
*/
-void CorbaCorba::put(const void *data) throw(ConversionException)
+void CorbaCorba::put(const void *data)
{
put((CORBA::Any *)data);
}
/*!
* \param data : CORBA::Any object
*/
-void CorbaCorba::put(CORBA::Any *data) throw(ConversionException)
+void CorbaCorba::put(CORBA::Any *data)
{
CORBA::Any *a = convertCorbaCorba(edGetType(),data);
_port->put(a);
{
public:
CorbaCorba(InputCorbaPort* p);
- virtual void put(const void *data) throw(ConversionException);
- void put(CORBA::Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(CORBA::Any *data);
};
}
* \param data : CORBA::Any object as a void * pointer
*/
- void CorbaCpp::put(const void *data) throw(ConversionException)
+ void CorbaCpp::put(const void *data)
{
put((CORBA::Any *)data);
}
/*!
* \param data : CORBA::Any object
*/
- void CorbaCpp::put(CORBA::Any *data) throw(ConversionException)
+ void CorbaCpp::put(CORBA::Any *data)
{
DEBTRACE("CorbaCpp::put");
YACS::ENGINE::Any *ob;
{
public:
CorbaCpp(InputPort* p);
- virtual void put(const void *data) throw(ConversionException);
- void put(CORBA::Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(CORBA::Any *data);
};
int isAdaptableCppCorba(const TypeCode *t1,const TypeCode *t2);
}
* \param data : CORBA::Any object as a void * pointer
*/
-void CorbaNeutral::put(const void *data) throw(ConversionException)
+void CorbaNeutral::put(const void *data)
{
put((CORBA::Any *)data);
}
/*!
* \param data : CORBA::Any object
*/
-void CorbaNeutral::put(CORBA::Any *data) throw(ConversionException)
+void CorbaNeutral::put(CORBA::Any *data)
{
DEBTRACE( "CorbaNeutral::put" )
YACS::ENGINE::Any *ob;
{
public:
CorbaNeutral(InputPort* p);
- virtual void put(const void *data) throw(ConversionException);
- void put(CORBA::Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(CORBA::Any *data);
};
}
}
InputPort::edRemoveManInit();
}
-void InputCorbaPort::put(const void *data) throw (ConversionException)
+void InputCorbaPort::put(const void *data)
{
put((CORBA::Any *)data);
}
{//do nothing - to be implemented
}
-void InputCorbaPort::put(CORBA::Any *data) throw (ConversionException)
+void InputCorbaPort::put(CORBA::Any *data)
{
#ifdef REFCNT
DEBTRACE("refcount CORBA : " << ((omni::TypeCode_base*)data->pd_tc.in())->pd_ref_count);
return new InputCorbaPort(*this,newHelder);
}
-void *InputCorbaPort::get() const throw(YACS::Exception)
+void *InputCorbaPort::get() const
{
return (void *)&_data;
}
#endif
}
-void OutputCorbaPort::put(const void *data) throw (ConversionException)
+void OutputCorbaPort::put(const void *data)
{
put((CORBA::Any *)data);
}
-void OutputCorbaPort::put(CORBA::Any *data) throw (ConversionException)
+void OutputCorbaPort::put(CORBA::Any *data)
{
InputPort *p;
virtual ~InputCorbaPort();
bool edIsManuallyInitialized() const;
void edRemoveManInit();
- virtual void put(const void *data) throw(ConversionException);
- void put(CORBA::Any *data) throw (ConversionException);
+ virtual void put(const void *data);
+ void put(CORBA::Any *data);
void releaseData() override;
InputPort *clone(Node *newHelder) const;
- void *get() const throw(Exception);
+ void *get() const ;
virtual bool isEmpty();
virtual CORBA::Any * getAny();
virtual std::string getAsString();
OutputCorbaPort(const std::string& name, Node *node, TypeCode * type);
OutputCorbaPort(const OutputCorbaPort& other, Node *newHelder);
virtual ~OutputCorbaPort();
- virtual void put(const void *data) throw(ConversionException);
- void put(CORBA::Any *data) throw (ConversionException);
+ virtual void put(const void *data);
+ void put(CORBA::Any *data);
OutputPort *clone(Node *newHelder) const;
virtual CORBA::Any * getAny();
virtual CORBA::Any * getAnyOut();
: ProxyPort(p), DataPort(p->getName(), p->getNode(), p->edGetType()), Port(p->getNode())
{}
-void CorbaPyDouble::put(const void *data) throw(ConversionException)
+void CorbaPyDouble::put(const void *data)
{
put((CORBA::Any *)data);
}
/*!
* \param data : CORBA::Any object
*/
-void CorbaPyDouble::put(CORBA::Any *data) throw(ConversionException)
+void CorbaPyDouble::put(CORBA::Any *data)
{
InterpreterUnlocker loc;
PyObject* ob=convertCorbaPyObject(edGetType(),data);
: ProxyPort(p), DataPort(p->getName(), p->getNode(), p->edGetType()), Port(p->getNode())
{}
-void CorbaPyInt::put(const void *data) throw(ConversionException)
+void CorbaPyInt::put(const void *data)
{
put((CORBA::Any *)data);
}
/*!
* \param data : CORBA::Any object
*/
-void CorbaPyInt::put(CORBA::Any *data) throw(ConversionException)
+void CorbaPyInt::put(CORBA::Any *data)
{
InterpreterUnlocker loc;
PyObject* ob=convertCorbaPyObject(edGetType(),data);
CorbaPyString::CorbaPyString(InputPyPort* p)
: ProxyPort(p), DataPort(p->getName(), p->getNode(), p->edGetType()), Port(p->getNode())
{}
-void CorbaPyString::put(const void *data) throw(ConversionException)
+void CorbaPyString::put(const void *data)
{
put((CORBA::Any *)data);
}
/*!
* \param data : CORBA::Any object
*/
-void CorbaPyString::put(CORBA::Any *data) throw(ConversionException)
+void CorbaPyString::put(CORBA::Any *data)
{
InterpreterUnlocker loc;
PyObject* ob=convertCorbaPyObject(edGetType(),data);
/*!Convert a CORBA::Any boolean to a PyObject boolean
* It's only a wrapper around put(CORBA::Any *data)
*/
-void CorbaPyBool::put(const void *data) throw(ConversionException)
+void CorbaPyBool::put(const void *data)
{
put((CORBA::Any *)data);
}
/*!
* \param data : CORBA::Any object
*/
-void CorbaPyBool::put(CORBA::Any *data) throw(ConversionException)
+void CorbaPyBool::put(CORBA::Any *data)
{
InterpreterUnlocker loc;
PyObject* ob=convertCorbaPyObject(edGetType(),data);
: ProxyPort(p), DataPort(p->getName(), p->getNode(), p->edGetType()), Port(p->getNode())
{}
-void CorbaPyObjref::put(const void *data) throw(ConversionException)
+void CorbaPyObjref::put(const void *data)
{
put((CORBA::Any *)data);
}
/*!
* \param data : CORBA::Any object
*/
-void CorbaPyObjref::put(CORBA::Any *data) throw(ConversionException)
+void CorbaPyObjref::put(CORBA::Any *data)
{
InterpreterUnlocker loc;
PyObject* ob=convertCorbaPyObject(edGetType(),data);
_dynfactory = getSALOMERuntime()->getDynFactory();
}
-void CorbaPySequence::put(const void *data) throw(ConversionException)
+void CorbaPySequence::put(const void *data)
{
put((CORBA::Any *)data);
}
/*!
* \param data : CORBA::Any object
*/
-void CorbaPySequence::put(CORBA::Any *data) throw(ConversionException)
+void CorbaPySequence::put(CORBA::Any *data)
{
InterpreterUnlocker loc;
PyObject* ob=convertCorbaPyObject(edGetType(),data);
{
}
-void CorbaPyStruct::put(const void *data) throw(ConversionException)
+void CorbaPyStruct::put(const void *data)
{
put((CORBA::Any *)data);
}
/*!
* \param data : CORBA::Any object
*/
-void CorbaPyStruct::put(CORBA::Any *data) throw(ConversionException)
+void CorbaPyStruct::put(CORBA::Any *data)
{
InterpreterUnlocker loc;
PyObject* ob=convertCorbaPyObject(edGetType(),data);
{
public:
CorbaPyDouble(InputPyPort* p);
- virtual void put(const void *data) throw(ConversionException);
- void put(CORBA::Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(CORBA::Any *data);
};
/*! \brief Class for conversion from CORBA Output port to Python Input port
{
public:
CorbaPyInt(InputPyPort* p);
- virtual void put(const void *data) throw(ConversionException);
- void put(CORBA::Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(CORBA::Any *data);
};
/*! \brief Class for conversion from CORBA Output port to Python Input port
{
public:
CorbaPyString(InputPyPort* p);
- virtual void put(const void *data) throw(ConversionException);
- void put(CORBA::Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(CORBA::Any *data);
};
/*! \brief Class for conversion from CORBA Output port to Python Input port
{
public:
CorbaPyBool(InputPyPort* p);
- virtual void put(const void *data) throw(ConversionException);
- void put(CORBA::Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(CORBA::Any *data);
};
/*! \brief Class for conversion from CORBA Output port to Python Input port
{
public:
CorbaPyObjref(InputPyPort* p);
- virtual void put(const void *data) throw(ConversionException);
- void put(CORBA::Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(CORBA::Any *data);
};
/*! \brief Class for conversion from CORBA Output port to Python Input port
{
public:
CorbaPySequence(InputPyPort* p);
- virtual void put(const void *data) throw(ConversionException);
- void put(CORBA::Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(CORBA::Any *data);
protected:
DynamicAny::DynAnyFactory_ptr _dynfactory;
};
{
public:
CorbaPyStruct(InputPyPort* p);
- virtual void put(const void *data) throw(ConversionException);
- void put(CORBA::Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(CORBA::Any *data);
};
}
* \param data : CORBA::Any object as a void * pointer
*/
-void CorbaXml::put(const void *data) throw(ConversionException)
+void CorbaXml::put(const void *data)
{
put((CORBA::Any *)data);
}
/*!
* \param data : CORBA::Any object
*/
-void CorbaXml::put(CORBA::Any *data) throw(ConversionException)
+void CorbaXml::put(CORBA::Any *data)
{
DEBTRACE("CorbaXml::put" );
std::string sss = convertCorbaXml(edGetType(),data);
{
public:
CorbaXml(InputXmlPort* p);
- virtual void put(const void *data) throw(ConversionException);
- void put(CORBA::Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(CORBA::Any *data);
};
}
}
return new OutputCalStreamPort(*this,newHelder);
}
-bool OutputCalStreamPort::addInPort(InPort *inPort) throw(YACS::Exception)
+bool OutputCalStreamPort::addInPort(InPort *inPort)
{
DEBTRACE("OutputCalStreamPort::addInPort " << InputCalStreamPort::NAME );
if(inPort->getNameOfTypeOfCurrentInstance()!=InputCalStreamPort::NAME)
}
-int OutputCalStreamPort::removeInPort(InPort *inPort, bool forward) throw(YACS::Exception)
+int OutputCalStreamPort::removeInPort(InPort *inPort, bool forward)
{
DEBTRACE("OutputCalStreamPort::removeInPort");
if(inPort->getNameOfTypeOfCurrentInstance()!=InputCalStreamPort::NAME && !forward)
void setSchema(const std::string& schema);
std::string getSchema(){return _schema;};
void setProperty(const std::string& name, const std::string& value);
- virtual bool addInPort(InPort *inPort) throw(Exception);
+ virtual bool addInPort(InPort *inPort) ;
std::string getNameOfTypeOfCurrentInstance() const;
OutputCalStreamPort * clone(Node *newHelder) const;
- virtual int removeInPort(InPort *inPort, bool forward) throw(Exception);
+ virtual int removeInPort(InPort *inPort, bool forward) ;
protected:
std::string _depend;
std::string _schema;
return convertNeutralCorba(t, data);
}
- void CppCorba::put(const void *data) throw(ConversionException)
+ void CppCorba::put(const void *data)
{
put((Any *)data);
}
* \param data : python object
*/
- void CppCorba::put(Any *data) throw(ConversionException)
+ void CppCorba::put(Any *data)
{
CORBA::Any* a = convertCppCorba(edGetType(), data);
_port->put(a);
public:
CppCorba(InputCorbaPort* p)
: ProxyPort(p), DataPort(p->getName(), p->getNode(), p->edGetType()), Port(p->getNode()) {}
- virtual void put(const void *data) throw(ConversionException);
- void put(Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(Any *data);
};
int isAdaptableCorbaCpp(const TypeCode *t1, const TypeCode *t2);
}
}
void CppComponent::run (const char * service, int nbIn, int nbOut,
- Any ** argIn, Any ** argOut) throw (YACS::Exception)
+ Any ** argIn, Any ** argOut)
{
int i;
returnInfo return_code;
virtual ~CppComponent();
void run(const char * service, int nbIn, int nbOut,
- Any ** argIn, Any ** argOut) throw (YACS::Exception);
+ Any ** argIn, Any ** argOut);
static const char KIND[];
virtual std::string getKind() const;
return NULL != _trueCont;
}
-void CppContainer::start(const Task *askingNode) throw (YACS::Exception)
+void CppContainer::start(const Task *askingNode)
{
_trueCont = LocalContainer::get();
}
return new CppContainer(*this);
}
-bool CppContainer::loadComponentLibrary(const std::string & componentName) throw (YACS::Exception)
+bool CppContainer::loadComponentLibrary(const std::string & componentName)
{
if (_trueCont)
{
return "/";
}
-void CppContainer::checkCapabilityToDealWith(const ComponentInstance *inst) const throw(YACS::Exception)
+void CppContainer::checkCapabilityToDealWith(const ComponentInstance *inst) const
{
if(inst->getKind()!=CppComponent::KIND)
throw Exception("CppContainer::checkCapabilityToDealWith : CppContainer is not able to deal with this type of ComponentInstance.");
virtual ~CppContainer();
std::string getKind() const;
bool isAlreadyStarted(const Task *askingNode) const;
- void start(const Task *askingNode) throw (YACS::Exception);
+ void start(const Task *askingNode);
void shutdown(int level);
std::string getPlacementId(const Task *askingNode) const;
std::string getFullPlacementId(const Task *askingNode) const;
void lock();
void unLock();
- void checkCapabilityToDealWith(const ComponentInstance *inst) const throw (YACS::Exception);
- bool loadComponentLibrary(const std::string & componentName) throw (YACS::Exception);
+ void checkCapabilityToDealWith(const ComponentInstance *inst) const;
+ bool loadComponentLibrary(const std::string & componentName);
CppComponent * createComponentInstance(const std::string & componentName);
void createInternalInstance(const std::string & componentName,
void *& obj, RunFunction &r, TerminateFunction &t);
* transition method from const void* to Any*
* \param data : const void * data
*/
- void CppCpp::put(const void *data) throw(ConversionException)
+ void CppCpp::put(const void *data)
{
put((Any *)data);
}
/*!
* \param data : Any object
*/
- void CppCpp::put(Any *data) throw(ConversionException)
+ void CppCpp::put(Any *data)
{
Any *a = convertCppCpp(edGetType(),data);
DEBTRACE( "before put refcnt: " << a->getRefCnt() );
{
public:
CppCpp(InputCppPort* p);
- virtual void put(const void *data) throw(ConversionException);
- void put(Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(Any *data);
};
}
{
}
- void CppNeutral::put(const void *data) throw(ConversionException)
+ void CppNeutral::put(const void *data)
{
DEBTRACE(" CppNeutral::put(const void *data)");
put((Any *)data);
* \param data : Neutral (Any *) value
*/
- void CppNeutral::put(Any *data) throw(ConversionException)
+ void CppNeutral::put(Any *data)
{
DEBTRACE("CppNeutral::put " << data);
Any *ob;
{
public:
CppNeutral(InputPort* p);
- virtual void put(const void *data) throw(ConversionException);
- void put(Any *data) throw(ConversionException);
+ virtual void put(const void *data) ;
+ void put(Any *data);
};
int isAdaptableNeutralCpp(const TypeCode * t1, const TypeCode * t2);
}
InputPort::edRemoveManInit();
}
-void InputCppPort::put(const void *data) throw(ConversionException)
+void InputCppPort::put(const void *data)
{
put((YACS::ENGINE::Any *)data);
}
_data=nullptr;
}
-void InputCppPort::put(YACS::ENGINE::Any *data) throw(ConversionException)
+void InputCppPort::put(YACS::ENGINE::Any *data)
{
releaseData();
_data=data;
return _data;
}
-void *InputCppPort::get() const throw(YACS::Exception)
+void *InputCppPort::get() const
{
return (void*) _data;
}
{
}
-void OutputCppPort::put(const void *data) throw(ConversionException)
+void OutputCppPort::put(const void *data)
{
put((YACS::ENGINE::Any *)data);
}
-void OutputCppPort::put(YACS::ENGINE::Any *data) throw(ConversionException)
+void OutputCppPort::put(YACS::ENGINE::Any *data)
{
InputPort *p;
if(_data)
~InputCppPort();
bool edIsManuallyInitialized() const;
void edRemoveManInit();
- virtual void put(const void *data) throw(ConversionException);
- void put(YACS::ENGINE::Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(YACS::ENGINE::Any *data);
void releaseData() override;
InputPort *clone(Node *newHelder) const;
virtual YACS::ENGINE::Any * getCppObj() const;
- void *get() const throw(Exception);
+ void *get() const ;
virtual bool isEmpty();
virtual void exSaveInit();
virtual void exRestoreInit();
OutputCppPort(const std::string& name, Node * node, TypeCode * type);
OutputCppPort(const OutputCppPort& other, Node *newHelder);
~OutputCppPort();
- virtual void put(const void *data) throw(ConversionException);
- void put(YACS::ENGINE::Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(YACS::ENGINE::Any *data);
OutputPort *clone(Node *newHelder) const;
virtual YACS::ENGINE::Any * get() const;
virtual std::string dump();
/*!
* \param data : C++ value received
*/
- void CppPy::put(const void *data) throw(ConversionException)
+ void CppPy::put(const void *data)
{
put((Any *) data);
}
- void CppPy::put(Any *data) throw(ConversionException)
+ void CppPy::put(Any *data)
{
DEBTRACE(" CppPython::put(Any *data)");
PyObject *ob;
{
public:
CppPy(InputPyPort* p);
- virtual void put(const void *data) throw(ConversionException);
- virtual void put(Any *a) throw(ConversionException);
+ virtual void put(const void *data) ;
+ virtual void put(Any *a) ;
};
int isAdaptablePyObjectCpp(const TypeCode *t1, const TypeCode *t2);
}
* \param data : YACS::ENGINE::Any object as a void * pointer
*/
- void CppXml::put(const void *data) throw(ConversionException)
+ void CppXml::put(const void *data)
{
put((YACS::ENGINE::Any *)data);
}
/*!
* \param data : YACS::ENGINE::Any object
*/
- void CppXml::put(YACS::ENGINE::Any *data) throw(ConversionException)
+ void CppXml::put(YACS::ENGINE::Any *data)
{
DEBTRACE("CppXml::put");
std::string s = convertCppXml(edGetType(), data);
{
public:
CppXml(InputXmlPort* p);
- virtual void put(const void *data) throw(ConversionException);
- void put(YACS::ENGINE::Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(YACS::ENGINE::Any *data);
};
int isAdaptableXmlCpp(const TypeCode *t1, const TypeCode *t2);
}
using namespace std;
-void NeutralCorbaInt::put(const void *data) throw(ConversionException)
+void NeutralCorbaInt::put(const void *data)
{
put((YACS::ENGINE::Any *)data);
}
* \param data : YACS::ENGINE::Any object
*/
-void NeutralCorbaInt::put(YACS::ENGINE::Any *data) throw(ConversionException)
+void NeutralCorbaInt::put(YACS::ENGINE::Any *data)
{
CORBA::Any *a =convertNeutralCorba(edGetType(),data);
_port->put(a);
delete a;
}
-void NeutralCorbaBool::put(const void *data) throw(ConversionException)
+void NeutralCorbaBool::put(const void *data)
{
put((YACS::ENGINE::Any *)data);
}
* \param data : YACS::ENGINE::Any object
*/
-void NeutralCorbaBool::put(YACS::ENGINE::Any *data) throw(ConversionException)
+void NeutralCorbaBool::put(YACS::ENGINE::Any *data)
{
CORBA::Any *a =convertNeutralCorba(edGetType(),data);
_port->put(a);
}
-void NeutralCorbaDouble::put(const void *data) throw(ConversionException)
+void NeutralCorbaDouble::put(const void *data)
{
put((YACS::ENGINE::Any *)data);
}
* \param data : YACS::ENGINE::Any object
*/
-void NeutralCorbaDouble::put(YACS::ENGINE::Any *data) throw(ConversionException)
+void NeutralCorbaDouble::put(YACS::ENGINE::Any *data)
{
CORBA::Any *a =convertNeutralCorba(edGetType(),data);
_port->put(a);
delete a;
}
-void NeutralCorbaSequence::put(const void *data) throw(ConversionException)
+void NeutralCorbaSequence::put(const void *data)
{
put((YACS::ENGINE::Any *)data);
}
/*!
* \param data : Neutral::Any object
*/
-void NeutralCorbaSequence::put(YACS::ENGINE::Any *data) throw(ConversionException)
+void NeutralCorbaSequence::put(YACS::ENGINE::Any *data)
{
CORBA::Any *a =convertNeutralCorba(edGetType(),data);
_port->put(a);
{
}
-void NeutralCorbaString::put(const void *data) throw(ConversionException)
+void NeutralCorbaString::put(const void *data)
{
put((YACS::ENGINE::Any *)data);
}
/*!
* \param data : Neutral::Any object
*/
-void NeutralCorbaString::put(YACS::ENGINE::Any *data) throw(ConversionException)
+void NeutralCorbaString::put(YACS::ENGINE::Any *data)
{
CORBA::Any *a =convertNeutralCorba(edGetType(),data);
_port->put(a);
{
}
-void NeutralCorbaObjref::put(const void *data) throw(ConversionException)
+void NeutralCorbaObjref::put(const void *data)
{
put((YACS::ENGINE::Any *)data);
}
/*!
* \param data : Neutral::Any object
*/
-void NeutralCorbaObjref::put(YACS::ENGINE::Any *data) throw(ConversionException)
+void NeutralCorbaObjref::put(YACS::ENGINE::Any *data)
{
CORBA::Any *a =convertNeutralCorba(edGetType(),data);
_port->put(a);
{
}
-void NeutralCorbaStruct::put(const void *data) throw(ConversionException)
+void NeutralCorbaStruct::put(const void *data)
{
put((YACS::ENGINE::Any *)data);
}
/*!
* \param data : Neutral::Any object
*/
-void NeutralCorbaStruct::put(YACS::ENGINE::Any *data) throw(ConversionException)
+void NeutralCorbaStruct::put(YACS::ENGINE::Any *data)
{
CORBA::Any *a =convertNeutralCorba(edGetType(),data);
_port->put(a);
public:
NeutralCorbaInt(InputCorbaPort* p)
: ProxyPort(p), DataPort(p->getName(), p->getNode(), p->edGetType()), Port(p->getNode()) {}
- virtual void put(const void *data) throw(ConversionException);
- void put(YACS::ENGINE::Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(YACS::ENGINE::Any *data);
};
class NeutralCorbaDouble : public ProxyPort
public:
NeutralCorbaDouble(InputCorbaPort* p)
: ProxyPort(p), DataPort(p->getName(), p->getNode(), p->edGetType()), Port(p->getNode()) {}
- virtual void put(const void *data) throw(ConversionException);
- void put(YACS::ENGINE::Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(YACS::ENGINE::Any *data);
};
class NeutralCorbaBool : public ProxyPort
public:
NeutralCorbaBool(InputCorbaPort* p)
: ProxyPort(p), DataPort(p->getName(), p->getNode(), p->edGetType()), Port(p->getNode()) {}
- virtual void put(const void *data) throw(ConversionException);
- void put(YACS::ENGINE::Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(YACS::ENGINE::Any *data);
};
class NeutralCorbaSequence : public ProxyPort
public:
NeutralCorbaSequence(InputCorbaPort* p)
: ProxyPort(p), DataPort(p->getName(), p->getNode(), p->edGetType()), Port(p->getNode()) {}
- virtual void put(const void *data) throw(ConversionException);
- void put(YACS::ENGINE::Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(YACS::ENGINE::Any *data);
};
class NeutralCorbaString : public ProxyPort
{
public:
NeutralCorbaString(InputCorbaPort* p);
- virtual void put(const void *data) throw(ConversionException);
- void put(YACS::ENGINE::Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(YACS::ENGINE::Any *data);
};
class NeutralCorbaObjref : public ProxyPort
{
public:
NeutralCorbaObjref(InputCorbaPort* p);
- virtual void put(const void *data) throw(ConversionException);
- void put(YACS::ENGINE::Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(YACS::ENGINE::Any *data);
};
class NeutralCorbaStruct : public ProxyPort
{
public:
NeutralCorbaStruct(InputCorbaPort* p);
- virtual void put(const void *data) throw(ConversionException);
- void put(YACS::ENGINE::Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(YACS::ENGINE::Any *data);
};
}
}
* transition method from const void* to Any*
* \param data : const void * data
*/
- void NeutralCpp::put(const void *data) throw(ConversionException)
+ void NeutralCpp::put(const void *data)
{
put((Any *)data);
}
/*!
* \param data : Any object
*/
- void NeutralCpp::put(Any *data) throw(ConversionException)
+ void NeutralCpp::put(Any *data)
{
Any *a = convertNeutralCpp(edGetType(),data);
DEBTRACE( "before put refcnt: " << a->getRefCnt() );
{
public:
NeutralCpp(InputCppPort* p);
- virtual void put(const void *data) throw(ConversionException);
- void put(YACS::ENGINE::Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(YACS::ENGINE::Any *data);
};
int isAdaptableCppNeutral(const TypeCode * t1, const TypeCode * t2);
}
{
}
-void NeutralInit::put(const void *data) throw(ConversionException)
+void NeutralInit::put(const void *data)
{
DEBTRACE(" NeutralInit::put(const void *data)");
put((YACS::ENGINE::Any *)data);
* \param data : YACS::ENGINE::Any object
*/
-void NeutralInit::put(YACS::ENGINE::Any *data) throw(ConversionException)
+void NeutralInit::put(YACS::ENGINE::Any *data)
{
DEBTRACE("NeutralInit::put " << data);
if(!edGetType()->isAdaptable(data->getType()))
{
public:
NeutralInit(InputPort* p);
- virtual void put(const void *data) throw(ConversionException);
- void put(YACS::ENGINE::Any *data) throw(ConversionException);
+ virtual void put(const void *data) ;
+ void put(YACS::ENGINE::Any *data);
};
}
}
using namespace YACS::ENGINE;
using namespace std;
-void NeutralPyDouble::put(const void *data) throw(ConversionException)
+void NeutralPyDouble::put(const void *data)
{
put((YACS::ENGINE::Any *)data);
}
/*!
* \param data : YACS::ENGINE::Any object
*/
-void NeutralPyDouble::put(YACS::ENGINE::Any *data) throw(ConversionException)
+void NeutralPyDouble::put(YACS::ENGINE::Any *data)
{
InterpreterUnlocker loc;
PyObject* ob=convertNeutralPyObject(edGetType(),data);
}
-void NeutralPyInt::put(const void *data) throw(ConversionException)
+void NeutralPyInt::put(const void *data)
{
put((YACS::ENGINE::Any *)data);
}
/*!
* \param data : YACS::ENGINE::Any object
*/
-void NeutralPyInt::put(YACS::ENGINE::Any *data) throw(ConversionException)
+void NeutralPyInt::put(YACS::ENGINE::Any *data)
{
InterpreterUnlocker loc;
PyObject* ob=convertNeutralPyObject(edGetType(),data);
Py_DECREF(ob);
}
-void NeutralPyString::put(const void *data) throw(ConversionException)
+void NeutralPyString::put(const void *data)
{
put((YACS::ENGINE::Any *)data);
}
/*!
* \param data : YACS::ENGINE::Any object
*/
-void NeutralPyString::put(YACS::ENGINE::Any *data) throw(ConversionException)
+void NeutralPyString::put(YACS::ENGINE::Any *data)
{
InterpreterUnlocker loc;
PyObject* ob=convertNeutralPyObject(edGetType(),data);
Py_DECREF(ob);
}
-void NeutralPyBool::put(const void *data) throw(ConversionException)
+void NeutralPyBool::put(const void *data)
{
put((YACS::ENGINE::Any *)data);
}
/*!
* \param data : YACS::ENGINE::Any object
*/
-void NeutralPyBool::put(YACS::ENGINE::Any *data) throw(ConversionException)
+void NeutralPyBool::put(YACS::ENGINE::Any *data)
{
InterpreterUnlocker loc;
PyObject* ob=convertNeutralPyObject(edGetType(),data);
Py_DECREF(ob);
}
-void NeutralPyObjref::put(const void *data) throw(ConversionException)
+void NeutralPyObjref::put(const void *data)
{
put((YACS::ENGINE::Any *)data);
}
/*!
* \param data : Neutral::Any object
*/
-void NeutralPyObjref::put(YACS::ENGINE::Any *data) throw(ConversionException)
+void NeutralPyObjref::put(YACS::ENGINE::Any *data)
{
InterpreterUnlocker loc;
PyObject* ob=convertNeutralPyObject(edGetType(),data);
DEBTRACE( "ob refcnt: " << ob->ob_refcnt );
}
-void NeutralPySequence::put(const void *data) throw(ConversionException)
+void NeutralPySequence::put(const void *data)
{
put((YACS::ENGINE::Any *)data);
}
/*!
* \param data : Neutral::Any object
*/
-void NeutralPySequence::put(YACS::ENGINE::Any *data) throw(ConversionException)
+void NeutralPySequence::put(YACS::ENGINE::Any *data)
{
DEBTRACE( "--------NeutralPySequence::put" );
InterpreterUnlocker loc;
DEBTRACE( "ob refcnt: " << ob->ob_refcnt );
}
-void NeutralPyStruct::put(const void *data) throw(ConversionException)
+void NeutralPyStruct::put(const void *data)
{
put((YACS::ENGINE::Any *)data);
}
/*!
* \param data : Neutral::Any object
*/
-void NeutralPyStruct::put(YACS::ENGINE::Any *data) throw(ConversionException)
+void NeutralPyStruct::put(YACS::ENGINE::Any *data)
{
InterpreterUnlocker loc;
PyObject* ob=convertNeutralPyObject(edGetType(),data);
public:
NeutralPyDouble(InputPyPort* p)
: ProxyPort(p), DataPort(p->getName(), p->getNode(), p->edGetType()), Port(p->getNode()) {}
- virtual void put(const void *data) throw(ConversionException);
- void put(YACS::ENGINE::Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(YACS::ENGINE::Any *data);
};
class NeutralPyInt : public ProxyPort
public:
NeutralPyInt(InputPyPort* p)
: ProxyPort(p), DataPort(p->getName(), p->getNode(), p->edGetType()), Port(p->getNode()) {}
- virtual void put(const void *data) throw(ConversionException);
- void put(YACS::ENGINE::Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(YACS::ENGINE::Any *data);
};
class NeutralPyString : public ProxyPort
public:
NeutralPyString(InputPyPort* p)
: ProxyPort(p), DataPort(p->getName(), p->getNode(), p->edGetType()), Port(p->getNode()) {}
- virtual void put(const void *data) throw(ConversionException);
- void put(YACS::ENGINE::Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(YACS::ENGINE::Any *data);
};
class NeutralPyBool : public ProxyPort
public:
NeutralPyBool(InputPyPort* p)
: ProxyPort(p), DataPort(p->getName(), p->getNode(), p->edGetType()), Port(p->getNode()) {}
- virtual void put(const void *data) throw(ConversionException);
- void put(YACS::ENGINE::Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(YACS::ENGINE::Any *data);
};
class NeutralPyObjref : public ProxyPort
public:
NeutralPyObjref(InputPyPort* p)
: ProxyPort(p), DataPort(p->getName(), p->getNode(), p->edGetType()), Port(p->getNode()) {}
- virtual void put(const void *data) throw(ConversionException);
- void put(YACS::ENGINE::Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(YACS::ENGINE::Any *data);
};
class NeutralPySequence : public ProxyPort
public:
NeutralPySequence(InputPyPort* p)
: ProxyPort(p), DataPort(p->getName(), p->getNode(), p->edGetType()), Port(p->getNode()) {}
- virtual void put(const void *data) throw(ConversionException);
- void put(YACS::ENGINE::Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(YACS::ENGINE::Any *data);
};
class NeutralPyStruct : public ProxyPort
public:
NeutralPyStruct(InputPyPort* p)
: ProxyPort(p), DataPort(p->getName(), p->getNode(), p->edGetType()), Port(p->getNode()) {}
- virtual void put(const void *data) throw(ConversionException);
- void put(YACS::ENGINE::Any *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(YACS::ENGINE::Any *data);
};
}
}
{
}
-void NeutralXml::put(const void *data) throw(ConversionException)
+void NeutralXml::put(const void *data)
{
DEBTRACE(" NeutralXml::put(const void *data)");
put((YACS::ENGINE::Any *)data);
* \param data : YACS::ENGINE::Any object
*/
-void NeutralXml::put(YACS::ENGINE::Any *data) throw(ConversionException)
+void NeutralXml::put(YACS::ENGINE::Any *data)
{
DEBTRACE("NeutralXml::put " << data);
std::string sss = convertNeutralXml(edGetType(),data);
{
public:
NeutralXml(InputXmlPort* p);
- virtual void put(const void *data) throw(ConversionException);
- void put(YACS::ENGINE::Any *data) throw(ConversionException);
+ virtual void put(const void *data) ;
+ void put(YACS::ENGINE::Any *data);
};
}
}
inp->setData(data);
}
-void OutNode::checkBasicConsistency() const throw(YACS::Exception)
+void OutNode::checkBasicConsistency() const
{
DEBTRACE("OutNode::checkBasicConsistency");
if (! _setOfOutputPort.empty())
OutNode(const OutNode& other, ComposedNode *father);
virtual void execute();
virtual void accept(Visitor *visitor);
- virtual void checkBasicConsistency() const throw(Exception);
+ virtual void checkBasicConsistency() const ;
virtual void setData(InputPort* port, const std::string& data);
virtual void dump(std::ostream &os);
virtual InputPort *createInputPort(const std::string& inputPortName, TypeCode* type);
outp->setData(data);
}
-void PresetNode::checkBasicConsistency() const throw(YACS::Exception)
+void PresetNode::checkBasicConsistency() const
{
DEBTRACE("PresetNode::checkBasicConsistency");
if (! _setOfInputPort.empty())
PresetNode(const PresetNode& other, ComposedNode *father);
virtual void execute();
virtual void accept(Visitor *visitor);
- virtual void checkBasicConsistency() const throw(Exception);
+ virtual void checkBasicConsistency() const ;
virtual void setData(OutputPort* port, const std::string& data);
virtual OutputPort *createOutputPort(const std::string& outputPortName, TypeCode* type);
virtual std::string typeName() {return "YACS__ENGINE__PresetNode";}
modified();
}
-void OutputPresetPort::checkBasicConsistency() const throw(YACS::Exception)
+void OutputPresetPort::checkBasicConsistency() const
{
DEBTRACE("OutputPresetPort::checkBasicConsistency " << _storeData);
if (_storeData.empty())
OutputPort *clone(Node *newHelder) const;
void setData(std::string data);
std::string getData();
- virtual void checkBasicConsistency() const throw(Exception);
+ virtual void checkBasicConsistency() const ;
virtual std::string dump();
virtual std::string getAsString();
virtual PyObject* getPyObj();
OptimizerAlgBase::finishProxy();
}
-void PyOptimizerAlgBase::initializeProxy(const Any *input) throw (YACS::Exception)
+void PyOptimizerAlgBase::initializeProxy(const Any *input)
{
GILState gs;
OptimizerAlgBase::initializeProxy(input);
virtual TypeCode *getTCForOutProxy() const;
virtual TypeCode *getTCForAlgoInitProxy() const;
virtual TypeCode *getTCForAlgoResultProxy() const;
- virtual void initializeProxy(const Any *input) throw (Exception);
+ virtual void initializeProxy(const Any *input) ;
virtual void startProxy();
virtual void takeDecisionProxy();
virtual void finishProxy();
/*!Convert a PyObject (integer) to CORBA::Any (integer)
* It's only a wrapper around put(PyObject *data)
*/
-void PyCorbaInt::put(const void *data) throw(ConversionException)
+void PyCorbaInt::put(const void *data)
{
put((PyObject *)data);
}
/*!
* \param data : python object
*/
-void PyCorbaInt::put(PyObject *data) throw(ConversionException)
+void PyCorbaInt::put(PyObject *data)
{
CORBA::Any *a= convertPyObjectCorba(_port->edGetType(),data);
YACS::ENGINE::InterpreterSaveThread _loc;
*
* \param data : python object
*/
-void PyCorbaBool::put(const void *data) throw(ConversionException)
+void PyCorbaBool::put(const void *data)
{
put((PyObject *)data);
}
*
* \param data : python object
*/
-void PyCorbaBool::put(PyObject *data) throw(ConversionException)
+void PyCorbaBool::put(PyObject *data)
{
CORBA::Any *a= convertPyObjectCorba(_port->edGetType(),data);
YACS::ENGINE::InterpreterSaveThread _loc;
delete a;
}
-void PyCorbaString::put(const void *data) throw(ConversionException)
+void PyCorbaString::put(const void *data)
{
put((PyObject *)data);
}
* \param data : python object
*/
-void PyCorbaString::put(PyObject *data) throw(ConversionException)
+void PyCorbaString::put(PyObject *data)
{
CORBA::Any *a= convertPyObjectCorba(_port->edGetType(),data);
YACS::ENGINE::InterpreterSaveThread _loc;
}
-void PyCorbaDouble::put(const void *data) throw(ConversionException)
+void PyCorbaDouble::put(const void *data)
{
put((PyObject *)data);
}
* \param data : python object
*/
-void PyCorbaDouble::put(PyObject *data) throw(ConversionException)
+void PyCorbaDouble::put(PyObject *data)
{
CORBA::Any *a= convertPyObjectCorba(_port->edGetType(),data);
YACS::ENGINE::InterpreterSaveThread _loc;
* \param data : python object
*/
-void PyCorbaSequence::put(const void *data) throw(ConversionException)
+void PyCorbaSequence::put(const void *data)
{
put((PyObject *)data);
}
-void PyCorbaSequence::put(PyObject *data) throw(ConversionException)
+void PyCorbaSequence::put(PyObject *data)
{
DEBTRACE("data refcnt: " << data->ob_refcnt);
#ifdef _DEVDEBUG_
* \param data : python object
*/
-void PyCorbaObjref::put(const void *data) throw(ConversionException)
+void PyCorbaObjref::put(const void *data)
{
put((PyObject *)data);
}
-void PyCorbaObjref::put(PyObject *data) throw(ConversionException)
+void PyCorbaObjref::put(PyObject *data)
{
DEBTRACE("data refcnt: " << data->ob_refcnt);
#ifdef _DEVDEBUG_
{
}
-void PyCorbaStruct::put(const void *data) throw(ConversionException)
+void PyCorbaStruct::put(const void *data)
{
put((PyObject *)data);
}
/*!
* \param data : python object
*/
-void PyCorbaStruct::put(PyObject *data) throw(ConversionException)
+void PyCorbaStruct::put(PyObject *data)
{
DEBTRACE("data refcnt: " << data->ob_refcnt);
#ifdef _DEVDEBUG_
public:
PyCorbaInt(InputCorbaPort* p)
: ProxyPort(p), DataPort(p->getName(), p->getNode(), p->edGetType()), Port(p->getNode()) {}
- virtual void put(const void *data) throw(ConversionException);
- void put(PyObject *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(PyObject *data);
};
class PyCorbaDouble : public ProxyPort
public:
PyCorbaDouble(InputCorbaPort* p)
: ProxyPort(p), DataPort(p->getName(), p->getNode(), p->edGetType()), Port(p->getNode()) {}
- virtual void put(const void *data) throw(ConversionException);
- void put(PyObject *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(PyObject *data);
};
class PyCorbaString : public ProxyPort
public:
PyCorbaString(InputCorbaPort* p)
: ProxyPort(p), DataPort(p->getName(), p->getNode(), p->edGetType()), Port(p->getNode()) {}
- virtual void put(const void *data) throw(ConversionException);
- void put(PyObject *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(PyObject *data);
};
class PyCorbaBool : public ProxyPort
public:
PyCorbaBool(InputCorbaPort* p)
: ProxyPort(p), DataPort(p->getName(), p->getNode(), p->edGetType()), Port(p->getNode()) {}
- virtual void put(const void *data) throw(ConversionException);
- void put(PyObject *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(PyObject *data);
};
class PyCorbaObjref : public ProxyPort
{
public:
PyCorbaObjref(InputCorbaPort* p);
- virtual void put(const void *data) throw(ConversionException);
- void put(PyObject *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(PyObject *data);
protected:
PyObject * _pyorb;
CORBA::ORB_ptr _orb;
{
public:
PyCorbaSequence(InputCorbaPort* p);
- virtual void put(const void *data) throw(ConversionException);
- void put(PyObject *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(PyObject *data);
};
class PyCorbaStruct : public ProxyPort
{
public:
PyCorbaStruct(InputCorbaPort* p);
- virtual void put(const void *data) throw(ConversionException);
- void put(PyObject *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(PyObject *data);
};
}
return convertPyObjectNeutral(t, data);
}
- void PyCpp::put(const void *data) throw(ConversionException)
+ void PyCpp::put(const void *data)
{
put((PyObject *)data);
}
* \param data : python object
*/
- void PyCpp::put(PyObject *data) throw(ConversionException)
+ void PyCpp::put(PyObject *data)
{
YACS::ENGINE::Any *a;
//Do not need to take the Python GIL as put is called from Python node
public:
PyCpp(InputCppPort* p)
: ProxyPort(p), DataPort(p->getName(), p->getNode(), p->edGetType()), Port(p->getNode()) {}
- virtual void put(const void *data) throw(ConversionException);
- void put(PyObject *data) throw(ConversionException);
+ virtual void put(const void *data) ;
+ void put(PyObject *data);
};
int isAdaptableCppPyObject(const TypeCode *t1, const TypeCode *t2);
}
* \param data : PyObject object as a void * pointer
*/
-void PyInit::put(const void *data) throw(ConversionException)
+void PyInit::put(const void *data)
{
put((PyObject *)data);
}
/*!
* \param data : PyObject object
*/
-void PyInit::put(PyObject *data) throw(ConversionException)
+void PyInit::put(PyObject *data)
{
DEBTRACE("PyInit::put(PyObject *data)"<<data->ob_refcnt);
InterpreterUnlocker l;
{
public:
PyInit(InputPyPort* p);
- virtual void put(const void *data) throw(ConversionException);
- void put(PyObject *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(PyObject *data);
};
}
}
{
}
-void PyNeutral::put(const void *data) throw(ConversionException)
+void PyNeutral::put(const void *data)
{
DEBTRACE( " PyNeutral::put(const void *data)" );
put((PyObject *)data);
* \param data : Python value
*/
-void PyNeutral::put(PyObject *data) throw(ConversionException)
+void PyNeutral::put(PyObject *data)
{
DEBTRACE( "PyNeutral::put " );
YACS::ENGINE::Any *ob;
{
public:
PyNeutral(InputPort* p);
- virtual void put(const void *data) throw(ConversionException);
- void put(PyObject *data) throw(ConversionException);
+ virtual void put(const void *data) ;
+ void put(PyObject *data);
};
}
}
}
}
-void PythonNode::checkBasicConsistency() const throw(YACS::Exception)
+void PythonNode::checkBasicConsistency() const
{
DEBTRACE("checkBasicConsistency");
InlineNode::checkBasicConsistency();
setState(YACS::TORECONNECT);
}
-void PyFuncNode::checkBasicConsistency() const throw(YACS::Exception)
+void PyFuncNode::checkBasicConsistency() const
{
DEBTRACE("checkBasicConsistency");
InlineFuncNode::checkBasicConsistency();
PythonNode(const PythonNode& other, ComposedNode *father);
PythonNode(const std::string& name);
virtual ~PythonNode();
- virtual void checkBasicConsistency() const throw(Exception);
+ virtual void checkBasicConsistency() const ;
virtual void execute();
virtual void load();
virtual void loadRemote();
PyFuncNode(const std::string& name);
virtual ~PyFuncNode();
virtual void init(bool start=true);
- virtual void checkBasicConsistency() const throw(Exception);
+ virtual void checkBasicConsistency() const ;
virtual void execute();
virtual void load();
virtual void loadRemote();
InputPort::edRemoveManInit();
}
-void InputPyPort::put(const void *data) throw(ConversionException)
+void InputPyPort::put(const void *data)
{
put((PyObject *)data);
}
InputPyPort::releaseDataUnsafe();
}
-void InputPyPort::put(PyObject *data) throw(ConversionException)
+void InputPyPort::put(PyObject *data)
{
InterpreterUnlocker l;
InputPyPort::releaseDataUnsafe();
return _data;
}
-void *InputPyPort::get() const throw(YACS::Exception)
+void *InputPyPort::get() const
{
return (void*) _data;
}
Py_INCREF(_data);
}
-void OutputPyPort::put(const void *data) throw(ConversionException)
+void OutputPyPort::put(const void *data)
{
put((PyObject *)data);
}
-void OutputPyPort::putWithoutForward(PyObject *data) throw(ConversionException)
+void OutputPyPort::putWithoutForward(PyObject *data)
{
DEBTRACE( "OutputPyPort::put.ob refcnt: " << data->ob_refcnt );
#ifdef _DEVDEBUG_
//no registerPyObj : we steal the output reference of the node
}
-void OutputPyPort::put(PyObject *data) throw(ConversionException)
+void OutputPyPort::put(PyObject *data)
{
putWithoutForward(data);
DEBTRACE( "OutputPyPort::put.ob refcnt: " << data->ob_refcnt );
~InputPyPort();
bool edIsManuallyInitialized() const;
void edRemoveManInit();
- virtual void put(const void *data) throw(ConversionException);
+ virtual void put(const void *data);
void releaseData() override;
- void put(PyObject *data) throw(ConversionException);
+ void put(PyObject *data);
InputPort *clone(Node *newHelder) const;
//special typedef PyObj used in SWIG to increment ref count on output
virtual PyObj * getPyObj() const;
virtual std::string getAsString();
- void *get() const throw(Exception);
+ void *get() const ;
virtual std::string getHumanRepr();
virtual bool isEmpty();
virtual void exSaveInit();
OutputPyPort(const std::string& name, Node * node, TypeCode * type);
OutputPyPort(const OutputPyPort& other, Node *newHelder);
~OutputPyPort();
- virtual void put(const void *data) throw(ConversionException);
- void putWithoutForward(PyObject *data) throw(ConversionException);
- void put(PyObject *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void putWithoutForward(PyObject *data);
+ void put(PyObject *data);
OutputPort *clone(Node *newHelder) const;
virtual PyObject * get() const;
//special typedef PyObj used in SWIG to increment ref count on output
* \param data : PyObject object as a void * pointer
*/
-void PyXml::put(const void *data) throw(ConversionException)
+void PyXml::put(const void *data)
{
put((PyObject *)data);
}
/*!
* \param data : PyObject object
*/
-void PyXml::put(PyObject *data) throw(ConversionException)
+void PyXml::put(PyObject *data)
{
DEBTRACE("PyXml::put" );
std::string sss = convertPyObjectXml(edGetType(),data);
{
public:
PyXml(InputXmlPort* p);
- virtual void put(const void *data) throw(ConversionException);
- void put(PyObject *data) throw(ConversionException);
+ virtual void put(const void *data);
+ void put(PyObject *data);
};
}
}
*/
InputPort* RuntimeSALOME::adapt(InputPort* source,
const std::string& impl,
- TypeCode * type,bool init) throw (ConversionException)
+ TypeCode * type,bool init)
{
string imp_source=source->getNode()->getImplementation();
if(imp_source == PythonNode::IMPL_NAME)
*/
InputPort* RuntimeSALOME::adapt(InPropertyPort* source,
const std::string& impl,
- TypeCode * type,bool init) throw (ConversionException)
+ TypeCode * type,bool init)
{
return adaptNeutral((InputPort *)source,impl,type,init);
}
* \return an adaptated input port of type InputCorbaPort
*/
InputPort* RuntimeSALOME::adaptNeutralToCorba(InputPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
// BEWARE : using the generic check
if(inport->edGetType()->isAdaptable(type))
* \return an adaptated input port of type InputPyPort
*/
InputPort* RuntimeSALOME::adaptNeutralToPython(InputPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
// BEWARE : using the generic check
if(inport->edGetType()->isAdaptable(type))
* \return an input port of type InputXmlPort
*/
InputPort* RuntimeSALOME::adaptNeutralToXml(InputPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
// BEWARE : using the generic check
if(inport->edGetType()->isAdaptable(type))
* \return an input port of type InputCppPort
*/
InputPort* RuntimeSALOME::adaptNeutralToCpp(InputPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
DEBTRACE("RuntimeSALOME::adaptNeutralToCpp(InputPort* inport" );
if(isAdaptableNeutralCpp(type,inport->edGetType()))
*/
InputPort* RuntimeSALOME::adaptNeutral(InputPort* source,
const std::string& impl,
- TypeCode * type,bool init) throw (ConversionException)
+ TypeCode * type,bool init)
{
if(impl == CppNode::IMPL_NAME)
{
*/
InputPort* RuntimeSALOME::adaptXmlToCorba(InputXmlPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
if(isAdaptableXmlCorba(type,inport->edGetType()))
{
* \return an adaptated input port of type InputPyPort
*/
InputPort* RuntimeSALOME::adaptXmlToPython(InputXmlPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
if(inport->edGetType()->isAdaptable(type))
{
* \return an adaptated input port of type InputPyPort
*/
InputPort* RuntimeSALOME::adaptXmlToCpp(InputXmlPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
DEBTRACE("RuntimeSALOME::adaptXmlToCpp(InputPort* inport" );
DEBTRACE(type->kind() << " " << inport->edGetType()->kind() );
* \return an adaptated input port of type Neutralxxxx
*/
InputPort* RuntimeSALOME::adaptXmlToNeutral(InputXmlPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
if(inport->edGetType()->isAdaptable(type))
{
* \return an adaptated input port of type Xmlxxxx
*/
InputPort* RuntimeSALOME::adaptXmlToXml(InputXmlPort* inport,
- TypeCode * type,bool init) throw (ConversionException)
+ TypeCode * type,bool init)
{
if(init)
return new ProxyPort(inport);
InputPort* RuntimeSALOME::adapt(InputXmlPort* source,
const std::string& impl,
- TypeCode * type,bool init) throw (ConversionException)
+ TypeCode * type,bool init)
{
if(impl == CORBANode::IMPL_NAME)
{
* \return an adaptator port of type InputCORBAPort
*/
InputPort* RuntimeSALOME::adaptCorbaToCorba(InputCorbaPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
if(type->isA(inport->edGetType()))
{
*/
InputPort* RuntimeSALOME::adaptCorbaToPython(InputCorbaPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
if(inport->edGetType()->kind() == Double)
{
*/
InputPort* RuntimeSALOME::adaptCorbaToXml(InputCorbaPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
// BEWARE : using the generic check
if(inport->edGetType()->isAdaptable(type))
*/
InputPort* RuntimeSALOME::adaptCorbaToCpp(InputCorbaPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
DEBTRACE("RuntimeSALOME::adaptCorbaToCpp(InputCorbaPort* inport" );
if(isAdaptableCorbaCpp(type,inport->edGetType()))
*/
InputPort* RuntimeSALOME::adaptCorbaToNeutral(InputCorbaPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
if(inport->edGetType()->kind() == Double)
{
InputPort* RuntimeSALOME::adapt(InputCorbaPort* source,
const std::string& impl,
- TypeCode * type,bool init) throw (ConversionException)
+ TypeCode * type,bool init)
{
if(impl == CppNode::IMPL_NAME)
{
*/
InputPort* RuntimeSALOME::adaptPythonToPython(InputPyPort* inport,
- TypeCode * type,bool init) throw (ConversionException)
+ TypeCode * type,bool init)
{
if(init)
return new PyInit(inport);
*/
InputPort* RuntimeSALOME::adaptPythonToCpp(InputPyPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
DEBTRACE("RuntimeSALOME::adaptPythonToCpp(InputPyPort* inport" );
if(isAdaptablePyObjectCpp(type,inport->edGetType()))
*/
InputPort* RuntimeSALOME::adaptPythonToNeutral(InputPyPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
if(inport->edGetType()->kind() == Double)
{
*/
InputPort* RuntimeSALOME::adaptPythonToCorba(InputPyPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
if(inport->edGetType()->kind() == Double)
{
*/
InputPort* RuntimeSALOME::adaptPythonToXml(InputPyPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
// BEWARE : using the generic check
if(inport->edGetType()->isAdaptable(type))
InputPort* RuntimeSALOME::adapt(InputPyPort* source,
const std::string& impl,
- TypeCode * type,bool init) throw (ConversionException)
+ TypeCode * type,bool init)
{
if(impl == CppNode::IMPL_NAME)
{
*/
InputPort* RuntimeSALOME::adaptCppToCorba(InputCppPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
DEBTRACE("RuntimeSALOME::adaptCppToCorba(InputCppPort* inport)");
if(isAdaptableCppCorba(type,inport->edGetType()))
* \return an adaptated input port of type InputPyPort
*/
InputPort* RuntimeSALOME::adaptCppToPython(InputCppPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
DEBTRACE("RuntimeSALOME::adaptCppToPython(InputCppPort* inport)");
if(isAdaptableCppPyObject(type,inport->edGetType()))
* \return an adaptated input port of type InputPyPort
*/
InputPort* RuntimeSALOME::adaptCppToCpp(InputCppPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
DEBTRACE("RuntimeSALOME::adaptCppToCpp(InputPort* inport" );
DEBTRACE(type->kind() << " " << inport->edGetType()->kind() );
* \return an adaptated input port of type InputPyPort
*/
InputPort* RuntimeSALOME::adaptCppToNeutral(InputCppPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
DEBTRACE("RuntimeSALOME::adaptCppToNeutral(InputPort* inport" );
DEBTRACE(type->kind() << " " << inport->edGetType()->kind() );
}
InputPort* RuntimeSALOME::adaptCppToXml(InputCppPort* inport,
- TypeCode * type) throw (ConversionException)
+ TypeCode * type)
{
DEBTRACE("RuntimeSALOME::adaptCppToXml(InputCppPort* inport" );
if(isAdaptableCppXml(type,inport->edGetType()))
InputPort* RuntimeSALOME::adapt(InputCppPort* source,
const std::string& impl,
- TypeCode * type,bool init) throw (ConversionException)
+ TypeCode * type,bool init)
{
DEBTRACE("RuntimeSALOME::adapt(InputCppPort* source)");
if(impl == CORBANode::IMPL_NAME)
virtual InputPort* adapt(InputPort* source,
const std::string& impl,
- TypeCode * type,bool init=false) throw (ConversionException);
+ TypeCode * type,bool init=false);
virtual InputPort* adapt(InPropertyPort* source,
const std::string& impl,
- TypeCode * type,bool init=false) throw (ConversionException);
+ TypeCode * type,bool init=false);
virtual InputPort* adaptNeutral(InputPort* source,
const std::string& impl,
- TypeCode * type,bool init) throw (ConversionException);
+ TypeCode * type,bool init);
virtual InputPort* adapt(InputCorbaPort* source,
const std::string& impl,
- TypeCode * type,bool init) throw (ConversionException);
+ TypeCode * type,bool init);
virtual InputPort* adaptCorbaToCorba(InputCorbaPort* source,
- TypeCode * type) throw (ConversionException);
+ TypeCode * type);
virtual InputPort* adaptCorbaToNeutral(InputCorbaPort* source,
- TypeCode * type) throw (ConversionException);
+ TypeCode * type);
virtual InputPort* adaptCorbaToPython(InputCorbaPort* source,
- TypeCode * type) throw (ConversionException);
+ TypeCode * type);
virtual InputPort* adaptCorbaToCpp(InputCorbaPort* source,
- TypeCode * type) throw (ConversionException);
+ TypeCode * type);
virtual InputPort* adaptCorbaToXml(InputCorbaPort* source,
- TypeCode * type) throw (ConversionException);
+ TypeCode * type);
virtual InputPort* adapt(InputPyPort* source,
const std::string& impl,
- TypeCode * type,bool init) throw (ConversionException);
+ TypeCode * type,bool init);
virtual InputPort* adaptPythonToCorba(InputPyPort* source,
- TypeCode * type) throw (ConversionException);
+ TypeCode * type);
virtual InputPort* adaptPythonToNeutral(InputPyPort* source,
- TypeCode * type) throw (ConversionException);
+ TypeCode * type);
virtual InputPort* adaptPythonToPython(InputPyPort* source,
- TypeCode * type,bool init) throw (ConversionException);
+ TypeCode * type,bool init);
virtual InputPort* adaptPythonToXml(InputPyPort* source,
- TypeCode * type) throw (ConversionException);
+ TypeCode * type);
virtual InputPort* adaptPythonToCpp(InputPyPort* source,
- TypeCode * type) throw (ConversionException);
+ TypeCode * type);
virtual InputPort* adapt(InputCppPort* source,
const std::string& impl,
- TypeCode * type,bool init) throw (ConversionException);
+ TypeCode * type,bool init);
virtual InputPort* adaptCppToCorba(InputCppPort* source,
- TypeCode * type) throw (ConversionException);
+ TypeCode * type);
virtual InputPort* adaptCppToNeutral(InputCppPort* source,
- TypeCode * type) throw (ConversionException);
+ TypeCode * type);
virtual InputPort* adaptCppToPython(InputCppPort* source,
- TypeCode * type) throw (ConversionException);
+ TypeCode * type);
virtual InputPort* adaptCppToXml(InputCppPort* source,
- TypeCode * type) throw (ConversionException);
+ TypeCode * type);
virtual InputPort* adaptCppToCpp(InputCppPort* source,
- TypeCode * type) throw (ConversionException);
+ TypeCode * type);
virtual InputPort* adapt(InputXmlPort* source,
const std::string& impl,
- TypeCode * type,bool init) throw (ConversionException);
+ TypeCode * type,bool init);
virtual InputPort* adaptXmlToCorba(InputXmlPort* source,
- TypeCode * type) throw (ConversionException);
+ TypeCode * type);
virtual InputPort* adaptXmlToPython(InputXmlPort* inport,
- TypeCode * type) throw (ConversionException);
+ TypeCode * type);
virtual InputPort* adaptXmlToCpp(InputXmlPort* inport,
- TypeCode * type) throw (ConversionException);
+ TypeCode * type);
virtual InputPort* adaptXmlToNeutral(InputXmlPort* inport,
- TypeCode * type) throw (ConversionException);
+ TypeCode * type);
virtual InputPort* adaptXmlToXml(InputXmlPort* inport,
- TypeCode * type,bool init) throw (ConversionException);
+ TypeCode * type,bool init);
virtual InputPort* adaptNeutralToXml(InputPort* inport,
- TypeCode * type) throw (ConversionException);
+ TypeCode * type);
virtual InputPort* adaptNeutralToPython(InputPort* inport,
- TypeCode * type) throw (ConversionException);
+ TypeCode * type);
virtual InputPort* adaptNeutralToCorba(InputPort* inport,
- TypeCode * type) throw (ConversionException);
+ TypeCode * type);
virtual InputPort* adaptNeutralToCpp(InputPort* inport,
- TypeCode * type) throw (ConversionException);
+ TypeCode * type);
virtual void* convertNeutral(TypeCode * type, Any *data);
virtual std::string convertNeutralAsString(TypeCode * type, Any *data);
return new SalomeContainer(*this);
}
-void SalomeContainer::checkCapabilityToDealWith(const ComponentInstance *inst) const throw(YACS::Exception)
+void SalomeContainer::checkCapabilityToDealWith(const ComponentInstance *inst) const
{
if(inst->getKind()!=SalomeComponent::KIND)
throw Exception("SalomeContainer::checkCapabilityToDealWith : SalomeContainer is not able to deal with this type of ComponentInstance.");
/*!
* \param inst the component instance
*/
-void SalomeContainer::start(const Task *askingNode) throw(YACS::Exception)
+void SalomeContainer::start(const Task *askingNode)
{
SalomeContainerTools::Start(_componentNames,_launchModeType,_sct,_shutdownLevel,this,askingNode);
}
std::string getKind() const;
bool isAlreadyStarted(const Task *askingNode) const;
Engines::Container_ptr getContainerPtr(const Task *askingNode) const;
- void start(const Task *askingNode) throw (Exception);
+ void start(const Task *askingNode) ;
Container *clone() const;
Container *cloneAlways() const;
std::string getPlacementId(const Task *askingNode) const;
std::string getFullPlacementId(const Task *askingNode) const;
- void checkCapabilityToDealWith(const ComponentInstance *inst) const throw (Exception);
+ void checkCapabilityToDealWith(const ComponentInstance *inst) const ;
void setProperty(const std::string& name, const std::string& value);
std::string getProperty(const std::string& name) const;
void clearProperties();
return helper->isAlreadyStarted(askingNode);
}
-void SalomeHPContainer::start(const Task *askingNode) throw(YACS::Exception)
+void SalomeHPContainer::start(const Task *askingNode)
{
SalomeContainerMonoHelper *helper(_launchModeType.getHelperOfTaskThreadSafe(this,askingNode));
SalomeContainerToolsDecorator sctDeco(&_sct,this->getPG(),&_launchModeType,askingNode,this->getNumberOfCoresPerWorker());
return _sct.getResourceProperties(name);
}
-void SalomeHPContainer::checkCapabilityToDealWith(const ComponentInstance *inst) const throw(YACS::Exception)
+void SalomeHPContainer::checkCapabilityToDealWith(const ComponentInstance *inst) const
{
if(inst->getKind()!=SalomeHPComponent::KIND)
throw Exception("SalomeHPContainer::checkCapabilityToDealWith : SalomeContainer is not able to deal with this type of ComponentInstance.");
std::string getKind() const;
std::string getDiscreminantStrOfThis(const Task *askingNode) const;
bool isAlreadyStarted(const Task *askingNode) const;
- void start(const Task *askingNode) throw(Exception);
+ void start(const Task *askingNode) ;
void shutdown(int level);
std::string getPlacementId(const Task *askingNode) const;
std::string getFullPlacementId(const Task *askingNode) const;
void addComponentName(const std::string& name);
std::map<std::string,std::string> getProperties() const;
std::map<std::string,std::string> getResourceProperties(const std::string& name) const;
- void checkCapabilityToDealWith(const ComponentInstance *inst) const throw(YACS::Exception);
+ void checkCapabilityToDealWith(const ComponentInstance *inst) const ;
std::vector<std::string> getKernelContainerNames() const;
int getNumberOfCoresPerWorker() const;
//
DEBTRACE("+++++++ end StudyInNode::execute +++++++++++" );
}
-void StudyInNode::checkBasicConsistency() const throw(YACS::Exception)
+void StudyInNode::checkBasicConsistency() const
{
DEBTRACE("StudyInNode::checkBasicConsistency");
if (! _setOfInputPort.empty())
DEBTRACE("+++++++ end StudyOutNode::execute +++++++++++" );
}
-void StudyOutNode::checkBasicConsistency() const throw(YACS::Exception)
+void StudyOutNode::checkBasicConsistency() const
{
DEBTRACE("StudyOutNode::checkBasicConsistency");
if (! _setOfOutputPort.empty())
StudyInNode(const StudyInNode& other, ComposedNode *father);
virtual void execute();
virtual void accept(Visitor *visitor);
- virtual void checkBasicConsistency() const throw(Exception);
+ virtual void checkBasicConsistency() const ;
virtual void setData(OutputPort* port, const std::string& data);
virtual OutputPort *createOutputPort(const std::string& outputPortName, TypeCode* type);
virtual std::string typeName() {return "YACS__ENGINE__StudyInNode";}
StudyOutNode(const StudyOutNode& other, ComposedNode *father);
virtual void execute();
virtual void accept(Visitor *visitor);
- virtual void checkBasicConsistency() const throw(Exception);
+ virtual void checkBasicConsistency() const ;
virtual void setData(InputPort* port, const std::string& data);
virtual InputPort *createInputPort(const std::string& inputPortName, TypeCode* type);
virtual std::string typeName() {return "YACS__ENGINE__StudyOutNode";}
inline Echo_i() {}
virtual ~Echo_i() {}
virtual char* echoString(const char* mesg);
- CORBA::Long echoLong(CORBA::Long i) throw(eo::SALOME_Exception);
+ CORBA::Long echoLong(CORBA::Long i);
void echoDouble(CORBA::Double i,CORBA::Double& j) ;
void echoDoubleVec(const eo::DoubleVec& i,eo::DoubleVec_out j) ;
void echoDoubleVecVec(const eo::DoubleVecVec&, eo::DoubleVecVec_out);
out=new eo::DoubleVecVec(in);
}
-CORBA::Long Echo_i::echoLong(CORBA::Long i ) throw(eo::SALOME_Exception)
+CORBA::Long Echo_i::echoLong(CORBA::Long i )
{
DEBTRACE("Echo_i::echoLong " << i);
if(i < 0) {
}
}
-void myTestRun(int nIn, int nOut, Any **In, Any **Out) throw (YACS::Exception)
+void myTestRun(int nIn, int nOut, Any **In, Any **Out)
{
double x, y;
cerr << "myTestRun nIn = " << nIn << endl;
{
}
-void XmlCorba::put(const void *data) throw(ConversionException)
+void XmlCorba::put(const void *data)
{
DEBTRACE((const char *)data);
put((const char *)data);
/*!
* \param data : Xml::char *
*/
-void XmlCorba::put(const char *data) throw(ConversionException)
+void XmlCorba::put(const char *data)
{
DEBTRACE(data);
xmlDocPtr doc;
{
public:
XmlCorba(InputCorbaPort* p);
- virtual void put(const void *data) throw(ConversionException);
- void put(const char *data) throw(ConversionException);
+ virtual void put(const void *data) ;
+ void put(const char *data);
};
}
}
{
}
- void XmlCpp::put(const void *data) throw(ConversionException)
+ void XmlCpp::put(const void *data)
{
DEBTRACE(" XmlCpp::put(const void *data)");
put((const char *)data);
* \param data : Xml::char *
*/
- void XmlCpp::put(const char *data) throw(ConversionException)
+ void XmlCpp::put(const char *data)
{
DEBTRACE("XmlCpp::put " << data);
xmlDocPtr doc;
{
public:
XmlCpp(InputPort* p);
- virtual void put(const void *data) throw(ConversionException);
- void put(const char *data) throw(ConversionException);
+ virtual void put(const void *data) ;
+ void put(const char *data);
};
int isAdaptableCppXml(const TypeCode *t1, const TypeCode *t2);
}
{
}
-void XmlNeutral::put(const void *data) throw(ConversionException)
+void XmlNeutral::put(const void *data)
{
DEBTRACE(" XmlNeutral::put(const void *data)");
put((const char *)data);
* \param data : Xml::char *
*/
-void XmlNeutral::put(const char *data) throw(ConversionException)
+void XmlNeutral::put(const char *data)
{
DEBTRACE("XmlNeutral::put " << data);
xmlDocPtr doc;
{
public:
XmlNeutral(InputPort* p);
- virtual void put(const void *data) throw(ConversionException);
- void put(const char *data) throw(ConversionException);
+ virtual void put(const void *data) ;
+ void put(const char *data);
};
}
}
return _data.c_str();
}
-void *InputXmlPort::get() const throw(YACS::Exception)
+void *InputXmlPort::get() const
{
return (void *) _data.c_str();
}
-void InputXmlPort::put(const void *data) throw (ConversionException)
+void InputXmlPort::put(const void *data)
{
DEBTRACE("put(void *)");
put((const char*)data);
}
-void InputXmlPort::put(const char *data) throw (ConversionException)
+void InputXmlPort::put(const char *data)
{
DEBTRACE(data);
_data = data;
{
}
-const char * OutputXmlPort::get() const throw (ConversionException)
+const char * OutputXmlPort::get() const
{
return _data.c_str();
}
-void OutputXmlPort::put(const void *data) throw (ConversionException)
+void OutputXmlPort::put(const void *data)
{
put((const char*)data);
}
-void OutputXmlPort::put(const char *data) throw (ConversionException)
+void OutputXmlPort::put(const char *data)
{
DEBTRACE(data);
InputPort *p;
InputXmlPort(const InputXmlPort& other, Node *newHelder);
bool edIsManuallyInitialized() const;
void edRemoveManInit();
- virtual void put(const void *data) throw (ConversionException);
- void put(const char *data) throw (ConversionException);
+ virtual void put(const void *data);
+ void put(const char *data);
void releaseData() override;
InputPort *clone(Node *newHelder) const;
virtual const char * getXml() const;
- void *get() const throw(Exception);
+ void *get() const ;
bool isEmpty();
virtual void exSaveInit();
virtual void exRestoreInit();
public:
OutputXmlPort(const std::string& name, Node* node, TypeCode * type);
OutputXmlPort(const OutputXmlPort& other, Node *newHelder);
- virtual void put(const void *data) throw (ConversionException);
- void put(const char *data) throw (ConversionException);
- virtual const char * get() const throw (ConversionException);
+ virtual void put(const void *data);
+ void put(const char *data);
+ virtual const char * get() const;
OutputPort *clone(Node *newHelder) const;
virtual std::string dump();
virtual std::string valToStr();
{
}
-void XmlPython::put(const void *data) throw(ConversionException)
+void XmlPython::put(const void *data)
{
DEBTRACE((const char *)data);
put((const char *)data);
* \param data : Xml::char *
*/
-void XmlPython::put(const char *data) throw(ConversionException)
+void XmlPython::put(const char *data)
{
DEBTRACE(data);
xmlDocPtr doc;
{
public:
XmlPython(InputPyPort* p);
- virtual void put(const void *data) throw(ConversionException);
- void put(const char *data) throw(ConversionException);
+ virtual void put(const void *data) ;
+ void put(const char *data);
};
}
}
virtual YACS::ENGINE::TypeCode *getTCForAlgoInit() const;
//! returns typecode of type expected as algo result. OwnerShip of returned pointer is held by this.
virtual YACS::ENGINE::TypeCode *getTCForAlgoResult() const;
- virtual void initialize(const YACS::ENGINE::Any *input) throw (YACS::Exception);
+ virtual void initialize(const YACS::ENGINE::Any *input);
virtual void startToTakeDecision();
virtual void finish();//! Called when optimization has succeed.
virtual YACS::ENGINE::Any * getAlgoResult();
* future to initialize an algorithm with custom data.
*/
void OptimizerAlgASyncExample::initialize(const YACS::ENGINE::Any *input)
- throw (YACS::Exception)
+
{
std::cout << "Algo initialize, input = " << input->getIntValue() << std::endl;
}
virtual YACS::ENGINE::TypeCode *getTCForAlgoInit() const;
//! returns typecode of type expected as algo result. OwnerShip of returned pointer is held by this.
virtual YACS::ENGINE::TypeCode *getTCForAlgoResult() const;
- virtual void initialize(const YACS::ENGINE::Any *input) throw (YACS::Exception);
+ virtual void initialize(const YACS::ENGINE::Any *input);
virtual void start(); //! Update _pool attribute before performing anything.
virtual void takeDecision();//! _pool->getCurrentId gives the \b id at the origin of this call.
//! Perform the job of analysing to know what new jobs to do (_pool->pushInSample)
* future to initialize an algorithm with custom data.
*/
void OptimizerAlgSyncExample::initialize(const YACS::ENGINE::Any *input)
- throw (YACS::Exception)
+
{
std::cout << "Algo initialize, input = " << input->getIntValue() << std::endl;
}
virtual ~Echo_i() {}
virtual char* echoString(const char* mesg);
virtual CORBA::Boolean echoBoolean(CORBA::Boolean b);
- CORBA::Long echoLong(CORBA::Long i) throw(eo::SALOME_Exception);
+ CORBA::Long echoLong(CORBA::Long i);
void echoDouble(CORBA::Double i,CORBA::Double& j) ;
void echoDoubleVec(const eo::DoubleVec& i,eo::DoubleVec_out j) ;
void echoDoubleVecVec(const eo::DoubleVecVec&, eo::DoubleVecVec_out);
out=new eo::DoubleVecVec(in);
}
-CORBA::Long Echo_i::echoLong(CORBA::Long i ) throw(eo::SALOME_Exception)
+CORBA::Long Echo_i::echoLong(CORBA::Long i )
{
DEBTRACE("Echo_i::echoLong " << i);
if(i < 0) {
ENGINE::Node * getNode() { return _node; }
// Those two methods should never be called
- bool edAddLink(ENGINE::OutPort *start, ENGINE::InPort *end) throw(Exception) { YASSERT(false); }
- bool edAddDFLink(ENGINE::OutPort *start, ENGINE::InPort *end) throw(Exception) { YASSERT(false); }
+ bool edAddLink(ENGINE::OutPort *start, ENGINE::InPort *end) { YASSERT(false); }
+ bool edAddDFLink(ENGINE::OutPort *start, ENGINE::InPort *end) { YASSERT(false); }
protected:
ENGINE::Node * _node;
