method_call_expression.hpp

Go to the documentation of this file.

#pragma once
#include "as_expression.hpp"
#include "expression_operand.hpp"
#include "expression_stream.hpp"
#include "invocation_expression.hpp"
#include <utility>

namespace xtd {
  namespace expressions {
    template <typename method_t, typename... args_t>
    struct method_type {
      const char* name = nullptr;
      method_t method;
      std::tuple<args_t...> args;
    };
    
    template <typename method_t, typename... args_t>
    constexpr auto method(method_t method, args_t&&... args) {
      return method_type<method_t, decltype(as_expression(std::forward<args_t>(args)))...>{"<method>", method, std::make_tuple(as_expression(std::forward<args_t>(args))...)};
    }

    template <typename method_t, typename... args_t>
    constexpr auto method(const char* name, method_t method, args_t&&... args) {
      return method_type<method_t, decltype(as_expression(std::forward<args_t>(args)))...>{name, method, std::make_tuple(as_expression(std::forward<args_t>(args))...)};
    }

    template <typename expression_t, typename method_t>
    struct method_call_expression : invocation_expression {
      
      static constexpr operator_precedence precedence = operator_precedence::method_access;
      
      
      constexpr method_call_expression() = default;
      
      constexpr method_call_expression(expression_t expression, method_t method) : expression {std::move(expression)}, method {std::move(method)} {}
      
      
      template <typename... call_args_t>
      constexpr decltype(auto) operator()(call_args_t&&... call_args) const {
        auto&& obj = expression(std::forward<call_args_t>(call_args)...);
        auto invoke = [&](auto&&... evaluated_args) -> decltype(auto) {
          if constexpr (std::is_pointer_v<std::decay_t<decltype(obj)>>) return (obj->*method.method)(std::forward<decltype(evaluated_args)>(evaluated_args)...);
          else return (obj.*method.method)(std::forward<decltype(evaluated_args)>(evaluated_args)...);
        };
        auto eval_arg = [&](auto&& expr) -> decltype(auto) {return expr(std::forward<call_args_t>(call_args)...);};
        return std::apply([&](auto&&... exprs) -> decltype(auto) {return invoke(eval_arg(exprs)...);}, method.args);
      }

      
      friend inline auto operator <<(std::ostream& os, const method_call_expression& e) -> std::ostream& {
        os << expression_stream {e.expression, e.precedence} << "." << e.method.name << "(";
        std::apply([&os](auto&&... args) {
          bool first = true;
          ((os << (first ? "" : ", ") << expression_stream {args, operator_precedence::lowest}, first = false), ...);
        }, e.method.args);
        os << ")";
        return os;
      }
 
    private:
      [[no_unique_address]] expression_t expression;
      [[no_unique_address]] method_t method;
    };

    
    template <typename expression_t, typename method_t, typename... stored_args_t>
    requires expression_operand<expression_t> || expression_operand<method_type<method_t, stored_args_t...>>
    constexpr auto operator*(expression_t expression, method_type<method_t, stored_args_t...> method) {
      auto expr = as_expression(expression);
      return method_call_expression<std::decay_t<decltype(expr)>, method_type<method_t, stored_args_t...>> {std::move(expr), std::move(method)};
    }
    
    template <typename expression_t, typename method_t, typename... stored_args_t>
    requires expression_operand<expression_t> || expression_operand<method_type<method_t, stored_args_t...>>
    constexpr auto operator |(expression_t expression, method_type<method_t, stored_args_t...> method) {
      return std::forward<expression_t>(expression) * std::forward<method_type<method_t, stored_args_t...>>(method);
    }

  }
}