right_shift_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 "../numeric.hpp"
#include <utility>

namespace xtd {
  namespace expressions {
    template <typename left_t, typename right_t>
    struct right_shift_expression : binary_expression {
      
      static constexpr operator_precedence precedence = operator_precedence::bitwise_right;
      
      
      constexpr right_shift_expression() = default;
      
      constexpr right_shift_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 {
        auto&& l = left(std::forward<args_t>(args)...);
        using result_t = std::decay_t<decltype(l)>;
        if constexpr (xtd::numeric<result_t>) return static_cast<result_t>(l >> right(std::forward<args_t>(args)...));
        else return l >> right(std::forward<args_t>(args)...);
      }

      
      friend inline auto operator <<(std::ostream& os, const right_shift_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::right_shift(left_t left, right_t right) {
      auto left_expression = as_expression(left);
      auto right_expression = as_expression(right);
      return right_shift_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::right_shift(std::move(left), std::move(right));}
  }
}