tpgGraph.h

 
#ifndef TPG_GRAPH_H
#define TPG_GRAPH_H
 
#include <list>
#include <set>
 
#include "environment.h"
#include "tpg/tpgAction.h"
#include "tpg/tpgEdge.h"
#include "tpg/tpgFactory.h"
#include "tpg/tpgTeam.h"
#include "tpg/tpgVertex.h"
#include "util/genericComparator.h"
 
namespace TPG {
 
    class TPGGraph
    {
      public:
        TPGGraph(const Environment& e,
                 std::unique_ptr<TPGFactory> f = std::make_unique<TPGFactory>())
            : env{e}, factory{std::move(f)}
        {
        }
 
        TPGGraph(const TPGGraph& model) = delete;
 
        TPGGraph(TPGGraph&& model) noexcept : env{model.getEnvironment()}
        {
            swap(*this, model);
        }
 
        friend inline void swap(TPGGraph& a, TPGGraph& b)
        {
            using std::swap;
            swap(a.vertices, b.vertices);
            swap(a.edges, b.edges);
        }
 
        TPGGraph& operator=(TPGGraph model);
 
        virtual ~TPGGraph();
 
        void clear();
 
        const Environment& getEnvironment() const;
 
        const TPGFactory& getFactory() const;
 
        const TPGTeam& addNewTeam();
 
        const TPGAction& addNewAction(uint64_t actionID);
 
        size_t getNbVertices() const;
 
        const std::vector<const TPGVertex*> getVertices() const;
 
        uint64_t getNbRootVertices() const;
 
        const std::vector<const TPGAction*> getRootActions() const;
 
        const std::vector<const TPGTeam*> getRootTeams() const;
 
        const std::vector<const TPGVertex*> getRootVertices() const;
 
        bool hasVertex(const TPG::TPGVertex& vertex) const;
 
        void removeVertex(const TPGVertex& vertex);
 
        const TPGVertex& cloneVertex(const TPGVertex& vertex);
 
        const TPGEdge& addNewEdge(const TPGVertex& src, const TPGVertex& dest,
                                  const std::shared_ptr<Program::Program> prog);
        const TPGEdge& addNewActionEdge(
            const TPGVertex& src, const std::shared_ptr<Program::Program> prog,
            uint64_t actionClass);
 
        const std::set<std::unique_ptr<TPG::TPGEdge>, UniqueLess<TPG::TPGEdge>>&
        getEdges() const;
 
        void removeEdge(const TPGEdge& edge);
 
        void removeActionEdge(const TPGEdge& edge);
 
        const TPGEdge& cloneEdge(const TPGEdge& edge);
 
        bool setEdgeDestination(const TPGEdge& edge, const TPGVertex& newDest);
 
        bool setEdgeSource(const TPGEdge& edge, const TPGVertex& newSrc);
 
        void clearProgramIntrons();
 
        void setActionClassEdge(const TPGEdge* edge, uint64_t newActionClass);
 
        void updateAssessedActions(const TPG::TPGVertex* vertex);
 
        void updateAllAssessedActions();
 
        void orderActionEdges(const TPG::TPGAction* action);
 
        void setNewVertexID(const TPG::TPGVertex& vertex, uint64_t newID);
 
        void setNewEdgeID(const TPG::TPGEdge& edge, uint64_t newID);
 
      protected:
        const Environment& env;
 
        const std::unique_ptr<TPGFactory> factory;
 
        std::set<std::unique_ptr<TPGEdge>, UniqueLess<TPGEdge>> edges;
 
        std::set<std::unique_ptr<TPGVertex>, UniqueLess<TPGVertex>> vertices;
    };
}; // namespace TPG
 
#endif