#include <LinkedBlocPoint.hxx>

Inheritance diagram for YACS::ENGINE::LinkedBlocPoint:

Collaboration diagram for YACS::ENGINE::LinkedBlocPoint:

[legend]

Public Member Functions
	LinkedBlocPoint ()=default

	LinkedBlocPoint (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

virtual	~LinkedBlocPoint ()

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)

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 LinkedBlocPoint.hxx.

Constructor & Destructor Documentation

◆ LinkedBlocPoint() [1/2]

YACS::ENGINE::LinkedBlocPoint::LinkedBlocPoint ( )

default

◆ LinkedBlocPoint() [2/2]

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

Definition at line 34 of file LinkedBlocPoint.cxx.

                                                                                             :BlocPoint(nodes,father)
 {
 }

◆ ~LinkedBlocPoint()

LinkedBlocPoint::~LinkedBlocPoint ( )

virtual

Definition at line 136 of file LinkedBlocPoint.cxx.

137 {

138 }

Member Function Documentation

◆ accept()

void LinkedBlocPoint::accept ( PointVisitor * pv )

overridevirtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 128 of file LinkedBlocPoint.cxx.

 {
   pv->beginLinkedBlocPoint(this);
   for(auto it:_nodes)
     it->accept(pv);
   pv->endLinkedBlocPoint(this);
 }

References YACS::ENGINE::BlocPoint::_nodes, YACS::ENGINE::PointVisitor::beginLinkedBlocPoint(), and YACS::ENGINE::PointVisitor::endLinkedBlocPoint().

◆ deepCopy()

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

overridevirtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 38 of file LinkedBlocPoint.cxx.

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

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

Referenced by expandNonSimpleCaseOn().

◆ expandNonSimpleCaseOn()

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

overridevirtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 99 of file LinkedBlocPoint.cxx.

 {
   if(anyOf(uncatchedNodes))
     {
       for(auto& it : _nodes)
         {
           AbstractPoint *ret(it->expandNonSimpleCaseOn(pathologicalPt,uncatchedNodes));
           if(ret!=it)
             {
               ret->setFather(this);
               auto oldIt(it);
               it = ret;
               delete oldIt;
             }
         }
       return this;
     }
   else
     {
       std::list<AbstractPoint *> l;
       AbstractPoint *p0(this->deepCopy(getFather())),*p1(pathologicalPt->getUnique()->deepCopy(getFather()));
       l.push_back(p0);
       l.push_back(p1);
       AbstractPoint *ret(new ForkBlocPoint(l,getFather()));
       p0->setFather(ret); p1->setFather(ret);
       return ret;
     }
 }

References YACS::ENGINE::BlocPoint::_nodes, YACS::ENGINE::BlocPoint::anyOf(), YACS::ENGINE::AbstractPoint::deepCopy(), deepCopy(), YACS::ENGINE::AbstractPoint::getFather(), YACS::ENGINE::BlocPoint::getUnique(), testCppPluginInvokation::l, and YACS::ENGINE::AbstractPoint::setFather().

◆ getFirstNode()

Node * LinkedBlocPoint::getFirstNode ( )

overridevirtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 46 of file LinkedBlocPoint.cxx.

 {
   if(_nodes.empty())
     throw Exception("LinkedBlocPoint::getFirstNode : error no branches !");
   return _nodes.front()->getFirstNode();
 }

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

◆ getLastNode()

Node * LinkedBlocPoint::getLastNode ( )

overridevirtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 53 of file LinkedBlocPoint.cxx.

 {
   if(_nodes.empty())
     throw Exception("LinkedBlocPoint::getFirstNode : error no branches !");
   return _nodes.back()->getLastNode();
 }

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

◆ getMaxLevelOfParallelism()

int LinkedBlocPoint::getMaxLevelOfParallelism ( ) const

virtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 60 of file LinkedBlocPoint.cxx.

 {
   int ret(0);
   for(std::list<AbstractPoint *>::const_iterator it=_nodes.begin();it!=_nodes.end();it++)
     ret=std::max(ret,(*it)->getMaxLevelOfParallelism());
   return ret;
 }

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

◆ getRepr()

std::string LinkedBlocPoint::getRepr ( ) const

virtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 85 of file LinkedBlocPoint.cxx.

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

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

◆ getWeightRegardingDPL()

void LinkedBlocPoint::getWeightRegardingDPL ( ComplexWeight * weight )

virtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 68 of file LinkedBlocPoint.cxx.

 {
   ComplexWeight localWeight;
   for(std::list<AbstractPoint *>::const_iterator it=_nodes.begin();it!=_nodes.end();it++)
   {
     (*it)->getWeightRegardingDPL(&localWeight);
     weight->addWeight(&localWeight);
     localWeight.setToZero();
   }
 }

References YACS::ENGINE::BlocPoint::_nodes, YACS::ENGINE::ComplexWeight::addWeight(), and YACS::ENGINE::ComplexWeight::setToZero().

◆ partitionRegardingDPL()

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

virtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 79 of file LinkedBlocPoint.cxx.

 {
   for(std::list<AbstractPoint *>::const_iterator it=_nodes.begin();it!=_nodes.end();it++)
     (*it)->partitionRegardingDPL(pd,zeMap);
 }

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

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

src/engine/LinkedBlocPoint.hxx
src/engine/LinkedBlocPoint.cxx

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ LinkedBlocPoint() [1/2]

◆ LinkedBlocPoint() [2/2]

◆ ~LinkedBlocPoint()

Member Function Documentation

◆ accept()

◆ deepCopy()

◆ expandNonSimpleCaseOn()

◆ getFirstNode()

◆ getLastNode()

◆ getMaxLevelOfParallelism()

◆ getRepr()

◆ getWeightRegardingDPL()

◆ partitionRegardingDPL()