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