Catch::ExprLhs< LhsT > Class Template Reference

#include <catch_decomposer.h>

Public Member Functions
	ExprLhs (LhsT lhs)
template<typename RhsT >
auto	operator== (RhsT const &rhs) -> BinaryExpr< LhsT, RhsT const & > const
auto	operator== (bool rhs) -> BinaryExpr< LhsT, bool > const
template<typename RhsT >
auto	operator!= (RhsT const &rhs) -> BinaryExpr< LhsT, RhsT const & > const
auto	operator!= (bool rhs) -> BinaryExpr< LhsT, bool > const
template<typename RhsT >
auto	operator> (RhsT const &rhs) -> BinaryExpr< LhsT, RhsT const & > const
template<typename RhsT >
auto	operator< (RhsT const &rhs) -> BinaryExpr< LhsT, RhsT const & > const
template<typename RhsT >
auto	operator>= (RhsT const &rhs) -> BinaryExpr< LhsT, RhsT const & > const
template<typename RhsT >
auto	operator<= (RhsT const &rhs) -> BinaryExpr< LhsT, RhsT const & > const
template<typename RhsT >
auto	operator&& (RhsT const &) -> BinaryExpr< LhsT, RhsT const & > const
template<typename RhsT >
auto	operator|| (RhsT const &) -> BinaryExpr< LhsT, RhsT const & > const
auto	makeUnaryExpr () const -> UnaryExpr< LhsT >
	ExprLhs (LhsT lhs)
template<typename RhsT >
auto	operator== (RhsT const &rhs) -> BinaryExpr< LhsT, RhsT const & > const
auto	operator== (bool rhs) -> BinaryExpr< LhsT, bool > const
template<typename RhsT >
auto	operator!= (RhsT const &rhs) -> BinaryExpr< LhsT, RhsT const & > const
auto	operator!= (bool rhs) -> BinaryExpr< LhsT, bool > const
template<typename RhsT >
auto	operator> (RhsT const &rhs) -> BinaryExpr< LhsT, RhsT const & > const
template<typename RhsT >
auto	operator< (RhsT const &rhs) -> BinaryExpr< LhsT, RhsT const & > const
template<typename RhsT >
auto	operator>= (RhsT const &rhs) -> BinaryExpr< LhsT, RhsT const & > const
template<typename RhsT >
auto	operator<= (RhsT const &rhs) -> BinaryExpr< LhsT, RhsT const & > const
template<typename RhsT >
auto	operator&& (RhsT const &) -> BinaryExpr< LhsT, RhsT const & > const
template<typename RhsT >
auto	operator|| (RhsT const &) -> BinaryExpr< LhsT, RhsT const & > const
auto	makeUnaryExpr () const -> UnaryExpr< LhsT >

Detailed Description

template<typename LhsT>
class Catch::ExprLhs< LhsT >

Definition at line 1984 of file catch.hpp.

Constructor & Destructor Documentation

ExprLhs() [1/2]

template<typename LhsT >

Catch::ExprLhs< LhsT >::ExprLhs ( LhsT lhs )

inlineexplicit

Definition at line 169 of file catch_decomposer.h.

: m_lhs( lhs ) {}

ExprLhs() [2/2]

template<typename LhsT >

Catch::ExprLhs< LhsT >::ExprLhs ( LhsT lhs )

inlineexplicit

Definition at line 1987 of file catch.hpp.

: m_lhs( lhs ) {}

Member Function Documentation

makeUnaryExpr() [1/2]

template<typename LhsT >

auto Catch::ExprLhs< LhsT >::makeUnaryExpr ( ) const -> UnaryExpr<LhsT>

inline

Definition at line 218 of file catch_decomposer.h.

                                                      {
            return UnaryExpr<LhsT>{ m_lhs };
        }

Here is the caller graph for this function:

makeUnaryExpr() [2/2]

template<typename LhsT >

auto Catch::ExprLhs< LhsT >::makeUnaryExpr ( ) const -> UnaryExpr<LhsT>

inline

Definition at line 2036 of file catch.hpp.

                                                      {
            return UnaryExpr<LhsT>{ m_lhs };
        }

operator!=() [1/4]

template<typename LhsT >

auto Catch::ExprLhs< LhsT >::operator!= ( bool rhs ) -> BinaryExpr<LhsT, bool> const

inline

Definition at line 183 of file catch_decomposer.h.

                                                                      {
            return { m_lhs != rhs, m_lhs, "!=", rhs };
        }

operator!=() [2/4]

template<typename LhsT >

auto Catch::ExprLhs< LhsT >::operator!= ( bool rhs ) -> BinaryExpr<LhsT, bool> const

inline

Definition at line 2001 of file catch.hpp.

                                                                      {
            return { m_lhs != rhs, m_lhs, "!=", rhs };
        }

operator!=() [3/4]

template<typename LhsT >

template<typename RhsT >

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

inline

Definition at line 180 of file catch_decomposer.h.

                                                                                    {
            return { compareNotEqual( m_lhs, rhs ), m_lhs, "!=", rhs };
        }

Here is the call graph for this function:

operator!=() [4/4]

template<typename LhsT >

template<typename RhsT >

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

inline

Definition at line 1998 of file catch.hpp.

                                                                                    {
            return { compareNotEqual( m_lhs, rhs ), m_lhs, "!=", rhs };
        }

Here is the call graph for this function:

operator&&() [1/2]

template<typename LhsT >

template<typename RhsT >

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

inline

Definition at line 205 of file catch_decomposer.h.

                                                                                {
            static_assert(always_false<RhsT>::value,
            "operator&& is not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

operator&&() [2/2]

template<typename LhsT >

template<typename RhsT >

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

inline

Definition at line 2023 of file catch.hpp.

                                                                                {
            static_assert(always_false<RhsT>::value,
            "operator&& is not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

operator<() [1/2]

template<typename LhsT >

template<typename RhsT >

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

inline

Definition at line 192 of file catch_decomposer.h.

                                                                                   {
            return { static_cast<bool>(m_lhs < rhs), m_lhs, "<", rhs };
        }

operator<() [2/2]

template<typename LhsT >

template<typename RhsT >

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

inline

Definition at line 2010 of file catch.hpp.

                                                                                   {
            return { static_cast<bool>(m_lhs < rhs), m_lhs, "<", rhs };
        }

operator<=() [1/2]

template<typename LhsT >

template<typename RhsT >

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

inline

Definition at line 200 of file catch_decomposer.h.

                                                                                    {
            return { static_cast<bool>(m_lhs <= rhs), m_lhs, "<=", rhs };
        }

operator<=() [2/2]

template<typename LhsT >

template<typename RhsT >

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

inline

Definition at line 2018 of file catch.hpp.

                                                                                    {
            return { static_cast<bool>(m_lhs <= rhs), m_lhs, "<=", rhs };
        }

operator==() [1/4]

template<typename LhsT >

auto Catch::ExprLhs< LhsT >::operator== ( bool rhs ) -> BinaryExpr<LhsT, bool> const

inline

Definition at line 175 of file catch_decomposer.h.

                                                                      {
            return { m_lhs == rhs, m_lhs, "==", rhs };
        }

operator==() [2/4]

template<typename LhsT >

auto Catch::ExprLhs< LhsT >::operator== ( bool rhs ) -> BinaryExpr<LhsT, bool> const

inline

Definition at line 1993 of file catch.hpp.

                                                                      {
            return { m_lhs == rhs, m_lhs, "==", rhs };
        }

operator==() [3/4]

template<typename LhsT >

template<typename RhsT >

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

inline

Definition at line 172 of file catch_decomposer.h.

                                                                                    {
            return { compareEqual( m_lhs, rhs ), m_lhs, "==", rhs };
        }

Here is the call graph for this function:

operator==() [4/4]

template<typename LhsT >

template<typename RhsT >

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

inline

Definition at line 1990 of file catch.hpp.

                                                                                    {
            return { compareEqual( m_lhs, rhs ), m_lhs, "==", rhs };
        }

Here is the call graph for this function:

operator>() [1/2]

template<typename LhsT >

template<typename RhsT >

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

inline

Definition at line 188 of file catch_decomposer.h.

                                                                                   {
            return { static_cast<bool>(m_lhs > rhs), m_lhs, ">", rhs };
        }

operator>() [2/2]

template<typename LhsT >

template<typename RhsT >

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

inline

Definition at line 2006 of file catch.hpp.

                                                                                   {
            return { static_cast<bool>(m_lhs > rhs), m_lhs, ">", rhs };
        }

operator>=() [1/2]

template<typename LhsT >

template<typename RhsT >

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

inline

Definition at line 196 of file catch_decomposer.h.

                                                                                    {
            return { static_cast<bool>(m_lhs >= rhs), m_lhs, ">=", rhs };
        }

operator>=() [2/2]

template<typename LhsT >

template<typename RhsT >

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

inline

Definition at line 2014 of file catch.hpp.

                                                                                    {
            return { static_cast<bool>(m_lhs >= rhs), m_lhs, ">=", rhs };
        }

operator||() [1/2]

template<typename LhsT >

template<typename RhsT >

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

inline

Definition at line 212 of file catch_decomposer.h.

                                                                                {
            static_assert(always_false<RhsT>::value,
            "operator|| is not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

operator||() [2/2]

template<typename LhsT >

template<typename RhsT >

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

inline

Definition at line 2030 of file catch.hpp.

                                                                                {
            static_assert(always_false<RhsT>::value,
            "operator|| is 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