variantdatabase.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <optional>
#include <type_traits>
#include <promeki/optional.h>
#include <promeki/namespace.h>
#include <promeki/sharedptr.h>
#include <promeki/stringregistry.h>
#include <promeki/variant.h>
#include <promeki/variantspec.h>
#include <promeki/error.h>
#include <promeki/map.h>
#include <promeki/list.h>
#include <promeki/json.h>
#include <promeki/stringlist.h>
#include <promeki/textstream.h>
#include <promeki/datastream.h>
#include <promeki/readwritelock.h>
#include <promeki/logger.h>
#include <promeki/util.h>
 
PROMEKI_NAMESPACE_BEGIN
 
enum class SpecValidation {
        None,  
        Warn,  
        Strict 
};
 
template <CompiledString Name> class VariantDatabase {
        public:
                using ID = typename StringRegistry<Name>::Item;
 
                using SpecMap = ::promeki::Map<ID, VariantSpec>;
 
                // ============================================================
                // Static spec registry
                // ============================================================
 
                static ID declareID(const String &name, const VariantSpec &spec) {
                        // Use the strict registration path so a hash collision
                        // between two well-known names aborts at static-init
                        // time instead of silently diverging from
                        // `ID::literal(name)`.
                        ID id = ID::fromId(StringRegistry<Name>::instance().findOrCreateStrict(name));
                        specRegistry().insert(id.id(), spec);
                        return id;
                }
 
                static const VariantSpec *spec(ID id) { return specRegistry().find(id.id()); }
 
                static const VariantSpec *specFor(const String &name) {
                        ID id = ID::find(name);
                        if (!id.isValid()) return nullptr;
                        return spec(id);
                }
 
                static Map<uint64_t, VariantSpec> registeredSpecs() { return specRegistry().all(); }
 
                static VariantDatabase fromSpecs(const SpecMap &specs) {
                        VariantDatabase db;
                        Data           *d = db._d.modify();
                        for (auto it = specs.cbegin(); it != specs.cend(); ++it) {
                                const Variant &def = it->second.defaultValue();
                                if (def.isValid()) d->data.insert(it->first.id(), def);
                        }
                        return db;
                }
 
                static int writeSpecMapHelp(TextStream &stream, const SpecMap &specs,
                                            const StringList &skipKeys = StringList()) {
                        // Collect the visible set first so the column
                        // width pass doesn't count skipped keys.
                        StringList names;
                        for (auto it = specs.cbegin(); it != specs.cend(); ++it) {
                                const String &n = it->first.name();
                                if (skipKeys.contains(n)) continue;
                                names.pushToBack(n);
                        }
                        names = names.sort();
                        if (names.isEmpty()) return 0;
 
                        // Three-column layout: name | details | description.
                        // We cache the per-row details string so the width
                        // pass and the emit pass don't rebuild it twice.
                        List<String> details;
                        details.resize(names.size());
                        int nameWidth = 0;
                        int detailsWidth = 0;
                        for (size_t i = 0; i < names.size(); ++i) {
                                ID   id(names[i]);
                                auto it = specs.find(id);
                                if (it == specs.end()) continue;
                                int nw = static_cast<int>(names[i].size());
                                if (nw > nameWidth) nameWidth = nw;
                                details[i] = it->second.detailsString();
                                int dw = static_cast<int>(details[i].size());
                                if (dw > detailsWidth) detailsWidth = dw;
                        }
 
                        // Fixed structure: "  <name>  <details>  <desc>".
                        // Everything up to the description is a known
                        // size; the description's real width varies per
                        // row, so we track the widest actual line as we
                        // go and return that so the caller can draw a
                        // border matching the block.
                        const int prefixWidth = 2 + nameWidth + 2 + detailsWidth;
                        int       maxLineWidth = 0;
                        for (size_t i = 0; i < names.size(); ++i) {
                                ID   id(names[i]);
                                auto it = specs.find(id);
                                if (it == specs.end()) continue;
 
                                String nameCol = names[i];
                                while (static_cast<int>(nameCol.size()) < nameWidth) {
                                        nameCol += ' ';
                                }
                                String detailsCol = details[i];
                                while (static_cast<int>(detailsCol.size()) < detailsWidth) {
                                        detailsCol += ' ';
                                }
                                stream << "  " << nameCol << "  " << detailsCol;
                                const String &desc = it->second.description();
                                int           lineWidth = prefixWidth;
                                if (!desc.isEmpty()) {
                                        stream << "  " << desc;
                                        lineWidth += 2 + static_cast<int>(desc.size());
                                }
                                stream << endl;
                                if (lineWidth > maxLineWidth) maxLineWidth = lineWidth;
                        }
                        return maxLineWidth;
                }
 
                // ============================================================
                // Construction
                // ============================================================
 
                VariantDatabase() = default;
 
                Error setFromJson(ID id, const Variant &value) {
                        const VariantSpec *sp = spec(id);
                        if (sp != nullptr) {
                                // Recursive coercion: top-level Strings get
                                // parsed via VariantSpec::parseString, and
                                // nested VariantList / VariantMap entries get
                                // walked with their element / value sub-spec
                                // so a {"color": "red"} JSON object whose
                                // declared spec is TypeVariantMap with a
                                // TypeColor valueSpec lands as
                                // VariantMap{"color": Color::Red} rather than
                                // VariantMap{"color": String("red")}.
                                Error   ce;
                                Variant coerced = sp->coerce(value, &ce);
                                if (ce.isError()) {
                                        // The leaf parse / recursion failed
                                        // — surface that error rather than
                                        // storing a value that would fail
                                        // spec validation in Strict mode
                                        // anyway.
                                        return ce;
                                }
                                Error err;
                                set(id, std::move(coerced), &err);
                                return err;
                        }
                        Error err;
                        set(id, value, &err);
                        return err;
                }
 
                static VariantDatabase fromJson(const JsonObject &json) {
                        VariantDatabase db;
                        json.forEach([&db](const String &key, const Variant &val) { db.setFromJson(ID(key), val); });
                        return db;
                }
 
                // ============================================================
                // Validation mode
                // ============================================================
 
                void setValidation(SpecValidation mode) { _d.modify()->validation = mode; }
 
                SpecValidation validation() const { return _d->validation; }
 
                // ============================================================
                // Value management
                // ============================================================
 
                bool set(ID id, const Variant &value, Error *err = nullptr) {
                        if (!validateOnSet(id, value, err)) return false;
                        _d.modify()->data.insert(id.id(), value);
                        return true;
                }
 
                bool set(ID id, Variant &&value, Error *err = nullptr) {
                        if (!validateOnSet(id, value, err)) return false;
                        _d.modify()->data.insert(id.id(), std::move(value));
                        return true;
                }
 
                bool setIfMissing(ID id, const Variant &value) {
                        if (_d->data.contains(id.id())) return false;
                        _d.modify()->data.insert(id.id(), value);
                        return true;
                }
 
                bool setIfMissing(ID id, Variant &&value) {
                        if (_d->data.contains(id.id())) return false;
                        _d.modify()->data.insert(id.id(), std::move(value));
                        return true;
                }
 
                Variant get(ID id, const Variant &defaultValue = Variant()) const {
                        auto it = _d->data.find(id.id());
                        if (it == _d->data.end()) return defaultValue;
                        return it->second;
                }
 
                template <typename T> T getAs(ID id, const T &defaultValue = T{}, Error *err = nullptr) const {
                        auto it = _d->data.find(id.id());
                        if (it == _d->data.end()) {
                                if (err) *err = Error::IdNotFound;
                                return defaultValue;
                        }
                        Error e;
                        T     result = it->second.template get<T>(&e);
                        if (e.isError()) {
                                if (err) *err = Error::ConversionFailed;
                                return defaultValue;
                        }
                        if (err) *err = Error::Ok;
                        return result;
                }
 
                template <typename Resolver>
                String format(const String &tmpl, Resolver &&resolver, Error *err = nullptr) const {
                        if (err != nullptr) *err = Error::Ok;
                        String out;
                        out.reserve(tmpl.byteCount());
                        const char  *src = tmpl.cstr();
                        const size_t len = tmpl.byteCount();
                        bool         sawUnresolved = false;
                        size_t       i = 0;
                        while (i < len) {
                                char c = src[i];
                                if (c == '{') {
                                        if (i + 1 < len && src[i + 1] == '{') {
                                                out.pushBack('{');
                                                i += 2;
                                                continue;
                                        }
                                        size_t end = i + 1;
                                        while (end < len && src[end] != '}') ++end;
                                        if (end >= len) {
                                                out += String(src + i, len - i);
                                                break;
                                        }
                                        const char *bodyData = src + i + 1;
                                        const size_t bodyLen = end - (i + 1);
                                        size_t colon = bodyLen;
                                        for (size_t p = 0; p < bodyLen; ++p) {
                                                if (bodyData[p] == ':') {
                                                        colon = p;
                                                        break;
                                                }
                                        }
                                        const size_t keyLen = colon;
                                        const size_t specOff = (colon == bodyLen) ? bodyLen : colon + 1;
                                        String       keyName(bodyData, keyLen);
                                        String       specStr(bodyData + specOff, bodyLen - specOff);
                                        // Split on the first '.' (or '[') to allow
                                        // nested keys like "Foo.bar" or "Foo[0]"
                                        // when the value at "Foo" is a VariantMap
                                        // / VariantList.  The leading ID
                                        // component still must be a registered key.
                                        size_t      sep = keyName.byteCount();
                                        const char *kn = keyName.cstr();
                                        for (size_t p = 0; p < keyName.byteCount(); ++p) {
                                                if (kn[p] == '.' || kn[p] == '[') {
                                                        sep = p;
                                                        break;
                                                }
                                        }
                                        String headKey = (sep == keyName.byteCount()) ? keyName
                                                                                       : String(kn, sep);
                                        String tailPath;
                                        if (sep < keyName.byteCount()) {
                                                // Trim a leading '.' but keep '['.
                                                size_t start = (kn[sep] == '.') ? sep + 1 : sep;
                                                tailPath = String(kn + start, keyName.byteCount() - start);
                                        }
                                        ID               id = ID::find(headKey);
                                        auto             it = id.isValid() ? _d->data.find(id.id()) : _d->data.end();
                                        if (it != _d->data.end()) {
                                                Variant target = it->second;
                                                if (!tailPath.isEmpty()) {
                                                        Error pe;
                                                        target = promekiResolveVariantPath(target, tailPath, &pe);
                                                        if (pe.isError() || !target.isValid()) {
                                                                sawUnresolved = true;
                                                                out += '?';
                                                                out += String(bodyData, keyLen);
                                                                out += '?';
                                                                i = end + 1;
                                                                continue;
                                                        }
                                                }
                                                out += target.format(specStr);
                                        } else {
                                                Optional<String> resolved;
                                                if constexpr (!std::is_same_v<std::decay_t<Resolver>, std::nullptr_t>) {
                                                        resolved = resolver(keyName, specStr);
                                                }
                                                if (resolved.hasValue()) {
                                                        out += *resolved;
                                                } else {
                                                        sawUnresolved = true;
                                                        out += '?';
                                                        out += String(bodyData, keyLen);
                                                        out += '?';
                                                }
                                        }
                                        i = end + 1;
                                } else if (c == '}') {
                                        if (i + 1 < len && src[i + 1] == '}') {
                                                out.pushBack('}');
                                                i += 2;
                                        } else {
                                                out.pushBack('}');
                                                ++i;
                                        }
                                } else {
                                        out.pushBack(c);
                                        ++i;
                                }
                        }
                        if (sawUnresolved && err != nullptr) *err = Error::IdNotFound;
                        return out;
                }
 
                String format(const String &tmpl, Error *err = nullptr) const { return format(tmpl, nullptr, err); }
 
                bool contains(ID id) const { return _d->data.contains(id.id()); }
 
                bool remove(ID id) {
                        if (!_d->data.contains(id.id())) return false;
                        return _d.modify()->data.remove(id.id());
                }
 
                size_t size() const { return _d->data.size(); }
 
                bool isEmpty() const { return _d->data.isEmpty(); }
 
                void clear() {
                        if (_d->data.isEmpty()) return;
                        _d.modify()->data.clear();
                }
 
                List<ID> ids() const {
                        List<ID> ret;
                        for (auto it = _d->data.cbegin(); it != _d->data.cend(); ++it) {
                                ret.pushToBack(ID::fromId(it->first));
                        }
                        return ret;
                }
 
                StringList unknownKeys(const SpecMap &extraSpecs = SpecMap()) const {
                        StringList out;
                        for (auto it = _d->data.cbegin(); it != _d->data.cend(); ++it) {
                                ID id = ID::fromId(it->first);
                                if (extraSpecs.find(id) != extraSpecs.end()) continue;
                                if (spec(id) != nullptr) continue;
                                out.pushToBack(id.name());
                        }
                        // List<String>::sort() returns a List<String>, not a
                        // StringList — assign-through-base lets us keep
                        // StringList's type identity on the return value.
                        out = out.sort();
                        return out;
                }
 
                template <typename Func> void forEach(Func &&func) const {
                        for (auto it = _d->data.cbegin(); it != _d->data.cend(); ++it) {
                                func(ID::fromId(it->first), it->second);
                        }
                }
 
                void merge(const VariantDatabase &other) {
                        other.forEach([this](ID id, const Variant &val) { set(id, val); });
                }
 
                VariantDatabase extract(const List<ID> &idList) const {
                        VariantDatabase result;
                        Data           *r = result._d.modify();
                        for (size_t i = 0; i < idList.size(); ++i) {
                                auto it = _d->data.find(idList[i].id());
                                if (it != _d->data.end()) {
                                        r->data.insert(it->first, it->second);
                                }
                        }
                        return result;
                }
 
                // ============================================================
                // Comparison
                // ============================================================
 
                bool operator==(const VariantDatabase &other) const {
                        if (_d == other._d) return true;
                        return _d->data == other._d->data;
                }
 
                bool operator!=(const VariantDatabase &other) const { return !(*this == other); }
 
                // ============================================================
                // JSON serialization
                // ============================================================
 
                JsonObject toJson() const {
                        JsonObject json;
                        for (auto it = _d->data.cbegin(); it != _d->data.cend(); ++it) {
                                String name = StringRegistry<Name>::instance().name(it->first);
                                json.setFromVariant(name, it->second);
                        }
                        return json;
                }
 
                // ============================================================
                // DataStream serialization
                // ============================================================
 
                void writeTo(DataStream &stream) const {
                        stream << static_cast<uint32_t>(_d->data.size());
                        for (auto it = _d->data.cbegin(); it != _d->data.cend(); ++it) {
                                String name = StringRegistry<Name>::instance().name(it->first);
                                stream << name << it->second;
                        }
                }
 
                void readFrom(DataStream &stream) {
                        _d.modify()->data.clear();
                        uint32_t count = 0;
                        stream >> count;
                        for (uint32_t i = 0; i < count && stream.status() == DataStream::Ok; ++i) {
                                String  name;
                                Variant value;
                                stream >> name >> value;
                                if (stream.status() == DataStream::Ok) {
                                        set(ID(name), std::move(value));
                                }
                        }
                }
 
                // ============================================================
                // TextStream serialization
                // ============================================================
 
                void writeTo(TextStream &stream) const {
                        for (auto it = _d->data.cbegin(); it != _d->data.cend(); ++it) {
                                String name = StringRegistry<Name>::instance().name(it->first);
                                stream << name << " = " << it->second << endl;
                        }
                }
 
        private:
                struct Data {
                                PROMEKI_SHARED_FINAL(Data)
                                Map<uint64_t, Variant> data;
                                SpecValidation         validation = SpecValidation::Strict;
                };
                SharedPtr<Data> _d = SharedPtr<Data>::create();
 
                struct SpecRegistry {
                                static SpecRegistry &instance() {
                                        static SpecRegistry reg;
                                        return reg;
                                }
 
                                void insert(uint64_t id, const VariantSpec &spec) {
                                        ReadWriteLock::WriteLocker lock(_lock);
                                        _specs.insert(id, spec);
                                }
 
                                const VariantSpec *find(uint64_t id) const {
                                        ReadWriteLock::ReadLocker lock(_lock);
                                        auto                      it = _specs.find(id);
                                        if (it == _specs.end()) return nullptr;
                                        return &it->second;
                                }
 
                                Map<uint64_t, VariantSpec> all() const {
                                        ReadWriteLock::ReadLocker lock(_lock);
                                        return _specs;
                                }
 
                        private:
                                SpecRegistry() = default;
                                mutable ReadWriteLock      _lock;
                                Map<uint64_t, VariantSpec> _specs;
                };
 
                static SpecRegistry &specRegistry() { return SpecRegistry::instance(); }
 
                bool validateOnSet(ID id, const Variant &value, Error *err = nullptr) {
                        if (err) *err = Error::Ok;
                        const SpecValidation mode = _d->validation;
                        if (mode == SpecValidation::None) return true;
                        const VariantSpec *s = specRegistry().find(id.id());
                        if (!s) return true;
                        Error verr;
                        if (!s->validate(value, &verr)) {
                                if (mode == SpecValidation::Warn) {
                                        promekiWarn("VariantDatabase: value for '%s' fails spec (%s)", id.name().cstr(),
                                                    verr.name().cstr());
                                        return true;
                                }
                                if (err) *err = verr;
                                return false; // Strict: reject
                        }
                        return true;
                }
};
 
template <CompiledString Name> DataStream &operator<<(DataStream &stream, const VariantDatabase<Name> &db) {
        db.writeTo(stream);
        return stream;
}
 
template <CompiledString Name> DataStream &operator>>(DataStream &stream, VariantDatabase<Name> &db) {
        db.readFrom(stream);
        return stream;
}
 
template <CompiledString Name> TextStream &operator<<(TextStream &stream, const VariantDatabase<Name> &db) {
        db.writeTo(stream);
        return stream;
}
 
PROMEKI_NAMESPACE_END
 
#define PROMEKI_DECLARE_ID(Name, ...)                                                                                  \
        static constexpr ID                     Name = ID::literal(#Name);                                             \
        [[maybe_unused]] static inline const ID PROMEKI_CONCAT(_promeki_spec_reg_, Name) = declareID(#Name, __VA_ARGS__)
 
#endif // PROMEKI_ENABLE_CORE