ptr_tag.h

#pragma once
#include <algorithm>
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <type_traits>
#include <utility>
 
namespace asyncpp {
 
    template<size_t ID, typename T>
    void* ptr_tag(T* ptr) noexcept
        requires(alignof(T) > ID)
    {
        assert((reinterpret_cast<uintptr_t>(ptr) & (alignof(T) - 1)) == 0);
        //NOLINTNEXTLINE(performance-no-int-to-ptr)
        return reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(ptr) | ID);
    }
 
    template<auto ID, typename T>
    void* ptr_tag(T* ptr) noexcept
        requires(std::is_enum_v<decltype(ID)>)
    {
        return ptr_tag<static_cast<size_t>(ID), T>(ptr);
    }
 
    template<size_t ID, typename T>
    const void* ptr_tag(const T* ptr) noexcept
        requires(alignof(T) > ID)
    {
        assert((reinterpret_cast<uintptr_t>(ptr) & (alignof(T) - 1)) == 0);
        //NOLINTNEXTLINE(performance-no-int-to-ptr)
        return reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(ptr) | ID);
    }
 
    template<auto ID, typename T>
    const void* ptr_tag(const T* ptr) noexcept
        requires(std::is_enum_v<decltype(ID)>)
    {
        return ptr_tag<static_cast<size_t>(ID), T>(ptr);
    }
 
    template<typename T>
    std::pair<T*, size_t> ptr_untag(void* ptr) noexcept {
        const auto align_mask = static_cast<uintptr_t>(alignof(T) - 1);
        auto uptr = reinterpret_cast<uintptr_t>(ptr);
        return {reinterpret_cast<T*>(uptr & ~align_mask), uptr & align_mask};
    }
 
    template<typename T, typename TTag>
    std::pair<T*, TTag> ptr_untag(void* vptr) noexcept {
        auto [ptr, tag] = ptr_untag<T>(vptr);
        return {ptr, static_cast<TTag>(tag)};
    }
 
    template<typename T>
    std::pair<const T*, size_t> ptr_untag(const void* vptr) noexcept {
        const auto align_mask = static_cast<uintptr_t>(alignof(T) - 1);
        auto uptr = reinterpret_cast<uintptr_t>(vptr);
        return {reinterpret_cast<const T*>(uptr & ~align_mask), uptr & align_mask};
    }
 
    template<typename T, typename TTag>
    std::pair<const T*, TTag> ptr_untag(const void* vptr) noexcept {
        auto [ptr, tag] = ptr_untag<T>(vptr);
        return {ptr, static_cast<TTag>(tag)};
    }
 
    template<typename T1, typename... TExtra>
    constexpr size_t min_alignof() noexcept {
        if constexpr (sizeof...(TExtra) > 0)
            return (std::min)(alignof(T1), min_alignof<TExtra...>());
        else
            return alignof(T1);
    }
 
    template<typename... T>
    size_t ptr_get_tag(const void* vptr) noexcept {
        constexpr auto align_mask = static_cast<uintptr_t>(min_alignof<T...>() - 1);
        return reinterpret_cast<uintptr_t>(vptr) & align_mask;
    }
 
} // namespace asyncpp