#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 *	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)

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