--- /dev/null
+// Copyright (C) 2015 EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#include "AbstractPoint.hxx"
+#include "LinkedBlocPoint.hxx"
+#include "ForkBlocPoint.hxx"
+#include "SetOfPoints.hxx"
+#include "Node.hxx"
+
+using namespace YACS::ENGINE;
+
+AbstractPoint::~AbstractPoint()
+{
+}
+
+AbstractPoint *AbstractPoint::getGodFather()
+{
+ if(_father==0)
+ return this;
+ else
+ return _father->getGodFather();
+}
+
+bool AbstractPoint::isBegin()
+{
+ Node *beg(getFirstNode());
+ InGate *ing(beg->getInGate());
+ return ing->getBackLinks().empty();
+}
+
+bool AbstractPoint::isLast()
+{
+ Node *endd(getLastNode());
+ OutGate *oug(endd->getOutGate());
+ return oug->edSetInGate().empty();
+}
+
+bool AbstractPoint::isSimplyLinkedBeforeAfter(BlocPoint *sop)
+{
+ Node *beg(getFirstNode()),*endd(getLastNode());
+ return isSimplyLinkedBefore(sop,beg) && isSimplyLinkedAfter(sop,endd);
+}
+
+bool AbstractPoint::isSimplyLinkedAfterNullBefore(BlocPoint *sop)
+{
+ Node *beg(getFirstNode()),*endd(getLastNode());
+ return IsNoLinksBefore(beg) && isSimplyLinkedAfter(sop,endd);
+}
+
+bool AbstractPoint::isSimplyLinkedBeforeNullAfter(BlocPoint *sop)
+{
+ Node *beg(getFirstNode()),*endd(getLastNode());
+ return IsNoLinksAfter(endd) && isSimplyLinkedBefore(sop,beg);
+}
+
+/*!
+ * precondition : isSimplyLinkedBeforeAfter must return true on \a this.
+ */
+LinkedBlocPoint *AbstractPoint::tryAsLink(BlocPoint *sop)
+{
+ Node *bb(getFirstNode()),*ee(getLastNode());
+ std::list<AbstractPoint *> l; l.push_back(this);
+ AbstractPoint *cur2(0);
+ //
+ cur2=sop->getNodeB4(bb);
+ while(cur2)
+ {
+ Node *cur3(cur2->getFirstNode());
+ if(cur2->isSimplyLinkedBeforeAfter(sop))
+ {
+ l.push_front(cur2);
+ cur2=sop->getNodeB4(cur3);
+ continue;
+ }
+ else if(IsGatherB4Ext(cur3) && isSimplyLinkedAfter(sop,cur2->getLastNode()))
+ {
+ l.push_front(cur2);
+ break;
+ }
+ else
+ break;
+ }
+ //
+ cur2=sop->getNodeAfter(ee);
+ while(cur2)
+ {
+ Node *cur3(cur2->getLastNode());
+ if(cur2->isSimplyLinkedBeforeAfter(sop))
+ {
+ l.push_back(cur2);
+ cur2=sop->getNodeAfter(cur3);
+ continue;
+ }
+ else if(IsScatterAfterExt(cur3) && isSimplyLinkedBefore(sop,cur2->getFirstNode()))
+ {
+ l.push_back(cur2);
+ break;
+ }
+ else
+ break;
+ }
+ if(l.size()>1)
+ {
+ return new LinkedBlocPoint(l,getFather());
+ }
+ else
+ return 0;
+}
+
+/*!
+ * precondition : isSimplyLinkedBeforeAfter must return true on \a this.
+ */
+ForkBlocPoint *AbstractPoint::tryAsFork(BlocPoint *sop)
+{
+ Node *bb(GetNodeB4(getFirstNode())),*ee(GetNodeAfter(getLastNode()));
+ AbstractPoint *bb2(sop->findPointWithNode(bb)),*ee2(sop->findPointWithNode(ee));
+ //
+ const std::list<AbstractPoint *>& lp(sop->getListOfPoints());
+ std::list<AbstractPoint *> l; l.push_back(this);
+ for(std::list<AbstractPoint *>::const_iterator it=lp.begin();it!=lp.end();it++)
+ {
+ if(*it==this)
+ continue;
+ Node *curFirst((*it)->getFirstNode()),*curEnd((*it)->getLastNode());
+ if(!IsSimplyLinkedBeforeExt(curFirst) || !IsSimplyLinkedAfterExt(curEnd))
+ continue;
+ Node *curbb(GetNodeB4(curFirst)),*curee(GetNodeAfter(curEnd));
+ AbstractPoint *bb3(sop->findPointWithNode(curbb)),*ee3(sop->findPointWithNode(curee));
+ if(bb2==bb3 && ee2==ee3)
+ l.push_back(*it);
+ }
+ if(l.size()>1)
+ {
+ return new ForkBlocPoint(l,getFather());
+ }
+ else
+ return 0;
+}
+
+ForkBlocPoint *AbstractPoint::tryAsForkBis(BlocPoint *sop)
+{
+ Node *bb(GetNodeB4(getFirstNode())),*ee(GetNodeAfter(getLastNode()));
+ AbstractPoint *ee2(sop->findPointWithNode(ee));
+ //
+ const std::list<AbstractPoint *>& lp(sop->getListOfPoints());
+ std::list<AbstractPoint *> l; l.push_back(this);
+ for(std::list<AbstractPoint *>::const_iterator it=lp.begin();it!=lp.end();it++)
+ {
+ if(*it==this)
+ continue;
+ Node *curFirst((*it)->getFirstNode()),*curEnd((*it)->getLastNode());
+ if(!IsNoLinksBefore(curFirst) || !IsSimplyLinkedAfterExt(curEnd))
+ continue;
+ Node *curee(GetNodeAfter(curEnd));
+ AbstractPoint *ee3(sop->findPointWithNode(curee));
+ if(ee2==ee3)
+ l.push_back(*it);
+ }
+ if(l.size()>1)
+ {
+ return new ForkBlocPoint(l,getFather());
+ }
+ else
+ return 0;
+}
+
+ForkBlocPoint *AbstractPoint::tryAsForkTer(BlocPoint *sop)
+{
+ Node *bb(GetNodeB4(getFirstNode())),*ee(GetNodeAfter(getLastNode()));
+ AbstractPoint *bb2(sop->findPointWithNode(bb));
+ //
+ const std::list<AbstractPoint *>& lp(sop->getListOfPoints());
+ std::list<AbstractPoint *> l; l.push_back(this);
+ for(std::list<AbstractPoint *>::const_iterator it=lp.begin();it!=lp.end();it++)
+ {
+ if(*it==this)
+ continue;
+ Node *curFirst((*it)->getFirstNode()),*curEnd((*it)->getLastNode());
+ if(!IsSimplyLinkedBeforeExt(curFirst) || !IsNoLinksAfter(curEnd))
+ continue;
+ Node *curbb(GetNodeB4(curFirst));
+ AbstractPoint *bb3(sop->findPointWithNode(curbb));
+ if(bb2==bb3)
+ l.push_back(*it);
+ }
+ if(l.size()>1)
+ {
+ return new ForkBlocPoint(l,getFather());
+ }
+ else
+ return 0;
+}
+
+bool AbstractPoint::IsGatherB4Ext(Node *node)
+{
+ InGate *ing(node->getInGate());
+ return ing->getBackLinks().size()!=1;
+}
+
+bool AbstractPoint::isSimplyLinkedAfter(BlocPoint *sop, Node *node)
+{
+ OutGate *oug(node->getOutGate());
+ std::set<InGate *> ings(oug->edSetInGate());
+ if(ings.size()==1)
+ return true;
+ if(ings.size()==0)
+ return false;
+ AbstractPoint *dummy=0;
+ return IsCommonDirectSonOf(sop,ings,dummy);
+}
+
+bool AbstractPoint::IsSimplyLinkedAfterExt(Node *node)
+{
+ OutGate *oug(node->getOutGate());
+ return oug->edSetInGate().size()<=1;
+}
+
+bool AbstractPoint::IsScatterAfterExt(Node *node)
+{
+ OutGate *oug(node->getOutGate());
+ return oug->edSetInGate().size()!=1;
+}
+
+bool AbstractPoint::isSimplyLinkedBefore(BlocPoint *sop, Node *node)
+{
+ InGate *ing(node->getInGate());
+ std::list<OutGate *> outgs(ing->getBackLinks());
+ if(outgs.size()==1)
+ return true;
+ if(outgs.size()==0)
+ return false;
+ AbstractPoint *dummy=0;
+ return IsCommonDirectSonOf(sop,outgs,dummy);
+}
+
+bool AbstractPoint::IsSimplyLinkedBeforeExt(Node *node)
+{
+ InGate *ing(node->getInGate());
+ return ing->getBackLinks().size()<=1;
+}
+
+bool AbstractPoint::IsNoLinksBefore(Node *node)
+{
+ InGate *ing(node->getInGate());
+ return ing->getBackLinks().size()==0;
+}
+
+bool AbstractPoint::IsNoLinksAfter(Node *node)
+{
+ OutGate *oug(node->getOutGate());
+ return oug->edSetInGate().size()==0;
+}
+
+Node *AbstractPoint::GetNodeB4(Node *node)
+{
+ InGate *ing(node->getInGate());
+ std::list<OutGate *> bl(ing->getBackLinks());
+ if(bl.size()>1)
+ throw Exception("AbstractPoint::GetNodeB4 : precond not OK !");
+ if(bl.size()==0)
+ return 0;
+ return bl.front()->getNode();
+}
+
+Node *AbstractPoint::GetNodeAfter(Node *node)
+{
+ OutGate *oug(node->getOutGate());
+ std::set<InGate *> fl(oug->edSetInGate());
+ if(fl.size()>1)
+ throw Exception("AbstractPoint::GetNodeAfter : precond not OK !");
+ if(fl.size()==0)
+ return 0;
+ return (*fl.begin())->getNode();
+}
+
+AbstractPoint *AbstractPoint::GetDirectSonOf(AbstractPoint *refFather, AbstractPoint *sonOrLittleSon)
+{
+ AbstractPoint *curFath(sonOrLittleSon->getFather()),*cur(sonOrLittleSon);
+ while(curFath && curFath!=refFather)
+ {
+ cur=curFath;
+ curFath=cur->getFather();
+ }
+ if(!curFath)
+ throw YACS::Exception("AbstractPoint::GetDirectSonOf : not in the same family !");
+ return cur;
+}
+
+bool AbstractPoint::IsCommonDirectSonOf(AbstractPoint *refFather, const std::list<OutGate *>& outgs, AbstractPoint *&ret)
+{
+ if(outgs.size()<1)
+ throw YACS::Exception("AbstractPoint::GetCommonDirectSonOf1 : not enough !");
+ std::list<OutGate *>::const_iterator it(outgs.begin());
+ OutGate *ref(*(it++));
+ AbstractPoint *ref2(GetDirectSonOf(refFather,refFather->findPointWithNode(ref->getNode())));
+ for(;it!=outgs.end();it++)
+ {
+ if(!ref2->contains((*it)->getNode()))
+ return false;
+ }
+ ret=ref2;
+ return true;
+}
+
+bool AbstractPoint::IsCommonDirectSonOf(AbstractPoint *refFather, const std::set<InGate *>& ings, AbstractPoint *&ret)
+{
+ if(ings.size()<1)
+ throw YACS::Exception("AbstractPoint::GetCommonDirectSonOf2 : not enough !");
+ std::set<InGate *>::const_iterator it(ings.begin());
+ InGate *ref(*(it++));
+ AbstractPoint *ref2(GetDirectSonOf(refFather,refFather->findPointWithNode(ref->getNode())));
+ for(;it!=ings.end();it++)
+ {
+ if(!ref2->contains((*it)->getNode()))
+ return false;
+ }
+ ret=ref2;
+ return true;
+}
--- /dev/null
+// Copyright (C) 2015 EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#ifndef __ABSTRACTPOINT_HXX__
+#define __ABSTRACTPOINT_HXX__
+
+#include "YACSlibEngineExport.hxx"
+
+#include <set>
+#include <list>
+#include <vector>
+#include <string>
+
+namespace YACS
+{
+ namespace ENGINE
+ {
+ class Node;
+ class InGate;
+ class OutGate;
+ class BlocPoint;
+ class ForkBlocPoint;
+ class LinkedBlocPoint;
+
+ class YACSLIBENGINE_EXPORT AbstractPoint
+ {
+ public:
+ AbstractPoint(AbstractPoint *father):_father(father) { }
+ AbstractPoint *getFather() const { return _father; }
+ AbstractPoint *getGodFather();
+ bool amIGod() { return getGodFather()==0; }
+ void setFather(AbstractPoint *father) { _father=father; }
+ //
+ bool isBegin();
+ bool isLast();
+ bool isSimplyLinkedBeforeAfter(BlocPoint *sop);
+ bool isSimplyLinkedAfterNullBefore(BlocPoint *sop);
+ bool isSimplyLinkedBeforeNullAfter(BlocPoint *sop);
+ //
+ LinkedBlocPoint *tryAsLink(BlocPoint *sop);
+ ForkBlocPoint *tryAsFork(BlocPoint *sop);
+ ForkBlocPoint *tryAsForkBis(BlocPoint *sop);
+ ForkBlocPoint *tryAsForkTer(BlocPoint *sop);
+ //
+ virtual Node *getFirstNode() = 0;
+ virtual Node *getLastNode() = 0;
+ virtual AbstractPoint *findPointWithNode(Node *node) = 0;
+ virtual bool contains(Node *node) = 0;
+ virtual int getNumberOfNodes() const = 0;
+ virtual int getMaxLevelOfParallelism() const = 0;
+ virtual std::string getRepr() const = 0;
+ virtual ~AbstractPoint();
+ public:
+ static bool IsGatherB4Ext(Node *node);
+ bool isSimplyLinkedAfter(BlocPoint *sop, Node *node);
+ static bool IsSimplyLinkedAfterExt(Node *node);
+ static bool IsScatterAfterExt(Node *node);
+ bool isSimplyLinkedBefore(BlocPoint *sop, Node *node);
+ static bool IsSimplyLinkedBeforeExt(Node *node);
+ static bool IsNoLinksBefore(Node *node);
+ static bool IsNoLinksAfter(Node *node);
+ static Node *GetNodeB4(Node *node);
+ static Node *GetNodeAfter(Node *node);
+ static AbstractPoint *GetDirectSonOf(AbstractPoint *refFather, AbstractPoint *sonOrLittleSon);
+ static bool IsCommonDirectSonOf(AbstractPoint *refFather, const std::list<OutGate *>& outgs, AbstractPoint *&ret);
+ static bool IsCommonDirectSonOf(AbstractPoint *refFather, const std::set<InGate *>& ings, AbstractPoint *&ret);
+ protected:
+ AbstractPoint *_father;
+ };
+ }
+}
+
+
+#endif
--- /dev/null
+// Copyright (C) 2015 EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#include "BagPoint.hxx"
+#include "Exception.hxx"
+#include "LinkedBlocPoint.hxx"
+#include "ForkBlocPoint.hxx"
+
+#include <sstream>
+#include <algorithm>
+
+using namespace YACS::ENGINE;
+
+BagPoint::BagPoint(const std::list<AbstractPoint *>& nodes, AbstractPoint *father):BlocPoint(nodes,father)
+{
+}
+
+Node *BagPoint::getFirstNode()
+{
+ if(_nodes.size()!=1)
+ throw YACS::Exception("BagPoint::getFirstNode : invalid call !");
+ else
+ return (*_nodes.begin())->getFirstNode();
+}
+
+Node *BagPoint::getLastNode()
+{
+ if(_nodes.size()!=1)
+ throw YACS::Exception("BagPoint::getLastNode : invalid call !");
+ else
+ return (*_nodes.begin())->getLastNode();
+}
+
+int BagPoint::getMaxLevelOfParallelism() const
+{
+ if(_nodes.size()!=1)
+ throw YACS::Exception("BagPoint::getMaxLevelOfParallelism : invalid call !");
+ else
+ return (*_nodes.begin())->getMaxLevelOfParallelism();
+}
+
+std::string BagPoint::getRepr() const
+{
+ std::ostringstream oss;
+ for(std::list<AbstractPoint *>::const_iterator it=_nodes.begin();it!=_nodes.end();it++)
+ oss << (*it)->getRepr() << " - ";
+ return oss.str();
+}
+
+#include <iostream>
+
+void BagPoint::replaceInMe(BlocPoint *aSet)
+{
+ const std::list<AbstractPoint *>& pts(aSet->getListOfPoints());
+ for(std::list<AbstractPoint *>::const_iterator it0=pts.begin();it0!=pts.end();it0++)
+ {
+ std::list<AbstractPoint *>::iterator it1(std::find(_nodes.begin(),_nodes.end(),*it0));
+ if(it1==_nodes.end())
+ throw Exception("SetOfPoints::replaceInMe : internal error !");
+ _nodes.erase(it1);
+ }
+ _nodes.push_back(aSet);
+}
+
+void BagPoint::deal1(bool& somethingDone)
+{
+ somethingDone=false;
+ for(std::list<AbstractPoint *>::iterator it=_nodes.begin();it!=_nodes.end();it++)
+ {
+ if(!(*it)->isSimplyLinkedBeforeAfter(this))
+ if(!(*it)->isSimplyLinkedAfterNullBefore(this) && !(*it)->isSimplyLinkedBeforeNullAfter(this))
+ continue;
+ LinkedBlocPoint *try0((*it)->tryAsLink(this));
+ if(try0)
+ {
+ replaceInMe(try0);
+ somethingDone=true;
+ break;
+ }
+ }
+}
+
+void BagPoint::deal2(bool& somethingDone)
+{
+ somethingDone=false;
+ for(std::list<AbstractPoint *>::iterator it=_nodes.begin();it!=_nodes.end();it++)
+ {
+ if(!(*it)->isSimplyLinkedBeforeAfter(this))
+ continue;
+ ForkBlocPoint *try1((*it)->tryAsFork(this));
+ if(try1)
+ {
+ replaceInMe(try1);
+ somethingDone=true;
+ break;
+ }
+ }
+}
+
+void BagPoint::deal2Bis(bool& somethingDone)
+{
+ somethingDone=false;
+ for(std::list<AbstractPoint *>::iterator it=_nodes.begin();it!=_nodes.end();it++)
+ {
+ if(!(*it)->isSimplyLinkedAfterNullBefore(this))
+ continue;
+ ForkBlocPoint *try1((*it)->tryAsForkBis(this));
+ if(try1)
+ {
+ replaceInMe(try1);
+ somethingDone=true;
+ break;
+ }
+ }
+}
+
+void BagPoint::deal2Ter(bool& somethingDone)
+{
+ somethingDone=false;
+ for(std::list<AbstractPoint *>::iterator it=_nodes.begin();it!=_nodes.end();it++)
+ {
+ if(!(*it)->isSimplyLinkedBeforeNullAfter(this))
+ continue;
+ ForkBlocPoint *try1((*it)->tryAsForkTer(this));
+ if(try1)
+ {
+ replaceInMe(try1);
+ somethingDone=true;
+ break;
+ }
+ }
+}
+
--- /dev/null
+// Copyright (C) 2015 EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#ifndef __BAGPOINT_HXX__
+#define __BAGPOINT_HXX__
+
+#include "YACSlibEngineExport.hxx"
+#include "BlocPoint.hxx"
+
+#include <list>
+
+namespace YACS
+{
+ namespace ENGINE
+ {
+ class YACSLIBENGINE_EXPORT BagPoint : public BlocPoint
+ {
+ public:
+ BagPoint(const std::list<AbstractPoint *>& nodes, AbstractPoint *father);
+ public://overloading
+ Node *getFirstNode();
+ Node *getLastNode();
+ int getMaxLevelOfParallelism() const;
+ std::string getRepr() const;
+ public:
+ int size() const { return (int)_nodes.size(); }
+ void replaceInMe(BlocPoint *aSet);
+ void deal1(bool& somethingDone);
+ void deal2(bool& somethingDone);
+ void deal2Bis(bool& somethingDone);
+ void deal2Ter(bool& somethingDone);
+ };
+ }
+}
+
+
+#endif
#include "ElementaryNode.hxx"
#include "Visitor.hxx"
+#include <queue>
#include <iostream>
#include <numeric>
}
}
+std::vector< std::list<Node *> > Bloc::splitIntoIndependantGraph() const
+{
+ std::size_t sz(_setOfNode.size());
+ list<Node *>::const_iterator it=_setOfNode.begin();
+ for(;it!=_setOfNode.end();it++)
+ (*it)->_colour=White;
+ it=_setOfNode.begin();
+ std::vector< list<Node *> > ret;
+ while(it!=_setOfNode.end())
+ {
+ Node *start(*it); start->_colour=Grey;
+ ret.push_back(list<Node *>());
+ list<Node *>& ll(ret.back());
+ std::queue<Node *> fifo; fifo.push(start);
+ while(!fifo.empty())
+ {
+ Node *cur(fifo.front()); fifo.pop();
+ ll.push_back(cur);
+ //
+ OutGate *og(cur->getOutGate());
+ set<InGate *> og2(og->edSetInGate());
+ for(set<InGate *>::const_iterator it2=og2.begin();it2!=og2.end();it2++)
+ {
+ Node *cur2((*it2)->getNode());
+ if(cur2->_colour==White)
+ {
+ cur2->_colour=Grey;
+ fifo.push(cur2);
+ }
+ }
+ //
+ InGate *ig(cur->getInGate());
+ list<OutGate *> bl(ig->getBackLinks());
+ for(list<OutGate *>::const_iterator it3=bl.begin();it3!=bl.end();it3++)
+ {
+ Node *cur3((*it3)->getNode());
+ if(cur3->_colour==White)
+ {
+ cur3->_colour=Grey;
+ fifo.push(cur3);
+ }
+ }
+ }
+ for(it=_setOfNode.begin();it!=_setOfNode.end() && (*it)->_colour!=White;it++);
+ }
+ return ret;
+}
+
Node *Bloc::getChildByShortName(const std::string& name) const throw(YACS::Exception)
{
for (list<Node *>::const_iterator iter = _setOfNode.begin(); iter != _setOfNode.end(); iter++)
void edRemoveChild(Node *node) throw(Exception);
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);
virtual void writeDot(std::ostream &os) const;
void accept(Visitor *visitor);
--- /dev/null
+// Copyright (C) 2015 EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#include "BlocPoint.hxx"
+#include "Node.hxx"
+
+using namespace YACS::ENGINE;
+
+BlocPoint::BlocPoint(const std::list<AbstractPoint *>& nodes, AbstractPoint *father):AbstractPoint(father),_nodes(nodes)
+{
+ for(std::list<AbstractPoint *>::const_iterator it=_nodes.begin();it!=_nodes.end();it++)
+ (*it)->setFather(this);
+}
+
+AbstractPoint *BlocPoint::findPointWithNode(Node *node)
+{
+ for(std::list<AbstractPoint *>::iterator it=_nodes.begin();it!=_nodes.end();it++)
+ {
+ AbstractPoint *ret((*it)->findPointWithNode(node));
+ if(ret)
+ return AbstractPoint::GetDirectSonOf(this,ret);
+ }
+ return 0;
+}
+
+AbstractPoint *BlocPoint::getNodeAfter(Node *node)
+{
+ OutGate *oug(node->getOutGate());
+ std::set<InGate *> fl(oug->edSetInGate());
+ if(fl.size()>=1)
+ {
+ AbstractPoint *ret(0);
+ IsCommonDirectSonOf(this,fl,ret);
+ return ret;
+ }
+ else
+ return 0;
+}
+
+AbstractPoint *BlocPoint::getNodeB4(Node *node)
+{
+ InGate *ing(node->getInGate());
+ std::list<OutGate *> bl(ing->getBackLinks());
+ if(bl.size()>=1)
+ {
+ AbstractPoint *ret(0);
+ IsCommonDirectSonOf(this,bl,ret);
+ return ret;
+ }
+ else
+ return 0;
+}
+
+bool BlocPoint::contains(Node *node)
+{
+ for(std::list<AbstractPoint *>::iterator it=_nodes.begin();it!=_nodes.end();it++)
+ {
+ if((*it)->contains(node))
+ return true;
+ }
+ return false;
+}
+
+int BlocPoint::getNumberOfNodes() const
+{
+ int ret(0);
+ for(std::list<AbstractPoint *>::const_iterator it=_nodes.begin();it!=_nodes.end();it++)
+ ret+=(*it)->getNumberOfNodes();
+ return ret;
+}
+
+BlocPoint::~BlocPoint()
+{
+ for(std::list<AbstractPoint *>::iterator it=_nodes.begin();it!=_nodes.end();it++)
+ delete *it;
+}
--- /dev/null
+// Copyright (C) 2015 EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#ifndef __BLOCPOINT_HXX__
+#define __BLOCPOINT_HXX__
+
+#include "YACSlibEngineExport.hxx"
+#include "AbstractPoint.hxx"
+
+#include <list>
+
+namespace YACS
+{
+ namespace ENGINE
+ {
+ class YACSLIBENGINE_EXPORT BlocPoint : public AbstractPoint
+ {
+ protected:
+ std::list<AbstractPoint *> _nodes;
+ public:
+ BlocPoint(const std::list<AbstractPoint *>& nodes, AbstractPoint *father);
+ AbstractPoint *findPointWithNode(Node *node);
+ AbstractPoint *getNodeAfter(Node *node);
+ AbstractPoint *getNodeB4(Node *node);
+ bool contains(Node *node);
+ int getNumberOfNodes() const;
+ const std::list<AbstractPoint *>& getListOfPoints() const { return _nodes; }
+ virtual ~BlocPoint();
+ };
+ }
+}
+
+
+#endif
AnyOutputPort.hxx
ServerNode.hxx
InPropertyPort.hxx
+ AbstractPoint.hxx
+ BlocPoint.hxx
+ BagPoint.hxx
+ ForkBlocPoint.hxx
+ LinkedBlocPoint.hxx
+ ElementaryPoint.hxx
+ SetOfPoints.hxx
)
# --- sources ---
Task.cxx
Scheduler.cxx
InPropertyPort.cxx
+ AbstractPoint.cxx
+ BlocPoint.cxx
+ BagPoint.cxx
+ ForkBlocPoint.cxx
+ LinkedBlocPoint.cxx
+ ElementaryPoint.cxx
+ SetOfPoints.cxx
)
# --- rules ---
DataPort::~DataPort()
{
- _type->decrRef();
+ if(_type)
+ _type->decrRef();
}
DataPort::DataPort(const std::string& name, Node *node, TypeCode* type):Port(node),_name(name),_type(type)
{
- _type->incrRef();
+ if(_type)
+ _type->incrRef();
}
DataPort::DataPort(const DataPort& other, Node *newHelder):Port(other,newHelder),_name(other._name),_type(other._type)
{
- _type->incrRef();
+ if(_type)
+ _type->incrRef();
}
void DataPort::edSetType(TypeCode* type)
--- /dev/null
+// Copyright (C) 2015 EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#include "ElementaryPoint.hxx"
+#include "Node.hxx"
+
+using namespace YACS::ENGINE;
+
+ElementaryPoint::~ElementaryPoint()
+{
+}
+
+AbstractPoint *ElementaryPoint::findPointWithNode(Node *node)
+{
+ if(node==_node)
+ return this;
+ else
+ return 0;
+}
+
+bool ElementaryPoint::contains(Node *node)
+{
+ return _node==node;
+}
+
+Node *ElementaryPoint::getFirstNode()
+{
+ return _node;
+}
+
+Node *ElementaryPoint::getLastNode()
+{
+ return _node;
+}
+
+int ElementaryPoint::getNumberOfNodes() const
+{
+ return 1;
+}
+
+int ElementaryPoint::getMaxLevelOfParallelism() const
+{
+ return _node->getMaxLevelOfParallelism();
+}
+
+std::string ElementaryPoint::getRepr() const
+{
+ return _node->getName();
+}
--- /dev/null
+// Copyright (C) 2015 EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#ifndef __ELEMENTARYPOINT_HXX__
+#define __ELEMENTARYPOINT_HXX__
+
+#include "YACSlibEngineExport.hxx"
+#include "AbstractPoint.hxx"
+
+#include <vector>
+
+namespace YACS
+{
+ namespace ENGINE
+ {
+ class Node;
+
+ class YACSLIBENGINE_EXPORT ElementaryPoint : public AbstractPoint
+ {
+ private:
+ Node *_node;
+ public:
+ ElementaryPoint(Node *node):AbstractPoint(0),_node(node) { }
+ AbstractPoint *findPointWithNode(Node *node);
+ bool contains(Node *node);
+ Node *getFirstNode();
+ Node *getLastNode();
+ int getNumberOfNodes() const;
+ int getMaxLevelOfParallelism() const;
+ std::string getRepr() const;
+ virtual ~ElementaryPoint();
+ };
+ }
+}
+
+
+#endif
--- /dev/null
+// Copyright (C) 2015 EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#include "ForkBlocPoint.hxx"
+#include "Exception.hxx"
+
+#include <algorithm>
+
+using namespace YACS::ENGINE;
+
+ForkBlocPoint::ForkBlocPoint(const std::list<AbstractPoint *>& nodes, AbstractPoint *father):BlocPoint(nodes,father)
+{
+}
+
+ForkBlocPoint::~ForkBlocPoint()
+{
+}
+
+Node *ForkBlocPoint::getFirstNode()
+{
+ if(_nodes.empty())
+ throw Exception("ForkBlocPoint::getFirstNode : error no branches !");
+ return _nodes.front()->getFirstNode();
+}
+
+Node *ForkBlocPoint::getLastNode()
+{
+ if(_nodes.empty())
+ throw Exception("ForkBlocPoint::getLastNode : error no branches !");
+ return _nodes.front()->getLastNode();//not a bug - seen from the outside only first branch exists !
+}
+
+int ForkBlocPoint::getMaxLevelOfParallelism() const
+{
+ int ret(0);
+ for(std::list<AbstractPoint *>::const_iterator it=_nodes.begin();it!=_nodes.end();it++)
+ ret+=(*it)->getMaxLevelOfParallelism();
+ return ret;
+}
+
+std::string ForkBlocPoint::getRepr() const
+{
+ std::size_t sz(_nodes.size()),ii(0);
+ std::string ret("[");
+ std::vector<std::string> elts(sz);
+ for(std::list<AbstractPoint *>::const_iterator it=_nodes.begin();it!=_nodes.end();it++,ii++)
+ elts[ii]=(*it)->getRepr();
+ std::sort(elts.begin(),elts.end());
+ ii=0;
+ for(std::list<AbstractPoint *>::const_iterator it=_nodes.begin();it!=_nodes.end();it++,ii++)
+ {
+ ret+=elts[ii];
+ if(ii!=sz-1)
+ ret+="*";
+ }
+ ret+="]";
+ return ret;
+}
--- /dev/null
+// Copyright (C) 2015 EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#ifndef __FORKBLOCPOINT_HXX__
+#define __BLOKBLOCPOINT_HXX__
+
+#include "YACSlibEngineExport.hxx"
+#include "BlocPoint.hxx"
+
+namespace YACS
+{
+ namespace ENGINE
+ {
+ class YACSLIBENGINE_EXPORT ForkBlocPoint : public BlocPoint
+ {
+ public:
+ ForkBlocPoint(const std::list<AbstractPoint *>& nodes, AbstractPoint *father);
+ Node *getFirstNode();
+ Node *getLastNode();
+ int getMaxLevelOfParallelism() const;
+ std::string getRepr() const;
+ virtual ~ForkBlocPoint();
+ };
+ }
+}
+
+
+#endif
--- /dev/null
+// Copyright (C) 2015 EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#include "LinkedBlocPoint.hxx"
+#include "Exception.hxx"
+
+using namespace YACS::ENGINE;
+
+LinkedBlocPoint::LinkedBlocPoint(const std::list<AbstractPoint *>& nodes, AbstractPoint *father):BlocPoint(nodes,father)
+{
+}
+
+Node *LinkedBlocPoint::getFirstNode()
+{
+ if(_nodes.empty())
+ throw Exception("LinkedBlocPoint::getFirstNode : error no branches !");
+ return _nodes.front()->getFirstNode();
+}
+
+Node *LinkedBlocPoint::getLastNode()
+{
+ if(_nodes.empty())
+ throw Exception("LinkedBlocPoint::getFirstNode : error no branches !");
+ return _nodes.back()->getLastNode();
+}
+
+int LinkedBlocPoint::getMaxLevelOfParallelism() const
+{
+ int ret(0);
+ for(std::list<AbstractPoint *>::const_iterator it=_nodes.begin();it!=_nodes.end();it++)
+ ret=std::max(ret,(*it)->getMaxLevelOfParallelism());
+ return ret;
+}
+
+std::string LinkedBlocPoint::getRepr() const
+{
+ std::size_t sz(_nodes.size()),ii(0);
+ std::string ret("(");
+ for(std::list<AbstractPoint *>::const_iterator it=_nodes.begin();it!=_nodes.end();it++,ii++)
+ {
+ ret+=(*it)->getRepr();
+ if(ii!=sz-1)
+ ret+="+";
+ }
+ ret+=")";
+ return ret;
+}
+
+LinkedBlocPoint::~LinkedBlocPoint()
+{
+}
--- /dev/null
+// Copyright (C) 2015 EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#ifndef __LINKEDBLOCPOINT_HXX__
+#define __LINKEDBLOCPOINT_HXX__
+
+#include "YACSlibEngineExport.hxx"
+#include "BlocPoint.hxx"
+
+#include <vector>
+
+namespace YACS
+{
+ namespace ENGINE
+ {
+ class YACSLIBENGINE_EXPORT LinkedBlocPoint : public BlocPoint
+ {
+ public:
+ LinkedBlocPoint(const std::list<AbstractPoint *>& nodes, AbstractPoint *father);
+ Node *getFirstNode();
+ Node *getLastNode();
+ int getMaxLevelOfParallelism() const;
+ std::string getRepr() const;
+ virtual ~LinkedBlocPoint();
+ };
+ }
+}
+
+
+#endif
--- /dev/null
+// Copyright (C) 2015 EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#include "SetOfPoints.hxx"
+#include "BagPoint.hxx"
+#include "LinkedBlocPoint.hxx"
+#include "ForkBlocPoint.hxx"
+#include "ElementaryPoint.hxx"
+#include "Exception.hxx"
+
+#include <algorithm>
+
+using namespace YACS::ENGINE;
+
+SetOfPoints::SetOfPoints(const std::list<Node *>& nodes):_bp(0)
+{
+ std::list<AbstractPoint *> nodes2;
+ for(std::list<Node *>::const_iterator it=nodes.begin();it!=nodes.end();it++)
+ {
+ nodes2.push_back(new ElementaryPoint(*it));
+ }
+ _bp=new BagPoint(nodes2,0);
+}
+
+SetOfPoints::~SetOfPoints()
+{
+ if(!_bp)
+ return;
+ delete _bp;
+}
+
+void SetOfPoints::simplify()
+{
+ while(_bp->size()>1)
+ {
+ bool somethingDone(false);
+ _bp->deal1(somethingDone);
+ if(somethingDone)
+ continue;
+ _bp->deal2(somethingDone);
+ if(somethingDone)
+ continue;
+ _bp->deal2Bis(somethingDone);
+ if(somethingDone)
+ continue;
+ _bp->deal2Ter(somethingDone);
+ if(!somethingDone)
+ throw Exception("SetOfPoints::simplify : not implemented yet !");
+ }
+}
+
+std::string SetOfPoints::getRepr() const
+{
+ return _bp->getRepr();
+}
+
+AbstractPoint *SetOfPoints::findPointWithNode(Node *node)
+{
+ if(node==0)
+ return 0;
+ return _bp->findPointWithNode(node);
+}
+
+const std::list<AbstractPoint *>& SetOfPoints::getListOfPoints() const
+{
+ return _bp->getListOfPoints();
+}
+
+int SetOfPoints::getMaxLevelOfParallelism() const
+{
+ return _bp->getMaxLevelOfParallelism();
+}
--- /dev/null
+// Copyright (C) 2015 EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#ifndef __SETOFPOINTS_HXX__
+#define __SETOFPOINTS_HXX__
+
+#include "YACSlibEngineExport.hxx"
+
+#include <list>
+#include <string>
+
+namespace YACS
+{
+ namespace ENGINE
+ {
+ class Node;
+ class BagPoint;
+ class AbstractPoint;
+
+ class YACSLIBENGINE_EXPORT SetOfPoints
+ {
+ public:
+ SetOfPoints(const std::list<Node *>& nodes);
+ ~SetOfPoints();
+ void simplify();
+ std::string getRepr() const;
+ AbstractPoint *findPointWithNode(Node *node);
+ const std::list<AbstractPoint *>& getListOfPoints() const;
+ int getMaxLevelOfParallelism() const;
+ private:
+ BagPoint *_bp;
+ };
+ }
+}
+
+
+#endif
#include "Loop.hxx"
#include "Switch.hxx"
#include "VisitorSaveState.hxx"
+#include "SetOfPoints.hxx"
#include "SharedPtr.hxx"
#include "RuntimeForEngineTest.hxx"
CPPUNIT_ASSERT(logger->getStr()==expected2);
delete proc;
}
+
+void EngineTest::checkGraphAnalyser0()
+{
+ {
+ static const int N=2;
+ Bloc *t[N];
+ Bloc proc("proc");
+ for(int i=0;i<N;i++)
+ {
+ std::ostringstream oss; oss << "n" << i+1;
+ t[i]=new Bloc(oss.str());
+ proc.edAddChild(t[i]);
+ }
+ proc.edAddCFLink(t[0],t[1]);
+ std::vector< std::list<Node *> > r(proc.splitIntoIndependantGraph());
+ CPPUNIT_ASSERT_EQUAL(1,(int)r.size());
+ CPPUNIT_ASSERT_EQUAL(N,(int)r[0].size());
+ SetOfPoints sop(r[0]);
+ sop.simplify();
+ CPPUNIT_ASSERT(sop.getRepr()=="(n1+n2) - ");
+ }
+}
+
+void EngineTest::checkGraphAnalyser1()
+{
+ {
+ static const int N=24;
+ Bloc *t[N];
+ Bloc proc("proc");
+ for(int i=0;i<N;i++)
+ {
+ std::ostringstream oss; oss << "n" << i+1;
+ t[i]=new Bloc(oss.str());
+ proc.edAddChild(t[i]);
+ }
+ proc.edAddCFLink(t[20],t[21]); proc.edAddCFLink(t[21],t[15]); proc.edAddCFLink(t[15],t[14]); proc.edAddCFLink(t[14],t[0]); proc.edAddCFLink(t[0],t[1]); proc.edAddCFLink(t[1],t[23]); proc.edAddCFLink(t[23],t[5]);
+ proc.edAddCFLink(t[14],t[13]); proc.edAddCFLink(t[13],t[5]);
+ proc.edAddCFLink(t[15],t[12]); proc.edAddCFLink(t[12],t[11]); proc.edAddCFLink(t[11],t[9]); proc.edAddCFLink(t[9],t[8]); proc.edAddCFLink(t[8],t[7]); proc.edAddCFLink(t[7],t[6]); proc.edAddCFLink(t[6],t[5]);
+ proc.edAddCFLink(t[11],t[10]); proc.edAddCFLink(t[10],t[8]);
+ proc.edAddCFLink(t[15],t[16]); proc.edAddCFLink(t[16],t[17]); proc.edAddCFLink(t[17],t[19]); proc.edAddCFLink(t[19],t[2]); proc.edAddCFLink(t[2],t[4]); proc.edAddCFLink(t[4],t[5]);
+ proc.edAddCFLink(t[19],t[18]); proc.edAddCFLink(t[18],t[4]);
+ proc.edAddCFLink(t[19],t[3]); proc.edAddCFLink(t[3],t[4]);
+ proc.edAddCFLink(t[22],t[21]);
+ std::vector< std::list<Node *> > r(proc.splitIntoIndependantGraph());
+ CPPUNIT_ASSERT_EQUAL(1,(int)r.size());
+ CPPUNIT_ASSERT_EQUAL(N,(int)r[0].size());
+ SetOfPoints sop(r[0]);
+ sop.simplify();
+ CPPUNIT_ASSERT(sop.getRepr()=="([n21*n23]+(n22+n16+[((n13+n12)+[n10*n11]+(n9+n8+n7))*((n17+n18+n20)+[n19*n3*n4]+n5)*(n15+[(n1+n2+n24)*n14])]+n6)) - ");
+ }
+ //
+ {
+ static const int N=10;
+ Bloc *t[N];
+ Bloc proc("proc");
+ for(int i=0;i<N;i++)
+ {
+ std::ostringstream oss; oss << "n" << i+1;
+ t[i]=new Bloc(oss.str());
+ proc.edAddChild(t[i]);
+ }
+ proc.edAddCFLink(t[9],t[0]); proc.edAddCFLink(t[0],t[2]); proc.edAddCFLink(t[2],t[4]); proc.edAddCFLink(t[4],t[5]);
+ proc.edAddCFLink(t[0],t[1]); proc.edAddCFLink(t[1],t[6]); proc.edAddCFLink(t[6],t[7]); proc.edAddCFLink(t[7],t[5]);
+ proc.edAddCFLink(t[0],t[8]); proc.edAddCFLink(t[8],t[3]); proc.edAddCFLink(t[3],t[4]);
+ std::vector< std::list<Node *> > r(proc.splitIntoIndependantGraph());
+ CPPUNIT_ASSERT_EQUAL(1,(int)r.size());
+ CPPUNIT_ASSERT_EQUAL(N,(int)r[0].size());
+ SetOfPoints sop(r[0]);
+ sop.simplify();
+ CPPUNIT_ASSERT(sop.getRepr()=="((n10+n1)+[([(n9+n4)*n3]+n5)*(n2+n7+n8)]+n6) - ");
+ }
+}
+
+void EngineTest::checkGraphAnalyser2()
+{
+ {
+ static const int N=8;
+ Bloc *t[N];
+ Bloc proc("proc");
+ for(int i=0;i<N;i++)
+ {
+ std::ostringstream oss; oss << "n" << i+1;
+ t[i]=new Bloc(oss.str());
+ proc.edAddChild(t[i]);
+ }
+ proc.edAddCFLink(t[7],t[4]); proc.edAddCFLink(t[4],t[0]); proc.edAddCFLink(t[0],t[1]); proc.edAddCFLink(t[1],t[5]); proc.edAddCFLink(t[5],t[6]);
+ proc.edAddCFLink(t[4],t[2]); proc.edAddCFLink(t[2],t[3]); proc.edAddCFLink(t[3],t[5]);
+ std::vector< std::list<Node *> > r(proc.splitIntoIndependantGraph());
+ CPPUNIT_ASSERT_EQUAL(1,(int)r.size());
+ CPPUNIT_ASSERT_EQUAL(N,(int)r[0].size());
+ SetOfPoints sop(r[0]);
+ sop.simplify();
+ CPPUNIT_ASSERT(sop.getRepr()=="((n8+n5)+[(n1+n2)*(n3+n4)]+(n6+n7)) - ");
+ }
+ //
+ {
+ static const int NN=6;
+ Bloc *tt[NN];
+ Bloc proc2("proc2");
+ tt[0]=new Bloc("n21") ; tt[1]=new Bloc("n22") ; tt[2]=new Bloc("n23") ; tt[3]=new Bloc("n16"); tt[4]=new Bloc("n21@1"); tt[5]=new Bloc("n23@1");
+ for(int i=0;i<NN;i++)
+ proc2.edAddChild(tt[i]);
+ proc2.edAddCFLink(tt[0],tt[4]); proc2.edAddCFLink(tt[4],tt[1]); proc2.edAddCFLink(tt[2],tt[5]); proc2.edAddCFLink(tt[5],tt[1]); proc2.edAddCFLink(tt[1],tt[3]);
+ std::vector< std::list<Node *> > rr(proc2.splitIntoIndependantGraph());
+ CPPUNIT_ASSERT_EQUAL(1,(int)rr.size());
+ CPPUNIT_ASSERT_EQUAL(NN,(int)rr[0].size());
+ SetOfPoints sop2(rr[0]);
+ sop2.simplify();
+ CPPUNIT_ASSERT(sop2.getRepr()=="([(n21+n21@1)*(n23+n23@1)]+(n22+n16)) - ");
+ }
+ //
+ {
+ static const int NNN=6;
+ Bloc *ttt[NNN];
+ Bloc proc3("proc3");
+ ttt[0]=new Bloc("n21") ; ttt[1]=new Bloc("n22") ; ttt[2]=new Bloc("n23") ; ttt[3]=new Bloc("n16"); ttt[4]=new Bloc("n21@1"); ttt[5]=new Bloc("n23@1");
+ for(int i=0;i<NNN;i++)
+ proc3.edAddChild(ttt[i]);
+ proc3.edAddCFLink(ttt[0],ttt[4]); proc3.edAddCFLink(ttt[3],ttt[0]); proc3.edAddCFLink(ttt[2],ttt[5]); proc3.edAddCFLink(ttt[3],ttt[2]); proc3.edAddCFLink(ttt[1],ttt[3]);
+ std::vector< std::list<Node *> > rrr(proc3.splitIntoIndependantGraph());
+ CPPUNIT_ASSERT_EQUAL(1,(int)rrr.size());
+ CPPUNIT_ASSERT_EQUAL(NNN,(int)rrr[0].size());
+ SetOfPoints sop3(rrr[0]);
+ sop3.simplify();
+ CPPUNIT_ASSERT(sop3.getRepr()=="((n22+n16)+[(n21+n21@1)*(n23+n23@1)]) - ");
+ }
+}
+
+void EngineTest::checkGraphAnalyser3()
+{
+ {
+ static const int NNN=6;
+ Bloc *ttt[NNN];
+ Bloc proc3("proc3");
+ for(int i=0;i<NNN;i++)
+ {
+ std::ostringstream oss; oss << "n" << i+1;
+ ttt[i]=new Bloc(oss.str());
+ proc3.edAddChild(ttt[i]);
+ }
+ proc3.edAddCFLink(ttt[0],ttt[1]); proc3.edAddCFLink(ttt[1],ttt[4]);
+ proc3.edAddCFLink(ttt[0],ttt[2]); proc3.edAddCFLink(ttt[2],ttt[3]); proc3.edAddCFLink(ttt[3],ttt[4]);
+ proc3.edAddCFLink(ttt[5],ttt[3]);
+ std::vector< std::list<Node *> > rrr(proc3.splitIntoIndependantGraph());
+ CPPUNIT_ASSERT_EQUAL(1,(int)rrr.size());
+ CPPUNIT_ASSERT_EQUAL(NNN,(int)rrr[0].size());
+ SetOfPoints sop3(rrr[0]);
+ //sop3.simplify();
+ //std:cerr << std::endl << sop3.getRepr() << std::endl;
+ //CPPUNIT_ASSERT(sop3.getRepr()=="((n22+n16)+[(n21+n21@1)*(n23+n23@1)]) - ");
+ }
+}
CPPUNIT_TEST(RecursiveBlocs_removeNodes );
CPPUNIT_TEST(cleanUp);
CPPUNIT_TEST(checkLogger);
+ CPPUNIT_TEST(checkGraphAnalyser0);
+ CPPUNIT_TEST(checkGraphAnalyser1);
+ CPPUNIT_TEST(checkGraphAnalyser2);
+ CPPUNIT_TEST(checkGraphAnalyser3);
CPPUNIT_TEST_SUITE_END();
public:
void RecursiveBlocs_multipleRecursion();
void RecursiveBlocs_removeNodes();
void checkLogger();
-
+ void checkGraphAnalyser0();
+ void checkGraphAnalyser1();
+ void checkGraphAnalyser2();
+ void checkGraphAnalyser3();
protected:
static std::map<std::string, YACS::ENGINE::Node*> _nodeMap;
static std::map<std::string, YACS::ENGINE::ComposedNode*> _compoMap;
