Enforce.h

Go to the documentation of this file.

/* ex: set tabstop=4 expandtab: */
/*                                                             */
/*  (c) 2004-2006 Iowa State University                        */
/*      see the LICENSE file in the top level directory        */
/*                                                             */

#ifndef ENFORCE_H_
#define ENFORCE_H_

#include "FountainErrors.h"
#include <bamboo/define.h>
#include <string>
#include <sstream>
#include <stdexcept>

struct DefaultPredicate {
        template <class T>
        static bool Wrong(const T& obj){
                return !obj;
        }
};

struct DefaultRaiser {
    template <class T>
    static void Throw(const T&, const std::string& message, const char* locus) {
        throw FountainException(message + '\n' + locus);
    }
};

struct ErrorPredicate {
        static bool Wrong(int obj) {
                return obj == FAILURE;
        }
};

template<typename Ref, typename P, typename R>
class Enforcer {
public:
    Enforcer(Ref t, const char* locus) : t_(t), msg_(), locus_(P::Wrong(t) ? locus : 0) {}
        
    Ref operator*() const {
        if (locus_) R::Throw(t_, msg_, locus_);
        return t_;
    }
        
    template <class MsgType>
    Enforcer& operator()(const MsgType& msg) {
        if (locus_) {
            // Here we have time; an exception will be thrown
            std::ostringstream ss;
            ss << msg;
            msg_ += ss.str();
        }
        return *this;
    }
    
    Enforcer(const Enforcer& rhs) : t_(rhs.t_), msg_(rhs.msg_), locus_(rhs.locus_) {}
        
private:
        Enforcer& operator=(const Enforcer& rhs);
    Ref t_;
    std::string msg_;
    const char* const locus_;
};

template <class P, class R, typename T>
inline Enforcer<const T&, P, R> MakeEnforcer(const T& t, const char* locus) {
    return Enforcer<const T&, P, R>(t, locus);
}

template <class P, class R, typename T>
inline Enforcer<T&, P, R> MakeEnforcer(T& t, const char* locus) {
    return Enforcer<T&, P, R>(t, locus);
}

#define STRINGIZE(expr) STRINGIZE_HELPER(expr)

#define STRINGIZE_HELPER(expr) #expr

#define ENFORCE(exp) *MakeEnforcer<DefaultPredicate, DefaultRaiser>((exp), "Expression '" #exp "' failed in '" __FILE__ "', line: " STRINGIZE(__LINE__))

#define ENFORCE_SUCCESS(exp) *MakeEnforcer<ErrorPredicate, DefaultRaiser>((exp), "Expression '" #exp "' failed in '" __FILE__ "', line: " STRINGIZE(__LINE__))

#endif

---