scope_guard.h

/*****************************************************/
/* lean Smart                   (c) Tobias Zirr 2011 */
/*****************************************************/

#ifndef LEAN_SMART_SCOPE_GUARD
#define LEAN_SMART_SCOPE_GUARD

#include "../lean.h"
#include "../tags/noncopyable.h"
#include "../functional/callable.h"

namespace lean
{
namespace smart
{

class scope_annex_base : public nonassignable
{
private:
    mutable bool m_valid;

protected:
    LEAN_INLINE scope_annex_base()
        : m_valid(true) { }
    LEAN_INLINE scope_annex_base(const scope_annex_base &right)
        : m_valid(true)
    {
        right.m_valid = false;
    }
    LEAN_INLINE ~scope_annex_base() throw() { }

    LEAN_INLINE bool valid() const { return m_valid; }
};

template <class Callable>
class scope_annex_impl : public scope_annex_base
{
private:
    Callable m_callable;

public:
    LEAN_INLINE explicit scope_annex_impl(const Callable &callable)
        : m_callable(callable) { }
    LEAN_INLINE ~scope_annex_impl()
    {
        if (valid())
            m_callable();
    }
};

typedef const scope_annex_base& scope_annex;

template <class Callable>
LEAN_INLINE scope_annex_impl<Callable> make_scope_annex(const Callable& callable)
{
    return scope_annex_impl<Callable>(callable);
}

template <class Signature>
LEAN_INLINE scope_annex_impl< callable_fun<Signature> > make_scope_annex(Signature *fun)
{
    return make_scope_annex( make_callable(fun) );
}

template <class Class, class Signature>
LEAN_INLINE scope_annex_impl< callable_memfun<Class, Signature> > make_scope_annex(Class *obj, Signature Class::*fun)
{
    return make_scope_annex( make_callable(obj, fun) );
}

class scope_guard_base : public nonassignable
{
private:
    mutable bool m_armed;

protected:
    LEAN_INLINE explicit scope_guard_base(bool arm = true)
        : m_armed(arm) { }
    LEAN_INLINE scope_guard_base(const scope_guard_base &right)
        : m_armed(right.m_armed)
    {
        right.disarm();
    }
    LEAN_INLINE ~scope_guard_base() throw() { }

public:
    LEAN_INLINE void armed(bool arm) const { m_armed = arm; }
    LEAN_INLINE bool armed() const { return m_armed; }

    LEAN_INLINE void disarm() const { armed(false); }
    LEAN_INLINE void arm() const { armed(true); }
};

typedef const scope_guard_base& scope_guard;

template <class Callable>
class scope_guard_impl : public scope_guard_base
{
private:
    Callable m_callable;

public:
    LEAN_INLINE explicit scope_guard_impl(const Callable &callable, bool arm = true)
        : scope_guard_base(arm),
        m_callable(callable) { }
    LEAN_INLINE ~scope_guard_impl()
    {
        if (armed())
            m_callable();
    }
};

template <class Callable>
LEAN_INLINE scope_guard_impl<Callable> make_scope_guard(const Callable& callable)
{
    return scope_guard_impl<Callable>(callable);
}

template <class Signature>
LEAN_INLINE scope_guard_impl< callable_fun<Signature> > make_scope_guard(Signature *fun)
{
    return make_scope_guard( make_callable(fun) );
}

template <class Class, class Signature>
LEAN_INLINE scope_guard_impl< callable_memfun<Class, Signature> > make_scope_guard(Class *obj, Signature Class::*fun)
{
    return make_scope_guard( make_callable(obj, fun) );
}

} // namespace

using smart::scope_annex;
using smart::make_scope_annex;

using smart::scope_guard;
using smart::make_scope_guard;

} // namespace

#endif