src/engine/Loop.hxx

   1 #ifndef __LOOP_HXX__
   2 #define __LOOP_HXX__
   3
   4 #include "StaticDefinedComposedNode.hxx"
   5 #include "InputDataStreamPort.hxx"
   6 #include "ElementaryNode.hxx"
   7 #include "OutputPort.hxx"
   8 #include "InputPort.hxx"
   9
  10 namespace YACS
  11 {
  12   namespace ENGINE
  13   {
  14     class Loop;
  15     class ForLoop;
  16     class WhileLoop;
  17     class DFToDSForLoop;
  18     class DSToDFForLoop;
  19
  20     class InputPort4DF2DS : public InputPort
  21     {
  22     public:
  23       InputPort4DF2DS(DFToDSForLoop *node, TypeCode* type);
  24       void getAllRepresentants(std::set<InPort *>& repr) const;
  25       void put(const void *data) throw(ConversionException);
  26       InputPort *clone(Node *newHelder) const;
  27       void *get() const throw(Exception);
  28       void exRestoreInit();
  29       void exSaveInit();
  30       void put(Any *data);
  31       ~InputPort4DF2DS();
  32     protected:
  33       Any *_data;
  34     };
  35
  36     class DFToDSForLoop : public ElementaryNode
  37     {
  38       friend class Loop;
  39     private:
  40       int _nbOfTimeUsed;
  41       Loop *_loopArtificiallyBuiltMe;
  42     private:
  43       DFToDSForLoop(Loop *loop, const std::string& name, TypeCode* type);
  44       void loopHasOneMoreRef() { _nbOfTimeUsed++; }
  45       bool loopHasOneLessRef() { return --_nbOfTimeUsed==0; }
  46       void getReadyTasks(std::vector<Task *>& tasks);
  47       InputPort *getInputPort(const std::string& name) const throw(Exception);
  48       OutputDataStreamPort *getOutputDataStreamPort(const std::string& name) const throw(Exception);
  49       Node *simpleClone(ComposedNode *father, bool editionOnly=true) const;
  50       //run part
  51       void execute();
  52       void load();
  53     public:
  54       ~DFToDSForLoop();
  55     };
  56
  57     class OutputPort4DS2DF : public OutputPort
  58     {
  59     public:
  60       OutputPort4DS2DF(DSToDFForLoop *node, TypeCode *type);
  61       void getAllRepresented(std::set<OutPort *>& represented) const;
  62       void put(const void *data) throw(ConversionException);
  63       OutputPort *clone(Node *newHelder) const;
  64       void put(Any *data);
  65       ~OutputPort4DS2DF();
  66     protected:
  67       Any *_data;
  68     };
  69
  70     class InputDataStreamPort4DS2DF : public InputDataStreamPort
  71     {
  72     public:
  73       InputDataStreamPort4DS2DF(DSToDFForLoop *node, TypeCode* type);
  74       void getAllRepresentants(std::set<InPort *>& repr) const;
  75     };
  76
  77     class DSToDFForLoop : public ElementaryNode
  78     {
  79       friend class Loop;
  80     private:
  81       int _nbOfTimeUsed;
  82       Loop *_loopArtificiallyBuiltMe;
  83     private:
  84       DSToDFForLoop(Loop *loop, const std::string& name, TypeCode* type);
  85       Node *simpleClone(ComposedNode *father, bool editionOnly=true) const;
  86       void loopHasOneMoreRef() { _nbOfTimeUsed++; }
  87       bool loopHasOneLessRef() { return --_nbOfTimeUsed==0; }
  88       void getReadyTasks(std::vector<Task *>& tasks);
  89       OutputPort *getOutputPort(const std::string& name) const throw(Exception);
  90       InputDataStreamPort *getInputDataStreamPort(const std::string& name) const throw(Exception);
  91       //run part
  92       void execute();
  93       void load();
  94     public:
  95       ~DSToDFForLoop();
  96     };
  97
  98     class FakeNodeForLoop : public ElementaryNode
  99     {
 100       friend class ForLoop;
 101       friend class WhileLoop;
 102     private:
 103       Loop *_loop;
 104       bool _normalFinish;
 105       bool _internalError;
 106     private:
 107       FakeNodeForLoop(Loop *loop, bool normalFinish, bool internalError=false);
 108       FakeNodeForLoop(const FakeNodeForLoop& other);
 109       Node *simpleClone(ComposedNode *father, bool editionOnly) const;
 110       void exForwardFailed();
 111       void exForwardFinished();
 112       void execute();
 113       void aborted();
 114       void finished();
 115     };
 116
 117 /*! \brief Base class for loop node
 118  *
 119  * \ingroup Nodes
 120  *
 121  * \see ForLoop
 122  * \see WhileLoop
 123  */
 124     class Loop : public StaticDefinedComposedNode
 125     {
 126       friend class DSToDFForLoop;
 127       friend class FakeNodeForLoop;
 128       friend void NbDoneLoader(Loop* node, int val);
 129     protected:
 130       Node *_node;
 131       int _nbOfTurns;
 132       FakeNodeForLoop *_nodeForNullTurnOfLoops;
 133       std::set<DSToDFForLoop *> _inputsTraducer;
 134       std::set<DFToDSForLoop *> _outputsTraducer;
 135     public:
 136       Loop(const Loop& other, ComposedNode *father, bool editionOnly);
 137       Loop(const std::string& name);
 138       ~Loop();
 139       void init(bool start=true);
 140       int getNbOfTurns() const { return _nbOfTurns; }
 141       Node *edSetNode(Node *node);
 142       Node *edRemoveNode();
 143       void getReadyTasks(std::vector<Task *>& tasks);
 144       void edRemoveChild(Node *node) throw(Exception);
 145       bool isRepeatedUnpredictablySeveralTimes() const { return true; }
 146       void selectRunnableTasks(std::vector<Task *>& tasks);
 147       std::set<Node *> edGetDirectDescendants() const;
 148       void checkConsistency(ComposedNode *pointOfView) const throw(Exception);
 149       Node *getChildByShortName(const std::string& name) const throw(Exception);
 150       static TypeCode* MappingDF2DS(TypeCode* type) throw(Exception);
 151       static TypeCode* MappingDS2DF(TypeCode* type) throw(Exception);
 152       virtual bool edAddDFLink(OutPort *start, InPort *end) throw(Exception);
 153       void writeDot(std::ostream &os);
 154       virtual void accept(Visitor *visitor);
 155     protected:
 156       void buildDelegateOf(InPort * & port, OutPort *initialStart, const std::set<ComposedNode *>& pointsOfView);
 157       void buildDelegateOf(std::pair<OutPort *, OutPort *>& port, InPort *finalTarget, const std::set<ComposedNode *>& pointsOfView);
 158       void getDelegateOf(InPort * & port, OutPort *initialStart, const std::set<ComposedNode *>& pointsOfView) throw(Exception);
 159       void getDelegateOf(std::pair<OutPort *, OutPort *>& port, InPort *finalTarget, const std::set<ComposedNode *>& pointsOfView) throw(Exception);
 160       void releaseDelegateOf(InPort * & port, OutPort *initialStart, const std::set<ComposedNode *>& pointsOfView) throw(Exception);
 161       void releaseDelegateOf(OutPort *portDwn, OutPort *portUp, InPort *finalTarget, const std::set<ComposedNode *>& pointsOfView) throw(Exception);
 162       void checkNoCyclePassingThrough(Node *node) throw(Exception);
 163       static bool isNecessaryToBuildSpecificDelegateDF2DS(const std::set<ComposedNode *>& pointsOfView);
 164     };
 165
 166     void NbDoneLoader(Loop* node, int val);
 167   }
 168 }
 169
 170 #endif