#include <NotSimpleCasePoint.hxx>

Inheritance diagram for YACS::ENGINE::NotSimpleCasePoint:

Collaboration diagram for YACS::ENGINE::NotSimpleCasePoint:

[legend]

Public Member Functions
	NotSimpleCasePoint ()=default

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

	~NotSimpleCasePoint ()=default

AbstractPoint *	deepCopy (AbstractPoint *father) const override

Node *	getFirstNode () override

Node *	getLastNode () override

int	getMaxLevelOfParallelism () const override

void	getWeightRegardingDPL (ComplexWeight *weight) override

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

std::string	getRepr () const override

void	accept (PointVisitor *pv) override

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

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 29 of file NotSimpleCasePoint.hxx.

Constructor & Destructor Documentation

◆ NotSimpleCasePoint() [1/2]

YACS::ENGINE::NotSimpleCasePoint::NotSimpleCasePoint ( )

default

◆ NotSimpleCasePoint() [2/2]

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

Definition at line 29 of file NotSimpleCasePoint.cxx.

                                                                                                   :BlocPoint(nodes,father)
 {
 }

◆ ~NotSimpleCasePoint()

YACS::ENGINE::NotSimpleCasePoint::~NotSimpleCasePoint ( )

default

Member Function Documentation

◆ accept()

void NotSimpleCasePoint::accept ( PointVisitor * pv )

overridevirtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 94 of file NotSimpleCasePoint.cxx.

 {
   pv->beginNotSimpleCasePoint(this);
   for(auto it:_nodes)
     it->accept(pv);
   pv->endNotSimpleCasePoint(this);
 }

References YACS::ENGINE::BlocPoint::_nodes, YACS::ENGINE::PointVisitor::beginNotSimpleCasePoint(), and YACS::ENGINE::PointVisitor::endNotSimpleCasePoint().

◆ deepCopy()

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

overridevirtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 33 of file NotSimpleCasePoint.cxx.

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

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

◆ expandNonSimpleCaseOn()

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

overridevirtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 102 of file NotSimpleCasePoint.cxx.

 {
   throw YACS::Exception("NotSimpleCasePoint::expandNonSimpleCaseOn : ooops !");
 }

◆ getFirstNode()

Node * NotSimpleCasePoint::getFirstNode ( )

overridevirtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 41 of file NotSimpleCasePoint.cxx.

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

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

◆ getLastNode()

Node * NotSimpleCasePoint::getLastNode ( )

overridevirtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 48 of file NotSimpleCasePoint.cxx.

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

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

◆ getMaxLevelOfParallelism()

int NotSimpleCasePoint::getMaxLevelOfParallelism ( ) const

overridevirtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 55 of file NotSimpleCasePoint.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 NotSimpleCasePoint::getRepr ( ) const

overridevirtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 80 of file NotSimpleCasePoint.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 NotSimpleCasePoint::getWeightRegardingDPL ( ComplexWeight * weight )

overridevirtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 63 of file NotSimpleCasePoint.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 NotSimpleCasePoint::partitionRegardingDPL	(	const PartDefinition *	pd,
		std::map< ComposedNode *, YACS::BASES::AutoRefCnt< PartDefinition > > &	zeMap
	)		const

overridevirtual

Implements YACS::ENGINE::AbstractPoint.

Definition at line 74 of file NotSimpleCasePoint.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/NotSimpleCasePoint.hxx
src/engine/NotSimpleCasePoint.cxx

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ NotSimpleCasePoint() [1/2]

◆ NotSimpleCasePoint() [2/2]

◆ ~NotSimpleCasePoint()

Member Function Documentation

◆ accept()

◆ deepCopy()

◆ expandNonSimpleCaseOn()

◆ getFirstNode()

◆ getLastNode()

◆ getMaxLevelOfParallelism()

◆ getRepr()

◆ getWeightRegardingDPL()

◆ partitionRegardingDPL()