Cycles.h

Go to the documentation of this file.

 
#ifndef INCLUDE_MOLASSEMBLER_CYCLES_H
#define INCLUDE_MOLASSEMBLER_CYCLES_H
 
#include "boost/functional/hash.hpp"
#include "boost/optional/optional_fwd.hpp"
 
#include "Molassembler/IteratorRange.h"
#include "Molassembler/Types.h"
 
#include <functional>
#include <unordered_map>
 
struct RDL_data;
 
namespace Scine {
namespace Molassembler {
 
// Forward-declarations
class Graph;
class PrivateGraph;
 
class MASM_EXPORT Cycles {
public:
  struct RdlDataPtrs;
 
 
  struct RdlCyclePtrs;
 
  class AllCyclesIterator {
  public:
    // Iterator traits
    using iterator_category = std::forward_iterator_tag;
    using difference_type = std::ptrdiff_t;
    using value_type = const std::vector<BondIndex>&;
    using pointer = const std::vector<BondIndex>*;
    using reference = value_type;
 
    AllCyclesIterator() = delete;
    AllCyclesIterator(
      const std::shared_ptr<RdlDataPtrs>& dataPtr,
      unsigned rCycleIndex = 0
    );
 
    /* Rule of five members */
    AllCyclesIterator(const AllCyclesIterator& other);
    AllCyclesIterator(AllCyclesIterator&& other) noexcept;
    AllCyclesIterator& operator = (const AllCyclesIterator& other);
    AllCyclesIterator& operator = (AllCyclesIterator&& other) noexcept;
    ~AllCyclesIterator();
 
    AllCyclesIterator& operator ++ ();
    AllCyclesIterator operator ++ (int);
    value_type operator * () const;
    pointer operator -> () const;
 
 
    bool operator == (const AllCyclesIterator& other) const;
    bool operator != (const AllCyclesIterator& other) const;
 
  private:
    std::shared_ptr<RdlDataPtrs> rdlPtr_;
    std::unique_ptr<RdlCyclePtrs> cyclePtr_;
  };
 
  class UrfIdsCycleIterator {
  public:
    using difference_type = unsigned;
    using value_type = const std::vector<BondIndex>&;
    using pointer = const std::vector<BondIndex>*;
    using reference = value_type;
    using iterator_category = std::forward_iterator_tag;
 
    /* Rule of five members */
    UrfIdsCycleIterator(const UrfIdsCycleIterator& other);
    UrfIdsCycleIterator(UrfIdsCycleIterator&& other) noexcept;
    UrfIdsCycleIterator& operator = (const UrfIdsCycleIterator& other);
    UrfIdsCycleIterator& operator = (UrfIdsCycleIterator&& other) noexcept;
    ~UrfIdsCycleIterator();
 
    UrfIdsCycleIterator() = delete;
 
    /* Constructors */
    UrfIdsCycleIterator(
      AtomIndex soughtIndex,
      const std::shared_ptr<RdlDataPtrs>& dataPtr
    );
 
    UrfIdsCycleIterator(
      const BondIndex& soughtBond,
      std::vector<unsigned> urfs,
      const std::shared_ptr<RdlDataPtrs>& dataPtr
    );
 
    UrfIdsCycleIterator(
      const std::vector<BondIndex>& soughtBonds,
      std::vector<unsigned> urfs,
      const std::shared_ptr<RdlDataPtrs>& dataPtr
    );
 
    UrfIdsCycleIterator& operator ++ ();
    UrfIdsCycleIterator operator ++ (int);
    value_type operator * () const;
    pointer operator -> () const;
 
    void advanceToEnd();
 
    bool operator == (const UrfIdsCycleIterator& other) const;
    bool operator != (const UrfIdsCycleIterator& other) const;
 
  private:
    struct UrfHelper;
 
    std::shared_ptr<RdlDataPtrs> rdlPtr_;
    std::unique_ptr<UrfHelper> urfsPtr_;
    std::unique_ptr<RdlCyclePtrs> cyclePtr_;
 
    void advanceToNextPermissibleCycle_();
    void initializeCyclesFromUrfId_();
    void matchCycleState_(const UrfIdsCycleIterator& other);
  };
 
 
  Cycles(const Graph& sourceGraph, bool ignoreEtaBonds = true);
  Cycles(const PrivateGraph& innerGraph, bool ignoreEtaBonds = true);
 
 
  unsigned numCycleFamilies() const;
 
  unsigned numCycleFamilies(AtomIndex index) const;
 
  unsigned numCycleFamilies(const BondIndex& bond) const;
 
  unsigned numRelevantCycles() const;
 
  unsigned numRelevantCycles(AtomIndex index) const;
 
  unsigned numRelevantCycles(const BondIndex& bond) const;
 
  RDL_data* dataPtr() const;
 
  AllCyclesIterator begin() const;
  AllCyclesIterator end() const;
 
 
  IteratorRange<UrfIdsCycleIterator> containing(AtomIndex atom) const;
  IteratorRange<UrfIdsCycleIterator> containing(const BondIndex& bond) const;
  IteratorRange<UrfIdsCycleIterator> containing(const std::vector<BondIndex>& bonds) const;
 
  bool operator == (const Cycles& other) const;
  bool operator != (const Cycles& other) const;
 
private:
  std::shared_ptr<RdlDataPtrs> rdlPtr_;
  // Map from BondIndex to ordered list of its URF IDs
  std::unordered_map<BondIndex, std::vector<unsigned>, boost::hash<BondIndex>> urfMap_;
};
 
MASM_EXPORT boost::optional<unsigned> smallestCycleContaining(AtomIndex atom, const Cycles& cycles);
 
MASM_EXPORT std::unordered_map<AtomIndex, unsigned> makeSmallestCycleMap(const Cycles& cycleData);
 
MASM_EXPORT std::vector<AtomIndex> makeRingIndexSequence(
  std::vector<BondIndex> edgeDescriptors
);
 
MASM_EXPORT std::vector<AtomIndex> centralizeRingIndexSequence(
  std::vector<AtomIndex> ringIndexSequence,
  AtomIndex center
);
 
MASM_EXPORT unsigned countPlanarityEnforcingBonds(
  const std::vector<BondIndex>& edgeSet,
  const Graph& graph
);
 
} // namespace Molassembler
} // namespace Scine
 
#endif