Graph.h

Go to the documentation of this file.

 
#ifndef INCLUDE_MOLASSEMBLER_OUTER_GRAPH_H
#define INCLUDE_MOLASSEMBLER_OUTER_GRAPH_H
 
#include "Molassembler/Graph/GraphInterface.h"
#include "Molassembler/IteratorRange.h"
 
#include <memory>
#include <vector>
 
namespace Scine {
// Forward-declarations
namespace Utils {
using ElementTypeCollection = std::vector<ElementType>;
class BondOrderCollection;
} // namespace Utils
 
namespace Molassembler {
 
// Forward-declare PrivateGraph
class PrivateGraph;
class Cycles;
 
class MASM_EXPORT Graph final : public GraphInterface {
public:
 
  template<typename T, bool isVertexInitialized>
  class InnerBasedIterator {
  public:
    static_assert(
      std::is_same<T, AtomIndex>::value || std::is_same<T, BondIndex>::value,
      "You may not instantiate this type for other Ts than AtomIndex or BondIndex"
    );
 
    using iterator_category = std::forward_iterator_tag;
    using difference_type = std::ptrdiff_t;
    using value_type = T;
    using pointer = T;
    using reference = T;
 
    InnerBasedIterator(InnerBasedIterator&& other) noexcept;
    InnerBasedIterator& operator = (InnerBasedIterator&& other) noexcept;
    InnerBasedIterator(const InnerBasedIterator& other);
    InnerBasedIterator& operator = (const InnerBasedIterator& other);
    ~InnerBasedIterator();
 
    // Default constructor
    InnerBasedIterator();
 
    /* We want to use this iterator facade in four ways:
     *
     * Iterate through all valid atom indices: (graph) -> AtomIndex
     * Iterate through all valid bond indices: (graph) -> BondIndex
     * Iterate through all atom indices adjacent to i: (graph, i) -> AtomIndex
     * Iterate through all bonds incident on i: (graph, i) -> BondIndex
     *
     * So, we template and enable-if constructors for the cases that the
     * template parameter isVertexInitialized (which denotes whether
     * additionally to the graph, a vertex descriptor is required in the
     * constructor):
     */
 
    template<bool Dependent = isVertexInitialized, std::enable_if_t<!Dependent, int>...>
    InnerBasedIterator(const PrivateGraph& inner, bool begin);
 
    template<bool Dependent = isVertexInitialized, std::enable_if_t<Dependent, int>...>
    InnerBasedIterator(AtomIndex a, const PrivateGraph& inner, bool begin);
 
    InnerBasedIterator& operator ++ ();
    InnerBasedIterator operator ++ (int);
    value_type operator * () const;
 
    bool operator == (const InnerBasedIterator& other) const;
    bool operator != (const InnerBasedIterator& other) const;
 
  private:
    struct Impl;
    std::unique_ptr<Impl> pImpl_;
  };
 
  using AtomIterator = InnerBasedIterator<AtomIndex, false>;
  using BondIterator = InnerBasedIterator<BondIndex, false>;
  using AdjacencyIterator = InnerBasedIterator<AtomIndex, true>;
  using IncidentEdgesIterator = InnerBasedIterator<BondIndex, true>;
 
  Graph(Graph&& other) noexcept;
  Graph& operator = (Graph&& other) noexcept;
  Graph(const Graph& other);
  Graph& operator = (const Graph& other);
  ~Graph() final;
 
  Graph();
  explicit Graph(PrivateGraph&& inner);
 
  AtomIndex addAtom(Utils::ElementType e, AtomIndex i, BondType type) final;
 
  BondIndex addBond(AtomIndex i, AtomIndex j, BondType type) final;
 
  void setElementType(AtomIndex i, Utils::ElementType type) final;
 
  bool setBondType(AtomIndex i, AtomIndex j, BondType type) final;
 
  void removeAtom(AtomIndex i) final;
 
  void removeBond(const BondIndex& bond) final;
 
 
  bool adjacent(AtomIndex a, AtomIndex b) const final;
  std::vector<AtomIndex> atomsOfElement(Utils::ElementType e) const;
  boost::optional<BondIndex> bond(AtomIndex a, AtomIndex b) const final;
  Utils::BondOrderCollection bondOrders() const;
  BondType bondType(const BondIndex& edge) const final;
  bool canRemove(AtomIndex a) const final;
  bool canRemove(const BondIndex& edge) const final;
  const Cycles& cycles() const final;
  unsigned degree(AtomIndex a) const final;
  std::string dumpGraphviz() const;
  Utils::ElementTypeCollection elementCollection() const;
  Utils::ElementType elementType(AtomIndex a) const final;
 
  [[deprecated("Prefer V")]]
  AtomIndex N() const;
 
  AtomIndex V() const final;
  [[deprecated("Prefer E")]]
  unsigned B() const;
 
  unsigned E() const final;
 
  boost::optional<std::vector<AtomIndex>> modularIsomorphism(
    const Graph& other,
    AtomEnvironmentComponents components = AtomEnvironmentComponents::All
  ) const;
 
  std::pair<
    std::vector<AtomIndex>,
    std::vector<AtomIndex>
  > splitAlongBridge(BondIndex bridge) const;
 
  bool operator == (const Graph& other) const;
  inline bool operator != (const Graph& other) const {
    return !(*this == other);
  }
 
 
  IteratorRange<AtomIterator> atoms() const;
  IteratorRange<BondIterator> bonds() const;
  IteratorRange<AdjacencyIterator> adjacents(AtomIndex a) const;
  IteratorRange<IncidentEdgesIterator> bonds(AtomIndex a) const;
 
  MASM_NO_EXPORT PrivateGraph& inner();
 
  MASM_NO_EXPORT const PrivateGraph& inner() const;
 
private:
  std::unique_ptr<PrivateGraph> innerPtr_;
};
 
} // namespace Molassembler
} // namespace Scine
 
#endif