StringID.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2023 Rogiel Sulzbach. All rights reserved.
//
 
// NOTE: Based on https://github.com/foonathan/string_id
 
#pragma once
 
#include "Exception.hpp"
#include "Hash.hpp"
#include "String.hpp"
#include "Container/Atomic.hpp"
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/Threading/Threading.hpp"
 
#include <atomic>
#include <cstdint>
#include <cstring>
#include <exception>
#include <functional>
#include <memory>
#include <utility>
 
namespace CeresEngine {
 
    class StringDatabase;
 
    class StringID {
    public:
        using Hash = UInt64;
 
        enum class Status {
            Collision,
 
            NewString,
 
            OldString
        };
 
    private:
        Hash mID = 0;
        StringDatabase* mDatabase = nullptr;
 
    public:
        StringID() = default;
 
        explicit StringID(StringView string);
 
        StringID(StringDatabase& database, StringView string);
 
        StringID(const StringID& prefix, StringView string);
 
        StringID(StringDatabase& database, StringView string, Status& status);
 
        StringID(const StringID& prefix, StringView string, Status& status);
 
    public:
        [[nodiscard]] StringID::Hash getHashCode() const noexcept { return mID; }
 
        [[nodiscard]] StringView getString() const noexcept;
 
    public: // Comparison
        [[nodiscard]] friend bool operator==(const StringID a, const StringID b) noexcept { return a.mDatabase == b.mDatabase && a.mID == b.mID; }
        [[nodiscard]] friend bool operator==(const StringID::Hash a, const StringID& b) noexcept { return a == b.mID; }
        [[nodiscard]] friend bool operator==(const StringID& a, const StringID::Hash b) noexcept { return a.mID == b; }
        [[nodiscard]] friend bool operator!=(const StringID& a, const StringID& b) noexcept { return !(a == b); }
        [[nodiscard]] friend bool operator!=(const StringID::Hash a, const StringID& b) noexcept { return !(a == b); }
        [[nodiscard]] friend bool operator!=(const StringID& a, const StringID::Hash b) noexcept { return !(a == b); }
 
    public: // Collision handler
        using CollisionHandler = void (*)(StringID::Hash hash, StringView a, StringView b);
 
        static CollisionHandler setCollisionHandler(CollisionHandler h);
 
        [[nodiscard]] static CollisionHandler getCollisionHandler();
    };
 
    namespace literals {
        constexpr StringID::Hash operator""_id(const char* string, const std::size_t length) { return staticHash64(StringView(string, length)); }
    } // namespace literals
 
    class StringDatabase {
    public:
        StringDatabase(const StringDatabase&) = delete;
        StringDatabase(StringDatabase&&) = delete;
        virtual ~StringDatabase() = default;
 
    protected:
        StringDatabase() = default;
 
    public:
        [[nodiscard]] virtual StringID::Status insert(StringID::Hash hash, StringView string) = 0;
 
        [[nodiscard]] virtual StringID::Status insertPrefix(StringID::Hash hash, StringID::Hash prefix, StringView string);
 
        [[nodiscard]] virtual StringView lookup(StringID::Hash hash) const noexcept = 0;
 
    public:
        static StringDatabase& getDefault() noexcept;
    };
 
    class DummyStringDatabase : public StringDatabase {
    public:
        [[nodiscard]] StringID::Status insert(StringID::Hash, StringView) override { return StringID::Status::NewString; }
 
        [[nodiscard]] StringID::Status insertPrefix(StringID::Hash, StringID::Hash, StringView) override { return StringID::Status::NewString; }
 
        [[nodiscard]] StringView lookup(StringID::Hash) const noexcept override { return "StringID database disabled"; }
    };
 
    class MapStringDatabase : public StringDatabase {
    public:
        explicit MapStringDatabase(std::size_t size = 1024, double maxLoadFactor = 1.0);
        ~MapStringDatabase() noexcept override;
 
        [[nodiscard]] StringID::Status insert(StringID::Hash hash, StringView string) override;
 
        [[nodiscard]] StringID::Status insertPrefix(StringID::Hash hash, StringID::Hash prefix, StringView string) override;
 
        [[nodiscard]] StringView lookup(StringID::Hash hash) const noexcept override;
 
    private:
        void rehash();
 
        class NodeList;
        std::unique_ptr<NodeList[]> mBuckets;
        std::size_t mItemCount, mBucketCount;
        double mMaximumLoadFactor;
        std::size_t mNextResize;
    };
 
    template<class Parent, typename MutexType = Mutex> class ThreadSafeStringDatabase : public Parent {
        using super = Parent;
 
    private:
        mutable MutexType mMutex;
 
    public:
        // workaround of lacking inheriting constructors
        template<typename... Args> explicit ThreadSafeStringDatabase(Args&&... args) : super(std::forward<Args>(args)...) {}
 
    public:
        [[nodiscard]] typename StringID::Status insert(StringID::Hash hash, StringView string) override {
            Lock<MutexType> lock(mMutex);
            return super::insert(hash, string);
        }
 
        [[nodiscard]] typename StringID::Status insertPrefix(StringID::Hash hash, StringID::Hash prefix, StringView string) override {
            Lock<MutexType> lock(mMutex);
            return super::insertPrefix(hash, prefix, string);
        }
 
        [[nodiscard]] StringView lookup(StringID::Hash hash) const noexcept override {
            Lock<MutexType> lock(mMutex);
            return super::lookup(hash);
        }
    };
 
    using DefaultStringDatabase = ThreadSafeStringDatabase<MapStringDatabase>;
 
    class StringIDCollisionError : public RuntimeError {
    private:
        String mFirstString, mSecondString;
        StringID::Hash mHashCode;
 
    public:
        StringIDCollisionError(StringID::Hash hash, StringView a, StringView b)
                : RuntimeError("CollisionError: strings {0} and {1} are both producing the value {2}", a, b, hash), mFirstString(a), mSecondString(b),
                  mHashCode(hash) {}
 
    public:
        StringView getFirstString() const noexcept { return mFirstString; }
 
        StringView getSecondString() const noexcept { return mSecondString; }
 
        StringID::Hash getHashCode() const noexcept { return mHashCode; }
    };
 
} // namespace CeresEngine
 
template<> struct std::hash<CeresEngine::StringID> {
    size_t operator()(const CeresEngine::StringID& arg) const noexcept { return static_cast<size_t>(arg.getHashCode()); }
};