resource_manager.hpp

#if !defined(__RESOURCE_MANAGER_HPP__)
#define __RESOURCE_MANAGER_HPP__

//
// local includes
//
#include "core/common.hpp"

struct resource_manager
{
    //
    // range checker. defined here to specialize for 16 bit unsigned integer,
    //     which would otherwise produce an annoying warning.
    //
    template <typename IndexT, int NumberC>
    struct range_traits
    {
        static inline bool is_valid(const IndexT index)
        {
            static_assert(is_unsigned<IndexT>::conforms, "IndexT must be an unsigned integer");
            return (NumberC > integer_traits<IndexT>::const_max) || (index < NumberC);
        }
    };

    template <int NumberC>
    struct range_traits<uint16_t, NumberC>
    {
        static inline bool is_valid(const uint16_t index)
        {
            static_assert(NumberC > integer_traits<uint16_t>::const_max, "NumberC must be > 0xffff");
            return true;
        }
    };

    enum resource_flags_constants
    {
        /* internal flags */

        DONT_USE              = 0x0001,
        RESERVED_VIRTUAL      = 0x0002,
        RESERVED_PHYSICAL     = 0x0004,
        AVOID_USE             = 0x0008,
        AVAILABLE_FROM_OMEGA0 = 0x0010,
        ATTACHED              = 0x0020,

        /* usage flags */

        FIXED                 = 0x0100,
        VIRTUAL               = 0x0200,
        PHYSICAL              = 0x0400,

        /* masks */

        USE_MASK              = FIXED | VIRTUAL | PHYSICAL,
        ALL_MASK              = DONT_USE | RESERVED_VIRTUAL | RESERVED_PHYSICAL | AVOID_USE |
                                AVAILABLE_FROM_OMEGA0 | ATTACHED | FIXED | VIRTUAL | PHYSICAL
    };

    struct resource_flags : public bitmask<uint_value_t<ALL_MASK>::least>
    {
        //
        // constructor
        //
        inline resource_flags(const word_type bits=word_type())
            : bitmask<word_type>(bits)
        {}

        //
        // query functions
        //
        inline bool is_attached(void) const
        {
            return is(ATTACHED);
        }

        inline bool is_fixed(void) const
        {
            return is(FIXED);
        }

        inline bool is_virtual(void) const
        {
            return is(VIRTUAL);
        }

        inline bool is_physical(void) const
        {
            return is(PHYSICAL);
        }

        inline bool is_used(void) const
        {
            return any(VIRTUAL | PHYSICAL);
        }

        inline bool is_valid_use(void) const
        {
            return is_virtual() ^ is_physical();
        }

        inline bool is_equal_use(const resource_flags use) const
        {
            return (bits & USE_MASK) == (use & USE_MASK);
        }

        inline bool is_usable(const resource_flags use) const
        {
            return !any(DONT_USE | VIRTUAL | PHYSICAL) &&
                       (!is(RESERVED_VIRTUAL) || use.is_virtual()) &&
                       (!is(RESERVED_PHYSICAL) || use.is_physical());
        }
    };

    static_assert(integer_traits<resource_flags::word_type>::const_max >= ALL_MASK,
                  "resource_flags's max value is too small");
};

#endif

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