bitops.hpp

#if !defined(__SYSTEM_L4_BITOPS_HPP__)
#define __SYSTEM_L4_BITOPS_HPP__

//
// L4 includes
//
#include <l4/util/bitops.h>

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

//
// l4util bitops functions wrapped into a C++ class.
//
struct bitops
{
    //
    // attribute to store the value
    //
    l4_umword_t bits;

    //
    // constructor
    //
    inline bitops(const l4_umword_t bits=0)
        : bits(bits)
    {}

    //
    // atomic bit modifying functions
    //
    inline void set_bit(const uint8_t bit)
    {
        return set_bit(bit, &bits);
    }

    inline int test_bit(const uint8_t bit) const
    {
        return test_bit(bit, &bits);
    }

    inline void clear_bit(const uint8_t bit)
    {
        return clear_bit(bit, &bits);
    }

    inline int test_and_set_bit(const uint8_t bit)
    {
        return test_and_set_bit(bit, &bits);
    }

    inline int test_and_clear_bit(const uint8_t bit)
    {
        return test_and_clear_bit(bit, &bits);
    }

    inline int lowest_set_bit(void) const
    {
        return lowest_set_bit(bits);
    }

    inline int highest_set_bit(void) const
    {
        return highest_set_bit(bits);
    }

    //
    // atomic bit access operator (read-only, writing this way is not desired)
    //
    inline int operator [](const uint8_t bit) const
    {
        return test_bit(bit, &bits);
    }

    //
    // non-atomic access operators
    //
    ACCESS_FUNCTORS(bitops&, l4_umword_t, bits)
    ACCESS_OPERATORS(bitops&, l4_umword_t, bits)

    //
    // static helper functions for general use
    //
    static inline void set_bit(const int bit, volatile l4_umword_t *word)
    {
        return l4util_set_bit(bit, word);
    }

    static inline int test_bit(const int bit, const volatile l4_umword_t *word)
    {
        return l4util_test_bit(bit, word);
    }

    static inline void clear_bit(const int bit, volatile l4_umword_t *word)
    {
        return l4util_clear_bit(bit, word);
    }

    static inline int test_and_set_bit(const int bit, volatile l4_umword_t *word)
    {
        return l4util_test_and_set_bit(bit, word);
    }

    static inline int test_and_clear_bit(const int bit, volatile l4_umword_t *word)
    {
        return l4util_test_and_clear_bit(bit, word);
    }

    static inline int lowest_set_bit(const l4_umword_t word)
    {
        return l4util_bsf(word);
    }

    static inline int highest_set_bit(const l4_umword_t word)
    {
        return l4util_bsr(word);
    }
};

#endif

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