semaphore.hpp

#if !defined(__SYSTEM_L4_SEMAPHORE_HPP__)
#define __SYSTEM_L4_SEMAPHORE_HPP__

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

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

//
// a l4semaphore wrapped into a C++ class.
//
struct semaphore : protected l4semaphore, private noncopyable
{
    //
    // constructors
    //
    inline semaphore(void)
        : l4semaphore(L4SEMAPHORE_UNLOCKED)
    {}

    // do *NOT* copy another used l4semaphore (for L4SEMAPHORE_LOCKED/L4SEMAPHORE_UNLOCKED only).
    inline semaphore(const l4semaphore &initial_state)
        : l4semaphore(initial_state)
    {}

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

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

    //
    // map l4semaphore functions to methods ...
    //
    inline int down(void)
    {
        l4semaphore_down(this);
        return 0;
    }

    //
    // timeout in us. special values:
    //      0 -> timeout 0
    //     ~0 -> timeout NEVER
    //
    inline int down(unsigned timeout)
    {
        // l4semaphore_down_timed wants timeout in ms
        return (timeout == ~0u) ? down() : l4semaphore_down_timed(this, timeout / 1000);
    }

    inline int try_down(void)
    {
        return l4semaphore_try_down(this);
    }

    inline void up(void)
    {
        l4semaphore_up(this);
    }

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

    inline semaphore &operator --(void)
    {
        down();
        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 ***** //