add.hpp

Go to the documentation of this file.

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

namespace xtd {
  namespace expressions {
    template<typename left_t, typename right_t>
    struct add : binary_expression {
      
      static constexpr operator_precedence precedence = operator_precedence::addition;
      
      
      constexpr add() = default;

      constexpr add(left_t left, right_t right) : left {std::move(left)}, right {std::move(right)} {}
      
      
      template<typename... args_t>
      constexpr auto operator()(args_t&&... args) const {return left(std::forward<args_t>(args)...) + right(std::forward<args_t>(args)...);}
      
      friend inline auto operator <<(std::ostream& os, const add& e) -> std::ostream& {return os << expression_stream {e.left, e.precedence} << " + " << expression_stream {e.right, e.precedence};}
 
    private:
      [[no_unique_address]] left_t left;
      [[no_unique_address]] right_t right;
    };

    template<typename left_t, typename right_t>
    requires std::is_base_of_v<expression, std::decay_t<left_t>> || std::is_base_of_v<expression, std::decay_t<right_t>>
    constexpr auto expression::add(left_t left, right_t right) {
      auto left_expression = as_expression(left);
      auto right_expression = as_expression(right);
      return expressions::add<std::decay_t<decltype(left_expression)>, std::decay_t<decltype(right_expression)>> {std::move(left_expression), std::move(right_expression)};
    }

    
    template<typename left_t, typename right_t>
    requires expression_operand<left_t> || expression_operand<right_t>
    constexpr auto operator +(left_t left, right_t right) {return expression::add(std::move(left), std::move(right));}
  }
}