molecular.hpp

Go to the documentation of this file.

#ifndef INDIGOX_GRAPH_MOLECULAR_HPP
#define INDIGOX_GRAPH_MOLECULAR_HPP

#include "../algorithm/graph/cycles.hpp"
#include "../utils/fwd_declares.hpp"
#include "base_graph.hpp"

#include <EASTL/vector_map.h>
#include <iterator>
#include <map>
#include <memory>
#include <set>
#include <stdexcept>
#include <vector>

// Local declarations
namespace indigox::graph {
  class MGVertex {
    friend class MolecularGraph;
    friend class cereal::access;

  public:
    const Atom &GetAtom() const;

    const MolecularGraph &GetGraph() const;

  public:
    INDIGOX_GENERIC_PIMPL_CLASS_DEFAULTS(MGVertex);
    INDIGOX_GENERIC_PIMPL_CLASS_OPERATORS(MGVertex, v);

  private:
    MGVertex(const Atom &a, const MolecularGraph &graph);

    template <typename Archive>
    void serialise(Archive &archive, const uint32_t version);

  private:
    struct MGVertexData;
    std::shared_ptr<MGVertexData> m_data;
  };

  class MGEdge {
    friend class MolecularGraph;
    friend class cereal::access;

  public:
    const Bond &GetBond() const;

    const MolecularGraph &GetGraph() const;

  public:
    INDIGOX_GENERIC_PIMPL_CLASS_DEFAULTS(MGEdge);
    INDIGOX_GENERIC_PIMPL_CLASS_OPERATORS(MGEdge, e);

  private:
    MGEdge(const Bond &b, const MolecularGraph &graph);

    template <typename Archive>
    void serialise(Archive &archive, const uint32_t version);

  private:
    struct MGEdgeData;
    std::shared_ptr<MGEdgeData> m_data;
  };

  class MolecularGraph : public BaseGraph<MGVertex, MGEdge, MolecularGraph> {
  public:
    friend class indigox::Molecule;
    friend class cereal::access;

    using graph_type = BaseGraph<MGVertex, MGEdge, MolecularGraph>;
    using VertContain = std::vector<MGVertex>;
    using EdgeContain = std::vector<MGEdge>;
    using NbrsContain = std::map<MGVertex, VertContain>;
    using AtomMap = eastl::vector_map<Atom, MGVertex>;
    using BondMap = eastl::vector_map<Bond, MGEdge>;

  public:
    using EdgeIter = EdgeContain::const_iterator;
    using VertIter = VertContain::const_iterator;
    using NbrsIter = NbrsContain::mapped_type::const_iterator;
    using VertexType = MGVertex;
    using EdgeType = MGEdge;

  public:
    INDIGOX_GENERIC_PIMPL_CLASS_DEFAULTS(MolecularGraph);
    INDIGOX_GENERIC_PIMPL_CLASS_OPERATORS(MolecularGraph, g);

  public:
    MolecularGraph(const Molecule &mol);

  private:
    template <typename Archive>
    void serialise(Archive &archive, const uint32_t version);

    // modifcation methods are private so that the structure of the graph can
    // be controlled only by the molecule owning it.
    MGEdge AddEdge(const Bond &bnd);

    MGVertex AddVertex(const Atom &atm);

    void RemoveEdge(const MGEdge &e);

    void RemoveEdge(const MGVertex &u, const MGVertex &v);

    void RemoveVertex(const MGVertex &v);

  public:
    MolecularGraph Subgraph(std::vector<MGVertex> &vertices);

    MolecularGraph Subgraph(std::vector<MGVertex> &vertices,
                            std::vector<MGEdge> &edges);

    bool IsSubgraph() const;
    //    {
    //      return !_subg.expired();
    //    }

    using graph_type::GetEdge;
    using graph_type::HasEdge;
    using graph_type::HasVertex;

    const MGEdge &GetEdge(const Bond &bnd) const;

    const MGVertex &GetVertex(const Atom &atm) const;

    bool HasVertex(const Atom &v) const;

    bool HasEdge(const Bond &e) const;

    const Molecule &GetMolecule() const;

    const MolecularGraph &GetSuperGraph() const;

    // Can only generate/get the condensed graph when molecule is frozen
    const CondensedMolecularGraph &GetCondensedGraph();

  private:
    struct Impl;
    std::shared_ptr<Impl> m_data;
  };
} // namespace indigox::graph

#endif /* INDIGOX_GRAPH_MOLECULAR_HPP */