Guard.h

// -*- c++ -*-

#ifndef _GUARD_H_
#define _GUARD_H_

// tools
#include "tools/GenericException.h"
#include "tools/OrderedMutex.h"
#include "tools/NoCopy.h"

class epicsMutexGuard
{
public:

    epicsMutexGuard(epicsMutex &mutex) : mutex(mutex)
    {
        mutex.lock();
    }

    ~epicsMutexGuard()
    {
        mutex.unlock();
    }

    void check(const char *file, size_t line,
               const epicsMutex &the_one_it_should_be);

private:
    PROHIBIT_DEFAULT_COPY(epicsMutexGuard);
    epicsMutex &mutex;
};

class Guardable
{
public:
    virtual ~Guardable();
    
    virtual OrderedMutex &getMutex() = 0;
};

class Guard
{
public:
    Guard(const char *file, size_t line, Guardable &guardable)
     : mutex(guardable.getMutex()), is_locked(false)
    {
        lock(file, line);
        is_locked = true;
    }

    Guard(const char *file, size_t line, OrderedMutex &mutex)
     : mutex(mutex), is_locked(false)
    {
        lock(file, line);
        is_locked = true;
    }

    ~Guard()
    {
        if (!is_locked)
            throw GenericException(__FILE__, __LINE__,
                   "Found a released lock in Guard::~Guard()");
        mutex.unlock();
    }

    void check(const char *file, size_t line,
               const OrderedMutex &the_one_it_should_be);

    void unlock()
    {
        mutex.unlock();
        is_locked = false;
    }

    void lock(const char *file, size_t line);

    bool isLocked()
    {
        return is_locked;
    }

private:
    PROHIBIT_DEFAULT_COPY(Guard);
    OrderedMutex &mutex;
    bool is_locked;
};


class GuardRelease
{
public:
    GuardRelease(const char *file, size_t line, Guard &guard)
     : file(file), line(line), guard(guard)
    {
        guard.unlock();
    }

    ~GuardRelease()
    {
        guard.lock(file, line);
    }

private:
    PROHIBIT_DEFAULT_COPY(GuardRelease);
    const char *file;
    size_t line;
    Guard &guard;
};

#endif