assignment.hpp

Go to the documentation of this file.

#ifndef INDIGOX_GRAPH_ASSIGNMENT_HPP
#define INDIGOX_GRAPH_ASSIGNMENT_HPP
#include "../utils/common.hpp"
#include "../utils/fwd_declares.hpp"
#include "base_graph.hpp"

#include <EASTL/vector_map.h>
#include <cstdint>
#include <limits>
#include <map>
#include <memory>
#include <vector>

// Local declarations
namespace indigox::graph {

  class IXAGVertex : public std::enable_shared_from_this<IXAGVertex> {
  public:
    IXAGVertex() = delete; // no default constructor
    friend class IXAssignmentGraph;

  private:
    IXAGVertex(const MGVertex v)
        : _source_vert(v), _source_edge(), _pre(0), _count(0) {}

    IXAGVertex(const MGEdge e)
        : _source_vert(), _source_edge(e), _pre(2), _count(0) {}

  public:
    inline bool IsVertexMapped() const { return !_source_vert.expired(); }

    inline bool IsEdgeMapped() const { return !_source_edge.expired(); }

    inline MGVertex GetSourceVertex() const {
      return IsVertexMapped() ? _source_vert.lock() : MGVertex();
    }

    inline MGEdge GetSourceEdge() const {
      return IsEdgeMapped() ? _source_edge.lock() : MGEdge();
    }

    inline uint32_t GetPreAssignedCount() const { return _pre; }

    inline void SetPreAssignedCount(const uint32_t count) { _pre = count; }

    inline uint32_t GetAssignedCount() const { return _count; }

    inline uint32_t GetTotalAssigned() const { return _pre + _count; }

    inline void SetAssignedCount(const uint32_t count) { _count = count; }

  private:
    _MGVertex _source_vert;
    _MGEdge _source_edge;
    uint32_t _pre, _count;
  };

  class IXAssignmentGraph {
    friend struct indigox::test::TestAssignmentGraph;

    using graph_type = IXGraphBase<IXAGVertex, std::nullptr_t>;
    using VertContain = std::vector<AGVertex>;

  public:
    using VertIter = VertContain::const_iterator;
    using NbrsIter = VertContain::const_iterator;

  public:
    IXAssignmentGraph() = delete; // no default constructor

  public:
    IXAssignmentGraph(MolecularGraph g);

    inline bool HasVertex(const AGVertex &v) const {
      return _g.HasVertex(v.get());
    }

    inline bool HasVertex(const MGVertex &v) const {
      return _v2v.find(v) != _v2v.end();
    }

    inline bool HasVertex(const MGEdge &e) const {
      return _e2v.find(e) != _e2v.end();
    }

    inline AGVertex GetVertex(const MGVertex &v) const {
      return HasVertex(v) ? _v2v.at(v) : AGVertex();
    }

    inline AGVertex GetVertex(const MGEdge &e) const {
      return HasVertex(e) ? _e2v.at(e) : AGVertex();
    }

    inline size_t NumVertices() const { return _g.NumVertices(); }

    inline size_t Degree(const AGVertex &v) const {
      return HasVertex(v) ? _g.Degree(v.get())
                          : std::numeric_limits<size_t>::max();
    }

    inline std::pair<NbrsIter, NbrsIter>
    GetNeighbours(const AGVertex &v) const {
      return HasVertex(v) ? std::make_pair(_n.at(v).begin(), _n.at(v).end())
                          : std::make_pair(_v.end(), _v.end());
    }

    inline std::pair<VertIter, VertIter> GetVertices() const {
      return {_v.begin(), _v.end()};
    }

    //    inline bool IsConnected() { return _g.NumConnectedComponents() == 1; }

    void PreassignElectrons();

  private:
    AGVertex AddVertex(MGVertex v);

    void AddEdges(MGVertex s, MGVertex t, MGEdge e);

    void DetermineAllNeighbours();

  private:
    _MolecularGraph _source;
    graph_type _g;
    eastl::vector_map<MGVertex, AGVertex> _v2v;
    eastl::vector_map<MGEdge, AGVertex> _e2v;
    VertContain _v;
    std::map<AGVertex, VertContain> _n;
  };

} // namespace indigox::graph

#endif /* INDIGOX_GRAPH_ASSIGNMENT_HPP */