Catch::BinaryExpr< LhsT, RhsT > Class Template Reference

#include <catch_decomposer.h>

Inheritance diagram for Catch::BinaryExpr< LhsT, RhsT >:

Collaboration diagram for Catch::BinaryExpr< LhsT, RhsT >:

Public Member Functions
	BinaryExpr (bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs)
template<typename T >
auto	operator&& (T) const -> BinaryExpr< LhsT, RhsT const & > const
template<typename T >
auto	operator|| (T) const -> BinaryExpr< LhsT, RhsT const & > const
template<typename T >
auto	operator== (T) const -> BinaryExpr< LhsT, RhsT const & > const
template<typename T >
auto	operator!= (T) const -> BinaryExpr< LhsT, RhsT const & > const
template<typename T >
auto	operator> (T) const -> BinaryExpr< LhsT, RhsT const & > const
template<typename T >
auto	operator< (T) const -> BinaryExpr< LhsT, RhsT const & > const
template<typename T >
auto	operator>= (T) const -> BinaryExpr< LhsT, RhsT const & > const
template<typename T >
auto	operator<= (T) const -> BinaryExpr< LhsT, RhsT const & > const
	BinaryExpr (bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs)
template<typename T >
auto	operator&& (T) const -> BinaryExpr< LhsT, RhsT const & > const
template<typename T >
auto	operator|| (T) const -> BinaryExpr< LhsT, RhsT const & > const
template<typename T >
auto	operator== (T) const -> BinaryExpr< LhsT, RhsT const & > const
template<typename T >
auto	operator!= (T) const -> BinaryExpr< LhsT, RhsT const & > const
template<typename T >
auto	operator> (T) const -> BinaryExpr< LhsT, RhsT const & > const
template<typename T >
auto	operator< (T) const -> BinaryExpr< LhsT, RhsT const & > const
template<typename T >
auto	operator>= (T) const -> BinaryExpr< LhsT, RhsT const & > const
template<typename T >
auto	operator<= (T) const -> BinaryExpr< LhsT, RhsT const & > const
Public Member Functions inherited from Catch::ITransientExpression
auto	isBinaryExpression () const -> bool
auto	getResult () const -> bool
	ITransientExpression (bool isBinaryExpression, bool result)
virtual	~ITransientExpression ()
auto	isBinaryExpression () const -> bool
auto	getResult () const -> bool
	ITransientExpression (bool isBinaryExpression, bool result)
virtual	~ITransientExpression ()

Additional Inherited Members
Public Attributes inherited from Catch::ITransientExpression
bool	m_isBinaryExpression
bool	m_result

Detailed Description

template<typename LhsT, typename RhsT>
class Catch::BinaryExpr< LhsT, RhsT >

Definition at line 1870 of file catch.hpp.

Constructor & Destructor Documentation

BinaryExpr() [1/2]

template<typename LhsT , typename RhsT >

Catch::BinaryExpr< LhsT, RhsT >::BinaryExpr ( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )

inline

Definition at line 61 of file catch_decomposer.h.

        :   ITransientExpression{ true, comparisonResult },
            m_lhs( lhs ),
            m_op( op ),
            m_rhs( rhs )
        {}

BinaryExpr() [2/2]

template<typename LhsT , typename RhsT >

Catch::BinaryExpr< LhsT, RhsT >::BinaryExpr ( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )

inline

Definition at line 1881 of file catch.hpp.

        :   ITransientExpression{ true, comparisonResult },
            m_lhs( lhs ),
            m_op( op ),
            m_rhs( rhs )
        {}

Member Function Documentation

operator!=() [1/2]

template<typename LhsT , typename RhsT >

template<typename T >

auto Catch::BinaryExpr< LhsT, RhsT >::operator!= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const

inline

Definition at line 90 of file catch_decomposer.h.

                                                                            {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

operator!=() [2/2]

template<typename LhsT , typename RhsT >

template<typename T >

auto Catch::BinaryExpr< LhsT, RhsT >::operator!= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const

inline

Definition at line 1910 of file catch.hpp.

                                                                            {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

operator&&() [1/2]

template<typename LhsT , typename RhsT >

template<typename T >

auto Catch::BinaryExpr< LhsT, RhsT >::operator&& ( T ) const -> BinaryExpr<LhsT, RhsT const&> const

inline

Definition at line 69 of file catch_decomposer.h.

                                                                            {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

operator&&() [2/2]

template<typename LhsT , typename RhsT >

template<typename T >

auto Catch::BinaryExpr< LhsT, RhsT >::operator&& ( T ) const -> BinaryExpr<LhsT, RhsT const&> const

inline

Definition at line 1889 of file catch.hpp.

                                                                            {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

operator<() [1/2]

template<typename LhsT , typename RhsT >

template<typename T >

auto Catch::BinaryExpr< LhsT, RhsT >::operator< ( T ) const -> BinaryExpr<LhsT, RhsT const&> const

inline

Definition at line 104 of file catch_decomposer.h.

                                                                           {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

operator<() [2/2]

template<typename LhsT , typename RhsT >

template<typename T >

auto Catch::BinaryExpr< LhsT, RhsT >::operator< ( T ) const -> BinaryExpr<LhsT, RhsT const&> const

inline

Definition at line 1924 of file catch.hpp.

                                                                           {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

operator<=() [1/2]

template<typename LhsT , typename RhsT >

template<typename T >

auto Catch::BinaryExpr< LhsT, RhsT >::operator<= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const

inline

Definition at line 118 of file catch_decomposer.h.

                                                                            {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

operator<=() [2/2]

template<typename LhsT , typename RhsT >

template<typename T >

auto Catch::BinaryExpr< LhsT, RhsT >::operator<= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const

inline

Definition at line 1938 of file catch.hpp.

                                                                            {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

operator==() [1/2]

template<typename LhsT , typename RhsT >

template<typename T >

auto Catch::BinaryExpr< LhsT, RhsT >::operator== ( T ) const -> BinaryExpr<LhsT, RhsT const&> const

inline

Definition at line 83 of file catch_decomposer.h.

                                                                            {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

operator==() [2/2]

template<typename LhsT , typename RhsT >

template<typename T >

auto Catch::BinaryExpr< LhsT, RhsT >::operator== ( T ) const -> BinaryExpr<LhsT, RhsT const&> const

inline

Definition at line 1903 of file catch.hpp.

                                                                            {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

operator>() [1/2]

template<typename LhsT , typename RhsT >

template<typename T >

auto Catch::BinaryExpr< LhsT, RhsT >::operator> ( T ) const -> BinaryExpr<LhsT, RhsT const&> const

inline

Definition at line 97 of file catch_decomposer.h.

                                                                           {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

operator>() [2/2]

template<typename LhsT , typename RhsT >

template<typename T >

auto Catch::BinaryExpr< LhsT, RhsT >::operator> ( T ) const -> BinaryExpr<LhsT, RhsT const&> const

inline

Definition at line 1917 of file catch.hpp.

                                                                           {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

operator>=() [1/2]

template<typename LhsT , typename RhsT >

template<typename T >

auto Catch::BinaryExpr< LhsT, RhsT >::operator>= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const

inline

Definition at line 111 of file catch_decomposer.h.

                                                                            {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

operator>=() [2/2]

template<typename LhsT , typename RhsT >

template<typename T >

auto Catch::BinaryExpr< LhsT, RhsT >::operator>= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const

inline

Definition at line 1931 of file catch.hpp.

                                                                            {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

operator||() [1/2]

template<typename LhsT , typename RhsT >

template<typename T >

auto Catch::BinaryExpr< LhsT, RhsT >::operator|| ( T ) const -> BinaryExpr<LhsT, RhsT const&> const

inline

Definition at line 76 of file catch_decomposer.h.

                                                                            {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

operator||() [2/2]

template<typename LhsT , typename RhsT >

template<typename T >

auto Catch::BinaryExpr< LhsT, RhsT >::operator|| ( T ) const -> BinaryExpr<LhsT, RhsT const&> const

inline

Definition at line 1896 of file catch.hpp.

                                                                            {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

---

The documentation for this class was generated from the following files:

• libraries/sys-vm/external/Catch2/include/internal/catch_decomposer.h
• libraries/sys-vm/external/Catch2/single_include/catch2/catch.hpp