logical_not_expression.hpp

Go to the documentation of this file.

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

namespace xtd {
  namespace expressions {
    template <typename value_t>
    struct logical_not_expression : unary_expression {
      
      static constexpr operator_precedence precedence = operator_precedence::logical_not;
      
      
      constexpr logical_not_expression() = default;
      
      constexpr logical_not_expression(value_t value) : value {std::move(value)} {}
      
      
      template <typename... args_t>
      constexpr auto operator()(args_t&&... args) const {return !value(std::forward<args_t>(args)...);}
      
      friend inline auto operator <<(std::ostream& os, const logical_not_expression& e) -> std::ostream& {return os << "!" << expression_stream {e.value, e.precedence};}
 
    private:
      [[no_unique_address]] value_t value;
    };
    
    template <typename vakue_t>
    requires std::is_base_of_v<expression, std::decay_t<vakue_t>>
    constexpr auto expression::logical_not(vakue_t value) {
      auto expression = as_expression(value);
      return logical_not_expression<std::decay_t<decltype(expression)>> {std::move(expression)};
    }

    
    template <typename value_t>
    requires expression_operand<value_t>
    constexpr auto operator !(value_t value) {return expression::logical_not(std::move(value));}
  }
}