StereopermutatorList.h

Go to the documentation of this file.

 
#ifndef INCLUDE_MOLASSEMBLER_STEREOPERMUTATOR_LIST_H
#define INCLUDE_MOLASSEMBLER_STEREOPERMUTATOR_LIST_H
 
#include "Molassembler/Types.h"
#include "Molassembler/IteratorRange.h"
 
#include "boost/optional/optional_fwd.hpp"
#include <memory>
#include <vector>
 
namespace Scine {
namespace Molassembler {
 
class AtomStereopermutator;
class BondStereopermutator;
 
class MASM_EXPORT StereopermutatorList {
private:
  struct Impl;
 
public:
  template<typename Permutator>
  class iterator {
  public:
    static_assert(
      std::is_same<std::decay_t<Permutator>, AtomStereopermutator>::value
      || std::is_same<std::decay_t<Permutator>, BondStereopermutator>::value,
      "This type may not be instantiated for any type other than atom and bond stereopermutators"
    );
 
    using iterator_category = std::forward_iterator_tag;
    using difference_type = std::ptrdiff_t;
    using value_type = Permutator;
    using pointer = Permutator*;
    using reference = Permutator&;
 
    iterator(iterator&& other) noexcept;
    iterator& operator = (iterator&& other) noexcept;
    iterator(const iterator& other);
    iterator& operator = (const iterator& other);
    ~iterator();
 
    iterator();
 
    using ImplType = std::conditional_t<
      std::is_const<Permutator>::value,
      const StereopermutatorList::Impl&,
      StereopermutatorList::Impl&
    >;
    iterator(ImplType impl, bool begin);
 
    iterator& operator ++ ();
    iterator operator ++ (int);
    reference operator * () const;
 
    bool operator == (const iterator& other) const;
    bool operator != (const iterator& other) const;
 
  private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
  };
 
  using AtomStereopermutatorIterator = iterator<AtomStereopermutator>;
  using AtomStereopermutatorConstIterator = iterator<const AtomStereopermutator>;
  using BondStereopermutatorIterator = iterator<BondStereopermutator>;
  using BondStereopermutatorConstIterator = iterator<const BondStereopermutator>;
 
  StereopermutatorList();
  StereopermutatorList(StereopermutatorList&& other) noexcept;
  StereopermutatorList& operator = (StereopermutatorList&& other) noexcept;
  StereopermutatorList(const StereopermutatorList& other);
  StereopermutatorList& operator = (const StereopermutatorList& other);
  ~StereopermutatorList();
 
 
  AtomStereopermutator& at(AtomIndex index);
 
  BondStereopermutator& at(const BondIndex& index);
  AtomStereopermutator& add(AtomStereopermutator stereopermutator);
 
  BondStereopermutator& add(BondStereopermutator stereopermutator);
 
  void applyPermutation(const std::vector<AtomIndex>& permutation);
 
  void clear();
 
  void clearBonds();
 
  boost::optional<AtomStereopermutator&> option(AtomIndex index);
 
  boost::optional<BondStereopermutator&> option(const BondIndex& edge);
 
  void propagateVertexRemoval(AtomIndex removedIndex);
 
  bool remove(AtomIndex index);
 
  bool remove(const BondIndex& edge);
 
  [[deprecated("Prefer remove")]]
  void try_remove(AtomIndex index);
 
  [[deprecated("Prefer remove")]]
  void try_remove(const BondIndex& edge);
 
 
  const AtomStereopermutator& at(AtomIndex index) const;
 
  const BondStereopermutator& at(const BondIndex& index) const;
 
  bool compare(
    const StereopermutatorList& other,
    AtomEnvironmentComponents componentBitmask
  ) const;
 
  bool empty() const;
 
  bool hasZeroAssignmentStereopermutators() const;
 
  bool hasUnassignedStereopermutators() const;
 
  boost::optional<const AtomStereopermutator&> option(AtomIndex index) const;
 
  boost::optional<const BondStereopermutator&> option(const BondIndex& edge) const;
 
  unsigned A() const;
 
  unsigned B() const;
 
  unsigned size() const;
 
 
  IteratorRange<AtomStereopermutatorIterator> atomStereopermutators();
 
  IteratorRange<AtomStereopermutatorConstIterator> atomStereopermutators() const;
 
  IteratorRange<BondStereopermutatorIterator> bondStereopermutators();
 
  IteratorRange<BondStereopermutatorConstIterator> bondStereopermutators() const;
 
 
  bool operator == (const StereopermutatorList& other) const;
  bool operator != (const StereopermutatorList& other) const;
 
private:
  std::unique_ptr<Impl> impl_;
};
 
} // namespace Molassembler
} // namespace Scine
#endif