decomposition.h

Go to the documentation of this file.

#pragma once
 
#include "zeroerr/internal/config.h"
 
#include "zeroerr/dbg.h"
#include "zeroerr/print.h"
 
ZEROERR_SUPPRESS_COMMON_WARNINGS_PUSH
ZEROERR_SUPPRESS_COMPARE
 
#ifndef ZEROERR_DISABLE_COMPLEX_AND_OR
#define AND &&zeroerr::ExpressionDecomposer() <<
#define OR  || zeroerr::ExpressionDecomposer() <<
#endif
 
namespace zeroerr {
 
 
// SFINAE helper used to check L op R is supported, but the result type is `ret`
#define ZEROERR_SFINAE_OP(ret, op) \
    typename std::decay<decltype(std::declval<L>() op std::declval<R>(), std::declval<ret>())>::type
 
template <typename T>
struct deferred_false {
    static const bool value = false;
};
 
#define ZEROERR_EXPRESSION_COMPARISON(op, op_name)                                                 \
    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));                    \
    }
 
 
#define ZEROERR_EXPRESSION_ANDOR(op, op_name)                                       \
    ExprResult operator op(ExprResult rhs) {                                        \
        return ExprResult(res op rhs.res,                                           \
                          detail::joinDiagnostic(decomp, " " #op " ", rhs.decomp)); \
    }
 
 
#define ZEROERR_FORBIT_EXPRESSION(rt, op)                                 \
    template <typename R>                                                 \
    rt& operator op(const R&) {                                           \
        static_assert(deferred_false<R>::value,                           \
                      "Please Rewrite Expression As Binary Comparison!"); \
        return *this;                                                     \
    }
 
struct ExprResult {
    bool        res;
    zeroerr::String decomp;
 
    ExprResult(bool res, zeroerr::String decomposition = "") : res(res), decomp(decomposition) {}
 
    ZEROERR_EXPRESSION_ANDOR(&&, and)
    ZEROERR_EXPRESSION_ANDOR(||, or)
 
    ZEROERR_FORBIT_EXPRESSION(ExprResult, &)
    ZEROERR_FORBIT_EXPRESSION(ExprResult, ^)
    ZEROERR_FORBIT_EXPRESSION(ExprResult, |)
    ZEROERR_FORBIT_EXPRESSION(ExprResult, ==)
    ZEROERR_FORBIT_EXPRESSION(ExprResult, !=)
    ZEROERR_FORBIT_EXPRESSION(ExprResult, <)
    ZEROERR_FORBIT_EXPRESSION(ExprResult, >)
    ZEROERR_FORBIT_EXPRESSION(ExprResult, <=)
    ZEROERR_FORBIT_EXPRESSION(ExprResult, >=)
    ZEROERR_FORBIT_EXPRESSION(ExprResult, +=)
    ZEROERR_FORBIT_EXPRESSION(ExprResult, -=)
    ZEROERR_FORBIT_EXPRESSION(ExprResult, *=)
    ZEROERR_FORBIT_EXPRESSION(ExprResult, /=)
    ZEROERR_FORBIT_EXPRESSION(ExprResult, %=)
    ZEROERR_FORBIT_EXPRESSION(ExprResult, <<=)
    ZEROERR_FORBIT_EXPRESSION(ExprResult, >>=)
    ZEROERR_FORBIT_EXPRESSION(ExprResult, &=)
    ZEROERR_FORBIT_EXPRESSION(ExprResult, ^=)
    ZEROERR_FORBIT_EXPRESSION(ExprResult, |=)
};
 
namespace detail {
 
// Bind operands for one full expression without copying or re-evaluating them.
// Unlike Expression, a comparison does not first convert its left operand to bool.
template <class L>
struct ComparisonLhs {
    const L& lhs;
    Printer& printer;
 
#define ZEROERR_DIRECT_COMPARISON(op)                         \
    template <class R>                                       \
    ExprResult operator op(const R& rhs) const {             \
        return {lhs op rhs, printer(lhs, #op, rhs)};         \
    }
    ZEROERR_DIRECT_COMPARISON(==)
    ZEROERR_DIRECT_COMPARISON(!=)
    ZEROERR_DIRECT_COMPARISON(<)
    ZEROERR_DIRECT_COMPARISON(<=)
    ZEROERR_DIRECT_COMPARISON(>)
    ZEROERR_DIRECT_COMPARISON(>=)
#undef ZEROERR_DIRECT_COMPARISON
};
 
template <class L>
ComparisonLhs<L> makeComparisonLhs(const L& lhs, Printer& printer) {
    return {lhs, printer};
}
 
}  // namespace detail
 
namespace details {
// Detect whether a type can be explicitly converted to bool. This covers
// explicit operator bool (std::unique_ptr/std::shared_ptr), which
// std::is_convertible would miss. Scoped enums are excluded so that a bare
// CHECK(enum) does not silently turn into "value != 0"; unscoped enums keep
// their historical implicit-conversion behavior.
template <typename T, typename = void>
struct has_bool_conversion : std::false_type {};
 
template <typename T>
struct has_bool_conversion<T, decltype(static_cast<bool>(std::declval<T>()), void())>
    : std::integral_constant<
          bool, !(std::is_enum<typename std::decay<T>::type>::value &&
                  !std::is_convertible<typename std::decay<T>::type, int>::value)> {};
 
template <typename T>
typename std::enable_if<has_bool_conversion<T>::value, bool>::type getBool(T&& lhs) {
    return static_cast<bool>(lhs);
}
 
template <typename T>
typename std::enable_if<!has_bool_conversion<T>::value, bool>::type getBool(T&&) {
    return true;
}
}  // namespace details
 
template <typename L>
struct Expression {
    L           lhs;
    bool        res = true;
    zeroerr::String decomp;
 
    explicit Expression(L&& in) : lhs(static_cast<L&&>(in)) { res = details::getBool(lhs); }
    explicit Expression(L&& in, bool res, zeroerr::String&& decomp)
        : lhs(static_cast<L&&>(in)), res(res), decomp(static_cast<zeroerr::String&&>(decomp)) {}
 
    operator ExprResult() {
        if (decomp.empty()) {
            decomp = detail::valueText(detail::makeDiagnosticValue(lhs));
        }
        return ExprResult(res, decomp);
    }
 
    operator L() const { return lhs; }
 
    ZEROERR_EXPRESSION_COMPARISON(==, eq)
    ZEROERR_EXPRESSION_COMPARISON(!=, ne)
    ZEROERR_EXPRESSION_COMPARISON(>, gt)
    ZEROERR_EXPRESSION_COMPARISON(<, lt)
    ZEROERR_EXPRESSION_COMPARISON(>=, ge)
    ZEROERR_EXPRESSION_COMPARISON(<=, le)
 
    ZEROERR_EXPRESSION_ANDOR(&&, and)
    ZEROERR_EXPRESSION_ANDOR(||, or)
 
    ZEROERR_FORBIT_EXPRESSION(Expression, &)
    ZEROERR_FORBIT_EXPRESSION(Expression, ^)
    ZEROERR_FORBIT_EXPRESSION(Expression, |)
    ZEROERR_FORBIT_EXPRESSION(Expression, =)
    ZEROERR_FORBIT_EXPRESSION(Expression, +=)
    ZEROERR_FORBIT_EXPRESSION(Expression, -=)
    ZEROERR_FORBIT_EXPRESSION(Expression, *=)
    ZEROERR_FORBIT_EXPRESSION(Expression, /=)
    ZEROERR_FORBIT_EXPRESSION(Expression, %=)
    ZEROERR_FORBIT_EXPRESSION(Expression, <<=)
    ZEROERR_FORBIT_EXPRESSION(Expression, >>=)
    ZEROERR_FORBIT_EXPRESSION(Expression, &=)
    ZEROERR_FORBIT_EXPRESSION(Expression, ^=)
    ZEROERR_FORBIT_EXPRESSION(Expression, |=)
    ZEROERR_FORBIT_EXPRESSION(Expression, <<)
    ZEROERR_FORBIT_EXPRESSION(Expression, >>)
};
 
#undef ZEROERR_EXPRESSION_COMPARISON
#undef ZEROERR_EXPRESSION_ANDOR
#undef ZEROERR_FORBIT_EXPRESSION
 
struct ExpressionDecomposer {
    // The right operator for capturing expressions is "<=" instead of "<<" (based on the
    // operator precedence table) but then there will be warnings from GCC about "-Wparentheses"
    // and since "_Pragma()" is problematic this will stay for now...
    // https://github.com/catchorg/Catch2/issues/870
    // https://github.com/catchorg/Catch2/issues/565
 
    // For temporary objects, we need to use rvalue reference to avoid copy
    template <typename L>
    Expression<L> operator<<(L&& operand) {
        return Expression<L>(static_cast<L&&>(operand));
    }
 
    // For other objects, we will store the reference
    template <typename L,
              typename std::enable_if<!std::is_rvalue_reference<L>::value, void>::type* = nullptr>
    Expression<const L&> operator<<(const L& operand) {
        return Expression<const L&>(operand);
    }
};
 
 
template <typename T>
class IMatcher {
public:
    virtual ~IMatcher() = default;
 
 
    virtual bool match(const T&) const = 0;
};
 
template <typename T>
class IMatcherRef {
public:
    IMatcherRef(const IMatcher<T>* ptr) : p(ptr) {}
    IMatcherRef(const IMatcherRef&) = delete;
 
    IMatcherRef(IMatcherRef&& other) {
        p       = std::move(other.p);
        other.p = nullptr;
    }
    void operator=(IMatcherRef&& other) {
        p       = std::move(other.p);
        other.p = nullptr;
    }
    IMatcherRef& operator=(const IMatcherRef&) = delete;
    ~IMatcherRef() {
        if (p) delete p;
    }
 
    IMatcherRef operator&&(IMatcherRef&& other);
    IMatcherRef operator||(IMatcherRef&& other);
    IMatcherRef operator!();
 
    const IMatcher<T>* operator->() const { return p; }
 
protected:
    const IMatcher<T>* p = nullptr;
};
 
 
template <typename T>
class CombinedMatcher : public IMatcher<T> {
public:
    CombinedMatcher(IMatcherRef<T>&& lhs, IMatcherRef<T>&& rhs, bool is_and)
        : lhs(std::move(lhs)), rhs(std::move(rhs)), is_and(is_and) {}
 
    IMatcherRef<T> lhs;
    IMatcherRef<T> rhs;
    bool           is_and;
 
    virtual bool match(const T& t) const override {
        if (is_and) {
            return lhs->match(t) && rhs->match(t);
        } else {
            return lhs->match(t) || rhs->match(t);
        }
    }
};
 
template <typename T>
class NotMatcher : public IMatcher<T> {
public:
    NotMatcher(IMatcherRef<T>&& matcher) : matcher(std::move(matcher)) {}
    IMatcherRef<T> matcher;
 
    virtual bool match(const T& t) const override { return !matcher->match(t); }
};
 
template <typename T>
inline IMatcherRef<T> IMatcherRef<T>::operator&&(IMatcherRef<T>&& other) {
    return new CombinedMatcher<T>(std::move(*this), std::move(other), true);
}
 
template <typename T>
inline IMatcherRef<T> IMatcherRef<T>::operator||(IMatcherRef<T>&& other) {
    return new CombinedMatcher<T>(std::move(*this), std::move(other), false);
}
 
template <typename T>
inline IMatcherRef<T> IMatcherRef<T>::operator!() {
    return new NotMatcher<T>(std::move(*this));
}
 
 
template <typename T>
struct StartWithMatcher : public IMatcher<T> {
    StartWithMatcher(const T& s) : start(s) {}
    T start;
 
    virtual bool match(const T& t) const override {
        bool result = true;
        for (auto i = start.begin(), j = t.begin(); i != start.end(); ++i, ++j) {
            if (j == t.end() || *i != *j) {
                result = false;
                break;
            }
        }
        return result;
    }
};
 
template <typename T>
typename std::enable_if<std::is_constructible<zeroerr::String, T>::value,
                        IMatcherRef<zeroerr::String>>::type
start_with(T&& s) {
    return new StartWithMatcher<zeroerr::String>(zeroerr::String(s));
}
 
}  // namespace zeroerr
 
ZEROERR_SUPPRESS_COMPARE_POP
ZEROERR_SUPPRESS_COMMON_WARNINGS_POP