decomposition.h File Reference

#include "zeroerr/internal/config.h"
#include "zeroerr/dbg.h"
#include "zeroerr/print.h"

Include dependency graph for decomposition.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	zeroerr::deferred_false< T >
struct	zeroerr::ExprResult
struct	zeroerr::detail::ComparisonLhs< L >
struct	zeroerr::details::has_bool_conversion< T, typename >
struct	zeroerr::details::has_bool_conversion< T, decltype(static_cast< bool >(std::declval< T >()), void())>
struct	zeroerr::Expression< L >
struct	zeroerr::ExpressionDecomposer
class	zeroerr::IMatcher< T >
class	zeroerr::IMatcherRef< T >
class	zeroerr::CombinedMatcher< T >
class	zeroerr::NotMatcher< T >
struct	zeroerr::StartWithMatcher< T >

Namespaces
namespace	zeroerr
namespace	zeroerr::detail
namespace	zeroerr::details

Macros
#define	AND   &&zeroerr::ExpressionDecomposer() <<
#define	OR   || zeroerr::ExpressionDecomposer() <<
#define	ZEROERR_SFINAE_OP(ret, op)
#define	ZEROERR_EXPRESSION_COMPARISON(op, op_name)
#define	ZEROERR_EXPRESSION_ANDOR(op, op_name)
#define	ZEROERR_FORBIT_EXPRESSION(rt, op)
#define	ZEROERR_DIRECT_COMPARISON(op)

Functions
template<class L>
ComparisonLhs< L >	zeroerr::detail::makeComparisonLhs (const L &lhs, Printer &printer)
template<typename T>
std::enable_if< has_bool_conversion< T >::value, bool >::type	zeroerr::details::getBool (T &&lhs)
template<typename T>
std::enable_if<!has_bool_conversion< T >::value, bool >::type	zeroerr::details::getBool (T &&)
template<typename T>
std::enable_if< std::is_constructible< zeroerr::String, T >::value, IMatcherRef< zeroerr::String > >::type	zeroerr::start_with (T &&s)

Macro Definition Documentation

AND

#define AND   &&zeroerr::ExpressionDecomposer() <<

AND and OR are used to combine expressions in a more readable way. For example: CHECK(1 == 1 AND 2 == 2);

In its implementation, the expression is decomposed to ExpressionDecomposer() << 1 == 1 && ExpressionDecomposer() << 2 == 2

OR

#define OR   || zeroerr::ExpressionDecomposer() <<

ZEROERR_DIRECT_COMPARISON

#define ZEROERR_DIRECT_COMPARISON

(

op

)

Value:

    template <class R>                                       \
    ExprResult operator op(const R& rhs) const {             \
        return {lhs op rhs, printer(lhs, #op, rhs)};         \
    }

ZEROERR_EXPRESSION_ANDOR

#define ZEROERR_EXPRESSION_ANDOR	(		op,
			op_name )

Value:

    ExprResult operator op(ExprResult rhs) {                                        \
        return ExprResult(res op rhs.res,                                           \
                          detail::joinDiagnostic(decomp, " " #op " ", rhs.decomp)); \
    }

ZEROERR_EXPRESSION_COMPARISON

#define ZEROERR_EXPRESSION_COMPARISON	(		op,
			op_name )

Value:

    template <typename R>                                                                          \
    ZEROERR_DIAGNOSTIC_NOINLINE ZEROERR_SFINAE_OP(Expression<R>, op) operator op(R&& rhs) {        \
        zeroerr::String text =                                                                         \
            detail::comparisonText(decomp, detail::makeDiagnosticValue(lhs), " " #op " ",          \
                                   detail::makeDiagnosticValue(rhs), res);                         \
        return Expression<R>(static_cast<R&&>(rhs), res && (lhs op rhs), std::move(text));         \
    }                                                                                              \
    template <typename R,                                                                          \
              typename std::enable_if<!std::is_rvalue_reference<R>::value, void>::type* = nullptr> \
    ZEROERR_DIAGNOSTIC_NOINLINE ZEROERR_SFINAE_OP(Expression<const R&>, op) operator op(           \
        const R& rhs) {                                                                            \
        zeroerr::String text =                                                                         \
            detail::comparisonText(decomp, detail::makeDiagnosticValue(lhs), " " #op " ",          \
                                   detail::makeDiagnosticValue(rhs), res);                         \
        return Expression<const R&>(rhs, res && (lhs op rhs), std::move(text));                    \
    }

ZEROERR_FORBIT_EXPRESSION

#define ZEROERR_FORBIT_EXPRESSION	(		rt,
			op )

Value:

    template <typename R>                                                 \
    rt& operator op(const R&) {                                           \
        static_assert(deferred_false<R>::value,                           \
                      "Please Rewrite Expression As Binary Comparison!"); \
        return *this;                                                     \
    }

ZEROERR_SFINAE_OP

#define ZEROERR_SFINAE_OP	(		ret,
			op )

Value:

    typename std::decay<decltype(std::declval<L>() op std::declval<R>(), std::declval<ret>())>::type