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

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