dynamic_registry.h

Go to the documentation of this file.

#ifndef DYNAMIC_REGISTRY_H
#define DYNAMIC_REGISTRY_H
 
#include <string>
#include <string_view>
#include <vector>
#include <unordered_map>
#include <optional>
#include <algorithm>
#include <cctype>
 
// ------------------------------------------------------------------
// SymbolId<Tag> : wrapper string-strong-typed
// ------------------------------------------------------------------
 
template<class Tag>
class SymbolId {
    std::string name_;
public:
    SymbolId() = default;
 
    explicit SymbolId(std::string n) : name_(std::move(n)) {}
 
    const std::string& str() const { return name_; }
};
 
 
 
 
 
// ------------------------------------------------------------------
// case-insensitive
// ------------------------------------------------------------------
 
inline std::string normalize_key(std::string_view s) {
    std::string out;
    out.reserve(s.size());
    for (unsigned char c : s) {
        // if (!std::isalnum(c)) continue; // <-- option : ignore space and punctuation
        out.push_back(static_cast<char>(std::tolower(c)));
    }
    return out;
}
 
template<class Tag>
inline bool operator==(const SymbolId<Tag>& a, const SymbolId<Tag>& b) noexcept {
    return normalize_key(a.str()) == normalize_key(b.str());
}
 
template<class Tag>
inline bool operator<(const SymbolId<Tag>& a, const SymbolId<Tag>& b) noexcept {
    const auto an = normalize_key(a.str());
    const auto bn = normalize_key(b.str());
    return an < bn;
}
 
namespace std {
    template<class Tag>
    struct hash<SymbolId<Tag>> {
        size_t operator()(const SymbolId<Tag>& id) const noexcept {
            return std::hash<std::string>{}(normalize_key(id.str()));
        }
    };
}
 
 
// ------------------------------------------------------------------
// DynamicRegistry: registry of SymbolId with optional external key
// ------------------------------------------------------------------
 
template<class Tag, class ExternalKey, class Hash = std::hash<ExternalKey>>
class DynamicRegistry {
public:
    struct Entry {
        SymbolId<Tag> id;                   
        std::vector<std::string> aliases;   
        std::optional<ExternalKey> ext;     
        bool builtin = false;               
    };
 
private:
    std::unordered_map<std::string, Entry> by_name_;
    std::unordered_map<ExternalKey, std::string, Hash> by_ext_;
 
public:
    bool register_id(const SymbolId<Tag>& id,
                     std::vector<std::string> aliases,
                     std::optional<ExternalKey> ext,
                     bool builtin);
 
    std::optional<SymbolId<Tag>> find(std::string_view name) const;
 
    std::optional<SymbolId<Tag>> find_by_external(const ExternalKey& k) const;
 
    std::optional<ExternalKey> external_of(const SymbolId<Tag>& id) const;
 
    bool update_external(const SymbolId<Tag>& id, const ExternalKey& k);
 
    std::vector<SymbolId<Tag>> list_all() const;
};
 
// ------------------------------------------------------------------
// DynamicRegistry specialization without external key
// ------------------------------------------------------------------
 
template<class Tag>
class DynamicRegistry<Tag, void, void> {
public:
    struct Entry {
        SymbolId<Tag> id;                   
        std::vector<std::string> aliases;   
        bool builtin = false;               
    };
private:
    std::unordered_map<std::string, Entry> by_name_;
 
public:
    bool register_id(const SymbolId<Tag>& id,
                     std::vector<std::string> aliases,
                     bool builtin);
 
    std::optional<SymbolId<Tag>> find(std::string_view name) const;
 
    std::vector<SymbolId<Tag>> list_all() const;
};
 
#include "dynamic_registry.tpp"
 
#endif