OffsetPtr.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/Macros.hpp"
 
#include <iterator>
#include <type_traits>
 
namespace CeresEngine {
 
    template<class RawPointer, class OffsetType> class OffsetPointerCaster;
 
    template<class T, class OffsetType> class OffsetPointerCaster<T*, OffsetType> {
    private:
        OffsetType mOffset;
 
    public:
        explicit OffsetPointerCaster(OffsetType offset) : mOffset(offset) {}
        explicit OffsetPointerCaster(const volatile T* p) : mOffset(static_cast<OffsetType>(reinterpret_cast<std::intptr_t>(p))) {}
 
        [[nodiscard]] OffsetType offset() const { return mOffset; }
        [[nodiscard]] T* pointer() const { return reinterpret_cast<T*>(static_cast<std::intptr_t>(mOffset)); }
    };
 
    template<class OffsetType> OffsetType offset_ptr_offset(const volatile void* ptr, const volatile void* thisPtr) {
        using caster_t = OffsetPointerCaster<void*, std::intptr_t>;
        // NOTE: offset == 1 && ptr != 0 is not legal for this pointer
        if(!ptr) {
            return 1;
        }
        OffsetType offset = static_cast<OffsetType>(caster_t(ptr).offset() - caster_t(thisPtr).offset());
        CE_ASSERT(offset != 1);
        return offset;
    }
 
    template<class OffsetType> OffsetType offset_ptr_offset_from_other(const volatile void* thisPtr, const volatile void* otherPtr, OffsetType otherOffset) {
        using caster_t = OffsetPointerCaster<void*, std::intptr_t>;
        if(otherOffset == 1) {
            return 1;
        }
        OffsetType offset = static_cast<OffsetType>(caster_t(otherPtr).offset() - caster_t(thisPtr).offset() + otherOffset);
        CE_ASSERT(offset != 1);
        return offset;
    }
 
    template<class OffsetType> void* offset_ptr_raw_pointer(const volatile void* thisPtr, OffsetType offset) {
        using caster_t = OffsetPointerCaster<void*, std::intptr_t>;
        if(offset == 1) {
            return nullptr;
        }
        return caster_t(caster_t(thisPtr).offset() + offset).pointer();
    }
 
    template<typename PointedType, class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
    class OffsetPtr {
        //        static_assert(sizeof(OffsetType) >= sizeof(uintptr_t));
        //        static_assert(std::is_integral_v<OffsetType> && std::is_unsigned_v<OffsetType>);
 
    private:
        static constexpr OffsetType nullOffset = 1;
        alignas(OffsetAlignment) OffsetType mOffset = nullOffset;
 
    public: // C++ container concept
        using element_type = PointedType;
        using pointer = PointedType*;
        using reference = typename std::add_lvalue_reference_t<PointedType>;
        using value_type = std::remove_cv_t<PointedType>;
        using difference_type = DifferenceType;
        using iterator_category = std::random_access_iterator_tag;
        using offset_type = OffsetType;
 
        template<class U> using rebind = OffsetPtr<U, DifferenceType, OffsetType, OffsetAlignment>;
 
    public:
        explicit OffsetPtr() noexcept = default;
 
        CE_EXPLICIT(false) OffsetPtr(const pointer ptr) noexcept : mOffset(offset_ptr_offset<OffsetType>(ptr, this)) {}
 
        template<typename T>
        CE_EXPLICIT(false) OffsetPtr(T ptr) noexcept requires std::is_convertible_v<T*, PointedType*>
                : mOffset(offset_ptr_offset<OffsetType>(static_cast<PointedType*>(ptr), this)) {}
 
        CE_EXPLICIT(false) OffsetPtr(const OffsetPtr& ptr) noexcept : mOffset(offset_ptr_offset_from_other(this, &ptr, ptr.mOffset)) {}
 
        template<typename T2>
        CE_EXPLICIT(false) OffsetPtr(
            const OffsetPtr<T2, DifferenceType, OffsetType, OffsetAlignment>& ptr) noexcept requires std::is_convertible_v<T2*, PointedType*>
                : mOffset(offset_ptr_offset_from_other(this, &ptr, ptr.get_offset())) {}
 
        OffsetPtr& operator=(const pointer from) noexcept {
            mOffset = offset_ptr_offset<OffsetType>(from, this);
            return *this;
        }
 
        OffsetPtr& operator=(const OffsetPtr& ptr) noexcept {
            mOffset = offset_ptr_offset_from_other(this, &ptr, ptr.mOffset);
            return *this;
        }
 
        template<class T2>
        OffsetPtr& operator=(const OffsetPtr<T2, DifferenceType, OffsetType, OffsetAlignment>& ptr) noexcept requires std::is_convertible_v<T2*, PointedType*> {
            mOffset = offset_ptr_to_offset<OffsetType>(static_cast<PointedType*>(ptr.get()), this);
        }
 
        ~OffsetPtr() = default;
 
    private:
        struct static_cast_tag {};
        struct const_cast_tag {};
        struct dynamic_cast_tag {};
        struct reinterpret_cast_tag {};
 
        template<class T2, class P2, class O2, std::size_t A2>
        CE_EXPLICIT(false) OffsetPtr(const OffsetPtr<T2, P2, O2, A2>& r, static_cast_tag) noexcept
                : mOffset(offset_ptr_offset<OffsetType>(static_cast<PointedType*>(r.get()), this)) {}
 
        template<class T1, class P1, class O1, std::size_t A1, class T2, class P2, class O2, std::size_t A2>
        friend OffsetPtr<T1, P1, O1, A1> static_pointer_cast(const OffsetPtr<T2, P2, O2, A2>& r) noexcept;
 
        template<class T2, class P2, class O2, std::size_t A2>
        CE_EXPLICIT(false) OffsetPtr(const OffsetPtr<T2, P2, O2, A2>& r, const_cast_tag) noexcept
                : mOffset(offset_ptr_offset<OffsetType>(const_cast<PointedType*>(r.get()), this)) {}
 
        template<class T1, class P1, class O1, std::size_t A1, class T2, class P2, class O2, std::size_t A2>
        friend OffsetPtr<T1, P1, O1, A1> const_pointer_cast(const OffsetPtr<T2, P2, O2, A2>& r) noexcept;
 
        template<class T2, class P2, class O2, std::size_t A2>
        CE_EXPLICIT(false) OffsetPtr(const OffsetPtr<T2, P2, O2, A2>& r, dynamic_cast_tag) noexcept
                : mOffset(offset_ptr_offset<OffsetType>(dynamic_cast<PointedType*>(r.get()), this)) {}
 
        template<class T1, class P1, class O1, std::size_t A1, class T2, class P2, class O2, std::size_t A2>
        friend OffsetPtr<T1, P1, O1, A1> dynamic_pointer_cast(const OffsetPtr<T2, P2, O2, A2>& r) noexcept;
 
        template<class T2, class P2, class O2, std::size_t A2>
        CE_EXPLICIT(false) OffsetPtr(const OffsetPtr<T2, P2, O2, A2>& r, reinterpret_cast_tag) noexcept
                : mOffset(offset_ptr_offset<OffsetType>(reinterpret_cast<PointedType*>(r.get()), this)) {}
 
        template<class T1, class P1, class O1, std::size_t A1, class T2, class P2, class O2, std::size_t A2>
        friend OffsetPtr<T1, P1, O1, A1> reinterpret_pointer_cast(const OffsetPtr<T2, P2, O2, A2>& r) noexcept;
 
    public:
        [[nodiscard]] pointer get() const noexcept { return static_cast<pointer>(offset_ptr_raw_pointer(this, mOffset)); }
 
        [[nodiscard]] offset_type getOffset() const noexcept { return mOffset; }
 
        [[nodiscard]] pointer operator->() const noexcept { return get(); }
 
        [[nodiscard]] reference operator*() const noexcept { return *get(); }
 
        [[nodiscard]] reference operator[](difference_type idx) const noexcept {
            pointer* ptr = get();
            return ptr[idx];
        }
 
        inline void reset() noexcept { *this = nullptr; }
 
    public:
        inline OffsetPtr& operator+=(difference_type offset) noexcept {
            mOffset += offset * sizeof(PointedType);
            return *this;
        }
 
        inline OffsetPtr& operator-=(difference_type offset) noexcept {
            mOffset -= offset * sizeof(PointedType);
            return *this;
        }
 
        inline OffsetPtr& operator++(void) noexcept {
            mOffset += sizeof(PointedType);
            return *this;
        }
 
        inline OffsetPtr operator++(int) noexcept {
            OffsetPtr tmp(*this);
            mOffset += sizeof(PointedType);
            return tmp;
        }
 
        inline OffsetPtr& operator--(void) noexcept {
            mOffset -= sizeof(PointedType);
            return *this;
        }
 
        inline OffsetPtr operator--(int) noexcept {
            OffsetPtr tmp(*this);
            mOffset -= sizeof(PointedType);
            return tmp;
        }
 
        [[nodiscard]] explicit operator bool() const noexcept { return mOffset != nullOffset; }
 
        [[nodiscard]] bool operator!() const noexcept { return mOffset == nullOffset; }
 
    public:
        [[nodiscard]] inline static OffsetPtr pointer_to(reference r) noexcept { return OffsetPtr(&r); }
 
        inline friend OffsetPtr operator+(difference_type diff, OffsetPtr right) noexcept {
            right += diff;
            return right;
        }
 
        inline friend OffsetPtr operator+(OffsetPtr left, difference_type diff) noexcept {
            left += diff;
            return left;
        }
 
        inline friend OffsetPtr operator-(OffsetPtr left, difference_type diff) noexcept {
            left -= diff;
            return left;
        }
 
        inline friend OffsetPtr operator-(difference_type diff, OffsetPtr right) noexcept {
            right -= diff;
            return right;
        }
 
        inline friend difference_type operator-(const OffsetPtr& pt, const OffsetPtr& pt2) noexcept { return difference_type(pt.get() - pt2.get()); }
 
        [[nodiscard]] inline friend bool operator==(const OffsetPtr& pt1, const OffsetPtr& pt2) noexcept { return pt1.get() == pt2.get(); }
 
        [[nodiscard]] inline friend bool operator!=(const OffsetPtr& pt1, const OffsetPtr& pt2) noexcept { return pt1.get() != pt2.get(); }
 
        [[nodiscard]] inline friend bool operator<(const OffsetPtr& pt1, const OffsetPtr& pt2) noexcept { return pt1.get() < pt2.get(); }
 
        [[nodiscard]] inline friend bool operator<=(const OffsetPtr& pt1, const OffsetPtr& pt2) noexcept { return pt1.get() <= pt2.get(); }
 
        [[nodiscard]] inline friend bool operator>(const OffsetPtr& pt1, const OffsetPtr& pt2) noexcept { return pt1.get() > pt2.get(); }
 
        [[nodiscard]] inline friend bool operator>=(const OffsetPtr& pt1, const OffsetPtr& pt2) noexcept { return pt1.get() >= pt2.get(); }
 
        [[nodiscard]] inline friend bool operator==(pointer pt1, const OffsetPtr& pt2) noexcept { return pt1 == pt2.get(); }
 
        [[nodiscard]] inline friend bool operator!=(pointer pt1, const OffsetPtr& pt2) noexcept { return pt1 != pt2.get(); }
 
        [[nodiscard]] inline friend bool operator<(pointer pt1, const OffsetPtr& pt2) noexcept { return pt1 < pt2.get(); }
 
        [[nodiscard]] inline friend bool operator<=(pointer pt1, const OffsetPtr& pt2) noexcept { return pt1 <= pt2.get(); }
 
        [[nodiscard]] inline friend bool operator>(pointer pt1, const OffsetPtr& pt2) noexcept { return pt1 > pt2.get(); }
 
        [[nodiscard]] inline friend bool operator>=(pointer pt1, const OffsetPtr& pt2) noexcept { return pt1 >= pt2.get(); }
 
        [[nodiscard]] inline friend bool operator==(const OffsetPtr& pt1, pointer pt2) noexcept { return pt1.get() == pt2; }
 
        [[nodiscard]] inline friend bool operator!=(const OffsetPtr& pt1, pointer pt2) noexcept { return pt1.get() != pt2; }
 
        [[nodiscard]] inline friend bool operator<(const OffsetPtr& pt1, pointer pt2) noexcept { return pt1.get() < pt2; }
 
        [[nodiscard]] inline friend bool operator<=(const OffsetPtr& pt1, pointer pt2) noexcept { return pt1.get() <= pt2; }
 
        [[nodiscard]] inline friend bool operator>(const OffsetPtr& pt1, pointer pt2) noexcept { return pt1.get() > pt2; }
 
        [[nodiscard]] inline friend bool operator>=(const OffsetPtr& pt1, pointer pt2) noexcept { return pt1.get() >= pt2; }
 
        inline friend void swap(OffsetPtr& left, OffsetPtr& right) noexcept {
            pointer ptr = right.get();
            right = left;
            left = ptr;
        }
    };
 
    template<class T1, class P1, class O1, std::size_t A1, class T2, class P2, class O2, std::size_t A2>
    [[nodiscard]] OffsetPtr<T1, P1, O1, A1> static_pointer_cast(const OffsetPtr<T2, P2, O2, A2>& r) noexcept {
        return OffsetPtr<T1, P1, O1, A1>(r, OffsetPtr<T1, P1, O1, A1>::static_cast_tag());
    }
 
    template<class T1, class P1, class O1, std::size_t A1, class T2, class P2, class O2, std::size_t A2>
    [[nodiscard]] OffsetPtr<T1, P1, O1, A1> const_pointer_cast(const OffsetPtr<T2, P2, O2, A2>& r) noexcept {
        return OffsetPtr<T1, P1, O1, A1>(r, OffsetPtr<T1, P1, O1, A1>::const_cast_tag());
    }
 
    template<class T1, class P1, class O1, std::size_t A1, class T2, class P2, class O2, std::size_t A2>
    [[nodiscard]] OffsetPtr<T1, P1, O1, A1> dynamic_pointer_cast(const OffsetPtr<T2, P2, O2, A2>& r) noexcept {
        return OffsetPtr<T1, P1, O1, A1>(r, OffsetPtr<T1, P1, O1, A1>::dynamic_cast_tag());
    }
 
    template<class T1, class P1, class O1, std::size_t A1, class T2, class P2, class O2, std::size_t A2>
    [[nodiscard]] OffsetPtr<T1, P1, O1, A1> reinterpret_pointer_cast(const OffsetPtr<T2, P2, O2, A2>& r) noexcept {
        return OffsetPtr<T1, P1, O1, A1>(r, OffsetPtr<T1, P1, O1, A1>::reinterpret_cast_tag());
    }
 
} // namespace CeresEngine
 
template<typename PointedType, class DifferenceType, class OffsetType, std::size_t OffsetAlignment>
struct std::hash<CeresEngine::OffsetPtr<PointedType, DifferenceType, OffsetType, OffsetAlignment>> {
    using T = CeresEngine::OffsetPtr<PointedType, DifferenceType, OffsetType, OffsetAlignment>;
    [[nodiscard]] size_t operator()(const T& value) const noexcept { return std::hash<PointedType*>{}(value.get()); }
};