small_ptr.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSL-1.0
 
#ifndef TETL_MEMORY_SMALL_PTR_HPP
#define TETL_MEMORY_SMALL_PTR_HPP
 
#include <etl/_cstddef/nullptr_t.hpp>
#include <etl/_cstddef/ptrdiff_t.hpp>
#include <etl/_cstdint/uint_t.hpp>
#include <etl/_utility/ignore_unused.hpp>
 
namespace etl {

template <typename Type, intptr_t BaseAddress = 0, typename StorageType = uint16_t>
struct small_ptr {
    small_ptr() = default;

    small_ptr(nullptr_t null)
        : _value{0}
    {
        ignore_unused(null);
    }

    small_ptr(Type* ptr)
        : _value{compress(ptr)}
    {
    }

    [[nodiscard]] auto get() noexcept -> Type* { return reinterpret_cast<Type*>(BaseAddress + _value); }

    [[nodiscard]] auto get() const noexcept -> Type const*
    {
        return reinterpret_cast<Type const*>(BaseAddress + _value);
    }

    [[nodiscard]] auto compressed_value() const noexcept -> StorageType { return _value; }

    [[nodiscard]] auto operator->() const -> Type* { return get(); }

    [[nodiscard]] auto operator*() -> Type& { return *get(); }

    [[nodiscard]] auto operator*() const -> Type const& { return *get(); }

    [[nodiscard]] auto operator++(int) noexcept -> small_ptr
    {
        auto temp = *this;
        auto* ptr = get();
        ++ptr;
        _value = compress(ptr);
        return temp;
    }

    [[nodiscard]] auto operator++() noexcept -> small_ptr&
    {
        auto* ptr = get();
        ptr++;
        _value = compress(ptr);
        return *this;
    }

    [[nodiscard]] auto operator--(int) noexcept -> small_ptr
    {
        auto temp = *this;
        auto* ptr = get();
        --ptr;
        _value = compress(ptr);
        return temp;
    }

    [[nodiscard]] auto operator--() noexcept -> small_ptr&
    {
        auto* ptr = get();
        ptr--;
        _value = compress(ptr);
        return *this;
    }

    [[nodiscard]] auto operator-(small_ptr other) const noexcept -> ptrdiff_t { return get() - other.get(); }

    [[nodiscard]] operator Type*() noexcept { return get(); }

    [[nodiscard]] operator Type const*() const noexcept { return get(); }
 
private:
    [[nodiscard]] static auto compress(Type* ptr) -> StorageType
    {
        auto const obj = reinterpret_cast<intptr_t>(ptr);
        return StorageType(obj - BaseAddress);
    }
 
    StorageType _value;
};
 
} // namespace etl
 
#endif // TETL_MEMORY_SMALL_PTR_HPP