J:/Caro/C++_Coding/HierarchicalEdgeBundle/HierarchicalEdgeBundle/header/Graph.h

Go to the documentation of this file.

#pragma once
#include "Vertex.h"
#include "HierarchyEdge.h"
#include "RelationEdge.h"
#include "Hierarchy.h"

#include <iostream>
#include <iomanip>
#include <string>

#include <boost/ptr_container/ptr_sequence_adapter.hpp>

#include <boost/ptr_container/ptr_map.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
#include <boost/assign/ptr_map_inserter.hpp>  // for 'ptr_map_insert()'
#include <boost/shared_ptr.hpp>
#include <memory>
#include <vector>
#include <map>
#include <algorithm>

using namespace std;
using namespace boost;
using namespace boost::assign;

typedef boost::shared_ptr<Vertex> VertexPtr;
typedef boost::shared_ptr<HierarchyEdge> HierarchyPtr;
typedef boost::shared_ptr<RelationEdge> RelationPtr;

class Graph
{
public:
        Graph(void);
        ~Graph(void);

        void AddVertex(VertexPtr vert);
        VertexPtr GetVertexWithID(unsigned int id);
        int GetNumberOfVertices();
        void RemoveVertexWithID(unsigned int id);
        void RemoveVertex(Vertex& vert);

        void SetRoot(int id);
        VertexPtr GetRoot();

        HierarchyPtr GetHierarchyEdgeWithID(unsigned int id);
        void AddHierarchicEdge(HierarchyPtr edge);
        unsigned int GetNumberOfHiearchicEdges();
        HierarchyPtr GetHierarchyEdgeAt(unsigned int at);

        RelationPtr GetRelationEdgeWithID(unsigned int id);
        void AddRelationEdge(RelationPtr edge);
        unsigned int GetNumberOfRelationEdges();
        RelationPtr GetRelationEdgeAt(unsigned int at);

        void SetNumberOfHierarchies(int count);
        int GetNumberOfHierarchies();
        
        void AddHierarchy(Hierarchy hierarchy);
        void SetHierarchyAt(int level, Hierarchy hierarchy);
        Hierarchy GetHierarchyAt(int level);
        void RemoveHierarchy(int level);

        std::vector<VertexPtr> GetVertexPtrVectorFromIDVector(std::vector<unsigned int> ids);

        void Calculate();
        void CalculateHierarchy();
        /*
         * This method calculates a path to the root node for all nodes.
         */
        void CalculatePathToRoot();
        /*
         * This method calculates a path to the root
         * @param actPath [VertexPtr] act path
         * @param path [unsigned int] nodes 
         */
        void CalculatePathToRoot(VertexPtr actPath, std::vector<unsigned int> path);

        std::vector<unsigned int> CalculatePathOverLCA(RelationPtr edge);
        std::vector<unsigned int> CalculatePathOverLCA(VertexPtr start, VertexPtr end);

        std::vector<VertexPtr> GetAllVerticesWithoutChild();
protected:
        std::map<unsigned int, VertexPtr> m_vertices;
        std::map<unsigned int, HierarchyPtr> m_hierarchyedges;
        std::map<unsigned int, RelationPtr> m_relationedge;
        VertexPtr m_pkRoot;

        vector<Hierarchy> m_hierarchy;
};