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