gui_id_manager.h

Go to the documentation of this file.

#pragma once
 
#include <gui_core/gui_platform.h>
 
#include <stdint.h>
#include <source_location>
#include <vector>
#include <string_view>
 
// Uncomment to enable debug ID tracking
//#define TACHYON_ID_DEBUG
 
// ID system: static, dynamic and ranged identifiers for GUI elements.
namespace tachyon 
{
 
    struct ID;
    class IDManager
    {
        // ------------------------------------------------------------------------
        // Constructor
        // ------------------------------------------------------------------------
        public: IDManager()
        {
            m_parent_stack.reserve(4096);
            m_static_slots.reserve(4096);
            m_static_free_list.reserve(4096);
        }
 
        // ------------------------------------------------------------------------
        // Frame Management
        // ------------------------------------------------------------------------

        public: [[nodiscard]] bool BeginFrame();

        public: void EndFrame();

        public: [[nodiscard]] inline bool IsInsideFrame() const { return !m_parent_stack.empty(); }
 
        // ------------------------------------------------------------------------
        // Parent Stack
        // ------------------------------------------------------------------------
        
        public: [[nodiscard]] bool PushParent(ID parent_id);

        public: [[nodiscard]] bool PopParent();
 
        // ------------------------------------------------------------------------
        // Static IDs
        // ------------------------------------------------------------------------

        public: [[nodiscard]] ID CreateStaticID();

        public: bool ReleaseStaticID(ID id);
 
        // Tests reach it through IDManagerTestAccess (defined in the tests).
        private: bool SetGenerationForSlot(uint32_t index, int32_t generation);
        friend struct IDManagerTestAccess;

        public: bool IsStaticIDValid(ID id) const;
 
        // ------------------------------------------------------------------------
        // Dynamic IDs
        // ------------------------------------------------------------------------
 
        private: [[nodiscard]] ID AllocateDynamicID(uint64_t hash);
 
#ifdef TACHYON_SUPPORT_CPP20
        public: [[nodiscard]] inline ID AllocateDynamicID(const std::source_location location = std::source_location::current())
        {
            return AllocateDynamicID(location.file_name(), location.line());
        }
#endif

        public: [[nodiscard]] ID AllocateDynamicID(std::string_view file, int line);

        public: [[nodiscard]] ID AllocateDynamicID(std::string_view hint);

        public: [[nodiscard]] bool IsDynamicIDValid(ID id) const;
 
        // ------------------------------------------------------------------------
        // Ranged IDs
        // ------------------------------------------------------------------------
 
        private: [[nodiscard]] ID AllocateRangedID(uint32_t size, uint64_t hash);
 
#ifdef TACHYON_SUPPORT_CPP20
        public: [[nodiscard]] inline ID AllocateRangedID(uint32_t size, const std::source_location location = std::source_location::current())
        {
            return AllocateRangedID(size, location.file_name(), location.line());
        }
#endif
        public: [[nodiscard]] ID AllocateRangedID(uint32_t size, std::string_view file, int line);

        public: [[nodiscard]] ID AllocateRangedID(uint32_t size, std::string_view hint);

        public: uint32_t GetRangeSize(ID ranged_id) const;

        public: bool IsRangedIDValid(ID id) const;

        public: [[nodiscard]] ID GetSubID(ID ranged_id, uint32_t index) const;

        public: bool IsSubRangeIDValid(ID id) const;
 
        // ------------------------------------------------------------------------
        // Parent Stack Utilities
        // ------------------------------------------------------------------------

        public: bool IsInParentStack(ID id) const;

        public: ID GetStackParent() const;
 
 
        // ------------------------------------------------------------------------
        // Validation
        // ------------------------------------------------------------------------

        public: bool IsIDValid(ID id) const;

        public: inline size_t GetStaticIDCount() const { return m_static_id_count; }
        public: inline size_t GetDynamicIDCount() const { return m_dynamic_id_total; }
        public: inline size_t GetRangedIDCount() const { return m_ranged_count; }
 
 
 
    private:
        struct ParentData
        {
            ID id;
        };
 
        // Parent stack for hierarchical hashing
        std::vector<ParentData> m_parent_stack;
        // Dynamic IDs made so far this frame per call site (or hint) and parent: only a
        // repeat of the same site renumbers, so a widget appearing elsewhere doesn't. A flat
        // open-addressed table: a slot stamped with an older frame is empty, so a new frame
        // clears nothing and allocates nothing once the table has grown.
        struct SiteSlot { uint64_t site = 0; uint32_t count = 0; uint32_t frame = 0; };
        std::vector<SiteSlot> m_site_slots = std::vector<SiteSlot>(1024);
        uint32_t              m_site_used  = 0;
        uint32_t              m_frame      = 0;
        uint32_t NextSiteCount(uint64_t site);
        
        // Static ID management (slot map with generations)
        std::vector<int32_t> m_static_slots;
        std::vector<uint32_t> m_static_free_list;
        size_t m_static_id_count = 0;
 
        // Dynamic ID tracking
        size_t m_dynamic_id_total = 0; 
 
        // Ranged ID tracking
        size_t m_ranged_count = 0;
 
#ifdef TACHYON_ID_DEBUG
        std::vector<ID> m_debug_dynamic_ids;
        std::vector<ID> m_debug_ranges;
#endif
    };

} // namespace tachyon