/* * Copyright (C) 2023 Linux Studio Plugins Project * (C) 2023 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 26 февр. 2020 г. * * lsp-runtime-lib is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * lsp-runtime-lib is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with lsp-runtime-lib. If not, see . */ #include #include #include namespace lsp { namespace i18n { Dictionary::Dictionary(resource::ILoader *loader) { pLoader = loader; } Dictionary::~Dictionary() { clear(); } status_t Dictionary::load_json(IDictionary **dict, const io::Path *path) { JsonDictionary *d = new JsonDictionary(); status_t res; if (pLoader != NULL) { io::IInStream *is = pLoader->read_stream(path); if (is != NULL) { res = d->init(is); is->close(); delete is; } else res = pLoader->last_error(); } else res = d->init(path); if (res == STATUS_OK) *dict = d; else delete d; return res; } status_t Dictionary::create_child(IDictionary **dict, const LSPString *path) { LSPString xp; if (!xp.append(&sPath)) return STATUS_NO_MEM; if (!xp.append('/')) return STATUS_NO_MEM; if (!xp.append(path)) return STATUS_NO_MEM; Dictionary *d = new Dictionary(pLoader); status_t res = d->init(&xp); if (res != STATUS_OK) delete d; else *dict = d; return res; } status_t Dictionary::load_dictionary(const LSPString *id, IDictionary **dict) { status_t res; io::Path path; if ((res = path.set(&sPath)) != STATUS_OK) return res; if ((res = path.append_child(id)) != STATUS_OK) return res; if ((res = path.append(".json")) != STATUS_OK) return res; // Prefer builtin over external lsp_debug("Trying to load file %s...", path.as_native()); res = load_json(dict, &path); lsp_debug("Overall status = %d", int(res)); return res; } status_t Dictionary::lookup(const LSPString *key, LSPString *value) { if (key == NULL) return STATUS_INVALID_VALUE; LSPString id, subkey; ssize_t idx = key->index_of('.'); if (idx < 0) { if (!id.set(key)) return STATUS_NO_MEM; } else { if (!id.set(key, 0, idx)) return STATUS_NO_MEM; if (!subkey.set(key, idx+1)) return STATUS_NO_MEM; } // Perform binary search of the item ssize_t first = 0, last = vNodes.size()-1; while (first <= last) { ssize_t curr = (first + last) >> 1; node_t *node = vNodes.uget(curr); int cmp = node->sKey.compare_to(&id); if (cmp > 0) last = curr - 1; else if (cmp < 0) first = curr + 1; else { if (id.is_empty()) return STATUS_NOT_FOUND; return (node->pDict != NULL) ? node->pDict->lookup(&subkey, value) : STATUS_NOT_FOUND; } } // Dictionary identifier was specified? if (id.is_empty()) return STATUS_NOT_FOUND; // Dictionary not found, try to create new one IDictionary *dict = NULL; status_t res = load_dictionary(&id, &dict); if (res == STATUS_NOT_FOUND) res = create_child(&dict, &id); // Add node to list of nodes if (res != STATUS_OK) return res; node_t *child = new node_t; if ((child == NULL) || (!vNodes.insert(first, child))) { delete dict; return STATUS_NO_MEM; } child->sKey.swap(&id); child->pDict = dict; return dict->lookup(&subkey, value); } status_t Dictionary::lookup(const LSPString *key, IDictionary **value) { if (key == NULL) return STATUS_INVALID_VALUE; ssize_t idx = key->index_of('.'); LSPString id, subkey; if (idx > 0) { if (!id.set(key, 0, idx)) return STATUS_NO_MEM; if (!subkey.set(key, idx+1)) return STATUS_NO_MEM; } else if (!id.set(key)) return STATUS_NO_MEM; // Perform binary search of the dictionary IDictionary *dict = NULL; ssize_t first = 0, last = vNodes.size()-1; while (first <= last) { ssize_t curr = (first + last) >> 1; node_t *node = vNodes.uget(curr); int cmp = node->sKey.compare_to(&id); if (cmp > 0) last = curr - 1; else if (cmp < 0) first = curr + 1; else { if (node->pDict == NULL) return STATUS_NOT_FOUND; dict = node->pDict; break; } } // Dictionary object not found? if (dict == NULL) { // Try to load/create node bool root = false; status_t res = load_dictionary(&id, &dict); if (res == STATUS_NOT_FOUND) { res = create_child(&dict, &id); root = true; } if (res != STATUS_OK) return res; // Add node to list of nodes node_t *child = new node_t; if ((child == NULL) || (!vNodes.insert(first, child))) { delete dict; return STATUS_NO_MEM; } child->sKey.swap(&id); child->pDict = dict; child->bRoot = root; // There is no path element defined more? if ((child->bRoot) && (idx < 0)) return STATUS_NOT_FOUND; } if (idx > 0) return dict->lookup(&subkey, value); *value = dict; return STATUS_OK; } status_t Dictionary::get_value(size_t index, LSPString *key, LSPString *value) { node_t *node = vNodes.get(index); return (node == NULL) ? STATUS_NOT_FOUND : STATUS_BAD_TYPE; } status_t Dictionary::get_child(size_t index, LSPString *key, IDictionary **dict) { node_t *node = vNodes.get(index); if ((node == NULL) || (node->pDict == NULL)) return STATUS_NOT_FOUND; if ((key != NULL) && (!key->set(&node->sKey))) return STATUS_NO_MEM; if (dict != NULL) *dict = node->pDict; return STATUS_OK; } size_t Dictionary::size() { return vNodes.size(); } status_t Dictionary::Dictionary::init(const LSPString *path) { lsp_trace("Init dictionary path: %s" , path->get_utf8()); return (sPath.set(path)) ? STATUS_OK : STATUS_NO_MEM; } void Dictionary::Dictionary::clear() { for (size_t i=0, n=vNodes.size(); ipDict != NULL) delete node->pDict; delete node; } vNodes.flush(); } } /* namespace i18n */ } /* namespace lsp */