resource_region.hpp

#if !defined(__RESOURCE_REGION_HPP__)
#define __RESOURCE_REGION_HPP__

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

namespace detail
{
    template <typename AddressT>
    struct resource_region
    {
        typedef AddressT address_type;

        AddressT base;

        AddressT size;

        //
        // set functions
        //
        inline resource_region &operator ()(const AddressT base, const AddressT size=AddressT(1))
        {
            this->base=base;
            this->size=size;
            return *this;
        }

        //
        // query functions
        //
        inline bool is_empty(void) const
        {
            return size == 0;
        }

        inline bool equals(const AddressT base, const AddressT size=AddressT(1)) const
        {
            return (base == this->base) && (size == this->size);
        }

        friend inline bool operator ==(const resource_region &r1, const resource_region &r2)
        {
            return r1.equals(r2.base, r2.size);
        }

        inline bool contains(const AddressT base, const AddressT size=AddressT(1)) const
        {
            return (base >= this->base) && (base + size <= this->base + this->size);
        }

        inline bool contains(const resource_region &other) const
        {
            return contains(other.base, other.size);
        }

        inline bool overlaps(const AddressT base, const AddressT size=AddressT(1)) const
        {
            return contains(base) || ((base < this->base) && ((base + size) > this->base));
        }

        inline bool overlaps(const resource_region &other) const
        {
            return overlaps(other.base, other.size);
        }

        inline const resource_region disjunct(const AddressT base, const AddressT size=AddressT(1)) const
        {
            const AddressT start=min(base, this->base),
                           end=max(base + size, this->base + this->size);
            return (resource_region){base: start, size: end - start};
        }

        friend inline const resource_region operator |(const resource_region &r1, const resource_region &r2)
        {
            return r1.disjunct(r2.base, r2.size);
        }

        inline const resource_region conjunct(const AddressT base, const AddressT size=AddressT(1)) const
        {
            const AddressT start=max(base, this->base),
                           end=min(base + size, this->base + this->size);
            return (resource_region){base: start, size: (start < end) ? end - start : 0};
        }

        friend inline const resource_region operator &(const resource_region &r1, const resource_region &r2)
        {
            return r1.conjunct(r2.base, r2.size);
        }

        //
        // debug stuff
        //
        template <typename FormatT>
        inline int print(const char *prefix="", const char *suffix="") const
        {
            return log::print("%s%s-%s [%s]%s", prefix,
                              format_hex<FormatT>(base).c_str(),
                              format_hex<FormatT>(base + size - 1).c_str(),
                              format_hex<FormatT>(size).c_str(), suffix);
        }

        inline int print(const char *prefix="", const char *suffix="") const
        {
            return print<AddressT>(prefix, suffix);
        }
    };
}

template <typename AddressT>
struct resource_region : public detail::resource_region<AddressT>
{
    typedef detail::resource_region<AddressT> super_type;

    //
    // constructors
    //
    inline resource_region(const AddressT base=AddressT(), const AddressT size=AddressT(1))
    {
        (*this)(base, size);
    }

    inline resource_region(const super_type &other)
    {
        (*this)(other.base, other.size);
    }
};

#endif

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