formula_node.hpp

// Copyright Take Vos 2020-2022.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "formula_post_process_context.hpp"
#include "formula_evaluation_context.hpp"
#include "../utility/utility.hpp"
#include "../parser/parser.hpp"
#include "../codec/codec.hpp"
#include "../macros.hpp"
#include <vector>
#include <memory>
#include <string>
 
hi_export_module(hikogui.formula.formula_node);
 
namespace hi { inline namespace v1 {
 
struct formula_node {
    using formula_vector = std::vector<std::unique_ptr<formula_node>>;
 
    size_t line_nr;
    size_t column_nr;
 
    virtual ~formula_node() {}
    formula_node() = delete;
    formula_node(formula_node const&) = delete;
    formula_node(formula_node&&) = delete;
    formula_node& operator=(formula_node const&) = delete;
    formula_node& operator=(formula_node&&) = delete;
 
    formula_node(size_t line_nr, size_t column_nr) : line_nr(line_nr), column_nr(column_nr) {}
 
    virtual void post_process(formula_post_process_context& context) {}
 
    virtual void resolve_function_pointer(formula_post_process_context& context) {}
 
    virtual datum evaluate(formula_evaluation_context& context) const = 0;
 
    datum evaluate_without_output(formula_evaluation_context& context) const
    {
        context.disable_output();
        auto r = evaluate(context);
        context.enable_output();
        return r;
    }
 
    virtual datum& evaluate_lvalue(formula_evaluation_context& context) const
    {
        throw operation_error(std::format("{}:{}: Expression is not a modifiable value.", line_nr, column_nr));
    }
 
    virtual bool has_evaluate_xvalue() const
    {
        return false;
    }
 
    virtual datum const& evaluate_xvalue(formula_evaluation_context const& context) const
    {
        throw operation_error(std::format("{}:{}: Expression is not a xvalue.", line_nr, column_nr));
    }
 
    virtual datum& assign(formula_evaluation_context& context, datum const& rhs) const
    {
        return evaluate_lvalue(context) = rhs;
    }
 
    datum& assign_without_output(formula_evaluation_context& context, datum const& rhs) const
    {
        context.disable_output();
        auto& r = assign(context, rhs);
        context.enable_output();
        return r;
    }
 
    virtual datum call(formula_evaluation_context& context, datum::vector_type const& arguments) const
    {
        throw operation_error(std::format("{}:{}: Expression is not callable.", line_nr, column_nr));
    }
 
    virtual std::string get_name() const
    {
        throw parse_error(std::format("{}:{}: Expect a name, got {})", line_nr, column_nr, *this));
    }
 
    virtual std::vector<std::string> get_name_and_argument_names() const
    {
        throw parse_error(std::format("{}:{}: Expect a function definition, got {})", line_nr, column_nr, *this));
    }
 
    virtual std::string string() const noexcept = 0;
 
    friend std::string to_string(formula_node const& rhs) noexcept
    {
        return rhs.string();
    }
};
 
}} // namespace hi::v1
 
template<class CharT>
struct std::formatter<hi::formula_node, CharT> : std::formatter<std::string_view, CharT> {
    auto format(hi::formula_node const& t, auto& fc) const
    {
        return std::formatter<std::string_view, CharT>::format(to_string(t), fc);
    }
};
 
namespace hi { inline namespace v1 {
 
inline std::ostream& operator<<(std::ostream& lhs, formula_node const& rhs) noexcept
{
    return lhs << std::format("{}", rhs);
}
 
}} // namespace hi::v1