lock.hpp

#if !defined(__SYSTEM_L4_LOCK_HPP__)
#define __SYSTEM_L4_LOCK_HPP__

//
// L4 includes
//
#include <l4/lock/lock.h>

//
// local includes
//
#include "core/util/noncopyable.hpp"

//
// a l4lock wrapped into a C++ class.
//
struct lock : protected l4lock, private noncopyable
{
    //
    // constructors
    //
    inline lock(void)
        : l4lock(L4LOCK_UNLOCKED)
    {}

    // do *NOT* copy another used l4lock (for L4LOCK_LOCKED/L4LOCK_UNLOCKED only).
    inline lock(const l4lock &initial_state)
        : l4lock(initial_state)
    {}

    //
    // typecast operators
    //
    inline int operator ()(void) const
    {
        return ref_count;
    }

    inline operator int(void) const
    {
        return (*this)();
    }

    //
    // map l4lock functions to methods ...
    //
    inline int acquire(void)
    {
        l4lock_lock(this);
        return 0;
    }

    inline int try_acquire(void)
    {
        return l4lock_try_lock(this);
    }

    inline void release(void)
    {
        l4lock_unlock(this);
    }

    inline l4thread_t owner(void) const
    {
        return l4lock_owner(this);
    }

    //
    // prefix increment operators
    //
    inline lock &operator ++(void)
    {
        release();
        return *this;
    }

    inline lock &operator --(void)
    {
        acquire();
        return *this;
    }

    //
    // postfix increment operators: these ones return void to avoid to copy the entire object,
    //     thus violating standard compliance. DO NOT return a reference here.
    //
    inline void operator ++(int)
    {
        ++*this;
    }

    inline void operator --(int)
    {
        --*this;
    }
};

#endif

// ***** end of source ***** //