Catch::ExpressionLhs< T > Class Template Reference

#include <catch.hpp>

Public Member Functions
	ExpressionLhs (ResultBuilder &rb, T lhs)
template<typename RhsT >
ResultBuilder &	operator== (RhsT const &rhs)
template<typename RhsT >
ResultBuilder &	operator!= (RhsT const &rhs)
template<typename RhsT >
ResultBuilder &	operator< (RhsT const &rhs)
template<typename RhsT >
ResultBuilder &	operator> (RhsT const &rhs)
template<typename RhsT >
ResultBuilder &	operator<= (RhsT const &rhs)
template<typename RhsT >
ResultBuilder &	operator>= (RhsT const &rhs)
ResultBuilder &	operator== (bool rhs)
ResultBuilder &	operator!= (bool rhs)
void	endExpression ()
template<typename RhsT >
STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison &	operator+ (RhsT const &)
template<typename RhsT >
STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison &	operator- (RhsT const &)
template<typename RhsT >
STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison &	operator/ (RhsT const &)
template<typename RhsT >
STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison &	operator* (RhsT const &)
template<typename RhsT >
STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison &	operator&& (RhsT const &)
template<typename RhsT >
STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison &	operator|| (RhsT const &)

Private Member Functions
ExpressionLhs &	operator= (ExpressionLhs const &)
template<Internal::Operator Op, typename RhsT >
ResultBuilder &	captureExpression (RhsT const &rhs)

Private Attributes
ResultBuilder &	m_rb
T	m_lhs

Detailed Description

template<typename T>
class Catch::ExpressionLhs< T >

Definition at line 1800 of file catch.hpp.

Constructor & Destructor Documentation

ExpressionLhs()

template<typename T >

Catch::ExpressionLhs< T >::ExpressionLhs ( ResultBuilder &  rb, T  lhs  )

inline

Definition at line 1807 of file catch.hpp.

: m_rb( rb ), m_lhs( lhs ) {}

Member Function Documentation

captureExpression()

template<typename T >

template<Internal::Operator Op, typename RhsT >

ResultBuilder& Catch::ExpressionLhs< T >::captureExpression ( RhsT const &  rhs )

inlineprivate

Definition at line 1870 of file catch.hpp.

                                                        {
        return m_rb
            .setResultType( Internal::compare<Op>( m_lhs, rhs ) )
            .setLhs( Catch::toString( m_lhs ) )
            .setRhs( Catch::toString( rhs ) )
            .setOp( Internal::OperatorTraits<Op>::getName() );
    }

References Catch::ResultBuilder::setLhs(), Catch::ResultBuilder::setOp(), Catch::ResultBuilder::setResultType(), Catch::ResultBuilder::setRhs(), and Catch::toString().

endExpression()

template<typename T >

void Catch::ExpressionLhs< T >::endExpression ( )

inline

Definition at line 1851 of file catch.hpp.

                         {
        bool value = m_lhs ? true : false;
        m_rb
            .setLhs( Catch::toString( value ) )
            .setResultType( value )
            .endExpression();
    }

References Catch::toString().

operator!=() [1/2]

template<typename T >

ResultBuilder& Catch::ExpressionLhs< T >::operator!= ( bool  rhs )

inline

Definition at line 1847 of file catch.hpp.

                                            {
        return captureExpression<Internal::IsNotEqualTo>( rhs );
    }

operator!=() [2/2]

template<typename T >

template<typename RhsT >

ResultBuilder& Catch::ExpressionLhs< T >::operator!= ( RhsT const &  rhs )

inline

Definition at line 1819 of file catch.hpp.

                                                   {
        return captureExpression<Internal::IsNotEqualTo>( rhs );
    }

operator&&()

template<typename T >

template<typename RhsT >

STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& Catch::ExpressionLhs< T >::operator&&

(

RhsT const &

)

operator*()

template<typename T >

template<typename RhsT >

STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& Catch::ExpressionLhs< T >::operator*

(

RhsT const &

)

operator+()

template<typename T >

template<typename RhsT >

STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& Catch::ExpressionLhs< T >::operator+

(

RhsT const &

)

operator-()

template<typename T >

template<typename RhsT >

STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& Catch::ExpressionLhs< T >::operator-

(

RhsT const &

)

operator/()

template<typename T >

template<typename RhsT >

STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& Catch::ExpressionLhs< T >::operator/

(

RhsT const &

)

operator<()

template<typename T >

template<typename RhsT >

ResultBuilder& Catch::ExpressionLhs< T >::operator< ( RhsT const &  rhs )

inline

Definition at line 1824 of file catch.hpp.

                                                  {
        return captureExpression<Internal::IsLessThan>( rhs );
    }

operator<=()

template<typename T >

template<typename RhsT >

ResultBuilder& Catch::ExpressionLhs< T >::operator<= ( RhsT const &  rhs )

inline

Definition at line 1834 of file catch.hpp.

                                                   {
        return captureExpression<Internal::IsLessThanOrEqualTo>( rhs );
    }

operator=()

template<typename T >

ExpressionLhs& Catch::ExpressionLhs< T >::operator= ( ExpressionLhs< T > const &  )

private

operator==() [1/2]

template<typename T >

ResultBuilder& Catch::ExpressionLhs< T >::operator== ( bool  rhs )

inline

Definition at line 1843 of file catch.hpp.

                                            {
        return captureExpression<Internal::IsEqualTo>( rhs );
    }

operator==() [2/2]

template<typename T >

template<typename RhsT >

ResultBuilder& Catch::ExpressionLhs< T >::operator== ( RhsT const &  rhs )

inline

Definition at line 1814 of file catch.hpp.

                                                   {
        return captureExpression<Internal::IsEqualTo>( rhs );
    }

operator>()

template<typename T >

template<typename RhsT >

ResultBuilder& Catch::ExpressionLhs< T >::operator> ( RhsT const &  rhs )

inline

Definition at line 1829 of file catch.hpp.

                                                  {
        return captureExpression<Internal::IsGreaterThan>( rhs );
    }

operator>=()

template<typename T >

template<typename RhsT >

ResultBuilder& Catch::ExpressionLhs< T >::operator>= ( RhsT const &  rhs )

inline

Definition at line 1839 of file catch.hpp.

                                                   {
        return captureExpression<Internal::IsGreaterThanOrEqualTo>( rhs );
    }

operator||()

template<typename T >

template<typename RhsT >

STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& Catch::ExpressionLhs< T >::operator||

(

RhsT const &

)

Field Documentation

m_lhs

template<typename T >

T Catch::ExpressionLhs< T >::m_lhs

private

Definition at line 1880 of file catch.hpp.

m_rb

template<typename T >

ResultBuilder& Catch::ExpressionLhs< T >::m_rb

private

Definition at line 1879 of file catch.hpp.

---

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

• src/unittests/catch.hpp (986a3bf)