SmilesMoleculeBuilder.h

Go to the documentation of this file.

#ifndef INCLUDE_MOLASSEMBLER_IO_SMILES_MOLECULE_BUILDER_H
#define INCLUDE_MOLASSEMBLER_IO_SMILES_MOLECULE_BUILDER_H

#include "Molassembler/Shapes/Data.h"
#include "Molassembler/IO/SmilesParseData.h"
#include "Molassembler/Graph/PrivateGraph.h"
#include "boost/variant.hpp"
#include "boost/bimap.hpp"
#include "boost/graph/subgraph.hpp"
#include <stack>

namespace Scine {

namespace Utils {
enum class ElementType : unsigned;
} // namespace Utils


namespace Molassembler {

class Molecule;

namespace IO {

struct PiSubgraph {
  using BaseGraph = boost::adjacency_list<
    boost::vecS,
    boost::vecS,
    boost::undirectedS,
    boost::no_property,
    boost::property<boost::edge_index_t, int>
  >;
  using Graph = boost::subgraph<BaseGraph>;
  using Vertex = typename BaseGraph::vertex_descriptor;
  using Edge = typename BaseGraph::edge_descriptor;
  using IndexMap = boost::bimap<Vertex, Vertex>;
  using VertexSet = std::unordered_set<Vertex>;

  static bool hasUnpairedElectrons(Vertex i, int charge, const PrivateGraph& g);

  static bool permittedElementType(Utils::ElementType e) {
    switch(e) {
      case Utils::ElementType::C:
      case Utils::ElementType::N:
      case Utils::ElementType::O:
      case Utils::ElementType::S:
      case Utils::ElementType::P:
      case Utils::ElementType::As:
      case Utils::ElementType::Sb:
      case Utils::ElementType::Se:
      case Utils::ElementType::Te: {
        return true;
      }
      default:
        return false;
    }
  }

  struct EligibleOmissible {
    bool eligible;
    bool omissible;
  };

  static EligibleOmissible eligibleOmissible(
    Vertex i,
    const PrivateGraph& component,
    const AtomData& atomData
  );

  static boost::optional<EligibleOmissible> multipleOrderAdjacent(
    Vertex i,
    const PrivateGraph& component,
    const AtomData& atomData,
    const boost::optional<unsigned>& neighborCount
  );

  static boost::optional<EligibleOmissible> threeNeighborChargedCarbon(
    Vertex i,
    const PrivateGraph& component,
    const AtomData& atomData,
    const boost::optional<unsigned>& neighborCount
  );

  static boost::optional<EligibleOmissible> neutralTrivalents(
    Vertex i,
    const PrivateGraph& component,
    const AtomData& atomData,
    const boost::optional<unsigned>& neighborCount
  );

  static boost::optional<EligibleOmissible> neutralDivalents(
    Vertex i,
    const PrivateGraph& component,
    const AtomData& atomData,
    const boost::optional<unsigned>& neighborCount
  );

  Vertex findOrAdd(Vertex i) {
    const auto iter = index.left.find(i);
    if(iter == index.left.end()) {
      const Vertex a = boost::add_vertex(graph);
      index.insert(IndexMap::relation(i, a));
      return a;
    }
    return iter->second;
  }

  /* Find a perfect matching of the subgraph, considering optionally omissible
   * vertices.
   *
   * @note This is non-const because creating subgraphs mutates the parent
   * subgraph instances
   */
  boost::optional<VertexSet> match();

  Graph graph;
  IndexMap index;
  VertexSet omissible;
};

class MoleculeBuilder {
public:
  /* @brief Parsing trigger on encountering an atom
   *
   * Adds an atom with the last set bond information.
   */
  void addAtom(AtomData atom);

  void addRingClosure(const BondData& bond);

  inline void branchOpen() {
    vertexStack.push(vertexStack.top());
  }

  inline void branchClose() {
    assert(!vertexStack.empty());
    vertexStack.pop();
  }

  inline void setNextAtomUnbonded() {
    lastBondData = boost::none;
  }

  inline void setNextAtomBondInformation(const BondData& bond) {
    lastBondData = bond;
  }

  std::vector<Molecule> interpret(const std::string& smiles);

private:

  static BondType mutualBondType(
    const boost::optional<BondType>& a,
    const boost::optional<BondType>& b
  );

  static std::vector<Shapes::Vertex> shapeMap(const ChiralData& chiralData);

  std::unordered_set<PrivateGraph::Vertex> matchAromatics(
    std::vector<PrivateGraph>& precursors,
    const std::vector<unsigned>& componentMap,
    const std::vector<PrivateGraph::Vertex>& indexInComponentMap
  ) const;

  void setShapes(
    std::vector<Molecule>& molecules,
    const std::vector<unsigned>& componentMap,
    const std::vector<PrivateGraph::Vertex>& indexInComponentMap
  );

  void setAtomStereo(
    std::vector<Molecule>& molecules,
    const std::vector<unsigned>& componentMap,
    const std::vector<PrivateGraph::Vertex>& indexInComponentMap,
    const std::string& smiles
  );

  void setBondStereo(
    std::vector<Molecule>& molecules,
    const std::vector<unsigned>& componentMap,
    const std::vector<PrivateGraph::Vertex>& indexInComponentMap,
    const std::string& smiles
  );

  void addAromaticBondStereo(
    std::vector<Molecule>& molecules,
    const std::vector<unsigned>& componentMap,
    const std::vector<PrivateGraph::Vertex>& indexInComponentMap
  );

  boost::optional<BondData> lastBondData;

  PrivateGraph graph;

  std::stack<PrivateGraph::Vertex> vertexStack;

  using StereoMarkedBondTuple = std::tuple<PrivateGraph::Vertex, PrivateGraph::Vertex, SmilesBondType>;
  std::vector<StereoMarkedBondTuple> stereoMarkedBonds;

  std::vector<PrivateGraph::Edge> piSubgraphEdges;

  std::unordered_map<
    unsigned,
    std::pair<PrivateGraph::Vertex, boost::optional<BondType>>
  > ringClosures;

  std::vector<AtomData> vertexData;
};

} // namespace IO
} // namespace Molassembler
} // namespace Scine

#endif