hyper_graph.h

#pragma once
#include <NDEVR/Buffer.h>
#include <NDEVR/Dictionary.h>
#include <NDEVR/Set.h>
#include "eigen_types.h"
#include "DLLInfo.h"
/* graph optimization */
namespace NDEVR
{
    class HyperGraph
    {
    public:
 
        class HGVertex;
        class HGEdge;

        class HGVertex
        {
        public:
            explicit HGVertex(int id = -1)
                : _id(id)
            {
            }
            virtual ~HGVertex() {}
            int id() const { return _id; }
            void setId(int newId) { _id = newId; }
            const Buffer<HGEdge*>& edges() const { return _edges; }
            Buffer<HGEdge*>& edges() { return _edges; }
        protected:
            Buffer<HGEdge*> _edges; 
            int _id;                
        };

        class HGEdge
        {
        public:
            explicit HGEdge(int id = -1)
                : _id(id)
            {
            }
 
            virtual ~HGEdge() {}
            virtual uint04 vertexCount() const = 0;
            virtual const HGVertex* vertex(uint04 i) const = 0;
            virtual HGVertex* vertex(uint04 i) = 0;
            virtual void setVertex(uint04 i, HGVertex* v) = 0;

            int id() const { return _id; }
            void setId(int id) { _id = id; }
        protected:
            int _id; 
        };
 
    public:
        HyperGraph() {};
        virtual ~HyperGraph()
        {}

        HGVertex* vertex(int id)
        {
            auto it = _vertices.find(id);
            if (it == _vertices.end())
                return nullptr;
            return it->second;
        }

        const HGVertex* vertex(int id) const
        {
            auto it = _vertices.find(id);
            if (it == _vertices.end())
                return nullptr;
            return it->second;
        }

        /*virtual bool removeVertex(HGVertex* v)
        {
            auto vert_it = _vertices.find(v->id());
            if (vert_it == _vertices.end())
                return false;
            assert(vert_it->second == v);
            //remove all edges which are entering or leaving v;
            Set<HGEdge*> tmp(v->edges());
            for (auto it = tmp.begin(); it != tmp.end(); ++it) 
            {
                //TYLER PARKE: OPTIMIZE THIS
                if (!removeEdge(*it)) {
                    assert(0);
                }
            }
            _vertices.erase(vert_it);
            return true;
        }*/
        /*virtual bool removeEdge(HGEdge* e)
        {
            auto it = _edges.find(e);
            if (it == _edges.end())
                return false;
            _edges.erase(it);
 
            for (uint04 i = 0; i < e->vertexCount(); i++)
                e->vertex(i)->edges().removeElement(e);
            return true;
        }*/
        virtual void clear()
        {
            _vertices.clear();
            _edges.clear();
        }

        const Dictionary<int, HGVertex*>& vertices() const { return _vertices; }
        Dictionary<int, HGVertex*>& vertices() { return _vertices; }

        const Buffer<HGEdge*>& edges() const { return _edges; }
        Buffer<HGEdge*>& edges() { return _edges; }

        virtual bool addVertex(HGVertex& v)
        {
            lib_assert(!_vertices.contains(v.id()), "duplicate vertex entry");
            _vertices.insert(std::make_pair(v.id(), &v));
            return true;
        }

        virtual bool addEdge(HGEdge* e)
        {
            lib_assert(!_edges.contains(e), "duplicate vertex entry");
            _edges.add(e);
            for (uint04 i = 0; i < e->vertexCount(); i++)
            {
                auto v = e->vertex(i);
                if (v != nullptr)
                {
                    lib_assert(!v->edges().contains(e), "Already added vertex");
                    v->edges().add(e);
                }
            }
            return true;
        }
 
 
    protected:
        Dictionary<int, HGVertex*> _vertices;   
        Buffer<HGEdge*> _edges;                 
 
    private:
        // Disable the copy constructor and assignment operator
        HyperGraph(const HyperGraph&) = delete;
        HyperGraph& operator= (const HyperGraph&) = delete;
    public:
        EIGEN_MAKE_ALIGNED_OPERATOR_NEW
    };
 
}