Molecule.h

Go to the documentation of this file.

#ifndef INCLUDE_MOLASSEMBLER_MOLECULE_H
#define INCLUDE_MOLASSEMBLER_MOLECULE_H

#include "boost/optional.hpp"

#include "Molassembler/Options.h"

namespace Scine {
// External forward declarations
namespace Utils {
using ElementTypeCollection = std::vector<ElementType>;
class AtomCollection;
} // namespace Utils

namespace Molassembler {

// Forward declarations
class Graph;
class StereopermutatorList;
struct RankingInformation;

class MASM_EXPORT Molecule {
public:


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

  /* Rule of five members */
  Molecule(Molecule&& other) noexcept;
  Molecule& operator = (Molecule&& rhs) noexcept;
  Molecule(const Molecule& other);
  Molecule& operator = (const Molecule& rhs);
  ~Molecule();

  Molecule() noexcept;

  Molecule(Utils::ElementType element) noexcept;

  Molecule(
    Utils::ElementType a,
    Utils::ElementType b,
    BondType bondType = BondType::Single
  ) noexcept;

  explicit Molecule(Graph graph);

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

  MASM_NO_EXPORT Molecule(
    Graph graph,
    StereopermutatorList stereopermutators,
    boost::optional<AtomEnvironmentComponents> canonicalComponentsOption = boost::none
  );


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

  BondIndex addBond(
    AtomIndex a,
    AtomIndex b,
    BondType bondType = BondType::Single
  );

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

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

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

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

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

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

  void removeAtom(AtomIndex a);

  void removeBond(AtomIndex a, AtomIndex b);

  void removeBond(const BondIndex& bond);

  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;

  std::string str() const;

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


  bool canonicalCompare(
    const Molecule& other,
    AtomEnvironmentComponents componentBitmask = AtomEnvironmentComponents::All
  ) const;

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


  bool operator == (const Molecule& other) const;
  bool operator != (const Molecule& other) const;

private:
  struct Impl;
  std::unique_ptr<Impl> pImpl_;

  /* Allow access to implementation to editor class that enables more
   * macro-oriented editing as opposed to the low-level editing provided here
   */
  friend struct Editing;

  /* Allow access to implementation to DirectedConformerGenerator. This class
   * needs to make additions to the StereopermutatorList that should not be
   * part of the public interface.
   */
  friend class DirectedConformerGenerator;
};

} // namespace Molassembler
} // namespace Scine

MASM_EXPORT std::ostream& operator << (
  std::ostream& os,
  const Scine::Molassembler::Molecule& molecule
);

#endif