MoleculeImpl.h

Go to the documentation of this file.

#ifndef INCLUDE_MOLASSEMBLER_MOLECULE_IMPL_H
#define INCLUDE_MOLASSEMBLER_MOLECULE_IMPL_H

#include "Molassembler/Molecule.h"

#include "Molassembler/Graph.h"
#include "Molassembler/Graph/PrivateGraph.h"
#include "Molassembler/StereopermutatorList.h"
#include "Utils/Geometry/AtomCollection.h"

namespace Scine {
namespace Molassembler {

struct Molecule::Impl {
  static Utils::AtomCollection applyCanonicalizationMap(
    const std::vector<AtomIndex>& canonicalizationIndexMap,
    const Utils::AtomCollection& atomCollection
  );

  Graph adjacencies_;
  StereopermutatorList stereopermutators_;
  boost::optional<AtomEnvironmentComponents> canonicalComponentsOption_;

/* "Private" helpers */
  void tryAddAtomStereopermutator_(
    AtomIndex candidateIndex,
    StereopermutatorList& stereopermutators
  ) const;

  void tryAddBondStereopermutator_(
    const BondIndex& bond,
    StereopermutatorList& stereopermutators
  ) const;

  StereopermutatorList detectStereopermutators_() const;

  void ensureModelInvariants_() const;

  bool isValidIndex_(AtomIndex index) const;

  bool isGraphBasedBondStereopermutatorCandidate_(BondType bondType) const;

  void propagateGraphChange_();


  Impl() noexcept;

  Impl(Utils::ElementType element) noexcept;

  Impl(
    Utils::ElementType a,
    Utils::ElementType b,
    BondType bondType
  ) noexcept;

  explicit Impl(Graph graph);

  Impl(
    Graph graph,
    const AngstromPositions& positions,
    const boost::optional<
      std::vector<BondIndex>
    >& bondStereopermutatorCandidatesOptional = boost::none
  );

  Impl(
    Graph graph,
    StereopermutatorList stereopermutators,
    boost::optional<AtomEnvironmentComponents> canonicalComponentsOption
  );

  AtomIndex addAtom(
    Utils::ElementType elementType,
    AtomIndex adjacentTo,
    BondType bondType
  );

  BondIndex addBond(
    AtomIndex a,
    AtomIndex b,
    BondType bondType
  );

  void applyPermutation(const std::vector<AtomIndex>& permutation);

  void assignStereopermutator(
    AtomIndex a,
    const boost::optional<unsigned>& assignment
  );

  void assignStereopermutator(
    const BondIndex& edge,
    const boost::optional<unsigned>& assignment
  );

  void assignStereopermutatorRandomly(AtomIndex a, Random::Engine& engine);

  void assignStereopermutatorRandomly(const BondIndex& e, Random::Engine& engine);

  std::vector<AtomIndex> canonicalize(
    AtomEnvironmentComponents componentBitmask
  );

  void removeAtom(AtomIndex a);

  void removeBond(AtomIndex a, AtomIndex b);

  bool setBondType(
    AtomIndex a,
    AtomIndex b,
    BondType bondType
  );

  void setElementType(
    AtomIndex a,
    Utils::ElementType elementType
  );

  void setShapeAtAtom(
    AtomIndex a,
    Shapes::Shape shape
  );

  boost::optional<AtomEnvironmentComponents> canonicalComponents() const;

  boost::optional<Shapes::Shape> inferShape(
    AtomIndex index,
    const RankingInformation& ranking
  ) const;

  std::string dumpGraphviz() const;

  const Graph& graph() const;

  std::size_t hash() const;

  const StereopermutatorList& stereopermutators() const;

  StereopermutatorList inferStereopermutatorsFromPositions(
    const AngstromPositions& angstromWrapper,
    const boost::optional<
      std::vector<BondIndex>
    >& explicitBondStereopermutatorCandidatesOption = boost::none
  ) const;

  bool canonicalCompare(
    const Impl& other,
    AtomEnvironmentComponents componentBitmask
  ) const;

  boost::optional<std::vector<AtomIndex>> modularIsomorphism(
    const Impl& other,
    AtomEnvironmentComponents componentBitmask
  ) const;

  std::string str() const;

  RankingInformation rankPriority(
    AtomIndex a,
    const std::vector<AtomIndex>& excludeAdjacent = {},
    const boost::optional<AngstromPositions>& positionsOption = boost::none
  ) const;

  bool operator == (const Impl& other) const;
  bool operator != (const Impl& other) const;
};

} // namespace Molassembler
} // namespace Scine

#endif