modulo_expression.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 modulo_expression : binary_expression {
      
      static constexpr operator_precedence precedence = operator_precedence::modulo;
      
      
      constexpr modulo_expression() = default;
      
      constexpr modulo_expression(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 modulo_expression& 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::modulo(left_t left, right_t right) {
      auto left_expression = as_expression(left);
      auto right_expression = as_expression(right);
      return modulo_expression<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::modulo(std::move(left), std::move(right));}
  }
}