Graph.h

#ifndef _GRAPH_HEADER_
#define _GRAPH_HEADER_

#include "Block.h"


namespace charliesoft
{
  class SubBlock;
  class GraphOfProcess
  {
    static bool _pauseProcess;
    GraphOfProcess* _parent;
    SubBlock *_subBlock;
    std::map< Block*, std::set<Block*> > _waitingForRendering;
    std::map< Block*, boost::thread > _runningThread;
    std::vector<Block*> _vertices;
    boost::mutex _mtx;
    //edges are stored into Block (_myInputs[]->isLinked())

  public:
    GraphOfProcess();
    ~GraphOfProcess();

    void saveGraph(boost::property_tree::ptree& tree) const;
    void fromGraph(boost::property_tree::ptree& tree,
      std::map<unsigned int, ParamValue*>& = std::map<unsigned int, ParamValue*>());
    GraphOfProcess* getParent() const { return _parent; }
    void setParent(GraphOfProcess* val, SubBlock* block) { _parent = val; _subBlock = block; }

    void initChildDatas(Block*, std::set<Block*>& listOfRenderedBlocks);


    void addNewProcess(Block* filter);
    void deleteProcess(Block* process);
    void extractProcess(Block* process);

    void createLink(Block* src, std::string paramName, Block* dest, std::string paramNameDest);
    
    bool run(bool singleShot = false, bool delegateParent = true);
    void stop(bool delegateParent = true, bool waitEnd = true);
    void waitUntilEnd(size_t max_ms_time = 0);
    bool switchPause(bool delegateParent = true);
    bool isPause(){
      return _pauseProcess;
    };

    void blockProduced(Block* process, bool fullyRendered = true);

    void shouldWaitAncestors(Block* process);
    void updateAncestors(Block* process);
    void shouldWaitConsumers(Block* process=NULL);

    void clearWaitingList(Block* process);

    std::vector<Block*>& getVertices();
    void removeLink(const BlockLink& l);
  };
}


#endif