logical_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 <utility>

namespace xtd {
  namespace expressions {
    template <typename left_t, typename right_t>
    struct logical_and_expression : binary_expression {
      
      static constexpr operator_precedence precedence = operator_precedence::logical_and;
      
      
      constexpr logical_and_expression() = default;
      
      constexpr logical_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 {return left(std::forward<args_t>(args)...) && right(std::forward<args_t>(args)...);}
      
      friend inline auto operator <<(std::ostream& os, const logical_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_also(left_t left, right_t right) {return expression::logical_and(std::move(left), std::move(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::logical_and(left_t left, right_t right) {
      auto left_expression = as_expression(left);
      auto right_expression = as_expression(right);
      return logical_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::logical_and(std::move(left), std::move(right));}
  }
}