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

namespace xtd {
  namespace expressions {
    template <typename value_t>
    struct not_expression : unary_expression {
      
      static constexpr operator_precedence precedence = operator_precedence::bitwise_not;
      
      
      constexpr not_expression() = default;
      
      constexpr not_expression(value_t value) : value {std::move(value)} {}
      
      
      template <typename... args_t>
      constexpr auto operator()(args_t&&... args) const {
        auto&& v = value(std::forward<args_t>(args)...);
        using result_t = std::decay_t<decltype(v)>;
        if constexpr (xtd::numeric<result_t>) return static_cast<result_t>(~v);
        else return ~v;
      }

      
      friend inline auto operator <<(std::ostream& os, const 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::not_(vakue_t value) {
      auto expression = as_expression(value);
      return 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::not_(std::move(value));}
  }
}