and_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 and_expression : binary_expression {
      
      static constexpr operator_precedence precedence = operator_precedence::bitwise_and;
      
      
      constexpr and_expression() = default;
      
      constexpr and_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)...);
        auto&& r = right(std::forward<args_t>(args)...);
        using result_t = std::decay_t<decltype(l & r)>;
        if constexpr (xtd::numeric<result_t>) return static_cast<result_t>(l & r);
        else return l & r;
      }

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