processes.hpp

Go to the documentation of this file.

#pragma once

#include "reactions/element_traits.hpp"
#include "reactions/exceptions.hpp"
#include "reactions/pow_enum.hpp"
#include "reactions/tokens.hpp"

#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <utility>
#include <vector>

namespace reactions {

  // Forward declarations
  template <class Element> class element_wrapper;
  template <class Element> class reaction;
  template <class Element> class decay;

  namespace processes {
    REACTIONS_POW_ENUM_WITH_UNKNOWN(node_kind, element, reaction, decay);

    template <class FillElement, class FillExpression, class ArrowSwitch>
    void process_expression(std::string::const_iterator &sit,
                            std::string::const_iterator const &end,
                            FillElement fill_element,
                            FillExpression fill_expression,
                            ArrowSwitch arrow_switch) {

      while (tokens::match_token<tokens::space>(sit))
        ++sit; // remove leading spaces

      if (tokens::match_token<tokens::left_bra>(sit))
        throw reactions::exceptions::__syntax_error(
            "Expression starts with another expression", end - sit);

      auto start = sit; // keep track of the beginning of an expression
      while (sit != end) {

        if (tokens::match_token<tokens::space>(sit)) {

          if (sit == start) {
            // remove consecutive spaces
            start = ++sit;
            continue;
          } else {
            // add the new element
            fill_element(start);
            start = (sit += tokens::space::size);
            continue;
          }
        } else if (tokens::match_token<tokens::left_bra>(sit)) {

          if (sit == start) {

            sit += tokens::left_bra::size;

            // begin a new expression
            fill_expression();

            if (!tokens::match_token<tokens::right_bra>(sit))
              throw reactions::exceptions::__syntax_error(
                  "Expected closing braces", end - sit);

            start = (sit += tokens::right_bra::size);

            continue;

          } else {
            // add the new element
            fill_element(start);
            start = sit; // end up in the previous conditional
            continue;
          }
        } else if (tokens::match_token<tokens::right_bra>(sit)) {

          if (sit != start) {
            fill_element(start);
            start = sit;
          }

          break;

        } else if (tokens::match_token<tokens::arrow>(sit)) {

          if (sit != start)
            fill_element(start);

          start = (sit += tokens::arrow::size);

          // switch to the products
          arrow_switch();

          continue;

        } else
          ++sit;
      }

      if (sit != start)
        fill_element(start);
    }

    template <class Process>
    Process make_process(std::string const &str,
                         typename Process::builder_type builder) {

      try {

        auto sit = str.cbegin();
        auto const send = str.cend();

        Process p{sit, send, builder};

        if (sit != send) {
          if (tokens::match_token<tokens::right_bra>(sit))
            throw reactions::exceptions::__syntax_error("Mismatching braces",
                                                        send - sit);
          else
            throw reactions::exceptions::__syntax_error("Invalid syntax",
                                                        send - sit);
        }

        return p;

      } catch (reactions::exceptions::__syntax_error &e) {
        throw e.update(str);
      }
    }
  } // namespace processes

  struct node_object {
    node_object() = default;
    node_object(node_object const &) = default;
    node_object(node_object &&) = default;
    node_object &operator=(node_object const &) = default;
    virtual ~node_object() = default;
  };

  template <class Element> class node final {

  public:
    using element_type = element_wrapper<Element>;
    using reaction_type = reaction<Element>;
    using decay_type = decay<Element>;

    node(std::unique_ptr<element_type> &&ptr)
        : m_type{std::move(processes::node_kind::element)},
          m_ptr{ptr.release()} {}

    node(std::unique_ptr<reaction_type> &&ptr)
        : m_type{std::move(processes::node_kind::reaction)},
          m_ptr{ptr.release()} {}

    node(std::unique_ptr<decay_type> &&ptr)
        : m_type{std::move(processes::node_kind::decay)}, m_ptr{ptr.release()} {
    }

    node(node &&other) : m_type{other.m_type}, m_ptr{other.m_ptr} {
      other.m_ptr = nullptr;
    }

    ~node() noexcept(false) {

      if (m_ptr) {
        switch (m_type) {
        case (processes::node_kind::element):
          delete ptr_as_element_wrapper();
          return;
        case (processes::node_kind::reaction):
          delete ptr_as_reaction();
          return;
        case (processes::node_kind::decay):
          delete ptr_as_decay();
          return;
        case (processes::node_kind::unknown):
          throw reactions::internal_error(
              "A node type should always be set (internal error); please "
              "report the bug");
        }
      }
    }

    node() = delete;
    node(node const &) = delete;
    node &operator=(node const &) = delete;

    bool is_element() const { return m_type == processes::node_kind::element; }

    bool is_reaction() const {
      return m_type == processes::node_kind::reaction;
    }

    bool is_decay() const { return m_type == processes::node_kind::decay; }

    processes::node_kind type() const { return m_type; }

    node_object const *object() const { return m_ptr; }

    Element const *ptr_as_element() const {
      return ptr_as_element_wrapper()->operator->();
    }

    reaction_type const *ptr_as_reaction() const {
      return static_cast<reaction_type *>(m_ptr);
    }

    decay_type const *ptr_as_decay() const {
      return static_cast<decay_type *>(m_ptr);
    }

  protected:
    element_type const *ptr_as_element_wrapper() const {
      return static_cast<element_type *>(m_ptr);
    }

  private:
    processes::node_kind m_type = processes::node_kind::unknown;

    node_object *m_ptr = nullptr;
  };

  namespace processes::detail {
    template <class Element>
    inline bool check_nodes(std::vector<node<Element>> const &first,
                            std::vector<node<Element>> const &second) {

      auto size = first.size();

      if (size != second.size())
        return false;

      // two masks to count the elements that are gone
      std::vector<bool> mask(size, false);

      for (auto i = 0u; i < size; ++i) {

        for (auto j = 0u; j < size; ++j) {

          if (mask[j])
            // already used
            continue;

          if (second[j].type() != first[i].type())
            // different types
            continue;

          switch (first[i].type()) {
          case (processes::node_kind::element):
            if (*(first[i].ptr_as_element()) == *(second[i].ptr_as_element()))
              mask[j] = true;
            break;
          case (processes::node_kind::reaction):
            if (*(first[i].ptr_as_reaction()) == *(second[i].ptr_as_reaction()))
              mask[j] = true;
            break;
          case (processes::node_kind::decay):
            if (*(first[i].ptr_as_decay()) == *(second[i].ptr_as_decay()))
              mask[j] = true;
            break;
          case (processes::node_kind::unknown):
            throw reactions::internal_error(
                "A node can not be of unknown type (internal error); please "
                "report the bug");
            break;
          }
        }
        // if we reach this point, no match has been found for "first[i]"
        return false;
      }

      // all of them have been matched
      return true;
    }
  } // namespace processes::detail
} // namespace reactions

namespace reactions {

  template <class Element> class element_wrapper final : public node_object {

  public:
    element_wrapper(Element &&e) : node_object{}, m_element{std::move(e)} {}
    ~element_wrapper() override = default;
    element_wrapper(const element_wrapper &) = default;
    element_wrapper(element_wrapper &&) = default;
    element_wrapper &operator=(const element_wrapper &) = default;
    // No empty constructor
    element_wrapper() = delete;
    Element const &operator*() const { return m_element; }
    Element const *operator->() const { return &m_element; }

  protected:
    Element m_element;
  };

  template <class Element> class reaction final : public node_object {

  public:
    using element_type = element_wrapper<Element>; 
    using builder_type =
        element_traits::builder_tpl_t<Element>; 
    using nodes_type = std::vector<node<Element>>; 

    reaction(reaction &&) = default;
    reaction(const reaction &) = default;
    reaction &operator=(const reaction &) = default;
    ~reaction() = default;
    // No empty constructor
    reaction() = delete;

    nodes_type const &reactants() const { return m_reactants; }

    nodes_type const &products() const { return m_products; }

    bool operator==(reaction<Element> const &other) const {

      if (m_reactants.size() != other.m_reactants.size() ||
          m_products.size() != other.m_products.size())
        return false;

      return processes::detail::check_nodes(m_reactants, other.m_reactants) &&
             processes::detail::check_nodes(m_products, other.m_products);
    }

    bool operator!=(reaction<Element> const &other) const {
      return !(*this == other);
    }

  protected:
    reaction(std::string::const_iterator &&begin,
             std::string::const_iterator const &end, builder_type builder)
        : reaction{begin, end, builder} {}

    // Create a new instance using the protected constructor
    friend std::unique_ptr<reaction>
    std::make_unique<reaction>(std::string::const_iterator &,
                               std::string::const_iterator const &,
                               builder_type);

    template <class Process>
    friend Process
    reactions::processes::make_process(std::string const &,
                                       typename Process::builder_type);

    reaction(std::string::const_iterator &sit,
             std::string::const_iterator const &end, builder_type builder)
        : node_object{} {

      nodes_type *current_set = &m_reactants;

      auto fill_element =
          [&](std::string::const_iterator const &start) -> void {
        current_set->push_back(
            std::make_unique<element_type>(builder(std::string{start, sit})));
      };
      auto fill_reaction = [&]() -> void {
        current_set->push_back(std::make_unique<reaction>(sit, end, builder));
      };
      auto arrow_switch = [&]() -> void {
        if (!m_reactants.size())
          throw reactions::exceptions::__syntax_error("Missing reactants",
                                                      end - sit);

        if (current_set == &m_products)
          throw reactions::exceptions::__syntax_error("Duplicated arrow",
                                                      end - sit);

        current_set = &m_products;
      };

      processes::process_expression(sit, end, fill_element, fill_reaction,
                                    arrow_switch);

      if (!m_reactants.size())
        throw reactions::exceptions::__syntax_error("Missing reactants",
                                                    end - sit);

      if (!m_products.size())
        throw reactions::exceptions::__syntax_error("Missing products",
                                                    end - sit);
    }

    nodes_type m_reactants;
    nodes_type m_products;
  };

  template <class Element> class decay final : public node_object {

  public:
    using element_type = element_wrapper<Element>;
    using builder_type = element_traits::builder_tpl_t<Element>;
    using nodes_type = std::vector<node<Element>>;

    decay(decay &&) = default;
    decay(const decay &) = default;
    decay &operator=(const decay &) = default;
    ~decay() = default;

    decay() = delete;

    Element const &head() const { return *(*m_head); }

    nodes_type const &products() const { return m_products; }

    bool operator==(decay<Element> const &other) const {

      if (m_products.size() != other.m_products.size())
        return false;

      return (*m_head == *other.m_head) &&
             processes::detail::check_nodes(m_products, other.m_products);
    }

    bool operator!=(decay<Element> const &other) const {
      return !(*this == other);
    }

  protected:
    decay(std::string::const_iterator &&begin,
          std::string::const_iterator const &end, builder_type builder)
        : decay{begin, end, builder} {}

    friend std::unique_ptr<decay>
    std::make_unique<decay>(std::string::const_iterator &,
                            std::string::const_iterator const &, builder_type);

    template <class Process>
    friend Process
    reactions::processes::make_process(std::string const &,
                                       typename Process::builder_type);

    decay(std::string::const_iterator &sit,
          std::string::const_iterator const &end, builder_type builder)
        : node_object{} {

      bool fill_products = false; // keep track of the elements we are adding

      auto fill_element =
          [&](std::string::const_iterator const &start) -> void {
        if (!m_head) {
          this->m_head.emplace(builder(std::string{start, sit}));
        } else if (fill_products) {
          this->m_products.emplace_back(
              std::make_unique<element_type>(builder(std::string{start, sit})));
        } else
          throw reactions::exceptions::__syntax_error("Missing arrow",
                                                      end - start);
      };
      auto fill_decay = [&] {
        if (!m_head) {
          throw reactions::exceptions::__syntax_error("Missing head",
                                                      end - sit);
        } else if (fill_products) {
          this->m_products.push_back(
              std::make_unique<decay>(sit, end, builder));
        } else
          throw reactions::exceptions::__syntax_error("Missing arrow",
                                                      end - sit);
      };
      auto arrow_switch = [&] {
        if (fill_products)
          throw reactions::exceptions::__syntax_error("Duplicated arrow",
                                                      end - sit);

        else if (!m_head)
          throw reactions::exceptions::__syntax_error("Missing head particle",
                                                      end - sit);

        fill_products = true;
      };

      processes::process_expression(sit, end, fill_element, fill_decay,
                                    arrow_switch);

      if (!m_head)
        throw reactions::exceptions::__syntax_error(
            "No elements have been parsed", end - sit);

      if (!m_products.size())
        throw reactions::exceptions::__syntax_error("Expected products",
                                                    end - sit);
    }

    std::optional<element_type> m_head;
    nodes_type m_products;
  };

  template <class Element>
  reaction<Element>
  make_reaction_for(std::string const &str,
                    typename reaction<Element>::builder_type builder) {
    return processes::make_process<reaction<Element>>(str, builder);
  }

  template <class Element>
  reaction<Element> make_reaction(std::string const &str) {
    return make_reaction_for<Element>(str, element_traits::builder<Element>);
  }

  template <class Element>
  decay<Element> make_decay_for(std::string const &str,
                                typename decay<Element>::builder_type builder) {
    return processes::make_process<decay<Element>>(str, builder);
  }

  template <class Element> decay<Element> make_decay(std::string const &str) {
    return make_decay_for<Element>(str, element_traits::builder<Element>);
  }
} // namespace reactions