Version: 9.16.0
Public Member Functions | Static Public Member Functions | Protected Attributes | List of all members
YACS::ENGINE::AbstractPoint Class Referenceabstract

#include <AbstractPoint.hxx>

Inheritance diagram for YACS::ENGINE::AbstractPoint:
Inheritance graph
[legend]
Collaboration diagram for YACS::ENGINE::AbstractPoint:
Collaboration graph
[legend]

Public Member Functions

 AbstractPoint ()=default
 
 AbstractPoint (AbstractPoint *father)
 
AbstractPoint * getFather () const
 
AbstractPoint * getGodFather ()
 
bool amIGod ()
 
void setFather (AbstractPoint *father)
 
bool isBegin ()
 
bool isLast ()
 
bool isSimplyLinkedBeforeAfter (BlocPoint *sop)
 
bool isSimplyLinkedAfterNullBefore (BlocPoint *sop)
 
bool isSimplyLinkedBeforeNullAfter (BlocPoint *sop)
 
bool isNullBeforeNullAfter (BlocPoint *sop)
 
LinkedBlocPoint * tryAsLink (BlocPoint *sop)
 
ForkBlocPoint * tryAsFork (BlocPoint *sop)
 
ForkBlocPoint * tryAsForkBis (BlocPoint *sop)
 
ForkBlocPoint * tryAsForkTer (BlocPoint *sop)
 
ForkBlocPoint * tryAsForkQuatro (BlocPoint *sop)
 
virtual AbstractPoint * deepCopy (AbstractPoint *father) const =0
 
virtual Node * getFirstNode ()=0
 
virtual Node * getLastNode ()=0
 
virtual AbstractPoint * findPointWithNode (Node *node)=0
 
virtual bool contains (Node *node) const =0
 
virtual bool anyOf (const std::set< Node * > &nodes) const =0
 
virtual int getNumberOfNodes () const =0
 
virtual int getMaxLevelOfParallelism () const =0
 
virtual void getWeightRegardingDPL (ComplexWeight *weight)=0
 
virtual void partitionRegardingDPL (const PartDefinition *pd, std::map< ComposedNode *, YACS::BASES::AutoRefCnt< PartDefinition > > &zeMap) const =0
 
virtual std::string getRepr () const =0
 
virtual void accept (PointVisitor *pv)=0
 
virtual AbstractPoint * expandNonSimpleCaseOn (NotSimpleCasePoint *pathologicalPt, const std::set< Node * > &uncatchedNodes)=0
 
virtual ~AbstractPoint ()
 
bool isSimplyLinkedAfter (BlocPoint *sop, Node *node)
 
bool isSimplyLinkedBefore (BlocPoint *sop, Node *node)
 

Static Public Member Functions

static void TryAsNotSimpleCase (AbstractPoint *father, const std::vector< AbstractPoint * > &ptsToKill, std::list< AbstractPoint * > &nodes, bool &somethingDone)
 
static bool IsGatherB4Ext (Node *node)
 
static bool IsSimplyLinkedAfterExt (Node *node)
 
static bool IsScatterAfterExt (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::list< InGate * > &ings, AbstractPoint *&ret)
 
static void FeedData (AbstractPoint *ptToBeRewired, std::map< std::string, std::tuple< ElementaryPoint *, Node *, std::shared_ptr< Bloc > > > *m)
 
static void FeedData (const std::list< AbstractPoint * > &ptsToBeRewired, std::map< std::string, std::tuple< ElementaryPoint *, Node *, std::shared_ptr< Bloc > > > *m)
 
static void Rewire (const std::vector< AbstractPoint * > &ptsToKill, std::map< std::string, std::tuple< ElementaryPoint *, Node *, std::shared_ptr< Bloc > > > *m)
 
static void UnRewire (std::map< std::string, std::tuple< ElementaryPoint *, Node *, std::shared_ptr< Bloc > > > &m)
 
static void Display (std::map< std::string, std::tuple< ElementaryPoint *, Node *, std::shared_ptr< Bloc > > > *m)
 

Protected Attributes

AbstractPoint * _father = nullptr
 

Detailed Description

Definition at line 50 of file AbstractPoint.hxx.

Constructor & Destructor Documentation

◆ AbstractPoint() [1/2]

YACS::ENGINE::AbstractPoint::AbstractPoint ( )
default

◆ AbstractPoint() [2/2]

YACS::ENGINE::AbstractPoint::AbstractPoint ( AbstractPoint *  father)
inline

Definition at line 54 of file AbstractPoint.hxx.

54:_father(father) { }

◆ ~AbstractPoint()

AbstractPoint::~AbstractPoint ( )
virtual

Definition at line 34 of file AbstractPoint.cxx.

35{
36}

Member Function Documentation

◆ accept()

virtual void YACS::ENGINE::AbstractPoint::accept ( PointVisitor *  pv)
pure virtual

Implemented in YACS::ENGINE::BagPoint, YACS::ENGINE::ElementaryPoint, YACS::ENGINE::ForkBlocPoint, YACS::ENGINE::LinkedBlocPoint, and YACS::ENGINE::NotSimpleCasePoint.

Referenced by FeedData().

◆ amIGod()

bool YACS::ENGINE::AbstractPoint::amIGod ( )
inline

Definition at line 57 of file AbstractPoint.hxx.

57{ return getGodFather()==nullptr; }
YACS::ENGINE::AbstractPoint::getGodFather
AbstractPoint * getGodFather()
Definition: AbstractPoint.cxx:38

◆ anyOf()

virtual bool YACS::ENGINE::AbstractPoint::anyOf ( const std::set< Node * > &  nodes) const
pure virtual

Implemented in YACS::ENGINE::BlocPoint, and YACS::ENGINE::ElementaryPoint.

◆ contains()

virtual bool YACS::ENGINE::AbstractPoint::contains ( Node *  node) const
pure virtual

Implemented in YACS::ENGINE::BlocPoint, and YACS::ENGINE::ElementaryPoint.

Referenced by IsCommonDirectSonOf().

◆ deepCopy()

virtual AbstractPoint * YACS::ENGINE::AbstractPoint::deepCopy ( AbstractPoint *  father) const
pure virtual

Implemented in YACS::ENGINE::BagPoint, YACS::ENGINE::ElementaryPoint, YACS::ENGINE::ForkBlocPoint, YACS::ENGINE::LinkedBlocPoint, and YACS::ENGINE::NotSimpleCasePoint.

Referenced by YACS::ENGINE::ElementaryPoint::expandNonSimpleCaseOn(), and YACS::ENGINE::LinkedBlocPoint::expandNonSimpleCaseOn().

◆ Display()

void AbstractPoint::Display ( std::map< std::string, std::tuple< ElementaryPoint *, Node *, std::shared_ptr< Bloc > > > *  m)
static

Definition at line 375 of file AbstractPoint.cxx.

376{
377 for(auto it : *m)
378 {
379 ElementaryPoint *pt(std::get<0>(it.second));
380 auto newNode(pt->getNode());
381 for(auto it2 : newNode->getOutGate()->edSetInGate())
382 {
383 std::cerr << pt->getNodeName() << " -> " << it2->getNode()->getName() << " " << newNode->typeName() << std::endl;
384 }
385 }
386}

References YACS::ENGINE::ElementaryPoint::getNode(), YACS::ENGINE::ElementaryPoint::getNodeName(), and gui.GraphViewer::m.

◆ expandNonSimpleCaseOn()

virtual AbstractPoint * YACS::ENGINE::AbstractPoint::expandNonSimpleCaseOn ( NotSimpleCasePoint *  pathologicalPt,
const std::set< Node * > &  uncatchedNodes 
)
pure virtual

Implemented in YACS::ENGINE::BagPoint, YACS::ENGINE::ElementaryPoint, YACS::ENGINE::ForkBlocPoint, YACS::ENGINE::LinkedBlocPoint, and YACS::ENGINE::NotSimpleCasePoint.

Referenced by YACS::ENGINE::BagPoint::expandNonSimpleCaseOn().

◆ FeedData() [1/2]

void AbstractPoint::FeedData ( AbstractPoint *  ptToBeRewired,
std::map< std::string, std::tuple< ElementaryPoint *, Node *, std::shared_ptr< Bloc > > > *  m 
)
static

Feed m with all ElementaryPoints inside ptToBeRewired.

Definition at line 290 of file AbstractPoint.cxx.

291{
292 Visitor1 vis(m);
293 ptToBeRewired->accept(&vis);
294}
YACS::ENGINE::AbstractPoint::accept
virtual void accept(PointVisitor *pv)=0

References accept(), and gui.GraphViewer::m.

Referenced by FeedData(), and TryAsNotSimpleCase().

◆ FeedData() [2/2]

void AbstractPoint::FeedData ( const std::list< AbstractPoint * > &  ptsToBeRewired,
std::map< std::string, std::tuple< ElementaryPoint *, Node *, std::shared_ptr< Bloc > > > *  m 
)
static

Feed m with all ElementaryPoints inside ptsToBeRewired.

Definition at line 299 of file AbstractPoint.cxx.

300{
301 for(auto it : ptsToBeRewired)
302 FeedData(it,m);
303}
YACS::ENGINE::AbstractPoint::FeedData
static void FeedData(AbstractPoint *ptToBeRewired, std::map< std::string, std::tuple< ElementaryPoint *, Node *, std::shared_ptr< Bloc > > > *m)
Definition: AbstractPoint.cxx:290

References FeedData(), and gui.GraphViewer::m.

◆ findPointWithNode()

virtual AbstractPoint * YACS::ENGINE::AbstractPoint::findPointWithNode ( Node *  node)
pure virtual

Implemented in YACS::ENGINE::BlocPoint, and YACS::ENGINE::ElementaryPoint.

Referenced by IsCommonDirectSonOf().

◆ GetDirectSonOf()

AbstractPoint * AbstractPoint::GetDirectSonOf ( AbstractPoint *  refFather,
AbstractPoint *  sonOrLittleSon 
)
static

Definition at line 518 of file AbstractPoint.cxx.

519{
520 if(!sonOrLittleSon)
521 throw YACS::Exception("AbstractPoint::GetDirectSonOf : sonOrLittleSon is null !");
522 AbstractPoint *curFath(sonOrLittleSon->getFather()),*cur(sonOrLittleSon);
523 while(curFath && curFath!=refFather)
524 {
525 cur=curFath;
526 curFath=cur->getFather();
527 }
528 if(!curFath)
529 throw YACS::Exception("AbstractPoint::GetDirectSonOf : not in the same family !");
530 return cur;
531}
YACS::ENGINE::AbstractPoint::getFather
AbstractPoint * getFather() const
Definition: AbstractPoint.hxx:55

References getFather().

Referenced by YACS::ENGINE::BlocPoint::findPointWithNode(), and IsCommonDirectSonOf().

◆ getFather()

AbstractPoint * YACS::ENGINE::AbstractPoint::getFather ( ) const
inline

Definition at line 55 of file AbstractPoint.hxx.

55{ return _father; }

Referenced by YACS::ENGINE::ElementaryPoint::expandNonSimpleCaseOn(), YACS::ENGINE::LinkedBlocPoint::expandNonSimpleCaseOn(), GetDirectSonOf(), tryAsFork(), tryAsForkBis(), tryAsForkQuatro(), tryAsForkTer(), and tryAsLink().

◆ getFirstNode()

virtual Node * YACS::ENGINE::AbstractPoint::getFirstNode ( )
pure virtual

Implemented in YACS::ENGINE::BagPoint, YACS::ENGINE::ElementaryPoint, YACS::ENGINE::ForkBlocPoint, YACS::ENGINE::LinkedBlocPoint, and YACS::ENGINE::NotSimpleCasePoint.

Referenced by YACS::ENGINE::BagPoint::expandNonSimpleCaseOn(), YACS::ENGINE::BagPoint::getFirstNode(), isBegin(), isNullBeforeNullAfter(), isSimplyLinkedAfterNullBefore(), isSimplyLinkedBeforeAfter(), isSimplyLinkedBeforeNullAfter(), tryAsFork(), tryAsForkBis(), tryAsForkQuatro(), tryAsForkTer(), and tryAsLink().

◆ getGodFather()

AbstractPoint * AbstractPoint::getGodFather ( )

Definition at line 38 of file AbstractPoint.cxx.

39{
40 if(_father==0)
41 return this;
42 else
43 return _father->getGodFather();
44}

References _father, and getGodFather().

Referenced by getGodFather().

◆ getLastNode()

virtual Node * YACS::ENGINE::AbstractPoint::getLastNode ( )
pure virtual

Implemented in YACS::ENGINE::BagPoint, YACS::ENGINE::ElementaryPoint, YACS::ENGINE::ForkBlocPoint, YACS::ENGINE::LinkedBlocPoint, and YACS::ENGINE::NotSimpleCasePoint.

Referenced by YACS::ENGINE::BagPoint::expandNonSimpleCaseOn(), YACS::ENGINE::BagPoint::getLastNode(), isLast(), isNullBeforeNullAfter(), isSimplyLinkedAfterNullBefore(), isSimplyLinkedBeforeAfter(), isSimplyLinkedBeforeNullAfter(), tryAsFork(), tryAsForkBis(), tryAsForkQuatro(), tryAsForkTer(), and tryAsLink().

◆ getMaxLevelOfParallelism()

virtual int YACS::ENGINE::AbstractPoint::getMaxLevelOfParallelism ( ) const
pure virtual

Implemented in YACS::ENGINE::BagPoint, YACS::ENGINE::ElementaryPoint, YACS::ENGINE::ForkBlocPoint, YACS::ENGINE::LinkedBlocPoint, and YACS::ENGINE::NotSimpleCasePoint.

Referenced by YACS::ENGINE::BagPoint::getMaxLevelOfParallelism().

◆ GetNodeAfter()

Node * AbstractPoint::GetNodeAfter ( Node *  node)
static

Definition at line 507 of file AbstractPoint.cxx.

508{
509 OutGate *oug(node->getOutGate());
510 std::list<InGate *> fl(oug->edSetInGate());
511 if(fl.size()>1)
512 throw Exception("AbstractPoint::GetNodeAfter : precond not OK !");
513 if(fl.size()==0)
514 return 0;
515 return (*fl.begin())->getNode();
516}
YACS::ENGINE::Node::getOutGate
OutGate * getOutGate()
Definition: Node.hxx:124

References YACS::ENGINE::OutGate::edSetInGate(), and YACS::ENGINE::Node::getOutGate().

Referenced by tryAsFork(), tryAsForkBis(), tryAsForkQuatro(), and tryAsForkTer().

◆ GetNodeB4()

Node * AbstractPoint::GetNodeB4 ( Node *  node)
static

Definition at line 496 of file AbstractPoint.cxx.

497{
498 InGate *ing(node->getInGate());
499 std::list<OutGate *> bl(ing->getBackLinks());
500 if(bl.size()>1)
501 throw Exception("AbstractPoint::GetNodeB4 : precond not OK !");
502 if(bl.size()==0)
503 return 0;
504 return bl.front()->getNode();
505}
YACS::ENGINE::Node::getInGate
InGate * getInGate()
Definition: Node.hxx:123

References YACS::ENGINE::InGate::getBackLinks(), and YACS::ENGINE::Node::getInGate().

Referenced by tryAsFork(), tryAsForkBis(), tryAsForkQuatro(), and tryAsForkTer().

◆ getNumberOfNodes()

virtual int YACS::ENGINE::AbstractPoint::getNumberOfNodes ( ) const
pure virtual

Implemented in YACS::ENGINE::BlocPoint, and YACS::ENGINE::ElementaryPoint.

◆ getRepr()

virtual std::string YACS::ENGINE::AbstractPoint::getRepr ( ) const
pure virtual

Implemented in YACS::ENGINE::BagPoint, YACS::ENGINE::ElementaryPoint, YACS::ENGINE::ForkBlocPoint, YACS::ENGINE::LinkedBlocPoint, and YACS::ENGINE::NotSimpleCasePoint.

◆ getWeightRegardingDPL()

virtual void YACS::ENGINE::AbstractPoint::getWeightRegardingDPL ( ComplexWeight *  weight)
pure virtual

Implemented in YACS::ENGINE::BagPoint, YACS::ENGINE::ElementaryPoint, YACS::ENGINE::ForkBlocPoint, YACS::ENGINE::LinkedBlocPoint, and YACS::ENGINE::NotSimpleCasePoint.

Referenced by YACS::ENGINE::BagPoint::getWeightRegardingDPL().

◆ isBegin()

bool AbstractPoint::isBegin ( )

Definition at line 46 of file AbstractPoint.cxx.

47{
48 Node *beg(getFirstNode());
49 InGate *ing(beg->getInGate());
50 return ing->getBackLinks().empty();
51}
YACS::ENGINE::AbstractPoint::getFirstNode
virtual Node * getFirstNode()=0
YACS::ENGINE::Node
Base class for all nodes.
Definition: Node.hxx:70

References YACS::ENGINE::InGate::getBackLinks(), getFirstNode(), and YACS::ENGINE::Node::getInGate().

◆ IsCommonDirectSonOf() [1/2]

bool AbstractPoint::IsCommonDirectSonOf ( AbstractPoint *  refFather,
const std::list< InGate * > &  ings,
AbstractPoint *&  ret 
)
static

Definition at line 549 of file AbstractPoint.cxx.

550{
551 if(ings.size()<1)
552 throw YACS::Exception("AbstractPoint::GetCommonDirectSonOf2 : not enough !");
553 std::list<InGate *>::const_iterator it(ings.begin());
554 InGate *ref(*(it++));
555 AbstractPoint *ref2(GetDirectSonOf(refFather,refFather->findPointWithNode(ref->getNode())));
556 for(;it!=ings.end();it++)
557 {
558 if(!ref2->contains((*it)->getNode()))
559 return false;
560 }
561 ret=ref2;
562 return true;
563}
YACS::ENGINE::AbstractPoint::findPointWithNode
virtual AbstractPoint * findPointWithNode(Node *node)=0
YACS::ENGINE::AbstractPoint::GetDirectSonOf
static AbstractPoint * GetDirectSonOf(AbstractPoint *refFather, AbstractPoint *sonOrLittleSon)
Definition: AbstractPoint.cxx:518
gui.CONNECTOR.ref
def ref(target, callback=None)
Definition: CONNECTOR.py:120

References contains(), findPointWithNode(), GetDirectSonOf(), and gui.CONNECTOR::ref().

◆ IsCommonDirectSonOf() [2/2]

bool AbstractPoint::IsCommonDirectSonOf ( AbstractPoint *  refFather,
const std::list< OutGate * > &  outgs,
AbstractPoint *&  ret 
)
static

Definition at line 533 of file AbstractPoint.cxx.

534{
535 if(outgs.size()<1)
536 throw YACS::Exception("AbstractPoint::GetCommonDirectSonOf1 : not enough !");
537 std::list<OutGate *>::const_iterator it(outgs.begin());
538 OutGate *ref(*(it++));
539 AbstractPoint *ref2(GetDirectSonOf(refFather,refFather->findPointWithNode(ref->getNode())));
540 for(;it!=outgs.end();it++)
541 {
542 if(!ref2->contains((*it)->getNode()))
543 return false;
544 }
545 ret=ref2;
546 return true;
547}

References contains(), findPointWithNode(), GetDirectSonOf(), and gui.CONNECTOR::ref().

Referenced by YACS::ENGINE::BlocPoint::getNodeAfter(), YACS::ENGINE::BlocPoint::getNodeB4(), isSimplyLinkedAfter(), and isSimplyLinkedBefore().

◆ IsGatherB4Ext()

bool AbstractPoint::IsGatherB4Ext ( Node *  node)
static

Definition at line 436 of file AbstractPoint.cxx.

437{
438 InGate *ing(node->getInGate());
439 return ing->getBackLinks().size()!=1;
440}

References YACS::ENGINE::InGate::getBackLinks(), and YACS::ENGINE::Node::getInGate().

Referenced by tryAsLink().

◆ isLast()

bool AbstractPoint::isLast ( )

Definition at line 53 of file AbstractPoint.cxx.

54{
55 Node *endd(getLastNode());
56 OutGate *oug(endd->getOutGate());
57 return oug->edSetInGate().empty();
58}
YACS::ENGINE::AbstractPoint::getLastNode
virtual Node * getLastNode()=0

References YACS::ENGINE::OutGate::edSetInGate(), getLastNode(), and YACS::ENGINE::Node::getOutGate().

◆ IsNoLinksAfter()

bool AbstractPoint::IsNoLinksAfter ( Node *  node)
static

Definition at line 490 of file AbstractPoint.cxx.

491{
492 OutGate *oug(node->getOutGate());
493 return oug->edSetInGate().size()==0;
494}

References YACS::ENGINE::OutGate::edSetInGate(), and YACS::ENGINE::Node::getOutGate().

Referenced by isNullBeforeNullAfter(), isSimplyLinkedBeforeNullAfter(), tryAsForkQuatro(), and tryAsForkTer().

◆ IsNoLinksBefore()

bool AbstractPoint::IsNoLinksBefore ( Node *  node)
static

Definition at line 484 of file AbstractPoint.cxx.

485{
486 InGate *ing(node->getInGate());
487 return ing->getBackLinks().size()==0;
488}

References YACS::ENGINE::InGate::getBackLinks(), and YACS::ENGINE::Node::getInGate().

Referenced by isNullBeforeNullAfter(), isSimplyLinkedAfterNullBefore(), tryAsForkBis(), and tryAsForkQuatro().

◆ isNullBeforeNullAfter()

bool AbstractPoint::isNullBeforeNullAfter ( BlocPoint *  sop)

Definition at line 78 of file AbstractPoint.cxx.

79{
80 Node *beg(getFirstNode()),*endd(getLastNode());
81 return IsNoLinksBefore(beg) && IsNoLinksAfter(endd);
82}
YACS::ENGINE::AbstractPoint::IsNoLinksAfter
static bool IsNoLinksAfter(Node *node)
Definition: AbstractPoint.cxx:490
YACS::ENGINE::AbstractPoint::IsNoLinksBefore
static bool IsNoLinksBefore(Node *node)
Definition: AbstractPoint.cxx:484

References getFirstNode(), getLastNode(), IsNoLinksAfter(), and IsNoLinksBefore().

◆ IsScatterAfterExt()

bool AbstractPoint::IsScatterAfterExt ( Node *  node)
static

Definition at line 460 of file AbstractPoint.cxx.

461{
462 OutGate *oug(node->getOutGate());
463 return oug->edSetInGate().size()!=1;
464}

References YACS::ENGINE::OutGate::edSetInGate(), and YACS::ENGINE::Node::getOutGate().

Referenced by tryAsLink().

◆ isSimplyLinkedAfter()

bool AbstractPoint::isSimplyLinkedAfter ( BlocPoint *  sop,
Node *  node 
)

Definition at line 442 of file AbstractPoint.cxx.

443{
444 OutGate *oug(node->getOutGate());
445 std::list<InGate *> ings(oug->edSetInGate());
446 if(ings.size()==1)
447 return true;
448 if(ings.size()==0)
449 return false;
450 AbstractPoint *dummy=0;
451 return IsCommonDirectSonOf(sop,ings,dummy);
452}
YACS::ENGINE::AbstractPoint::IsCommonDirectSonOf
static bool IsCommonDirectSonOf(AbstractPoint *refFather, const std::list< OutGate * > &outgs, AbstractPoint *&ret)
Definition: AbstractPoint.cxx:533

References YACS::ENGINE::OutGate::edSetInGate(), YACS::ENGINE::Node::getOutGate(), and IsCommonDirectSonOf().

Referenced by isSimplyLinkedAfterNullBefore(), isSimplyLinkedBeforeAfter(), and tryAsLink().

◆ IsSimplyLinkedAfterExt()

bool AbstractPoint::IsSimplyLinkedAfterExt ( Node *  node)
static

Definition at line 454 of file AbstractPoint.cxx.

455{
456 OutGate *oug(node->getOutGate());
457 return oug->edSetInGate().size()<=1;
458}

References YACS::ENGINE::OutGate::edSetInGate(), and YACS::ENGINE::Node::getOutGate().

Referenced by tryAsFork(), and tryAsForkBis().

◆ isSimplyLinkedAfterNullBefore()

bool AbstractPoint::isSimplyLinkedAfterNullBefore ( BlocPoint *  sop)

Definition at line 66 of file AbstractPoint.cxx.

67{
68 Node *beg(getFirstNode()),*endd(getLastNode());
69 return IsNoLinksBefore(beg) && isSimplyLinkedAfter(sop,endd);
70}
YACS::ENGINE::AbstractPoint::isSimplyLinkedAfter
bool isSimplyLinkedAfter(BlocPoint *sop, Node *node)
Definition: AbstractPoint.cxx:442

References getFirstNode(), getLastNode(), IsNoLinksBefore(), and isSimplyLinkedAfter().

◆ isSimplyLinkedBefore()

bool AbstractPoint::isSimplyLinkedBefore ( BlocPoint *  sop,
Node *  node 
)

Definition at line 466 of file AbstractPoint.cxx.

467{
468 InGate *ing(node->getInGate());
469 std::list<OutGate *> outgs(ing->getBackLinks());
470 if(outgs.size()==1)
471 return true;
472 if(outgs.size()==0)
473 return false;
474 AbstractPoint *dummy=0;
475 return IsCommonDirectSonOf(sop,outgs,dummy);
476}

References YACS::ENGINE::InGate::getBackLinks(), YACS::ENGINE::Node::getInGate(), and IsCommonDirectSonOf().

Referenced by isSimplyLinkedBeforeAfter(), isSimplyLinkedBeforeNullAfter(), and tryAsLink().

◆ isSimplyLinkedBeforeAfter()

bool AbstractPoint::isSimplyLinkedBeforeAfter ( BlocPoint *  sop)

Definition at line 60 of file AbstractPoint.cxx.

61{
62 Node *beg(getFirstNode()),*endd(getLastNode());
63 return isSimplyLinkedBefore(sop,beg) && isSimplyLinkedAfter(sop,endd);
64}
YACS::ENGINE::AbstractPoint::isSimplyLinkedBefore
bool isSimplyLinkedBefore(BlocPoint *sop, Node *node)
Definition: AbstractPoint.cxx:466

References getFirstNode(), getLastNode(), isSimplyLinkedAfter(), and isSimplyLinkedBefore().

Referenced by tryAsLink().

◆ IsSimplyLinkedBeforeExt()

bool AbstractPoint::IsSimplyLinkedBeforeExt ( Node *  node)
static

Definition at line 478 of file AbstractPoint.cxx.

479{
480 InGate *ing(node->getInGate());
481 return ing->getBackLinks().size()<=1;
482}

References YACS::ENGINE::InGate::getBackLinks(), and YACS::ENGINE::Node::getInGate().

Referenced by tryAsFork(), and tryAsForkTer().

◆ isSimplyLinkedBeforeNullAfter()

bool AbstractPoint::isSimplyLinkedBeforeNullAfter ( BlocPoint *  sop)

Definition at line 72 of file AbstractPoint.cxx.

73{
74 Node *beg(getFirstNode()),*endd(getLastNode());
75 return IsNoLinksAfter(endd) && isSimplyLinkedBefore(sop,beg);
76}

References getFirstNode(), getLastNode(), IsNoLinksAfter(), and isSimplyLinkedBefore().

◆ partitionRegardingDPL()

virtual void YACS::ENGINE::AbstractPoint::partitionRegardingDPL ( const PartDefinition *  pd,
std::map< ComposedNode *, YACS::BASES::AutoRefCnt< PartDefinition > > &  zeMap 
) const
pure virtual

Implemented in YACS::ENGINE::BagPoint, YACS::ENGINE::ElementaryPoint, YACS::ENGINE::ForkBlocPoint, YACS::ENGINE::LinkedBlocPoint, and YACS::ENGINE::NotSimpleCasePoint.

Referenced by YACS::ENGINE::BagPoint::partitionRegardingDPL().

◆ Rewire()

void AbstractPoint::Rewire ( const std::vector< AbstractPoint * > &  ptsToKill,
std::map< std::string, std::tuple< ElementaryPoint *, Node *, std::shared_ptr< Bloc > > > *  m 
)
static

This method go throw all ElementaryPoints of m. For each ElementaryPoint change the Node instance underneath. And then create links between those new Node by excluding all links going whose destination :

  • is inside ptToKill
  • is not refered by m

CF links of old nodes are NOT touched for unrewire phase. Typically all ElementaryPoints inside ptToKill are NOT into m.

Definition at line 322 of file AbstractPoint.cxx.

323{
324 for(auto it : *m)
325 {
326 ElementaryPoint *pt(std::get<0>(it.second));
327 Node *node(std::get<1>(it.second));
328 auto newNode(std::get<2>(it.second).get());
329 pt->setNode(newNode);
330 }
331 for(auto it : *m)
332 {
333 ElementaryPoint *pt(std::get<0>(it.second));
334 Node *node(std::get<1>(it.second));
335 auto newNode(std::get<2>(it.second).get());
336 if(containsPtsToKill(ptsToKill,newNode))
337 continue;
338 for(auto it2 : node->getOutGate()->edSetInGate())
339 {
340 Node *nodeFwd(it2->getNode());
341 std::string nodeFwdName(nodeFwd->getName());
342 auto it3(m->find(nodeFwdName));
343 if(it3!=m->end())
344 {
345 Node *nodeFwdNew = std::get<2>(it3->second).get();
346 if(!containsPtsToKill(ptsToKill,newNode))
347 {
348 newNode->getOutGate()->edAddInGate(nodeFwdNew->getInGate());
349 }
350 //else
351 // node after nodeFwd is not in m fall into \a ptToKill
352 // -> ignore link.
353 }
354 //else
355 // node after nodeFwd is not in m. Typically because nodeFwd has not been put in m
356 // concretely : do not link incoming links to Node * inside ptToKill
357 }
358 }
359}
containsPtsToKill
bool containsPtsToKill(const std::vector< AbstractPoint * > &ptsToKill, Node *node)
Definition: AbstractPoint.cxx:305
YACS::ENGINE::OutGate::edAddInGate
bool edAddInGate(InGate *inGate)
Definition: OutGate.cxx:98

References containsPtsToKill(), YACS::ENGINE::OutGate::edAddInGate(), YACS::ENGINE::OutGate::edSetInGate(), YACS::ENGINE::Node::getInGate(), YACS::ENGINE::Node::getName(), YACS::ENGINE::Node::getOutGate(), gui.GraphViewer::m, and YACS::ENGINE::ElementaryPoint::setNode().

Referenced by TryAsNotSimpleCase().

◆ setFather()

void YACS::ENGINE::AbstractPoint::setFather ( AbstractPoint *  father)
inline

Definition at line 58 of file AbstractPoint.hxx.

58{ _father=father; }

Referenced by YACS::ENGINE::BlocPoint::BlocPoint(), YACS::ENGINE::BagPoint::deepCopy(), YACS::ENGINE::ElementaryPoint::deepCopy(), YACS::ENGINE::ForkBlocPoint::deepCopy(), YACS::ENGINE::LinkedBlocPoint::deepCopy(), YACS::ENGINE::NotSimpleCasePoint::deepCopy(), YACS::ENGINE::ElementaryPoint::expandNonSimpleCaseOn(), YACS::ENGINE::ForkBlocPoint::expandNonSimpleCaseOn(), YACS::ENGINE::LinkedBlocPoint::expandNonSimpleCaseOn(), YACS::ENGINE::BlocPoint::getOutPoint(), and TryAsNotSimpleCase().

◆ tryAsFork()

ForkBlocPoint * AbstractPoint::tryAsFork ( BlocPoint *  sop)

precondition : isSimplyLinkedBeforeAfter must return true on this.

Definition at line 145 of file AbstractPoint.cxx.

146{
147 Node *bb(GetNodeB4(getFirstNode())),*ee(GetNodeAfter(getLastNode()));
148 AbstractPoint *bb2(sop->findPointWithNode(bb)),*ee2(sop->findPointWithNode(ee));
149 //
150 const std::list<AbstractPoint *>& lp(sop->getListOfPoints());
151 std::list<AbstractPoint *> l; l.push_back(this);
152 for(std::list<AbstractPoint *>::const_iterator it=lp.begin();it!=lp.end();it++)
153 {
154 if(*it==this)
155 continue;
156 if(dynamic_cast<NotSimpleCasePoint *>(*it))
157 continue;
158 Node *curFirst((*it)->getFirstNode()),*curEnd((*it)->getLastNode());
159 if(!IsSimplyLinkedBeforeExt(curFirst) || !IsSimplyLinkedAfterExt(curEnd))
160 continue;
161 Node *curbb(GetNodeB4(curFirst)),*curee(GetNodeAfter(curEnd));
162 AbstractPoint *bb3(sop->findPointWithNode(curbb)),*ee3(sop->findPointWithNode(curee));
163 if(bb2==bb3 && ee2==ee3)
164 l.push_back(*it);
165 }
166 if(l.size()>1)
167 {
168 return new ForkBlocPoint(l,getFather());
169 }
170 else
171 return nullptr;
172}
YACS::ENGINE::AbstractPoint::IsSimplyLinkedBeforeExt
static bool IsSimplyLinkedBeforeExt(Node *node)
Definition: AbstractPoint.cxx:478
YACS::ENGINE::AbstractPoint::IsSimplyLinkedAfterExt
static bool IsSimplyLinkedAfterExt(Node *node)
Definition: AbstractPoint.cxx:454
YACS::ENGINE::AbstractPoint::GetNodeB4
static Node * GetNodeB4(Node *node)
Definition: AbstractPoint.cxx:496
YACS::ENGINE::AbstractPoint::GetNodeAfter
static Node * GetNodeAfter(Node *node)
Definition: AbstractPoint.cxx:507
YACS::ENGINE::BlocPoint::findPointWithNode
AbstractPoint * findPointWithNode(Node *node)
Definition: BlocPoint.cxx:52
YACS::ENGINE::BlocPoint::getListOfPoints
const std::list< AbstractPoint * > & getListOfPoints() const
Definition: BlocPoint.hxx:46

References YACS::ENGINE::BlocPoint::findPointWithNode(), getFather(), getFirstNode(), getLastNode(), YACS::ENGINE::BlocPoint::getListOfPoints(), GetNodeAfter(), GetNodeB4(), IsSimplyLinkedAfterExt(), IsSimplyLinkedBeforeExt(), and testCppPluginInvokation::l.

◆ tryAsForkBis()

ForkBlocPoint * AbstractPoint::tryAsForkBis ( BlocPoint *  sop)

Definition at line 174 of file AbstractPoint.cxx.

175{
176 Node *bb(GetNodeB4(getFirstNode())),*ee(GetNodeAfter(getLastNode()));
177 AbstractPoint *ee2(sop->findPointWithNode(ee));
178 //
179 const std::list<AbstractPoint *>& lp(sop->getListOfPoints());
180 std::list<AbstractPoint *> l; l.push_back(this);
181 for(std::list<AbstractPoint *>::const_iterator it=lp.begin();it!=lp.end();it++)
182 {
183 if(*it==this)
184 continue;
185 if(dynamic_cast<NotSimpleCasePoint *>(*it))
186 continue;
187 Node *curFirst((*it)->getFirstNode()),*curEnd((*it)->getLastNode());
188 if(!IsNoLinksBefore(curFirst) || !IsSimplyLinkedAfterExt(curEnd))
189 continue;
190 Node *curee(GetNodeAfter(curEnd));
191 AbstractPoint *ee3(sop->findPointWithNode(curee));
192 if(ee2==ee3)
193 l.push_back(*it);
194 }
195 if(l.size()>1)
196 {
197 return new ForkBlocPoint(l,getFather());
198 }
199 else
200 return nullptr;
201}

References YACS::ENGINE::BlocPoint::findPointWithNode(), getFather(), getFirstNode(), getLastNode(), YACS::ENGINE::BlocPoint::getListOfPoints(), GetNodeAfter(), GetNodeB4(), IsNoLinksBefore(), IsSimplyLinkedAfterExt(), and testCppPluginInvokation::l.

◆ tryAsForkQuatro()

ForkBlocPoint * AbstractPoint::tryAsForkQuatro ( BlocPoint *  sop)

Definition at line 232 of file AbstractPoint.cxx.

233{
234 Node *bb(GetNodeB4(getFirstNode())),*ee(GetNodeAfter(getLastNode()));
235 AbstractPoint *bb2(sop->findPointWithNode(bb));
236 //
237 const std::list<AbstractPoint *>& lp(sop->getListOfPoints());
238 std::list<AbstractPoint *> l; l.push_back(this);
239 for(std::list<AbstractPoint *>::const_iterator it=lp.begin();it!=lp.end();it++)
240 {
241 if(*it==this)
242 continue;
243 if(dynamic_cast<NotSimpleCasePoint *>(*it))
244 continue;
245 Node *curFirst((*it)->getFirstNode()),*curEnd((*it)->getLastNode());
246 if(!IsNoLinksBefore(curFirst) || !IsNoLinksAfter(curEnd))
247 continue;
248 Node *curbb(GetNodeB4(curFirst));
249 AbstractPoint *bb3(sop->findPointWithNode(curbb));
250 if(bb2==bb3)
251 l.push_back(*it);
252 }
253 if(l.size()>1)
254 {
255 return new ForkBlocPoint(l,getFather());
256 }
257 else
258 return nullptr;
259}

References YACS::ENGINE::BlocPoint::findPointWithNode(), getFather(), getFirstNode(), getLastNode(), YACS::ENGINE::BlocPoint::getListOfPoints(), GetNodeAfter(), GetNodeB4(), IsNoLinksAfter(), IsNoLinksBefore(), and testCppPluginInvokation::l.

◆ tryAsForkTer()

ForkBlocPoint * AbstractPoint::tryAsForkTer ( BlocPoint *  sop)

Definition at line 203 of file AbstractPoint.cxx.

204{
205 Node *bb(GetNodeB4(getFirstNode())),*ee(GetNodeAfter(getLastNode()));
206 AbstractPoint *bb2(sop->findPointWithNode(bb));
207 //
208 const std::list<AbstractPoint *>& lp(sop->getListOfPoints());
209 std::list<AbstractPoint *> l; l.push_back(this);
210 for(std::list<AbstractPoint *>::const_iterator it=lp.begin();it!=lp.end();it++)
211 {
212 if(*it==this)
213 continue;
214 if(dynamic_cast<NotSimpleCasePoint *>(*it))
215 continue;
216 Node *curFirst((*it)->getFirstNode()),*curEnd((*it)->getLastNode());
217 if(!IsSimplyLinkedBeforeExt(curFirst) || !IsNoLinksAfter(curEnd))
218 continue;
219 Node *curbb(GetNodeB4(curFirst));
220 AbstractPoint *bb3(sop->findPointWithNode(curbb));
221 if(bb2==bb3)
222 l.push_back(*it);
223 }
224 if(l.size()>1)
225 {
226 return new ForkBlocPoint(l,getFather());
227 }
228 else
229 return nullptr;
230}

References YACS::ENGINE::BlocPoint::findPointWithNode(), getFather(), getFirstNode(), getLastNode(), YACS::ENGINE::BlocPoint::getListOfPoints(), GetNodeAfter(), GetNodeB4(), IsNoLinksAfter(), IsSimplyLinkedBeforeExt(), and testCppPluginInvokation::l.

◆ tryAsLink()

LinkedBlocPoint * AbstractPoint::tryAsLink ( BlocPoint *  sop)

precondition : isSimplyLinkedBeforeAfter must return true on this.

Definition at line 87 of file AbstractPoint.cxx.

88{
89 Node *bb(getFirstNode()),*ee(getLastNode());
90 std::list<AbstractPoint *> l; l.push_back(this);
91 AbstractPoint *cur2(0);
92 //
93 cur2=sop->getNodeB4(bb);
94 while(cur2)
95 {
96 if(dynamic_cast<NotSimpleCasePoint *>(cur2))
97 continue;
98 Node *cur3(cur2->getFirstNode());
99 if(cur2->isSimplyLinkedBeforeAfter(sop))
100 {
101 l.push_front(cur2);
102 cur2=sop->getNodeB4(cur3);
103 continue;
104 }
105 else if(IsGatherB4Ext(cur3) && isSimplyLinkedAfter(sop,cur2->getLastNode()))
106 {
107 l.push_front(cur2);
108 break;
109 }
110 else
111 break;
112 }
113 //
114 cur2=sop->getNodeAfter(ee);
115 while(cur2)
116 {
117 if(dynamic_cast<NotSimpleCasePoint *>(cur2))
118 continue;
119 Node *cur3(cur2->getLastNode());
120 if(cur2->isSimplyLinkedBeforeAfter(sop))
121 {
122 l.push_back(cur2);
123 cur2=sop->getNodeAfter(cur3);
124 continue;
125 }
126 else if(IsScatterAfterExt(cur3) && isSimplyLinkedBefore(sop,cur2->getFirstNode()))
127 {
128 l.push_back(cur2);
129 break;
130 }
131 else
132 break;
133 }
134 if(l.size()>1)
135 {
136 return new LinkedBlocPoint(l,getFather());
137 }
138 else
139 return nullptr;
140}
YACS::ENGINE::AbstractPoint::IsScatterAfterExt
static bool IsScatterAfterExt(Node *node)
Definition: AbstractPoint.cxx:460
YACS::ENGINE::AbstractPoint::IsGatherB4Ext
static bool IsGatherB4Ext(Node *node)
Definition: AbstractPoint.cxx:436
YACS::ENGINE::BlocPoint::getNodeB4
AbstractPoint * getNodeB4(Node *node)
Definition: BlocPoint.cxx:77
YACS::ENGINE::BlocPoint::getNodeAfter
AbstractPoint * getNodeAfter(Node *node)
Definition: BlocPoint.cxx:63

References getFather(), getFirstNode(), getLastNode(), YACS::ENGINE::BlocPoint::getNodeAfter(), YACS::ENGINE::BlocPoint::getNodeB4(), IsGatherB4Ext(), IsScatterAfterExt(), isSimplyLinkedAfter(), isSimplyLinkedBefore(), isSimplyLinkedBeforeAfter(), and testCppPluginInvokation::l.

◆ TryAsNotSimpleCase()

void AbstractPoint::TryAsNotSimpleCase ( AbstractPoint *  father,
const std::vector< AbstractPoint * > &  ptsToKill,
std::list< AbstractPoint * > &  nodes,
bool &  somethingDone 
)
static

This methods tries to deal with sop that can t be considered as a composite of Link, Fork.

Do do so, this methods tries to exclude this from sop and then analyze if the graph can be decomposited into Links and Forks. If yes somethingDone is set to true and nodes is updated in consequence.

If the algorithm fails nodes are let untouched and somethingDone is let false.

Definition at line 396 of file AbstractPoint.cxx.

397{
398 std::list<AbstractPoint *> lp2;
399 for(auto it : nodes)
400 {
401 if(std::find(ptsToKill.cbegin(),ptsToKill.cend(),it)==ptsToKill.cend())
402 lp2.push_back(it->deepCopy(nullptr));
403 }
404 BagPoint *tmp(new BagPoint(lp2,nullptr));
405 for(auto it : lp2)
406 it->setFather(tmp);
407 SetOfPoints sopTest(tmp);
408 std::map< std::string, std::tuple< ElementaryPoint *, Node *, std::shared_ptr<Bloc> > > m;
409 FeedData(tmp,&m);
410 Rewire(ptsToKill,&m);
411 try
412 {
413 sopTest.basicSimplify();
414 }
415 catch(YACS::Exception& ex)
416 {// By removing elements in ptsToKill from this impossible to have a classical case -> un rewire to rollback nodes state
417 UnRewire(m);
418 return ;
419 }
420 AbstractPoint *pt(sopTest.getUniqueAndReleaseIt());
421 pt->setFather(father);
422 UnRewire(m);
423 for(auto it : nodes)
424 if(std::find(ptsToKill.cbegin(),ptsToKill.cend(),it)==ptsToKill.cend())
425 delete it;
426 nodes.clear();
427 nodes.push_back(pt);
428 for(auto it : ptsToKill)
429 {
430 std::list<AbstractPoint *> l; l.push_back(it);
431 nodes.push_back( new NotSimpleCasePoint(l,father) );
432 }
433 somethingDone = true;
434}
YACS::ENGINE::AbstractPoint::Rewire
static void Rewire(const std::vector< AbstractPoint * > &ptsToKill, std::map< std::string, std::tuple< ElementaryPoint *, Node *, std::shared_ptr< Bloc > > > *m)
Definition: AbstractPoint.cxx:322
YACS::ENGINE::AbstractPoint::UnRewire
static void UnRewire(std::map< std::string, std::tuple< ElementaryPoint *, Node *, std::shared_ptr< Bloc > > > &m)
Definition: AbstractPoint.cxx:365

References YACS::ENGINE::SetOfPoints::basicSimplify(), testCppPluginInvokation::ex, FeedData(), YACS::ENGINE::SetOfPoints::getUniqueAndReleaseIt(), testCppPluginInvokation::l, gui.GraphViewer::m, Rewire(), setFather(), and UnRewire().

Referenced by YACS::ENGINE::BagPoint::dealNotSimpleCase().

◆ UnRewire()

void AbstractPoint::UnRewire ( std::map< std::string, std::tuple< ElementaryPoint *, Node *, std::shared_ptr< Bloc > > > &  m)
static

Unrewire consists into replacing newly created nodes into old one in ElementaryPoints contained in m. As CF links of old ENGINE::Node * has not be touched the CF graph is the same.

Definition at line 365 of file AbstractPoint.cxx.

366{
367 for(auto it : m)
368 {
369 ElementaryPoint *pt(std::get<0>(it.second));
370 Node *node(std::get<1>(it.second));
371 pt->setNode(node);
372 }
373}

References gui.GraphViewer::m, and YACS::ENGINE::ElementaryPoint::setNode().

Referenced by TryAsNotSimpleCase().

Member Data Documentation

◆ _father

AbstractPoint* YACS::ENGINE::AbstractPoint::_father = nullptr
protected

Definition at line 110 of file AbstractPoint.hxx.

Referenced by getGodFather().

The documentation for this class was generated from the following files: