Is Operator Callable?

#include <m3ta/isoperatorcallable>

Checks if an operator can be called on given types.

Enumerators

m3ta::UnaryOperator
enum class UnaryOperator {
    plus,
    minus,
    postfixIncrement,
    postfixDecrement,
    prefixIncrement,
    prefixDecrement,
    logicalNot,
    bitwiseNot
};
plus

Plus operator +a.

minus

Minus operator -a.

posfixIncrement

Postfix increment operator a++.

postfixDecrement

Postfix decrement operator a--.

prefixIncrement

Prefix increment operator ++a.

prefixDecrement

Prefix decrement operator --a.

logicalNot

Logical NOT operator !a.

bitwiseNot

Bitwise NOT operator ~a.

m3ta::BinaryOperator
enum class BinaryOperator {
    assignment,
    addition,
    subtraction,
    multiplication,
    division,
    modulo,
    equalTo,
    notEqualTo,
    greaterThan,
    lessThan,
    greaterThanOrEqualTo,
    lessThanOrEqualTo,
    logicalAnd,
    logicalOr,
    bitwiseAnd,
    bitwiseOr,
    bitwiseXor,
    bitwiseLeftShift,
    bitwiseRightShift,
    additionAssignment,
    subtractionAssignment,
    multiplicationAssignment,
    divisionAssignment,
    moduloAssignment,
    bitwiseAndAssignment,
    bitwiseOrAssignment,
    bitwiseXorAssignment,
    bitwiseLeftShiftAssignment,
    bitwiseRightShiftAssignment
};
assignment

Assignment operator a = b.

addition

Addition operator a + b.

subtraction

Subtraction operator a - b.

multiplication

Multiplication operator a * b.

division

Division operator a / b.

modulo

Modulo operator a % b.

equalTo

Equal to operator a == b.

notEqualTo

Not equal to operator a != b.

greaterThan

Greater than operator a > b.

lessThan

Less than operator a < b.

greaterThanOrEqualTo

Greater than or equal to operator a >= b.

lessThanOrEqualTo

Less than or equal to operator a <= b.

logicalAnd

Logical AND operator a && b.

logicalOr

Logical OR operator a || b.

bitwiseAnd

Bitwise AND operator a & b.

bitwiseOr

Bitwise OR operator a | b.

bitwiseXOr

Bitwise XOR operator a ^ b.

bitwiseLeftShift

Bitwise left shift operator a << b.

bitwiseRightShift

Bitwise right shift operator a >> b.

additionAssignment

Addition assignment operator a += b.

subtractionAssignment

Subtraction assignment operator a -= b.

multiplicationAssignment

Multiplication assignment operator a *= b.

divisionAssignment

Division assignment operator a /= b.

moduloAssignment

Modulo assignment operator a %= b.

bitwiseAndAssignment

Bitwise AND assignment operator a &= b.

bitwiseOrAssignment

Bitwise OR assignment operator a |= b.

bitwiseXOrAssignment

Bitwise XOR assignment operator a ^= b.

bitwiseLeftShiftAssignment

Bitwise left shift assignment operator a <<= b.

bitwiseRightShiftAssignment

Bitwise right shift assignment operator a >>= b.

Functions

m3ta::isOperatorCallable
template<UnaryOperator T_operator, typename T>
constexpr bool
isOperatorCallable() noexcept

template<BinaryOperator T_operator, typename T, typename T_Other>
constexpr bool
isOperatorCallable() noexcept
Template Parameters:
 
  • T_operator — Operator to check for.
  • T — Type of the first operand.
  • T_Other — Type of the second operand. For binary operators only.

Returns

Whether the operator can be called on the operand(s).

Traits

m3ta::IsOperatorCallable
template<typename T_Operator, T_Operator T_operator, typename ... T>
struct IsOperatorCallable;
Template Parameters:
 
  • T_Operator – Type of the operator to check for.
  • T_operator – Operator to check for.
  • T - Type of the operand(s). Only one operand is expected when checking against unary operators, and two for the binary operators.

Member Types

type

The type std::integral_constant<bool, value> where value is the result of the function m3ta::isOperatorCallable().

value_type

The type bool.

Member Constants

static constexpr bool value

Whether the operator can be called on the operand(s).

Aliases

m3ta::IsOperatorCallableT
template<typename T_Operator, T_Operator T_operator, typename ... T>
using IsOperatorCallableT =
    typename IsOperatorCallable<T_Operator, T_operator, T ...>::type;

Usage Examples

bool value1 = m3ta::isOperatorCallable<
    m3ta::UnaryOperator::logicalNot,
    int
>(); // true
bool value2 = m3ta::isOperatorCallable<
    m3ta::BinaryOperator::addition,
    int,
    float
>(); // true
bool value3 = m3ta::isOperatorCallable<
    m3ta::BinaryOperator::multiplication,
    int,
    std::complex<float>
>(); // false

using Type1 = m3ta::IsOperatorCallableT<
    m3ta::UnaryOperator::logicalNot,
    int
>; // std::integral_constant<bool, true>
using Type2 = m3ta::IsOperatorCallableT<
    m3ta::BinaryOperator::addition,
    int,
    float
>; // std::integral_constant<bool, true>
using Type3 = m3ta::IsOperatorCallableT<
    m3ta::BinaryOperator::multiplication,
    int,
    std::complex<float>
>; // std::integral_constant<bool, false>