#include <BagPoint.hxx>

Inheritance diagram for YACS::ENGINE::BagPoint:

Collaboration diagram for YACS::ENGINE::BagPoint:

[legend]

Public Member Functions
	BagPoint ()=default

	BagPoint (const std::list< AbstractPoint * > &nodes, AbstractPoint *father)

AbstractPoint *	deepCopy (AbstractPoint *father) const override

Node *	getFirstNode () override

Node *	getLastNode () override

int	getMaxLevelOfParallelism () const

void	getWeightRegardingDPL (ComplexWeight *weight)

void	partitionRegardingDPL (const PartDefinition pd, std::map< ComposedNode , YACS::BASES::AutoRefCnt< PartDefinition > > &zeMap) const

std::string	getRepr () const

void	accept (PointVisitor *pv) override

AbstractPoint *	expandNonSimpleCaseOn (NotSimpleCasePoint pathologicalPt, const std::set< Node > &uncatchedNodes) override

int	size () const

void	replaceInMe (BlocPoint *aSet)

void	deal1 (bool &somethingDone)

void	deal2 (bool &somethingDone)

void	deal2Bis (bool &somethingDone)

void	deal2Ter (bool &somethingDone)

void	deal2Quatro (bool &somethingDone)

void	dealNotSimpleCase (bool &somethingDone)

void	expandNonSimpleCase ()

Public Member Functions inherited from YACS::ENGINE::BlocPoint
	BlocPoint ()=default

	BlocPoint (const std::list< AbstractPoint * > &nodes, AbstractPoint *father)

void	deepCopyFrom (const BlocPoint &other)

AbstractPoint *	findPointWithNode (Node *node)

AbstractPoint *	getNodeAfter (Node *node)

AbstractPoint *	getNodeB4 (Node *node)

bool	contains (Node *node) const override

bool	anyOf (const std::set< Node * > &nodes) const override

int	getNumberOfNodes () const

const std::list< AbstractPoint * > &	getListOfPoints () const

virtual	~BlocPoint ()

bool	internalContinueForSimplify () const

bool	presenceOfNonSimpleCase () const

AbstractPoint *	getUnique ()

const AbstractPoint *	getUnique () const

AbstractPoint *	getUniqueAndReleaseIt ()

Public Member Functions inherited from YACS::ENGINE::AbstractPoint
	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 ()

bool	isSimplyLinkedAfter (BlocPoint sop, Node node)

bool	isSimplyLinkedBefore (BlocPoint sop, Node node)

Private Member Functions
void	expandNonSimpleCaseOn (AbstractPoint *pathologicalPt)

Additional Inherited Members
Static Public Member Functions inherited from YACS::ENGINE::AbstractPoint
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 Member Functions inherited from YACS::ENGINE::BlocPoint
void	getOutPoint (AbstractPoint *node)

Protected Attributes inherited from YACS::ENGINE::BlocPoint
std::list< AbstractPoint * >	_nodes

Protected Attributes inherited from YACS::ENGINE::AbstractPoint
AbstractPoint *	_father = nullptr

Detailed Description

Definition at line 32 of file BagPoint.hxx.

Constructor & Destructor Documentation

◆ BagPoint() [1/2]

YACS::ENGINE::BagPoint::BagPoint ( )

default

◆ BagPoint() [2/2]

BagPoint::BagPoint	(	const std::list< AbstractPoint * > &	nodes,
		AbstractPoint *	father
	)

Definition at line 34 of file BagPoint.cxx.

                                                                               :BlocPoint(nodes,father)
 {
 }

Member Function Documentation

◆ accept()

void BagPoint::accept ( PointVisitor * pv )

overridevirtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 38 of file BagPoint.cxx.

 {
   for(auto it : _nodes)
     {
       if(!it)
         throw YACS::Exception("BagPoint::accept : Ooops !");
       it->accept(pv);
     }
 }

References YACS::ENGINE::BlocPoint::_nodes.

Referenced by YACS::ENGINE::SetOfPoints::accept().

◆ deal1()

void BagPoint::deal1 ( bool & somethingDone )

Definition at line 109 of file BagPoint.cxx.

 {
   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;
         }
     }
 }

References YACS::ENGINE::BlocPoint::_nodes, and replaceInMe().

Referenced by YACS::ENGINE::SetOfPoints::basicSimplify(), and YACS::ENGINE::SetOfPoints::simplify().

◆ deal2()

void BagPoint::deal2 ( bool & somethingDone )

Definition at line 127 of file BagPoint.cxx.

 {
   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;
         }
     }
 }

References YACS::ENGINE::BlocPoint::_nodes, and replaceInMe().

Referenced by YACS::ENGINE::SetOfPoints::basicSimplify(), and YACS::ENGINE::SetOfPoints::simplify().

◆ deal2Bis()

void BagPoint::deal2Bis ( bool & somethingDone )

Definition at line 144 of file BagPoint.cxx.

 {
   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;
         }
     }
 }

References YACS::ENGINE::BlocPoint::_nodes, and replaceInMe().

Referenced by YACS::ENGINE::SetOfPoints::basicSimplify(), and YACS::ENGINE::SetOfPoints::simplify().

◆ deal2Quatro()

void BagPoint::deal2Quatro ( bool & somethingDone )

Definition at line 178 of file BagPoint.cxx.

 {
   somethingDone=false;
   for(std::list<AbstractPoint *>::iterator it=_nodes.begin();it!=_nodes.end();it++)
     {
       if(!(*it)->isNullBeforeNullAfter(this))
         continue;
       ForkBlocPoint *try1((*it)->tryAsForkQuatro(this));
       if(try1)
         {
           replaceInMe(try1);
           somethingDone=true;
           break;
         }
       }
 }

References YACS::ENGINE::BlocPoint::_nodes, and replaceInMe().

Referenced by YACS::ENGINE::SetOfPoints::basicSimplify(), and YACS::ENGINE::SetOfPoints::simplify().

◆ deal2Ter()

void BagPoint::deal2Ter ( bool & somethingDone )

Definition at line 161 of file BagPoint.cxx.

 {
   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;
         }
       }
 }

References YACS::ENGINE::BlocPoint::_nodes, and replaceInMe().

Referenced by YACS::ENGINE::SetOfPoints::basicSimplify(), and YACS::ENGINE::SetOfPoints::simplify().

◆ dealNotSimpleCase()

void BagPoint::dealNotSimpleCase ( bool & somethingDone )

This method remove 1, 2 or 3 points from this by flagging them as pathological nodes. By doing so, we hope to simplify enough to have a standart case.

Definition at line 199 of file BagPoint.cxx.

 {
   somethingDone=false;
   for(auto it=_nodes.begin();it!=_nodes.end();it++)
     {
       std::vector<AbstractPoint *> v{*it};
       AbstractPoint::TryAsNotSimpleCase((*it)->getFather(),v,_nodes,somethingDone);
       if(somethingDone)
         break;
     }
   if(somethingDone)
     return ;
   //
   for(auto it=_nodes.cbegin();it!=_nodes.cend();it++)
     {
       auto it2(it); it2++;
       for(;it2!=_nodes.cend();it2++)
         {
           std::vector<AbstractPoint *> v{*it,*it2};
           AbstractPoint::TryAsNotSimpleCase((*it)->getFather(),v,_nodes,somethingDone);
           if(somethingDone)
             return;
         }
     }
   if(somethingDone)
     return ;
   //
   for(auto it=_nodes.cbegin();it!=_nodes.cend();it++)
     {
       auto it2(it); it2++;
       for(;it2!=_nodes.cend();it2++)
         {
           auto it3(it2); it3++;
           for(;it3!=_nodes.cend();it3++)
             {
               std::vector<AbstractPoint *> v{*it,*it2,*it3};
               AbstractPoint::TryAsNotSimpleCase((*it)->getFather(),v,_nodes,somethingDone);
               if(somethingDone)
                 return;
             }
         }
     }
 }

References YACS::ENGINE::BlocPoint::_nodes, and YACS::ENGINE::AbstractPoint::TryAsNotSimpleCase().

Referenced by YACS::ENGINE::SetOfPoints::simplify().

◆ deepCopy()

AbstractPoint * BagPoint::deepCopy ( AbstractPoint * father ) const

overridevirtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 53 of file BagPoint.cxx.

 {
   BagPoint *ret(new BagPoint);
   ret->deepCopyFrom(*this);
   ret->setFather(father);
   return ret;
 }

References YACS::ENGINE::BlocPoint::deepCopyFrom(), and YACS::ENGINE::AbstractPoint::setFather().

◆ expandNonSimpleCase()

void BagPoint::expandNonSimpleCase ( )

All NotSimpleCasePoint instances in this->_nodes are going to be scanned recursively accross this->_nodes. To do that NotSimpleCasePoint instance are added incrementaly.

Definition at line 297 of file BagPoint.cxx.

 {
   std::vector<AbstractPoint *> pathologicalPt;
   std::for_each(_nodes.begin(),_nodes.end(),[&pathologicalPt](AbstractPoint *elt) { if(dynamic_cast<NotSimpleCasePoint *>(elt)) pathologicalPt.push_back(elt); });
   if(pathologicalPt.empty())
     throw YACS::Exception("BagPoint::expandNonSimpleCase : Not found any pathological case !");
   for(auto it : pathologicalPt)
     this->expandNonSimpleCaseOn(it);
   
 }

References YACS::ENGINE::BlocPoint::_nodes, and expandNonSimpleCaseOn().

Referenced by YACS::ENGINE::SetOfPoints::simplify().

◆ expandNonSimpleCaseOn() [1/2]

void BagPoint::expandNonSimpleCaseOn ( AbstractPoint * pathologicalPt )

private

Append a single pathologicalPt point instance to AbstractPoint instances contained in this. To do that we start to locate in graph dependancy in this with ENGINE::Node cannot run in parallel with pathologicalPt. These nodes stored in nodesBeforeAfter.

By walking across Points in this if a Point has no intersection with nodesBeforeAfter this Point is converted to a ForkBlocPoint.

Definition at line 249 of file BagPoint.cxx.

 {
   NotSimpleCasePoint *pathologicalPt2(dynamic_cast<NotSimpleCasePoint *>(pathologicalPt));
   if(!pathologicalPt2)
     throw YACS::Exception("BagPoint::expandNonSimpleCaseOn : pathologicalPt is expected to be a NotSimpleCasePoint !");
   std::list<AbstractPoint *> nodes2;
   std::for_each(_nodes.begin(),_nodes.end(),[&nodes2](AbstractPoint *elt) { if(!dynamic_cast<NotSimpleCasePoint *>(elt)) nodes2.push_back(elt); });
   if(nodes2.size()!=1)
     throw YACS::Exception("BagPoint::expandNonSimpleCaseOn : Internal error only one AbstractPoint is expected !");
   
   Node *firstNode(pathologicalPt->getFirstNode()),*lastNode(pathologicalPt->getLastNode());
   //
   ComposedNode *parent(firstNode->getFather());
   Bloc *parentc(dynamic_cast<Bloc *>(parent));
   if(!parentc)
     throw YACS::Exception("BagPoint::expandNonSimpleCaseOn : internal error, Bloc expected");
   //
   std::set<Node *> nodesBefore, nodesAfter;
   {
     std::map<Node *, std::set<Node *> > accelStr;
     LinkInfo info(E_ALL);
     parentc->findAllNodesStartingFrom<false>(firstNode,nodesBefore,accelStr,info);
   }
   {
     std::map<Node *, std::set<Node *> > accelStr;
     LinkInfo info(E_ALL);
     parentc->findAllNodesStartingFrom<true>(lastNode,nodesAfter,accelStr,info);
   }
   //
   std::set<Node *> nodesBeforeAfter(nodesBefore.begin(),nodesBefore.end());
   nodesBeforeAfter.insert(nodesAfter.begin(),nodesAfter.end());
   //std::for_each(nodesBeforeAfter.begin(),nodesBeforeAfter.end(),[](Node *elt) { std::cerr << elt->getName() << " "; }); std::cerr << std::endl;
   //
   AbstractPoint *onlyOne(*nodes2.begin());
   AbstractPoint *res(onlyOne->expandNonSimpleCaseOn(pathologicalPt2,nodesBeforeAfter));
   if(res!=onlyOne)
     throw YACS::Exception("BagPoint::expandNonSimpleCaseOn : unexpected situation !");// impossible because by construction pathologicalPt cannot be merged to this. If it were possible, algo in simplify would be simply it !
   {// remove delete pathologicalPt and remove it from this->_nodes
     std::list<AbstractPoint *> nodes3;
     std::for_each(_nodes.begin(),_nodes.end(),[&nodes3,pathologicalPt](AbstractPoint *elt) { if(elt!=pathologicalPt) nodes3.push_back(elt); else delete elt; });
     _nodes = nodes3;
   }
 }

References YACS::ENGINE::BlocPoint::_nodes, YACS::ENGINE::E_ALL, YACS::ENGINE::AbstractPoint::expandNonSimpleCaseOn(), YACS::ENGINE::Bloc::findAllNodesStartingFrom(), YACS::ENGINE::AbstractPoint::getFirstNode(), and YACS::ENGINE::AbstractPoint::getLastNode().

◆ expandNonSimpleCaseOn() [2/2]

AbstractPoint * BagPoint::expandNonSimpleCaseOn	(	NotSimpleCasePoint *	pathologicalPt,
		const std::set< Node * > &	uncatchedNodes
	)

overridevirtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 48 of file BagPoint.cxx.

 {
   throw YACS::Exception("BagPoint::expandNonSimpleCaseOn : Ooops !");
 }

Referenced by expandNonSimpleCase().

◆ getFirstNode()

Node * BagPoint::getFirstNode ( )

overridevirtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 61 of file BagPoint.cxx.

 {
   return getUnique()->getFirstNode();
 }

References YACS::ENGINE::AbstractPoint::getFirstNode(), and YACS::ENGINE::BlocPoint::getUnique().

◆ getLastNode()

Node * BagPoint::getLastNode ( )

overridevirtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 66 of file BagPoint.cxx.

 {
   return getUnique()->getLastNode();
 }

References YACS::ENGINE::AbstractPoint::getLastNode(), and YACS::ENGINE::BlocPoint::getUnique().

◆ getMaxLevelOfParallelism()

int BagPoint::getMaxLevelOfParallelism ( ) const

virtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 71 of file BagPoint.cxx.

 {
   return getUnique()->getMaxLevelOfParallelism();
 }

References YACS::ENGINE::AbstractPoint::getMaxLevelOfParallelism(), and YACS::ENGINE::BlocPoint::getUnique().

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

◆ getRepr()

std::string BagPoint::getRepr ( ) const

virtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 86 of file BagPoint.cxx.

 {
   std::ostringstream oss;
   for(std::list<AbstractPoint *>::const_iterator it=_nodes.begin();it!=_nodes.end();it++)
     oss << (*it)->getRepr() << " - ";
   return oss.str();
 }

References YACS::ENGINE::BlocPoint::_nodes.

Referenced by YACS::ENGINE::SetOfPoints::getRepr().

◆ getWeightRegardingDPL()

void BagPoint::getWeightRegardingDPL ( ComplexWeight * weight )

virtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 76 of file BagPoint.cxx.

 {
   getUnique()->getWeightRegardingDPL(weight);
 }

References YACS::ENGINE::BlocPoint::getUnique(), and YACS::ENGINE::AbstractPoint::getWeightRegardingDPL().

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

◆ partitionRegardingDPL()

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

virtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 81 of file BagPoint.cxx.

 {
   getUnique()->partitionRegardingDPL(pd,zeMap);
 }

References YACS::ENGINE::BlocPoint::getUnique(), and YACS::ENGINE::AbstractPoint::partitionRegardingDPL().

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

◆ replaceInMe()

void BagPoint::replaceInMe ( BlocPoint * aSet )

Definition at line 96 of file BagPoint.cxx.

 {
   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);
 }

References YACS::ENGINE::BlocPoint::_nodes, and YACS::ENGINE::BlocPoint::getListOfPoints().

Referenced by deal1(), deal2(), deal2Bis(), deal2Quatro(), and deal2Ter().

◆ size()

int YACS::ENGINE::BagPoint::size ( ) const

inline

Definition at line 48 of file BagPoint.hxx.

48 { return (int)_nodes.size(); }

Referenced by YACS::ENGINE::SetOfPoints::basicSimplify().

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

src/engine/BagPoint.hxx
src/engine/BagPoint.cxx

Public Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ BagPoint() [1/2]

◆ BagPoint() [2/2]

Member Function Documentation

◆ accept()

◆ deal1()

◆ deal2()

◆ deal2Bis()

◆ deal2Quatro()

◆ deal2Ter()

◆ dealNotSimpleCase()

◆ deepCopy()

◆ expandNonSimpleCase()

◆ expandNonSimpleCaseOn() [1/2]

◆ expandNonSimpleCaseOn() [2/2]

◆ getFirstNode()

◆ getLastNode()

◆ getMaxLevelOfParallelism()

◆ getRepr()

◆ getWeightRegardingDPL()

◆ partitionRegardingDPL()

◆ replaceInMe()

◆ size()