Function operator!=

Summary

#include <include/type_safe/boolean.hpp>

(1) constexpr TYPE_SAFE_FORCE_INLINE bool operator!=(const boolean &a, const boolean &b) noexcept

(2) template <typename T, typename = detail::enable_boolean<T>>
    constexpr TYPE_SAFE_FORCE_INLINE bool operator!=(const boolean &a, T b) noexcept

(3) template <typename T, typename = detail::enable_boolean<T>>
    constexpr TYPE_SAFE_FORCE_INLINE bool operator!=(T a, const boolean &b) noexcept

#include <include/type_safe/flag.hpp>

(4) constexpr bool operator!=(flag lhs, flag rhs) noexcept

(5) template <typename T, typename = detail::enable_boolean<T>>
    constexpr bool operator!=(flag lhs, T rhs) noexcept

(6) template <typename T, typename = detail::enable_boolean<T>>
    constexpr bool operator!=(T lhs, flag rhs) noexcept

#include <include/type_safe/flag_set.hpp>

(7) template <typename Enum>
    constexpr bool operator!=(const flag_set< Enum > &a, const flag_set< Enum > &b) noexcept

(8) template <typename Enum>
    constexpr bool operator!=(const flag_set< Enum > &a, noflag_t b) noexcept

(9) template <typename Enum>
    constexpr bool operator!=(noflag_t a, const flag_set< Enum > &b) noexcept

(10) template <typename Enum, typename FlagCombo, typename = detail::enable_flag_combo<FlagCombo, Enum>>
     constexpr bool operator!=(const flag_set< Enum > &a, const FlagCombo &b) noexcept

(11) template <typename Enum, typename FlagCombo, typename = detail::enable_flag_combo<FlagCombo, Enum>>
     constexpr bool operator!=(const FlagCombo &a, const flag_set< Enum > &b) noexcept

#include <include/type_safe/reference.hpp>

(12) template <typename T, typename U, bool XValue, typename = decltype(std::declval<T*>() == std::declval<U*>())>
     constexpr bool operator!=(const object_ref< T, XValue > &a, const object_ref< U, XValue > &b) noexcept

(13) template <typename T, typename U, bool XValue, typename = decltype(std::declval<T*>() == std::declval<U*>())>
     constexpr bool operator!=(const object_ref< T, XValue > &a, U &b) noexcept

(14) template <typename T, typename U, bool XValue, typename = decltype(std::declval<T*>() == std::declval<U*>())>
     constexpr bool operator!=(const T &a, const object_ref< U, XValue > &b) noexcept

#include <include/type_safe/variant.hpp>

(15) template <class VariantPolicy, typename Head, typename... Types, typename T>
     bool operator!=(const basic_variant< VariantPolicy, Head, Types... > &lhs, const T &rhs)

(16) template <class VariantPolicy, typename Head, typename... Types, typename T>
     bool operator!=(const T &lhs, const basic_variant< VariantPolicy, Head, Types... > &rhs)

(17) template <class VariantPolicy, typename Head, typename... Types>
     bool operator!=(const basic_variant< VariantPolicy, Head, Types... > &lhs, const basic_variant< VariantPolicy, Head, Types... > &rhs)

Function overload

Synopsis

#include <include/type_safe/boolean.hpp>

constexpr TYPE_SAFE_FORCE_INLINE bool operator!=(const boolean &a, const boolean &b) noexcept

Description

[ts::boolean]() in-equality comparison.

Returns
false if (1) both [ts::boolean]() objects have the same value, (2)/(3) the boolean has the same value as the given value, true otherwise. \notes (2)/(3) do not participate in overload resolution if T is not a boolean type. \group boolean_comp_unequal \module types

Source

Lines 120-123 in include/type_safe/boolean.hpp.

TYPE_SAFE_FORCE_INLINE constexpr bool operator!=(const boolean& a, const boolean& b) noexcept
{
    return static_cast<bool>(a) != static_cast<bool>(b);
}

Synopsis

#include <include/type_safe/boolean.hpp>

template <typename T, typename = detail::enable_boolean<T>>
constexpr TYPE_SAFE_FORCE_INLINE bool operator!=(const boolean &a, T b) noexcept

Description

\group boolean_comp_unequal

Parameters

1 - \exclude

Source

Lines 128-132 in include/type_safe/boolean.hpp.

template <typename T, typename = detail::enable_boolean<T>>
TYPE_SAFE_FORCE_INLINE constexpr bool operator!=(const boolean& a, T b) noexcept
{
    return static_cast<bool>(a) != static_cast<bool>(b);
}

Synopsis

#include <include/type_safe/boolean.hpp>

template <typename T, typename = detail::enable_boolean<T>>
constexpr TYPE_SAFE_FORCE_INLINE bool operator!=(T a, const boolean &b) noexcept

Description

\group boolean_comp_unequal

Parameters

1 - \exclude

Source

Lines 137-141 in include/type_safe/boolean.hpp.

template <typename T, typename = detail::enable_boolean<T>>
TYPE_SAFE_FORCE_INLINE constexpr bool operator!=(T a, const boolean& b) noexcept
{
    return static_cast<bool>(a) != static_cast<bool>(b);
}

Synopsis

#include <include/type_safe/flag.hpp>

constexpr bool operator!=(flag lhs, flag rhs) noexcept

Description

[ts::flag]() in-equality comparison.

Returns
true if (1) both [ts::flag]() objects are in the same state, (2)/(3) the flag is in the given state. \notes (2)/(3) do not participate in overload resolution unless T is a boolean type. \group flag_unequal \module types

Source

Lines 162-165 in include/type_safe/flag.hpp.

constexpr bool operator!=(flag lhs, flag rhs) noexcept
{
    return !(lhs == rhs);
}

Synopsis

#include <include/type_safe/flag.hpp>

template <typename T, typename = detail::enable_boolean<T>>
constexpr bool operator!=(flag lhs, T rhs) noexcept

Description

\group flag_unequal

Parameters

1 - \exclude

Source

Lines 170-174 in include/type_safe/flag.hpp.

template <typename T, typename = detail::enable_boolean<T>>
constexpr bool operator!=(flag lhs, T rhs) noexcept
{
    return !(lhs == rhs);
}

Synopsis

#include <include/type_safe/flag.hpp>

template <typename T, typename = detail::enable_boolean<T>>
constexpr bool operator!=(T lhs, flag rhs) noexcept

Description

\group flag_unequal

Parameters

1 - \exclude

Source

Lines 179-183 in include/type_safe/flag.hpp.

template <typename T, typename = detail::enable_boolean<T>>
constexpr bool operator!=(T lhs, flag rhs) noexcept
{
    return !(lhs == rhs);
}

Synopsis

#include <include/type_safe/flag_set.hpp>

template <typename Enum>
constexpr bool operator!=(const flag_set< Enum > &a, const flag_set< Enum > &b) noexcept

Description

\group flag_set_equal

Source

Lines 667-671 in include/type_safe/flag_set.hpp.

template <typename Enum>
constexpr bool operator!=(const flag_set<Enum>& a, const flag_set<Enum>& b) noexcept
{
    return !(a == b);
}

Synopsis

#include <include/type_safe/flag_set.hpp>

template <typename Enum>
constexpr bool operator!=(const flag_set< Enum > &a, noflag_t b) noexcept

Description

\group flag_set_equal

Source

Lines 674-678 in include/type_safe/flag_set.hpp.

template <typename Enum>
constexpr bool operator!=(const flag_set<Enum>& a, noflag_t b) noexcept
{
    return !(a == b);
}

Synopsis

#include <include/type_safe/flag_set.hpp>

template <typename Enum>
constexpr bool operator!=(noflag_t a, const flag_set< Enum > &b) noexcept

Description

\group flag_set_equal

Source

Lines 681-685 in include/type_safe/flag_set.hpp.

template <typename Enum>
constexpr bool operator!=(noflag_t a, const flag_set<Enum>& b) noexcept
{
    return !(a == b);
}

Synopsis

#include <include/type_safe/flag_set.hpp>

template <typename Enum, typename FlagCombo, typename = detail::enable_flag_combo<FlagCombo, Enum>>
constexpr bool operator!=(const flag_set< Enum > &a, const FlagCombo &b) noexcept

Description

\group flag_set_equal

Source

Lines 688-692 in include/type_safe/flag_set.hpp.

template <typename Enum, typename FlagCombo, typename = detail::enable_flag_combo<FlagCombo, Enum>>
constexpr bool operator!=(const flag_set<Enum>& a, const FlagCombo& b) noexcept
{
    return !(a == b);
}

Synopsis

#include <include/type_safe/flag_set.hpp>

template <typename Enum, typename FlagCombo, typename = detail::enable_flag_combo<FlagCombo, Enum>>
constexpr bool operator!=(const FlagCombo &a, const flag_set< Enum > &b) noexcept

Description

\group flag_set_equal

Source

Lines 695-699 in include/type_safe/flag_set.hpp.

template <typename Enum, typename FlagCombo, typename = detail::enable_flag_combo<FlagCombo, Enum>>
constexpr bool operator!=(const FlagCombo& a, const flag_set<Enum>& b) noexcept
{
    return !(a == b);
}

Synopsis

#include <include/type_safe/reference.hpp>

template <typename T, typename U, bool XValue, typename = decltype(std::declval<T*>() == std::declval<U*>())>
constexpr bool operator!=(const object_ref< T, XValue > &a, const object_ref< U, XValue > &b) noexcept

Description

\group ref_compare

Parameters

3 - \exclude

Source

Lines 191-196 in include/type_safe/reference.hpp.

template <typename T, typename U, bool XValue,
          typename = decltype(std::declval<T*>() == std::declval<U*>())>
constexpr bool operator!=(const object_ref<T, XValue>& a, const object_ref<U, XValue>& b) noexcept
{
    return !(a == b);
}

Synopsis

#include <include/type_safe/reference.hpp>

template <typename T, typename U, bool XValue, typename = decltype(std::declval<T*>() == std::declval<U*>())>
constexpr bool operator!=(const object_ref< T, XValue > &a, U &b) noexcept

Description

\group ref_compare

Parameters

3 - \exclude

Source

Lines 201-206 in include/type_safe/reference.hpp.

template <typename T, typename U, bool XValue,
          typename = decltype(std::declval<T*>() == std::declval<U*>())>
constexpr bool operator!=(const object_ref<T, XValue>& a, U& b) noexcept
{
    return !(a == b);
}

Synopsis

#include <include/type_safe/reference.hpp>

template <typename T, typename U, bool XValue, typename = decltype(std::declval<T*>() == std::declval<U*>())>
constexpr bool operator!=(const T &a, const object_ref< U, XValue > &b) noexcept

Description

\group ref_compare

Parameters

3 - \exclude

Source

Lines 211-216 in include/type_safe/reference.hpp.

template <typename T, typename U, bool XValue,
          typename = decltype(std::declval<T*>() == std::declval<U*>())>
constexpr bool operator!=(const T& a, const object_ref<U, XValue>& b) noexcept
{
    return !(a == b);
}

Synopsis

#include <include/type_safe/variant.hpp>

template <class VariantPolicy, typename Head, typename... Types, typename T>
bool operator!=(const basic_variant< VariantPolicy, Head, Types... > &lhs, const T &rhs)

Description

\group variant_comp_t

Source

Lines 585-589 in include/type_safe/variant.hpp.

template <class VariantPolicy, typename Head, typename... Types, typename T>
bool operator!=(const basic_variant<VariantPolicy, Head, Types...>& lhs, const T& rhs)
{
    return !(lhs == rhs);
}

Synopsis

#include <include/type_safe/variant.hpp>

template <class VariantPolicy, typename Head, typename... Types, typename T>
bool operator!=(const T &lhs, const basic_variant< VariantPolicy, Head, Types... > &rhs)

Description

\group variant_comp_t

Source

Lines 591-595 in include/type_safe/variant.hpp.

template <class VariantPolicy, typename Head, typename... Types, typename T>
bool operator!=(const T& lhs, const basic_variant<VariantPolicy, Head, Types...>& rhs)
{
    return !(rhs == lhs);
}

Synopsis

#include <include/type_safe/variant.hpp>

template <class VariantPolicy, typename Head, typename... Types>
bool operator!=(const basic_variant< VariantPolicy, Head, Types... > &lhs, const basic_variant< VariantPolicy, Head, Types... > &rhs)

Description

\group variant_comp

Source

Lines 672-677 in include/type_safe/variant.hpp.

template <class VariantPolicy, typename Head, typename... Types>
bool operator!=(const basic_variant<VariantPolicy, Head, Types...>& lhs,
                const basic_variant<VariantPolicy, Head, Types...>& rhs)
{
    return !(lhs == rhs);
}





Add Discussion as Guest

Log in