File indexing completed on 2024-05-12 04:42:19

 /*
     SPDX-FileCopyrightText: 2020-2021 Volker Krause <vkrause@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #ifndef KOSM_STRINGPOOL_H
 #define KOSM_STRINGPOOL_H
 
 #include <kosm_export.h>
 
 #include <cstring>
 #include <vector>
 
 namespace OSM {
 
 enum class StringMemory { Persistent, Transient };
 
 /** @internal */
 class KOSM_EXPORT StringKeyRegistryBase
 {
 protected:
     explicit StringKeyRegistryBase();
     StringKeyRegistryBase(StringKeyRegistryBase&&) noexcept;
     StringKeyRegistryBase& operator=(StringKeyRegistryBase&&) noexcept;
     ~StringKeyRegistryBase();
 
     [[nodiscard]] const char* makeKeyInternal(const char *name, std::size_t len, StringMemory memOpt);
     [[nodiscard]] const char* keyInternal(const char *name) const;
 
     std::vector<char*> m_pool;
     std::vector<const char*> m_registry;
 };
 
 /** Registry of unique string keys.
  *  @tparam T Sub-classes of StringKey, to have a compile-time check against comparing keys from different pools.
  */
 template <typename T>
 class StringKeyRegistry : protected StringKeyRegistryBase
 {
 public:
     explicit StringKeyRegistry() = default;
     StringKeyRegistry(const StringKeyRegistry&) = delete;
     StringKeyRegistry(StringKeyRegistry&&) = default;
     ~StringKeyRegistry() = default;
     StringKeyRegistry& operator=(const StringKeyRegistry&) = delete;
     StringKeyRegistry& operator=(StringKeyRegistry&&) = default;
 
     /** Add a new string to the registry if needed, or returns an existing one if already present. */
     inline T makeKey(const char *name, StringMemory memOpt)
     {
         return makeKey(name, std::strlen(name), memOpt);
     }
     inline T makeKey(const char *name, std::size_t len, StringMemory memOpt)
     {
         T key;
         key.key = makeKeyInternal(name, len, memOpt);
         return key;
     }
 
     /** Looks up an existing key, if that doesn't exist an null key is returned. */
     inline T key(const char *name) const
     {
         T key;
         key.key = keyInternal(name);
         return key;
     }
 };
 
 /** Base class for unique string keys. */
 class StringKey
 {
 public:
     constexpr inline StringKey() = default;
     constexpr inline const char* name() const { return key; }
     constexpr inline bool isNull() const { return !key; }
 
     // yes, pointer compare is enough here
     inline constexpr bool operator<(StringKey other) const { return key < other.key; }
     inline constexpr bool operator==(StringKey other) const { return key == other.key; }
     inline constexpr bool operator!=(StringKey other) const { return key != other.key; }
 
 protected:
     explicit constexpr inline StringKey(const char *keyData) : key(keyData) {}
 
 private:
     template <typename T> friend class StringKeyRegistry;
     const char* key = nullptr;
 };
 
 }
 
 #endif // KOSM_STRINGPOOL_H