test_BuiltinFunctionRegister.hpp

#ifndef TEST_BUILTIN_FUNCTION_REGISTER_H
#define TEST_BUILTIN_FUNCTION_REGISTER_H

#include <language/utils/ASTNodeDataTypeTraits.hpp>
#include <language/utils/BuiltinFunctionEmbedder.hpp>
#include <language/utils/TypeDescriptor.hpp>
#include <utils/Exceptions.hpp>

template <>
inline ASTNodeDataType ast_node_data_type_from<std::shared_ptr<const double>> =
  ASTNodeDataType::build<ASTNodeDataType::type_id_t>("builtin_t");
const auto builtin_data_type = ast_node_data_type_from<std::shared_ptr<const double>>;

namespace test_only
{
class test_BuiltinFunctionRegister
{
 private:
  std::unordered_map<std::string, std::shared_ptr<IBuiltinFunctionEmbedder>> m_name_builtin_function_map;

  void
  _populateNameBuiltinFunctionMap()
  {
    m_name_builtin_function_map.insert(
      std::make_pair("runtimeError", std::make_shared<BuiltinFunctionEmbedder<void(void)>>(
                                       [](void) -> void { throw NormalError("runtime error"); })));

    m_name_builtin_function_map.insert(std::make_pair("RtoR", std::make_shared<BuiltinFunctionEmbedder<double(double)>>(
                                                                [](double x) -> double { return x + 1; })));

    m_name_builtin_function_map.insert(
      std::make_pair("ZtoR", std::make_shared<BuiltinFunctionEmbedder<double(int64_t)>>(
                               [](int64_t z) -> double { return 0.5 * z; })));

    m_name_builtin_function_map.insert(
      std::make_pair("NtoR", std::make_shared<BuiltinFunctionEmbedder<double(uint64_t)>>(
                               [](uint64_t n) -> double { return 0.5 * n; })));

    m_name_builtin_function_map.insert(std::make_pair("BtoR", std::make_shared<BuiltinFunctionEmbedder<double(bool)>>(
                                                                [](bool b) -> double { return b; })));

    m_name_builtin_function_map.insert(
      std::make_pair("RRtoB", std::make_shared<BuiltinFunctionEmbedder<bool(double, double)>>(
                                [](double x, double y) -> bool { return x > y; })));

    m_name_builtin_function_map.insert(
      std::make_pair("StoB", std::make_shared<BuiltinFunctionEmbedder<bool(std::string)>>(
                               [](const std::string& s) -> bool { return s.size() > 0; })));

    m_name_builtin_function_map.insert(
      std::make_pair("RtoR1", std::make_shared<BuiltinFunctionEmbedder<TinyVector<1>(double)>>(
                                [](double r) -> TinyVector<1> { return {r}; })));

    m_name_builtin_function_map.insert(
      std::make_pair("R1toR", std::make_shared<BuiltinFunctionEmbedder<double(TinyVector<1>)>>(
                                [](TinyVector<1> x) -> double { return x[0]; })));

    m_name_builtin_function_map.insert(
      std::make_pair("R2toR", std::make_shared<BuiltinFunctionEmbedder<double(TinyVector<2>)>>(
                                [](TinyVector<2> x) -> double { return x[0] + x[1]; })));

    m_name_builtin_function_map.insert(
      std::make_pair("R3toR", std::make_shared<BuiltinFunctionEmbedder<double(const TinyVector<3>&)>>(
                                [](const TinyVector<3>& x) -> double { return x[0] + x[1] + x[2]; })));

    m_name_builtin_function_map.insert(
      std::make_pair("R3R2toR",
                     std::make_shared<BuiltinFunctionEmbedder<double(TinyVector<3>, TinyVector<2>)>>(
                       [](TinyVector<3> x, TinyVector<2> y) -> double { return x[0] * y[1] + (y[0] - x[2]) * x[1]; })));

    m_name_builtin_function_map.insert(
      std::make_pair("RtoR11", std::make_shared<BuiltinFunctionEmbedder<TinyMatrix<1>(double)>>(
                                 [](double r) -> TinyMatrix<1> { return {r}; })));

    m_name_builtin_function_map.insert(
      std::make_pair("R11toR", std::make_shared<BuiltinFunctionEmbedder<double(TinyMatrix<1>)>>(
                                 [](TinyMatrix<1> x) -> double { return x(0, 0); })));

    m_name_builtin_function_map.insert(
      std::make_pair("R22toR", std::make_shared<BuiltinFunctionEmbedder<double(TinyMatrix<2>)>>(
                                 [](TinyMatrix<2> x) -> double { return x(0, 0) + x(0, 1) + x(1, 0) + x(1, 1); })));

    m_name_builtin_function_map.insert(
      std::make_pair("R33toR", std::make_shared<BuiltinFunctionEmbedder<double(const TinyMatrix<3>&)>>(
                                 [](const TinyMatrix<3>& x) -> double { return x(0, 0) + x(1, 1) + x(2, 2); })));

    m_name_builtin_function_map.insert(
      std::make_pair("R33R22toR", std::make_shared<BuiltinFunctionEmbedder<double(TinyMatrix<3>, TinyMatrix<2>)>>(
                                    [](TinyMatrix<3> x, TinyMatrix<2> y) -> double {
                                      return (x(0, 0) + x(1, 1) + x(2, 2)) * (y(0, 0) + y(0, 1) + y(1, 0) + y(1, 1));
                                    })));

    m_name_builtin_function_map.insert(
      std::make_pair("fidToR", std::make_shared<BuiltinFunctionEmbedder<double(const FunctionSymbolId&)>>(
                                 [](const FunctionSymbolId&) -> double { return 0; })));

    m_name_builtin_function_map.insert(
      std::make_pair("builtinToBuiltin",
                     std::make_shared<
                       BuiltinFunctionEmbedder<std::shared_ptr<const double>(std::shared_ptr<const double>)>>(
                       [](std::shared_ptr<const double> x) -> std::shared_ptr<const double> { return x; })));

    m_name_builtin_function_map.insert(
      std::make_pair("tuple_BtoR", std::make_shared<BuiltinFunctionEmbedder<double(std::vector<bool>)>>(
                                     [](const std::vector<bool>&) -> double { return 0.5; })));

    m_name_builtin_function_map.insert(
      std::make_pair("tuple_NtoR", std::make_shared<BuiltinFunctionEmbedder<double(std::vector<uint64_t>)>>(
                                     [](const std::vector<uint64_t>&) -> double { return 0.5; })));

    m_name_builtin_function_map.insert(
      std::make_pair("tuple_ZtoR", std::make_shared<BuiltinFunctionEmbedder<double(std::vector<int64_t>)>>(
                                     [](const std::vector<int64_t>&) -> double { return 0.5; })));

    m_name_builtin_function_map.insert(
      std::make_pair("tuple_RtoB", std::make_shared<BuiltinFunctionEmbedder<bool(std::vector<double>)>>(
                                     [](const std::vector<double>&) -> bool { return false; })));

    m_name_builtin_function_map.insert(
      std::make_pair("tuple_stringtoB", std::make_shared<BuiltinFunctionEmbedder<bool(std::vector<std::string>)>>(
                                          [](const std::vector<std::string>&) -> bool { return true; })));

    m_name_builtin_function_map.insert(
      std::make_pair("tuple_builtinToB",
                     std::make_shared<BuiltinFunctionEmbedder<bool(std::vector<std::shared_ptr<const double>>)>>(
                       [](const std::vector<std::shared_ptr<const double>>&) -> bool { return true; })));

    m_name_builtin_function_map.insert(
      std::make_pair("tuple_R1ToR",
                     std::make_shared<BuiltinFunctionEmbedder<double(const std::vector<TinyVector<1>>&)>>(
                       [](const std::vector<TinyVector<1>>&) -> double { return 1; })));

    m_name_builtin_function_map.insert(
      std::make_pair("tuple_R2ToR",
                     std::make_shared<BuiltinFunctionEmbedder<double(const std::vector<TinyVector<2>>&)>>(
                       [](const std::vector<TinyVector<2>>&) -> double { return 1; })));

    m_name_builtin_function_map.insert(
      std::make_pair("tuple_R3ToR", std::make_shared<BuiltinFunctionEmbedder<double(const std::vector<TinyVector<3>>)>>(
                                      [](const std::vector<TinyVector<3>>&) -> double { return 0; })));

    m_name_builtin_function_map.insert(
      std::make_pair("tuple_R11ToR",
                     std::make_shared<BuiltinFunctionEmbedder<double(const std::vector<TinyMatrix<1>>&)>>(
                       [](const std::vector<TinyMatrix<1>>&) -> double { return 1; })));

    m_name_builtin_function_map.insert(
      std::make_pair("tuple_R22ToR",
                     std::make_shared<BuiltinFunctionEmbedder<double(const std::vector<TinyMatrix<2>>&)>>(
                       [](const std::vector<TinyMatrix<2>>&) -> double { return 1; })));

    m_name_builtin_function_map.insert(
      std::make_pair("tuple_R33ToR",
                     std::make_shared<BuiltinFunctionEmbedder<double(const std::vector<TinyMatrix<3>>)>>(
                       [](const std::vector<TinyMatrix<3>>&) -> double { return 0; })));
  }

  void
  _addBuiltinTypeAndVariables(ASTNode& ast)
  {
    SymbolTable& symbol_table = *ast.m_symbol_table;
    auto [i_symbol, success]  = symbol_table.add(builtin_data_type.nameOfTypeId(), ast.begin());
    if (not success) {
      throw UnexpectedError("cannot add '" + builtin_data_type.nameOfTypeId() + "' type for testing");
    }

    i_symbol->attributes().setDataType(ASTNodeDataType::build<ASTNodeDataType::type_name_id_t>());
    i_symbol->attributes().setIsInitialized();
    i_symbol->attributes().value() = symbol_table.typeEmbedderTable().size();
    symbol_table.typeEmbedderTable().add(std::make_shared<TypeDescriptor>(builtin_data_type.nameOfTypeId()));

    auto [i_symbol_a, success_a] = symbol_table.add("a", ast.begin());
    if (not success_a) {
      throw UnexpectedError("cannot add 'a' of type builtin_t for testing");
    }
    i_symbol_a->attributes().setDataType(ast_node_data_type_from<std::shared_ptr<const double>>);
    i_symbol_a->attributes().setIsInitialized();
    auto [i_symbol_b, success_b] = symbol_table.add("b", ast.begin());
    if (not success_b) {
      throw UnexpectedError("cannot add 'b' of type builtin_t for testing");
    }
    i_symbol_b->attributes().setDataType(ast_node_data_type_from<std::shared_ptr<const double>>);
    i_symbol_b->attributes().setIsInitialized();
  }

 public:
  test_BuiltinFunctionRegister(ASTNode& root_node)
  {
    SymbolTable& symbol_table = *root_node.m_symbol_table;

    auto& builtin_function_embedder_table = symbol_table.builtinFunctionEmbedderTable();

    this->_populateNameBuiltinFunctionMap();
    this->_addBuiltinTypeAndVariables(root_node);

    for (const auto& [symbol_name, builtin_function] : m_name_builtin_function_map) {
      auto [i_symbol, success] = symbol_table.add(symbol_name, root_node.begin());

      if (not success) {
        std::ostringstream error_message;
        error_message << "cannot add symbol '" << symbol_name << "' it is already defined";
        throw ParseError(error_message.str(), root_node.begin());
      }

      i_symbol->attributes().setDataType(ASTNodeDataType::build<ASTNodeDataType::builtin_function_t>());
      i_symbol->attributes().setIsInitialized();
      i_symbol->attributes().value() = builtin_function_embedder_table.size();

      builtin_function_embedder_table.add(builtin_function);
    }
  }
};
}   // namespace test_only

#endif /* TEST_BUILTIN_FUNCTION_REGISTER_H */