Affirm.h

#ifndef ROSE_Affirm_H
#define ROSE_Affirm_H
 
#include <Rose/Exception.h>
#include <string>
 
namespace Rose {
 
class AffirmationError: public Exception {
public:
    explicit AffirmationError(const std::string &mesg)
        : Exception(mesg) {}
 
    ~AffirmationError() throw() {}
};
 
// std::is_invocable backported for C++14
template<class F, class... Args>
struct is_invocable {
    template<class U>
    static auto test(U *p) -> decltype((*p)(std::declval<Args>()...), void(), std::true_type());
 
    template<class U>
    static auto test(...) -> decltype(std::false_type());
 
    static constexpr bool value = decltype(test<F>(0))::value;
};
 
template<class Value, class Predicate>
typename std::enable_if<is_invocable<Predicate, Value>::value, Value&>::type
affirm(Value&& value, Predicate predicate) {
    if (predicate(value))
        return value;
    throw AffirmationError("predicate failed for value");
}
 
template<class Value, class Predicate>
typename std::enable_if<is_invocable<Predicate, Value>::value, Value&>::type
affirm(Value& value, Predicate predicate) {
    if (predicate(value))
        return value;
    throw AffirmationError("predicate failed for value");
}
 
template<class Value, class Predicate>
typename std::enable_if<is_invocable<Predicate, Value>::value, Value&>::type
affirm(Value&& value, Predicate predicate, std::string const& message) {
    if (predicate(value))
        return value;
    throw AffirmationError(message);
}
 
template<class Value, class Predicate>
typename std::enable_if<is_invocable<Predicate, Value>::value, Value&>::type
affirm(Value& value, Predicate predicate, std::string const& message) {
    if (predicate(value))
        return value;
    throw AffirmationError(message);
}
template<class Value>
Value&
affirm(Value&& value) {
    if (value)
        return value;
    throw AffirmationError("value does not evaluate to true in Boolean context");
}
 
template<class Value>
Value&
affirm(Value& value) {
    if (value)
        return value;
    throw AffirmationError("value does not evaluate to true in Boolean context");
}
 
template<class Value>
Value&
affirm(Value&& value, std::string const& message) {
    if (value)
        return value;
    throw AffirmationError(message);
}
 
template<class Value>
Value&
affirm(Value& value, std::string const& message) {
    if (value)
        return value;
    throw AffirmationError(message);
}
template<class Pointer>
Pointer&
notnull(Pointer&& pointer) {
    if (pointer)
        return pointer;
    throw AffirmationError("null pointer");
}
 
template<class Pointer>
Pointer&
notnull(Pointer& pointer) {
    if (pointer)
        return pointer;
    throw AffirmationError("null pointer");
}
} // namespace
 
// Convenience macro. The predicate should be a C++ Boolean expression in terms of a variable `x`. For example:
//
//    const int n = ROSE_AFFIRM(foo(a, b), x < 100); // will throw if foo(a,b) returns a value >= 100
//
#define ROSE_AFFIRM(VALUE, PREDICATE) ::Rose::affirm((VALUE), [](auto x) -> bool { return PREDICATE; })
 
#endif