A C++ data-oriented registry with compile-time type mapping and cache-efficient handle-based storage.

Based on the provided code snippet, this is a C++ header file for a data-oriented registry system that uses compile-time type mapping via a `LinearTable` of `Entry` types. It defines a `lookup` metafunction to resolve types at compile time and includes a `DefaultHandleProvider` for cache-efficient handle-based storage. The code is copyrighted by Félix-Olivier Dumas and appears to be from May 2026.

Created May 22, 2026 17:29 - - Save unrays/158d58e795bf9d0606ec344fd57fcdb8 to your computer and use it in GitHub Desktop. A C++ data-oriented registry with compile-time type mapping and cache-efficient handle-based storage. This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters. Learn more about bidirectional Unicode characters https://github.co/hiddenchars | // Copyright c May 2026 Félix-Olivier Dumas. All rights reserved. | | | // Licensed under the terms described in the LICENSE file | | | pragma once | | | include <cstddef | | | include <tuple | | | include <utility | | | include <type traits | | | include <iostream | | | / / | | | / SENTINEL / | | | / / | | | struct SENTINEL {}; | | | / / | | | / LINEAR TABLE / | | | / / | | | template<typename... Types | | | struct LinearTable : Types... {}; | | | template<typename Key, typename Value | | | struct Entry {}; | | | / / | | | / ENTRY TRAITS / | | | / / | | | template<typename... | | | struct entry traits; | | | template<typename K, typename V | | | struct entry traits<Entry<K, V | | | { | | | using key = K; | | | using value = V; | | | }; | | | / / | | | / LOOKUP / | | | / / | | | template<typename... | | | struct lookup; | | | template<typename Key, typename Target, typename... Rest | | | struct lookup<Key, LinearTable<Entry<Key, Target , Rest... | | | { | | | using type = Target; | | | }; | | | template<typename Key, typename Head, typename... Rest | | | struct lookup<Key, LinearTable<Head, Rest... | | | { | | | using type = typename lookup<Key, Rest... ::type; | | | }; | | | template<typename Key, typename Empty | | | struct lookup<Key, Empty | | | { | | | using type = SENTINEL; | | | }; | | | template<typename Key, typename Table | | | using table lookup t = typename lookup<Key, Table ::type; | | | / / | | | / SIZE OF TABLE / | | | / / | | | template<typename | | | struct size of; | | | template<typename... Types | | | struct size of<LinearTable<Types... | | | { | | | static constexpr std::size t value = sizeof... Types ; | | | }; | | | template<typename Table | | | static constexpr std::size t size of v = size of<Table ::value; | | | / / | | | / HANDLE PROVIDERS / | | | / / | | | struct DefaultHandleProvider | | | { | | | template<typename Tp | | | nodiscard constexpr std::size t operator const Tp obj | | | { | | | return obj- id; | | | } | | | }; | | | / / | | | / REGISTRY STORAGE BUILDER / | | | / / | | | template<typename Table, template<typename typename StorageType | | | struct make registry storage; | | | template<typename... Entries, template<typename... typename StorageType | | | struct make registry storage<LinearTable<Entries... , StorageType | | | { | | | using type = std::tuple< | | | StorageType<typename entry traits<Entries ::value ... | | | ; | | | }; | | | template<typename Table, template<typename... typename StorageType | | | using make registry storage t = | | | typename make registry storage<Table, StorageType ::type; | | | / / | | | / SMART STORAGE / | | | / / | | | template<typename Tp, std::size t N | | | class SmartStorage final | | | { | | | protected: | | | static constexpr std::uint16 t MaxStack = 1 << 14; | | | using OnlyIfStackEligible = | | | std::conditional t< | | | N sizeof Tp <= MaxStack , | | | std::byte N sizeof Tp , | | | std::monostate | | | ; | | | public: | | | SmartStorage | | | : is constructed {} | | | { | | | if constexpr is heap eligible { | | | buffer ptr = static cast<std::byte | | | ::operator new N sizeof Tp , std::align val t alignof Tp | | | ; | | | } | | | else { | | | buffer ptr = &stack buffer 0 ; | | | } | | | } | | | ~SmartStorage noexcept | | | { | | | reset ; | | | if constexpr is heap eligible { | | | ::operator delete buffer ptr , std::align val t alignof Tp ; | | | } | | | } | | | protected: | | | void throw if out of range std::size t index const | | | { | | | if index = N unlikely { | | | throw std::out of range | | | " EXOTIC::SmartStorage index out of range: " | | | + std::to string index | | | + " valid range: 0.." | | | + std::to string N - 1 | | | + " " | | | ; | | | } | | | } | | | void throw if existing std::size t index const | | | { | | | if is constructed index unlikely { | | | throw std::runtime error | | | " EXOTIC::SmartStorage construction conflict: slot already occupied at index " | | | + std::to string index | | | ; | | | } | | | } | | | void throw if nonexistent std::size t index const | | | { | | | if is constructed index unlikely { | | | throw std::runtime error | | | " EXOTIC::SmartStorage access violation: no object constructed at index " | | | + std::to string index | | | ; | | | } | | | } | | | public: | | | nodiscard Tp& get std::size t index | | | { | | | throw if out of range index ; | | | throw if nonexistent index ; | | | return reinterpret cast<Tp buffer ptr + index sizeof Tp ; | | | } | | | nodiscard const Tp& get std::size t index const | | | { | | | throw if out of range index ; | | | throw if nonexistent index ; | | | return reinterpret cast<const Tp buffer ptr + index sizeof Tp ; | | | } | | | public: | | | template<typename... Types | | | Tp& emplace std::size t index, Types&&... args | | | noexcept std::is nothrow constructible v<std::decay<Tp , Types&&... | | | { | | | throw if out of range index ; | | | throw if existing index ; | | | Tp ptr = reinterpret cast<Tp buffer ptr + index sizeof Tp ; | | | new ptr Tp std::forward<Types args ... ; | | | is constructed index = true; | | | return ptr; | | | } | | | public: | | | Tp& insert std::size t index, Tp&& obj | | | { | | | throw if out of range index ; | | | Tp ptr = reinterpret cast<Tp buffer ptr + index sizeof Tp ; | | | if is constructed index { | | | ptr = obj; | | | } | | | else { | | | new ptr Tp obj ; | | | is constructed index = true; | | | } | | | return ptr; | | | } | | | Tp& insert std::size t index, Tp& obj | | | { | | | throw if out of range index ; | | | Tp ptr = reinterpret cast<Tp buffer ptr + index sizeof Tp ; | | | if is constructed index { | | | ptr = obj; | | | } | | | else { | | | new ptr Tp obj ; | | | is constructed index = true; | | | } | | | return ptr; | | | } | | | public: | | | void destroy std::size t index noexcept | | | { | | | throw if out of range index ; | | | throw if nonexistent index ; | | | Tp ptr = reinterpret cast<Tp buffer ptr + index sizeof Tp ; | | | ptr- ~Tp ; | | | is constructed index = false; | | | } | | | void reset noexcept | | | { | | | for std::size t i = 0; i < N; ++i { | | | if is constructed i { | | | Tp ptr = reinterpret cast<Tp buffer ptr + i sizeof Tp ; | | | ptr- ~Tp ; | | | is constructed i = false; | | | } | | | } | | | std::memset buffer ptr , 0, N sizeof Tp ; | | | } | | | public: | | | nodiscard constexpr std::size t capacity const noexcept | | | { | | | return N; | | | } | | | private: | | | alignas Tp OnlyIfStackEligible stack buffer ; | | | std::byte buffer ptr ; | | | static constexpr bool is heap eligible = | | | std::is same v<OnlyIfStackEligible, std::monostate ; | | | std::array<bool, N is constructed ; | | | }; | | | / / | | | / MULTI STORAGE REGISTRY / | | | / / | | | template<typename Table, typename HandleProvider, std::size t N = 1 << 14 | | | class MultiStorageRegistry final | | | { | | | protected: | | | static constexpr std::size t BytesPerStorage = N / size of v<Table ; | | | template<typename Up | | | using RegistryStorageStrategy = | | | SmartStorage<Up, BytesPerStorage / sizeof Up ; | | | public: | | | explicit MultiStorageRegistry HandleProvider provider = {} | | | : handleProvider provider , storage {} | | | { | | | std::cout << " NODE REGISTRY CTOR this = " << this << "\n"; | | | } | | | ~MultiStorageRegistry noexcept | | | { | | | reset ; | | | } | | | public: | | | template<typename Tp | | | auto& resolve storage noexcept | | | { | | | using Result = std::decay t< | | | table lookup t<std::decay t<Tp , Table | | | ; | | | static assert | | | std::is same v<Result, PRYSMA SENTINEL , | | | "Unable to resolve the requested type from the LinearTable." | | | ; | | | return std::get<RegistryStorageStrategy<Result storage ; | | | } | | | public: | | | template<typename Tp | | | nodiscard const auto& get const Tp obj const noexcept | | | { | | | const auto& storage = resolve storage<Tp ; | | | return storage.get handleProvider obj ; | | | } | | | template<typename Up, typename Tp | | | nodiscard const auto& get for const Tp obj const noexcept | | | { | | | const auto& storage = std::get<RegistryStorageStrategy<Up storage ; | | | return storage.get handleProvider obj ; | | | } | | | public: | | | template<typename Tp | | | nodiscard auto& get const Tp obj noexcept | | | { | | | auto& storage = resolve storage<Tp ; | | | return storage.get handleProvider obj ; | | | } | | | template<typename Up, typename Tp | | | nodiscard auto& get for const Tp obj noexcept | | | { | | | auto& storage = std::get<RegistryStorageStrategy<Up storage ; | | | return storage.get handleProvider obj ; | | | } | | | public: | | | template<typename Tp, typename... Types | | | auto& construct const Tp obj, Types&&... args | | | { | | | auto& storage = resolve storage<Tp ; | | | return storage.emplace handleProvider obj , std::forward<Types args ... ; | | | } | | | template<typename Up, typename Tp, typename... Types | | | auto& construct for const Tp obj, Types&&... args | | | { | | | auto& storage = std::get<RegistryStorageStrategy<Up storage ; | | | return storage.emplace handleProvider obj , std::forward<Types args ... ; | | | } | | | public: | | | template<typename Tp, typename Up | | | auto& assign const Tp obj, Up&& arg | | | { | | | auto& storage = resolve storage<Tp ; | | | return storage.insert handleProvider obj , std::forward<Up arg ; | | | } | | | template<typename Up, typename Tp | | | auto& assign for const Tp obj, Up&& arg | | | { | | | auto& storage = std::get<RegistryStorageStrategy<Up storage ; | | | return storage.insert handleProvider obj , std::forward<Up arg ; | | | } | | | public: | | | void reset noexcept | | | { | | | std::apply auto&... storage { | | | storage.reset , ... ; | | | }, storage ; | | | } | | | template<typename Up | | | void reset for noexcept | | | { | | | auto& storage = std::get<RegistryStorageStrategy<Up storage ; | | | storage.reset ; | | | } | | | private: | | | make registry storage t<Table, RegistryStorageStrategy storage ; | | | HandleProvider handleProvider ; | | | }; | | | using ExampleRegistry = MultiStorageRegistry<ExampleRegistryTable, DefaultHandleProvider, 1 << 10 ; |