Range.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Hash.hpp"
 
#include <algorithm>
#include <cstdint>
 
namespace CeresEngine::inline Math {
 
    template<typename OffsetT = UInt64, typename LengthT = OffsetT> struct TRange final {
        CE_SCRIPT_EXPORT()
        OffsetT offset = 0;
 
        CE_SCRIPT_EXPORT()
        LengthT length = 0;
 
        CE_SCRIPT_EXPORT()
        constexpr TRange() noexcept = default;
 
        CE_SCRIPT_EXPORT()
        constexpr TRange(OffsetT offset, LengthT length) noexcept : offset(offset), length(length) {}
 
        constexpr TRange(const TRange&) noexcept = default;
        constexpr TRange& operator=(const TRange&) noexcept = default;
 
        [[nodiscard]] constexpr bool operator[](OffsetT off) const noexcept;
 
        [[nodiscard]] constexpr explicit operator bool() const noexcept;
 
        [[nodiscard]] constexpr bool empty() const noexcept;
 
        constexpr void clear() noexcept;
 
        [[nodiscard]] constexpr OffsetT begin() const noexcept { return offset; }
        [[nodiscard]] constexpr OffsetT end() const noexcept { return offset + length; }
    };
 
    template<typename OffsetT, typename LengthT> constexpr bool TRange<OffsetT, LengthT>::operator[](OffsetT off) const noexcept {
        return off >= offset && off < (offset + length);
    }
 
    template<typename OffsetT, typename LengthT> constexpr TRange<OffsetT, LengthT>::operator bool() const noexcept { return length != 0; }
    template<typename OffsetT, typename LengthT> constexpr bool TRange<OffsetT, LengthT>::empty() const noexcept { return length == 0; }
    template<typename OffsetT, typename LengthT> constexpr void TRange<OffsetT, LengthT>::clear() noexcept {
        offset = 0;
        length = 0;
    }
 
    template<typename OffsetT, typename LengthT>
    [[nodiscard]] constexpr TRange<OffsetT, LengthT> operator&(TRange<OffsetT, LengthT> a, TRange<OffsetT, LengthT> b) noexcept {
        OffsetT start = std::max<OffsetT>(a.offset, b.offset);
        OffsetT end = std::min<OffsetT>(a.offset + a.length, b.offset + b.length);
        if(start > end) { // no intersection
            return TRange<OffsetT, LengthT>();
        }
 
        LengthT length = end - start;
        return TRange<OffsetT, LengthT>(start, length);
    }
 
    template<typename OffsetT, typename LengthT> [[nodiscard]] constexpr bool operator==(TRange<OffsetT, LengthT> a, TRange<OffsetT, LengthT> b) noexcept {
        return a.offset == b.offset && a.length == b.length;
    }
 
    template<typename OffsetT, typename LengthT> [[nodiscard]] constexpr bool operator!=(TRange<OffsetT, LengthT> a, TRange<OffsetT, LengthT> b) noexcept {
        return a.offset != b.offset || a.length != b.length;
    }
 
    template<typename OffsetT, typename LengthT>
    [[nodiscard]] constexpr bool operator<(decltype(TRange<OffsetT, LengthT>::offset) offset, TRange<OffsetT, LengthT> range) noexcept {
        return offset < range.offset;
    }
 
    template<typename OffsetT, typename LengthT>
    [[nodiscard]] constexpr bool operator<=(decltype(TRange<OffsetT, LengthT>::offset) offset, TRange<OffsetT, LengthT> range) noexcept {
        return offset < range || range[offset];
    }
 
    template<typename OffsetT, typename LengthT>
    [[nodiscard]] constexpr bool operator>(decltype(TRange<OffsetT, LengthT>::offset) offset, TRange<OffsetT, LengthT> range) noexcept {
        return offset >= (range.offset + range.length);
    }
 
    template<typename OffsetT, typename LengthT>
    [[nodiscard]] constexpr bool operator>=(decltype(TRange<OffsetT, LengthT>::offset) offset, TRange<OffsetT, LengthT> range) noexcept {
        return offset > range || range[offset];
    }
 
    extern template struct CE_SCRIPT_EXPORT(name = "RangeFloat") TRange<float>;
    extern template struct CE_SCRIPT_EXPORT(name = "Range") TRange<double>;
    extern template struct TRange<Int8>;
    extern template struct TRange<UInt8>;
    extern template struct TRange<Int16>;
    extern template struct TRange<UInt16>;
    extern template struct TRange<Int32>;
    extern template struct TRange<UInt32>;
    extern template struct CE_SCRIPT_EXPORT(name = "RangeInteger") TRange<Int64>;
    extern template struct TRange<UInt64>;
 
    using Range = TRange<double>;
    using Rangef = TRange<float>;
    using Rangei = TRange<Int64>;
 
} // namespace CeresEngine::inline Math
 
template<typename Offset, typename Length> struct std::hash<CeresEngine::Math::TRange<Offset, Length>> {
    using Type = CeresEngine::Math::TRange<Offset, Length>;
    constexpr size_t operator()(const Type& obj) const { return CeresEngine::hash(obj.offset, obj.length); }
};