SmilesParseData.h

Go to the documentation of this file.

#ifndef INCLUDE_MOLASSEMBLER_IO_SMILES_PARSER_DATA_H
#define INCLUDE_MOLASSEMBLER_IO_SMILES_PARSER_DATA_H

#include <boost/fusion/adapted/struct/adapt_struct.hpp>
#include <boost/fusion/include/adapt_struct.hpp>

#include "Utils/Geometry/ElementInfo.h"
#include "Molassembler/Shapes/Shapes.h"
#include "boost/optional.hpp"
#include "Molassembler/Types.h"

namespace Scine {
namespace Molassembler {
namespace IO {

struct ElementData {
  unsigned Z = 0;
  bool aromatic = false;

  ElementData() = default;
  explicit ElementData(Utils::ElementType e) : Z(Utils::ElementInfo::Z(e)) {}

  static inline ElementData aromaticElement(Utils::ElementType e) {
    ElementData d(e);
    d.aromatic = true;
    return d;
  }
};

struct ChiralData {
  Shapes::Shape shape;
  unsigned chiralIndex;
};

struct AtomData {
  unsigned A = 0;
  ElementData partialElement;
  boost::optional<ChiralData> chiralOptional;
  boost::optional<unsigned> hCount;
  boost::optional<int> chargeOptional;
  bool atomBracket = false;

  inline Utils::ElementType getElement() const {
    if(partialElement.Z == 0) {
      return Utils::ElementType::none;
    }

    if(A == 0) {
      return Utils::ElementInfo::element(partialElement.Z);
    }

    return Utils::ElementInfo::isotope(partialElement.Z, A);
  }
};

enum class SmilesBondType {
  Single,
  Double,
  Triple,
  Quadruple,
  Aromatic,
  Forward,
  Backward
};

struct BondData {
  static BondType toBondType(SmilesBondType b) {
    switch(b) {
      case SmilesBondType::Single:
      case SmilesBondType::Aromatic:
      case SmilesBondType::Forward:
      case SmilesBondType::Backward:
        return BondType::Single;
      case SmilesBondType::Double:
        return BondType::Double;
      case SmilesBondType::Triple:
        return BondType::Triple;
      case SmilesBondType::Quadruple:
        return BondType::Quadruple;
      default:
        throw std::logic_error("Unhandled bond type");
    }
  }

  boost::optional<SmilesBondType> type;
  boost::optional<unsigned> ringNumber;
};

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

BOOST_FUSION_ADAPT_STRUCT(
  Scine::Molassembler::IO::ElementData,
  (unsigned, Z),
  (bool, aromatic)
)

BOOST_FUSION_ADAPT_STRUCT(
  Scine::Molassembler::IO::ChiralData,
  (Scine::Molassembler::Shapes::Shape, shape),
  (unsigned, chiralIndex)
)

BOOST_FUSION_ADAPT_STRUCT(
  Scine::Molassembler::IO::AtomData,
  (unsigned, A),
  (Scine::Molassembler::IO::ElementData, partialElement),
  (boost::optional<Scine::Molassembler::IO::ChiralData>, chiralOptional),
  (boost::optional<unsigned>, hCount),
  (boost::optional<int>, chargeOptional),
  (bool, atomBracket)
)

BOOST_FUSION_ADAPT_STRUCT(
  Scine::Molassembler::IO::BondData,
  (boost::optional<Scine::Molassembler::BondType>, type),
  (boost::optional<unsigned>, ringNumber)
)

#endif