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,
      const std::vector<unsigned> urfs,
      const std::shared_ptr<RdlDataPtrs>& dataPtr
    );

    UrfIdsCycleIterator(
      const std::vector<BondIndex>& soughtBonds,
      const 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& index) 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