stringregistry.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cstdint>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/map.h>
#include <promeki/list.h>
#include <promeki/readwritelock.h>
#include <promeki/fnv1a.h>
 
PROMEKI_NAMESPACE_BEGIN
 
namespace detail {
 
        [[noreturn]] void stringRegistryCollisionAbort(const char *registryName, const String &existing,
                                                       const String &incoming, uint64_t hash);
 
} // namespace detail
 
template <CompiledString Name> class StringRegistry;
 
template <CompiledString Name> class StringRegistryItem {
        public:
                static constexpr uint64_t InvalidID = UINT64_MAX;
 
                constexpr StringRegistryItem() = default;
 
                StringRegistryItem(const String &name)
                    : _id(StringRegistry<Name>::instance().findOrCreateProbe(name)) {}
 
                StringRegistryItem(const char *name)
                    : _id(StringRegistry<Name>::instance().findOrCreateProbe(String(name))) {}
 
                static constexpr StringRegistryItem literal(const char *name) {
                        StringRegistryItem item;
                        item._id = fnv1a(name);
                        return item;
                }
 
                static StringRegistryItem find(const String &name) {
                        StringRegistryItem item;
                        item._id = StringRegistry<Name>::instance().findId(name);
                        return item;
                }
 
                static constexpr StringRegistryItem fromId(uint64_t id) {
                        StringRegistryItem item;
                        item._id = id;
                        return item;
                }
 
                constexpr uint64_t id() const { return _id; }
 
                String name() const { return StringRegistry<Name>::instance().name(_id); }
 
                constexpr bool isValid() const { return _id != InvalidID; }
 
                constexpr bool operator==(const StringRegistryItem &other) const { return _id == other._id; }
 
                constexpr bool operator!=(const StringRegistryItem &other) const { return _id != other._id; }
 
                constexpr bool operator<(const StringRegistryItem &other) const { return _id < other._id; }
 
        private:
                uint64_t _id = InvalidID;
};
 
template <CompiledString Name> class StringRegistry {
        public:
                using Item = StringRegistryItem<Name>;
 
                static constexpr uint64_t InvalidID = StringRegistryItem<Name>::InvalidID;
 
                static StringRegistry &instance() {
                        static StringRegistry reg;
                        return reg;
                }
 
                uint64_t findId(const String &str) const {
                        ReadWriteLock::ReadLocker lock(_lock);
                        uint64_t                  slot = fnv1a(str.cstr());
                        while (true) {
                                auto it = _names.find(slot);
                                if (it == _names.end()) return InvalidID;
                                if (it->second == str) return slot;
                                ++slot;
                        }
                }
 
                uint64_t findOrCreateStrict(const String &str) {
                        uint64_t h = fnv1a(str.cstr());
                        // Fast path: check under a read lock first.
                        {
                                ReadWriteLock::ReadLocker lock(_lock);
                                auto                      it = _names.find(h);
                                if (it != _names.end()) {
                                        if (it->second == str) return h;
                                        detail::stringRegistryCollisionAbort(Name.bytes(), it->second, str, h);
                                }
                        }
                        ReadWriteLock::WriteLocker lock(_lock);
                        auto                       it = _names.find(h);
                        if (it != _names.end()) {
                                if (it->second == str) return h;
                                detail::stringRegistryCollisionAbort(Name.bytes(), it->second, str, h);
                        }
                        _names.insert(h, str);
                        return h;
                }
 
                uint64_t findOrCreateProbe(const String &str) {
                        uint64_t start = fnv1a(str.cstr());
                        // Fast path: read-locked probe.
                        {
                                ReadWriteLock::ReadLocker lock(_lock);
                                uint64_t                  slot = start;
                                while (true) {
                                        auto it = _names.find(slot);
                                        if (it == _names.end()) break;
                                        if (it->second == str) return slot;
                                        ++slot;
                                }
                        }
                        // Slow path: acquire write lock and retry so we can
                        // safely insert if still missing.
                        ReadWriteLock::WriteLocker lock(_lock);
                        uint64_t                   slot = start;
                        while (true) {
                                auto it = _names.find(slot);
                                if (it == _names.end()) {
                                        _names.insert(slot, str);
                                        return slot;
                                }
                                if (it->second == str) return slot;
                                ++slot;
                        }
                }
 
                String name(uint64_t id) const {
                        ReadWriteLock::ReadLocker lock(_lock);
                        auto                      it = _names.find(id);
                        if (it == _names.end()) return String();
                        return it->second;
                }
 
                size_t count() const {
                        ReadWriteLock::ReadLocker lock(_lock);
                        return _names.size();
                }
 
                bool contains(const String &str) const { return findId(str) != InvalidID; }
 
        private:
                StringRegistry() = default;
 
                mutable ReadWriteLock _lock;
                Map<uint64_t, String> _names;
};
 
PROMEKI_NAMESPACE_END
 
template <promeki::CompiledString Name> struct std::hash<promeki::StringRegistryItem<Name>> {
                std::size_t operator()(const promeki::StringRegistryItem<Name> &item) const noexcept {
                        return static_cast<std::size_t>(item.id());
                }
};
 
#endif // PROMEKI_ENABLE_CORE