member_expression.hpp

Go to the documentation of this file.

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

namespace xtd {
  namespace expressions {
    template <typename member_t>
    struct member_type {
      const char* name = nullptr;
      member_t member;
    };
    
    template <typename member_t>
    constexpr auto member(member_t member) {
      return member_type<member_t>{"<member>", member};
    }

    template <typename member_t>
    constexpr auto member(const char* name, member_t member) {
      return member_type<member_t>{name, member};
    }
    
    template <typename expression_t, typename member_t>
    struct member_expression : private expression {
      
      static constexpr operator_precedence precedence = operator_precedence::member_access;

      
      constexpr member_expression() = default;
      
      constexpr member_expression(expression_t expression, member_t member) : expression {std::move(expression)}, member {std::move(member)} {}
      
      
      constexpr decltype(auto) operator()(auto&&... args) const {
        auto&& obj = expression(std::forward<decltype(args)>(args)...);
        if constexpr (std::is_pointer_v<std::decay_t<decltype(obj)>>) return (obj->*member.member);
        else return (obj.*member.member);
      }
      
      friend inline auto operator <<(std::ostream& os, const member_expression& e) -> std::ostream& {return os << expression_stream {e.expression, e.precedence} << "." << e.member.name;}
 
    private:
      [[no_unique_address]] expression_t expression;
      [[no_unique_address]] member_t member;
    };
    
    
    template <typename expression_t, typename member_t>
    requires expression_operand<expression_t> || expression_operand<member_type<member_t>>
    constexpr auto operator *(expression_t expression, member_type<member_t> member) {
      auto expr = as_expression(expression);
      return member_expression<std::decay_t<decltype(expr)>, member_type<member_t>> {std::move(expr), std::move(member)};
    }

    template <typename expression_t, typename member_t>
    requires expression_operand<expression_t> || expression_operand<member_type<member_t>>
    constexpr auto operator |(expression_t expression, member_type<member_t> member) {
      return std::forward<expression_t>(expression) * std::forward<member_type<member_t>>(member);
    }

  }
}