processes.hpp

Go to the documentation of this file.

#pragma once

#include <optional>
#include <string>
#include <utility>
#include <variant>
#include <vector>

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

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_type, 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

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

  template <class Element, template <class> class Chain>
  class node final
      : protected std::variant<element_wrapper<Element>, Chain<Element>> {

  public:
    using base_type = std::variant<element_wrapper<Element>, Chain<Element>>;
    using element_type = element_wrapper<Element>;
    using chain_type = Chain<Element>;

    using base_type::base_type;

    bool is_element() const {
      return this->type() == processes::node_type::element;
    }

    bool is_reaction() const {
      return type() == processes::node_type::reaction;
    }

    bool is_decay() const {
      return this->type() == processes::node_type::decay;
    }

    processes::node_type type() const {

      if (std::holds_alternative<element_type>(*this))
        return processes::node_type::element;
      else {
        if constexpr (utils::is_template_specialization_v<chain_type, reaction>)
          return processes::node_type::reaction;
        else if constexpr (utils::is_template_specialization_v<chain_type,
                                                               decay>)
          return processes::node_type::decay;
        else
          static_assert(utils::dependent_false_v<decltype(*this)>,
                        "Unexpected internal compile-time error");
      }
    }

    Element const &as_element() const { return *as_element_wrapper(); }

    chain_type const &as_chain() const {
      return std::get<Chain<Element>>(*this);
    }

  protected:
    element_type const &as_element_wrapper() const {
      return std::get<element_type>(*this);
    }
  };

  namespace processes::detail {
    template <class Element, template <class> class Chain>
    inline bool check_nodes(std::vector<node<Element, Chain>> const &first,
                            std::vector<node<Element, Chain>> 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_type::element):
            if (first[i].as_element() == second[i].as_element())
              mask[j] = true;
            break;
          case (processes::node_type::reaction):
            if (first[i].as_chain() == second[i].as_chain())
              mask[j] = true;
            break;
          case (processes::node_type::decay):
            if (first[i].as_chain() == second[i].as_chain())
              mask[j] = true;
            break;
          case (processes::node_type::unknown_node_type):
            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:
    element_wrapper(Element &&e) : m_element{std::move(e)} {}
    ~element_wrapper() = 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:
    using element_type = element_wrapper<Element>; 
    using builder_type =
        element_traits::builder_tpl_t<Element>; 
    using nodes_type =
        std::vector<node<Element, reaction>>; 

    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} {}

    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) {

      nodes_type *current_set = &m_reactants;

      auto fill_element =
          [&](std::string::const_iterator const &start) -> void {
        current_set->emplace_back(builder(std::string{start, sit}));
      };
      auto fill_reaction = [&]() -> void {
        current_set->emplace_back(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:
    using element_type = element_wrapper<Element>;
    using builder_type = element_traits::builder_tpl_t<Element>;
    using nodes_type = std::vector<node<Element, decay>>;

    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} {}

    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) {

      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(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.emplace_back(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