/* * Copyright (C) 2025 Linux Studio Plugins Project * (C) 2025 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 19 февр. 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 namespace lsp { namespace expr { Parameters::Parameters() { } Parameters::~Parameters() { destroy_params(vParams); } void Parameters::modified() { } Parameters *Parameters::clone() const { Parameters *res = new Parameters(); if (res == NULL) return NULL; status_t status = res->set(this); if (status == STATUS_OK) return res; delete res; return NULL; } void Parameters::swap(Parameters *src) { if (src == this) return; vParams.swap(&src->vParams); src->modified(); this->modified(); } void Parameters::clear() { destroy_params(vParams); modified(); } status_t Parameters::resolve(value_t *value, const char *name, size_t num_indexes, const ssize_t *indexes) { if (name == NULL) return STATUS_BAD_ARGUMENTS; LSPString key; if (!key.set_utf8(name)) return STATUS_NO_MEM; return resolve(value, &key, num_indexes, indexes); } Parameters::param_t *Parameters::lookup_by_name(const LSPString *name) { for (size_t i=0, n=vParams.size(); ilen >= 0) && (name->equals(p->name, p->len))) return p; } return NULL; } ssize_t Parameters::get_index(const LSPString *name) const { for (size_t i=0, n=vParams.size(); ilen >= 0) && (name->equals(p->name, p->len))) return i; } return -STATUS_NOT_FOUND; } ssize_t Parameters::get_index(const char *name) const { LSPString tmp; if (!tmp.set_utf8(name)) return STATUS_NO_MEM; return get_index(&tmp); } status_t Parameters::get_name(size_t index, LSPString *name) const { const param_t *p = vParams.get(index); if (p == NULL) return STATUS_INVALID_VALUE; else if (p->len < 0) return STATUS_NULL; return (name->set(p->name, p->len)) ? STATUS_OK : STATUS_NO_MEM; } ssize_t Parameters::get_type(size_t index) const { const param_t *p = vParams.get(index); return (p != NULL) ? p->value.type : -STATUS_INVALID_VALUE; } ssize_t Parameters::get_type(const char *name) const { LSPString tmp; if (!tmp.set_utf8(name)) return STATUS_NO_MEM; return get_type(&tmp); } ssize_t Parameters::get_type(const LSPString *name) const { param_t *p = const_cast(this)->lookup_by_name(name); return (p != NULL) ? p->value.type : -STATUS_NOT_FOUND; } Parameters::param_t *Parameters::lookup_by_name(const LSPString *name, size_t *idx) { for (size_t i=0, n=vParams.size(); ilen >= 0) && (name->equals(p->name, p->len))) { *idx = i; return p; } } return NULL; } status_t Parameters::resolve(value_t *value, const LSPString *name, size_t num_indexes, const ssize_t *indexes) { // Need to form indexes? LSPString tmp; const LSPString *search; if (num_indexes > 0) { if (!tmp.set(name)) return STATUS_NO_MEM; for (size_t i=0; ivalue); return STATUS_OK; } void Parameters::destroy_params(lltl::parray ¶ms) { for (size_t i=0; ivalue); ::free(p); } Parameters::param_t *Parameters::allocate() { param_t *p = reinterpret_cast(::malloc(align_size(sizeof(param_t), DEFAULT_ALIGN))); if (p != NULL) { init_value(&p->value); p->len = -1; } return p; } Parameters::param_t *Parameters::allocate(const lsp_wchar_t *name, ssize_t len) { size_t to_alloc = sizeof(param_t) + len * sizeof(lsp_wchar_t); param_t *p = reinterpret_cast(::malloc(align_size(to_alloc, DEFAULT_ALIGN))); if (p != NULL) { init_value(&p->value); p->len = len; ::memcpy(p->name, name, len * sizeof(lsp_wchar_t)); } return p; } Parameters::param_t *Parameters::clone(const param_t *src) { size_t len = (src->len < 0) ? 0 : src->len; size_t to_alloc = sizeof(param_t) + len * sizeof(lsp_wchar_t); param_t *p = reinterpret_cast(::malloc(align_size(to_alloc, DEFAULT_ALIGN))); if (p != NULL) { init_value(&p->value, &src->value); p->len = src->len; ::memcpy(p->name, src->name, len * sizeof(lsp_wchar_t)); } return p; } status_t Parameters::set(const Parameters *p, ssize_t first, ssize_t last) { const lltl::parray &vp = p->vParams; // Check ranges if (first < 0) return STATUS_UNDERFLOW; if (last < 0) { last = vp.size(); if (first > last) return STATUS_OVERFLOW; } else { if (last > ssize_t(vp.size())) return STATUS_OVERFLOW; if (first > last) return STATUS_INVALID_VALUE; } // Perform a copy lltl::parray slice; for ( ; first < last; ++first) { param_t *p = clone(vp.uget(first)); if ((p == NULL) || (!slice.add(p))) { destroy_params(slice); return STATUS_NO_MEM; } } // Swap parameters and destroy old data vParams.swap(&slice); destroy_params(slice); modified(); return STATUS_OK; } status_t Parameters::insert(size_t index, const Parameters *p, ssize_t first, ssize_t last) { if ((first < 0) || (first > last) || (last > ssize_t(p->vParams.size()))) return STATUS_INVALID_VALUE; if (index > vParams.size()) return STATUS_OVERFLOW; // Perform a copy lltl::parray slice; param_t **vp = vParams.array(); if (!slice.add_n(index, &vp[0])) return STATUS_NO_MEM; // Clone parameters and append to the current tail for (ssize_t i=first; i < last; ++i) { param_t *cp = clone(p->vParams.uget(i)); if ((cp == NULL) || (!slice.add(cp))) { // Destroy cloned parameters size_t count = slice.size() - index; for (size_t j=0; j last) || (last > ssize_t(p->vParams.size()))) return STATUS_INVALID_VALUE; // Clone parameters and append to the tail for (ssize_t i=first; i < last; ++i) { param_t *cp = clone(p->vParams.uget(i)); if ((cp == NULL) || (!vParams.add(cp))) { // Destroy cloned parameters size_t count = vParams.size() - first; for (size_t j=0; jvalue, value); if (res == STATUS_OK) { if (vParams.add(p)) { modified(); return STATUS_OK; } res = STATUS_NO_MEM; } destroy(p); return res; } status_t Parameters::add_move(const LSPString *name, value_t *value) { if (name == NULL) return add(value); param_t *p = allocate(name); if (p == NULL) return STATUS_NO_MEM; init_value_move(&p->value, value); if (vParams.add(p)) { modified(); return STATUS_OK; } destroy(p); return STATUS_NO_MEM; } status_t Parameters::add(const char *name, const value_t *value) { if (name == NULL) return add(value); LSPString tmp; if (!tmp.set_utf8(name)) return STATUS_NO_MEM; return add(&tmp, value); } status_t Parameters::add_move(const char *name, value_t *value) { if (name == NULL) return add(value); LSPString tmp; if (!tmp.set_utf8(name)) return STATUS_NO_MEM; return add_move(&tmp, value); } status_t Parameters::add(const value_t *value) { param_t *p = allocate(); if (p == NULL) return STATUS_NO_MEM; status_t res = init_value(&p->value, value); if (res == STATUS_OK) { if (vParams.add(p)) { modified(); return STATUS_OK; } res = STATUS_NO_MEM; } destroy(p); return res; } status_t Parameters::add_move(value_t *value) { param_t *p = allocate(); if (p == NULL) return STATUS_NO_MEM; init_value_move(&p->value, value); if (vParams.add(p)) { modified(); return STATUS_OK; } destroy(p); return STATUS_NO_MEM; } status_t Parameters::add_int(const char *name, ssize_t value) { value_t v; v.type = VT_INT; v.v_int = value; return add(name, &v); } status_t Parameters::add_float(const char *name, double value) { value_t v; v.type = VT_FLOAT; v.v_float = value; return add(name, &v); } status_t Parameters::add_bool(const char *name, bool value) { value_t v; v.type = VT_BOOL; v.v_bool = value; return add(name, &v); } status_t Parameters::add_cstring(const char *name, const char *value) { if (value == NULL) return add_null(name); value_t v; status_t res = init_value_string(&v, value); if (res == STATUS_OK) res = add_move(name, &v); lsp_finally { destroy_value(&v); }; return res; } status_t Parameters::add_string(const char *name, const LSPString *value) { if (value == NULL) return add_null(name); value_t v; v.type = VT_STRING; v.v_str = const_cast(value); return add(name, &v); } status_t Parameters::add_null(const char *name) { value_t v; v.type = VT_NULL; v.v_str = NULL; return add(name, &v); } status_t Parameters::add_undef(const char *name) { value_t v; v.type = VT_UNDEF; v.v_str = NULL; return add(name, &v); } status_t Parameters::add_int(const LSPString *name, ssize_t value) { value_t v; v.type = VT_INT; v.v_int = value; return add(name, &v); } status_t Parameters::add_float(const LSPString *name, double value) { value_t v; v.type = VT_FLOAT; v.v_float = value; return add(name, &v); } status_t Parameters::add_bool(const LSPString *name, bool value) { value_t v; v.type = VT_BOOL; v.v_bool = value; return add(name, &v); } status_t Parameters::add_cstring(const LSPString *name, const char *value) { if (value == NULL) return add_null(name); LSPString s; if (!s.set_utf8(value)) return STATUS_NO_MEM; value_t v; v.type = VT_STRING; v.v_str = &s; return add(name, &v); } status_t Parameters::add_string(const LSPString *name, const LSPString *value) { if (value == NULL) return add_null(name); value_t v; v.type = VT_STRING; v.v_str = const_cast(value); return add(name, &v); } status_t Parameters::add_null(const LSPString *name) { value_t v; v.type = VT_NULL; v.v_str = NULL; return add(name, &v); } status_t Parameters::add_undef(const LSPString *name) { value_t v; v.type = VT_UNDEF; v.v_str = NULL; return add(name, &v); } status_t Parameters::add_int(ssize_t value) { value_t v; v.type = VT_INT; v.v_int = value; return add(&v); } status_t Parameters::add_float(double value) { value_t v; v.type = VT_FLOAT; v.v_float = value; return add(&v); } status_t Parameters::add_bool(bool value) { value_t v; v.type = VT_BOOL; v.v_bool = value; return add(&v); } status_t Parameters::add_cstring(const char *value) { if (value == NULL) return add_null(); LSPString s; if (!s.set_utf8(value)) return STATUS_NO_MEM; value_t v; v.type = VT_STRING; v.v_str = &s; return add(&v); } status_t Parameters::add_string(const LSPString *value) { if (value == NULL) return add_null(); value_t v; v.type = VT_STRING; v.v_str = const_cast(value); return add(&v); } status_t Parameters::add_null() { value_t v; v.type = VT_NULL; v.v_str = NULL; return add(&v); } status_t Parameters::add_undef() { value_t v; v.type = VT_UNDEF; v.v_str = NULL; return add(&v); } status_t Parameters::insert(size_t index, const char *name, const value_t *value) { if (name == NULL) return insert(index, value); LSPString tmp; if (!tmp.set_utf8(name)) return STATUS_NO_MEM; return insert(index, &tmp, value); } status_t Parameters::insert(size_t index, const LSPString *name, const value_t *value) { if (name == NULL) return insert(index, value); else if (index > vParams.size()) return STATUS_INVALID_VALUE; param_t *p = allocate(name); if (p == NULL) return STATUS_NO_MEM; status_t res = init_value(&p->value, value); if (res == STATUS_OK) { if (vParams.insert(index, p)) { modified(); return STATUS_OK; } res = STATUS_NO_MEM; } destroy(p); return res; } status_t Parameters::insert(size_t index, const value_t *value) { if (index > vParams.size()) return STATUS_INVALID_VALUE; param_t *p = allocate(); if (p == NULL) return STATUS_NO_MEM; status_t res = init_value(&p->value, value); if (res == STATUS_OK) { if (vParams.insert(index, p)) { modified(); return STATUS_OK; } res = STATUS_NO_MEM; } destroy(p); return res; } status_t Parameters::insert_int(size_t index, const char *name, ssize_t value) { value_t v; v.type = VT_INT; v.v_int = value; return insert(index, name, &v); } status_t Parameters::insert_float(size_t index, const char *name, double value) { value_t v; v.type = VT_FLOAT; v.v_float = value; return insert(index, name, &v); } status_t Parameters::insert_bool(size_t index, const char *name, bool value) { value_t v; v.type = VT_BOOL; v.v_bool = value; return insert(index, name, &v); } status_t Parameters::insert_string(size_t index, const char *name, const char *value) { if (value == NULL) return insert_null(index, name); LSPString s; if (!s.set_utf8(value)) return STATUS_NO_MEM; value_t v; v.type = VT_STRING; v.v_str = &s; return insert(index, name, &v); } status_t Parameters::insert_string(size_t index, const char *name, const LSPString *value) { if (value == NULL) return insert_null(index, name); value_t v; v.type = VT_STRING; v.v_str = const_cast(value); return insert(index, name, &v); } status_t Parameters::insert_null(size_t index, const char *name) { value_t v; v.type = VT_NULL; v.v_str = NULL; return insert(index, name, &v); } status_t Parameters::insert_undef(size_t index, const char *name) { value_t v; v.type = VT_UNDEF; v.v_str = NULL; return insert(index, name, &v); } status_t Parameters::insert_int(size_t index, const LSPString *name, ssize_t value) { value_t v; v.type = VT_INT; v.v_int = value; return insert(index, name, &v); } status_t Parameters::insert_float(size_t index, const LSPString *name, double value) { value_t v; v.type = VT_FLOAT; v.v_float = value; return insert(index, name, &v); } status_t Parameters::insert_bool(size_t index, const LSPString *name, bool value) { value_t v; v.type = VT_BOOL; v.v_bool = value; return insert(index, name, &v); } status_t Parameters::insert_string(size_t index, const LSPString *name, const char *value) { if (value == NULL) return insert_null(index, name); LSPString s; if (!s.set_utf8(value)) return STATUS_NO_MEM; value_t v; v.type = VT_STRING; v.v_str = &s; return insert(index, name, &v); } status_t Parameters::insert_string(size_t index, const LSPString *name, const LSPString *value) { if (value == NULL) return insert_null(index, name); value_t v; v.type = VT_STRING; v.v_str = const_cast(value); return insert(index, name, &v); } status_t Parameters::insert_null(size_t index, const LSPString *name) { value_t v; v.type = VT_NULL; v.v_str = NULL; return insert(index, name, &v); } status_t Parameters::insert_undef(size_t index, const LSPString *name) { value_t v; v.type = VT_UNDEF; v.v_str = NULL; return insert(index, name, &v); } status_t Parameters::insert_int(size_t index, ssize_t value) { value_t v; v.type = VT_INT; v.v_int = value; return insert(index, &v); } status_t Parameters::insert_float(size_t index, double value) { value_t v; v.type = VT_FLOAT; v.v_float = value; return insert(index, &v); } status_t Parameters::insert_bool(size_t index, bool value) { value_t v; v.type = VT_BOOL; v.v_bool = value; return insert(index, &v); } status_t Parameters::insert_cstring(size_t index, const char *value) { if (value == NULL) return insert_null(index); LSPString s; if (!s.set_utf8(value)) return STATUS_NO_MEM; value_t v; v.type = VT_STRING; v.v_str = &s; return insert(index, &v); } status_t Parameters::insert_string(size_t index, const LSPString *value) { if (value == NULL) return insert_null(index); value_t v; v.type = VT_STRING; v.v_str = const_cast(value); return insert(index, &v); } status_t Parameters::insert_null(size_t index) { value_t v; v.type = VT_NULL; v.v_str = NULL; return insert(index, &v); } status_t Parameters::insert_undef(size_t index) { value_t v; v.type = VT_UNDEF; v.v_str = NULL; return insert(index, &v); } status_t Parameters::get(size_t index, value_t *value) const { const param_t *v = vParams.get(index); if (v == NULL) return STATUS_INVALID_VALUE; return (value != NULL) ? copy_value(value, &v->value) : STATUS_OK; } status_t Parameters::get(const char *name, value_t *value) const { LSPString tmp; if (!tmp.set_utf8(name)) return STATUS_NO_MEM; return get(&tmp, value); } status_t Parameters::get(const LSPString *name, value_t *value) const { param_t *v = const_cast(this)->lookup_by_name(name); if (v == NULL) return STATUS_NOT_FOUND; return (value != NULL) ? copy_value(value, &v->value) : STATUS_OK; } status_t Parameters::get_int(size_t index, ssize_t *value) const { const param_t *v = vParams.get(index); if (v == NULL) return STATUS_INVALID_VALUE; else if (v->value.type != VT_INT) return STATUS_BAD_TYPE; else if (value != NULL) *value = v->value.v_int; return STATUS_OK; } status_t Parameters::get_float(size_t index, double *value) const { const param_t *v = vParams.get(index); if (v == NULL) return STATUS_INVALID_VALUE; else if (v->value.type != VT_FLOAT) return STATUS_BAD_TYPE; else if (value != NULL) *value = v->value.v_float; return STATUS_OK; } status_t Parameters::get_bool(size_t index, bool *value) const { const param_t *v = vParams.get(index); if (v == NULL) return STATUS_INVALID_VALUE; else if (v->value.type != VT_BOOL) return STATUS_BAD_TYPE; else if (value != NULL) *value = v->value.v_bool; return STATUS_OK; } status_t Parameters::get_string(size_t index, LSPString *value) const { const param_t *v = vParams.get(index); if (v == NULL) return STATUS_INVALID_VALUE; else if (v->value.type != VT_STRING) return STATUS_BAD_TYPE; else if (value != NULL) { if (!value->set(v->value.v_str)) return STATUS_NO_MEM; } return STATUS_OK; } status_t Parameters::get_null(size_t index) const { const param_t *v = vParams.get(index); if (v == NULL) return STATUS_INVALID_VALUE; else if (v->value.type != VT_NULL) return STATUS_BAD_TYPE; return STATUS_OK; } status_t Parameters::get_undef(size_t index) const { const param_t *v = vParams.get(index); if (v == NULL) return STATUS_INVALID_VALUE; else if (v->value.type != VT_UNDEF) return STATUS_BAD_TYPE; return STATUS_OK; } status_t Parameters::get_int(const char *name, ssize_t *value) const { if (name == NULL) return STATUS_INVALID_VALUE; LSPString tmp; if (!tmp.set_utf8(name)) return STATUS_NO_MEM; return get_int(&tmp, value); } status_t Parameters::get_float(const char *name, double *value) const { if (name == NULL) return STATUS_INVALID_VALUE; LSPString tmp; if (!tmp.set_utf8(name)) return STATUS_NO_MEM; return get_float(&tmp, value); } status_t Parameters::get_bool(const char *name, bool *value) const { if (name == NULL) return STATUS_INVALID_VALUE; LSPString tmp; if (!tmp.set_utf8(name)) return STATUS_NO_MEM; return get_bool(&tmp, value); } status_t Parameters::get_string(const char *name, LSPString *value) const { if (name == NULL) return STATUS_INVALID_VALUE; LSPString tmp; if (!tmp.set_utf8(name)) return STATUS_NO_MEM; return get_string(&tmp, value); } status_t Parameters::get_null(const char *name) const { if (name == NULL) return STATUS_INVALID_VALUE; LSPString tmp; if (!tmp.set_utf8(name)) return STATUS_NO_MEM; return get_null(&tmp); } status_t Parameters::get_undef(const char *name) const { if (name == NULL) return STATUS_INVALID_VALUE; LSPString tmp; if (!tmp.set_utf8(name)) return STATUS_NO_MEM; return get_undef(&tmp); } status_t Parameters::get_int(const LSPString *name, ssize_t *value) const { if (name == NULL) return STATUS_INVALID_VALUE; param_t *v = const_cast(this)->lookup_by_name(name); if (v == NULL) return STATUS_NOT_FOUND; else if (v->value.type != VT_INT) return STATUS_BAD_TYPE; else if (value != NULL) *value = v->value.v_int; return STATUS_OK; } status_t Parameters::get_float(const LSPString *name, double *value) const { if (name == NULL) return STATUS_INVALID_VALUE; param_t *v = const_cast(this)->lookup_by_name(name); if (v == NULL) return STATUS_NOT_FOUND; else if (v->value.type != VT_FLOAT) return STATUS_BAD_TYPE; else if (value != NULL) *value = v->value.v_float; return STATUS_OK; } status_t Parameters::get_bool(const LSPString *name, bool *value) const { if (name == NULL) return STATUS_INVALID_VALUE; param_t *v = const_cast(this)->lookup_by_name(name); if (v == NULL) return STATUS_NOT_FOUND; else if (v->value.type != VT_BOOL) return STATUS_BAD_TYPE; else if (value != NULL) *value = v->value.v_bool; return STATUS_OK; } status_t Parameters::get_string(const LSPString *name, LSPString *value) const { if (name == NULL) return STATUS_INVALID_VALUE; param_t *v = const_cast(this)->lookup_by_name(name); if (v == NULL) return STATUS_NOT_FOUND; else if (v->value.type != VT_STRING) return STATUS_BAD_TYPE; else if (value != NULL) { if (!value->set(v->value.v_str)) return STATUS_NO_MEM; } return STATUS_OK; } status_t Parameters::get_null(const LSPString *name) const { if (name == NULL) return STATUS_INVALID_VALUE; param_t *v = const_cast(this)->lookup_by_name(name); if (v == NULL) return STATUS_NOT_FOUND; else if (v->value.type != VT_NULL) return STATUS_BAD_TYPE; return STATUS_OK; } status_t Parameters::get_undef(const LSPString *name) const { if (name == NULL) return STATUS_INVALID_VALUE; param_t *v = const_cast(this)->lookup_by_name(name); if (v == NULL) return STATUS_NOT_FOUND; else if (v->value.type != VT_UNDEF) return STATUS_BAD_TYPE; return STATUS_OK; } status_t Parameters::as_value(size_t index, value_t *value, value_type_t type) const { const param_t *v = const_cast(this)->vParams.get(index); if (v == NULL) return STATUS_INVALID_VALUE; value_t tmp; status_t res = init_value(&tmp, &v->value); if (res == STATUS_OK) { if ((res = cast_value(&tmp, type)) == STATUS_OK) res = (tmp.type == type) ? copy_value(value, &tmp) : STATUS_BAD_TYPE; } destroy_value(&tmp); return res; } status_t Parameters::as_value(const LSPString *name, value_t *value, value_type_t type) const { if (name == NULL) return STATUS_INVALID_VALUE; param_t *v = const_cast(this)->lookup_by_name(name); if (v == NULL) return STATUS_NOT_FOUND; value_t tmp; status_t res = init_value(&tmp, &v->value); if (res == STATUS_OK) { if ((res = cast_value(&tmp, type)) == STATUS_OK) res = (tmp.type == type) ? copy_value(value, &tmp) : STATUS_BAD_TYPE; } destroy_value(&tmp); return res; } status_t Parameters::as_value(const char *name, value_t *value, value_type_t type) const { if (name == NULL) return STATUS_INVALID_VALUE; LSPString tmp; if (!tmp.set_utf8(name)) return STATUS_NO_MEM; return as_value(&tmp, value, type); } status_t Parameters::as_int(size_t index, ssize_t *value) const { value_t v; init_value(&v); status_t res = as_value(index, &v, VT_INT); if (res == STATUS_OK) *value = v.v_int; destroy_value(&v); return res; } status_t Parameters::as_float(size_t index, double *value) const { value_t v; init_value(&v); status_t res = as_value(index, &v, VT_FLOAT); if (res == STATUS_OK) *value = v.v_float; destroy_value(&v); return res; } status_t Parameters::as_bool(size_t index, bool *value) const { value_t v; init_value(&v); status_t res = as_value(index, &v, VT_BOOL); if (res == STATUS_OK) *value = v.v_bool; destroy_value(&v); return res; } status_t Parameters::as_string(size_t index, LSPString *value) const { value_t v; init_value(&v); status_t res = as_value(index, &v, VT_STRING); if (res == STATUS_OK) res = (value->set(v.v_str)) ? STATUS_OK : STATUS_NO_MEM; destroy_value(&v); return res; } status_t Parameters::as_null(size_t index) const { value_t v; init_value(&v); status_t res = as_value(index, &v, VT_NULL); destroy_value(&v); return res; } status_t Parameters::as_undef(size_t index) const { value_t v; init_value(&v); status_t res = as_value(index, &v, VT_UNDEF); destroy_value(&v); return res; } status_t Parameters::as_int(const char *name, ssize_t *value) const { value_t v; init_value(&v); status_t res = as_value(name, &v, VT_INT); if (res == STATUS_OK) *value = v.v_int; destroy_value(&v); return res; } status_t Parameters::as_float(const char *name, double *value) const { value_t v; init_value(&v); status_t res = as_value(name, &v, VT_FLOAT); if (res == STATUS_OK) *value = v.v_float; destroy_value(&v); return res; } status_t Parameters::as_bool(const char *name, bool *value) const { value_t v; init_value(&v); status_t res = as_value(name, &v, VT_BOOL); if (res == STATUS_OK) *value = v.v_bool; destroy_value(&v); return res; } status_t Parameters::as_string(const char *name, LSPString *value) const { value_t v; init_value(&v); status_t res = as_value(name, &v, VT_STRING); if (res == STATUS_OK) res = (value->set(v.v_str)) ? STATUS_OK : STATUS_NO_MEM; destroy_value(&v); return res; } status_t Parameters::as_null(const char *name) const { value_t v; init_value(&v); status_t res = as_value(name, &v, VT_NULL); destroy_value(&v); return res; } status_t Parameters::as_undef(const char *name) const { value_t v; init_value(&v); status_t res = as_value(name, &v, VT_UNDEF); destroy_value(&v); return res; } status_t Parameters::as_int(const LSPString *name, ssize_t *value) const { value_t v; init_value(&v); status_t res = as_value(name, &v, VT_INT); if (res == STATUS_OK) *value = v.v_int; destroy_value(&v); return res; } status_t Parameters::as_float(const LSPString *name, double *value) const { value_t v; init_value(&v); status_t res = as_value(name, &v, VT_FLOAT); if (res == STATUS_OK) *value = v.v_float; destroy_value(&v); return res; } status_t Parameters::as_bool(const LSPString *name, bool *value) const { value_t v; init_value(&v); status_t res = as_value(name, &v, VT_BOOL); if (res == STATUS_OK) *value = v.v_bool; destroy_value(&v); return res; } status_t Parameters::as_string(const LSPString *name, LSPString *value) const { value_t v; init_value(&v); status_t res = as_value(name, &v, VT_STRING); if (res == STATUS_OK) res = (value->set(v.v_str)) ? STATUS_OK : STATUS_NO_MEM; destroy_value(&v); return res; } status_t Parameters::as_null(const LSPString *name) const { value_t v; init_value(&v); status_t res = as_value(name, &v, VT_NULL); destroy_value(&v); return res; } status_t Parameters::as_undef(const LSPString *name) const { value_t v; init_value(&v); status_t res = as_value(name, &v, VT_UNDEF); destroy_value(&v); return res; } status_t Parameters::set(const char *name, const value_t *value) { if (name == NULL) return STATUS_INVALID_VALUE; LSPString tmp; if (!tmp.set_utf8(name)) return STATUS_NO_MEM; return set(&tmp, value); } status_t Parameters::set(const LSPString *name, const value_t *value) { param_t *v = lookup_by_name(name); if (v == NULL) return add(name, value); status_t res = copy_value(&v->value, value); if (res == STATUS_OK) modified(); return res; } status_t Parameters::set(size_t index, const value_t *value) { param_t *v = vParams.get(index); if (v == NULL) return STATUS_INVALID_VALUE; status_t res = copy_value(&v->value, value); if (res == STATUS_OK) modified(); return res; } status_t Parameters::set_int(const char *name, ssize_t value) { value_t v; v.type = VT_INT; v.v_int = value; return set(name, &v); } status_t Parameters::set_float(const char *name, double value) { value_t v; v.type = VT_FLOAT; v.v_float = value; return set(name, &v); } status_t Parameters::set_bool(const char *name, bool value) { value_t v; v.type = VT_BOOL; v.v_bool = value; return set(name, &v); } status_t Parameters::set_cstring(const char *name, const char *value) { if (value == NULL) return set_null(name); LSPString tmp; if (!tmp.set_utf8(value)) return STATUS_NO_MEM; value_t v; v.type = VT_STRING; v.v_str = &tmp; return set(name, &v); } status_t Parameters::set_string(const char *name, const LSPString *value) { value_t v; v.type = VT_STRING; v.v_str = const_cast(value); return set(name, &v); } status_t Parameters::set_null(const char *name) { value_t v; v.type = VT_NULL; v.v_str = NULL; return set(name, &v); } status_t Parameters::set_undef(const char *name) { value_t v; v.type = VT_UNDEF; v.v_str = NULL; return set(name, &v); } status_t Parameters::set_int(const LSPString *name, ssize_t value) { value_t v; v.type = VT_INT; v.v_int = value; return set(name, &v); } status_t Parameters::set_float(const LSPString *name, double value) { value_t v; v.type = VT_FLOAT; v.v_float = value; return set(name, &v); } status_t Parameters::set_bool(const LSPString *name, bool value) { value_t v; v.type = VT_BOOL; v.v_bool = value; return set(name, &v); } status_t Parameters::set_cstring(const LSPString *name, const char *value) { if (value == NULL) return set_null(name); LSPString tmp; if (!tmp.set_utf8(value)) return STATUS_NO_MEM; value_t v; v.type = VT_STRING; v.v_str = &tmp; return set(name, &v); } status_t Parameters::set_string(const LSPString *name, const LSPString *value) { value_t v; v.type = VT_STRING; v.v_str = const_cast(value); return set(name, &v); } status_t Parameters::set_null(const LSPString *name) { value_t v; v.type = VT_NULL; v.v_str = NULL; return set(name, &v); } status_t Parameters::set_undef(const LSPString *name) { value_t v; v.type = VT_UNDEF; v.v_str = NULL; return set(name, &v); } status_t Parameters::set_int(size_t index, ssize_t value) { value_t v; v.type = VT_INT; v.v_int = value; return set(index, &v); } status_t Parameters::set_float(size_t index, double value) { value_t v; v.type = VT_FLOAT; v.v_float = value; return set(index, &v); } status_t Parameters::set_bool(size_t index, bool value) { value_t v; v.type = VT_BOOL; v.v_bool = value; return set(index, &v); } status_t Parameters::set_cstring(size_t index, const char *value) { if (value == NULL) return set_null(index); LSPString tmp; if (!tmp.set_utf8(value)) return STATUS_NO_MEM; value_t v; v.type = VT_STRING; v.v_str = &tmp; return set(index, &v); } status_t Parameters::set_string(size_t index, const LSPString *value) { value_t v; v.type = VT_STRING; v.v_str = const_cast(value); return set(index, &v); } status_t Parameters::set_null(size_t index) { value_t v; v.type = VT_NULL; v.v_str = NULL; return set(index, &v); } status_t Parameters::set_undef(size_t index) { value_t v; v.type = VT_UNDEF; v.v_str = NULL; return set(index, &v); } status_t Parameters::remove(size_t index, value_t *value) { param_t *v = vParams.get(index); if (v == NULL) return STATUS_INVALID_VALUE; if (value != NULL) { status_t res = copy_value(value, &v->value); if (res != STATUS_OK) return res; } vParams.remove(index); destroy(v); modified(); return STATUS_OK; } status_t Parameters::remove_value(size_t index, value_type_t type, value_t *value) { param_t *v = vParams.get(index); if (v == NULL) return STATUS_INVALID_VALUE; else if (v->value.type != type) return STATUS_BAD_TYPE; if (value != NULL) { status_t res = copy_value(value, &v->value); if (res != STATUS_OK) return res; } vParams.remove(index); destroy(v); modified(); return STATUS_OK; } status_t Parameters::remove(const char *name, value_t *value) { if (name == NULL) return STATUS_INVALID_VALUE; LSPString tmp; if (!tmp.set_utf8(name)) return STATUS_NO_MEM; return remove(&tmp, value); } status_t Parameters::remove_value(const char *name, value_type_t type, value_t *value) { if (name == NULL) return STATUS_INVALID_VALUE; LSPString tmp; if (!tmp.set_utf8(name)) return STATUS_NO_MEM; return remove_value(&tmp, type, value); } status_t Parameters::remove(const LSPString *name, value_t *value) { if (name == NULL) return STATUS_INVALID_VALUE; size_t index; param_t *v = lookup_by_name(name, &index); if (v == NULL) return STATUS_NOT_FOUND; if (value != NULL) { status_t res = copy_value(value, &v->value); if (res != STATUS_OK) return res; } vParams.remove(index); destroy(v); modified(); return STATUS_OK; } status_t Parameters::remove_value(const LSPString *name, value_type_t type, value_t *value) { if (name == NULL) return STATUS_INVALID_VALUE; size_t index; param_t *v = lookup_by_name(name, &index); if (v == NULL) return STATUS_NOT_FOUND; else if (v->value.type != type) return STATUS_BAD_TYPE; if (value != NULL) { status_t res = copy_value(value, &v->value); if (res != STATUS_OK) return res; } vParams.remove(index); destroy(v); modified(); return STATUS_OK; } status_t Parameters::remove(ssize_t first, ssize_t last) { if ((first < 0) || (last > ssize_t(vParams.size()))) return STATUS_INVALID_VALUE; ssize_t count = last - first; if (count < 0) return STATUS_INVALID_VALUE; for (ssize_t i=first; ivalue.type != type) return STATUS_BAD_TYPE; vParams.remove(index); *out = v; modified(); return STATUS_OK; } status_t Parameters::drop_value(const char *name, value_type_t type, param_t **out) { if (name == NULL) return STATUS_INVALID_VALUE; LSPString tmp; if (!tmp.set_utf8(name)) return STATUS_NO_MEM; return drop_value(&tmp, type, out); } status_t Parameters::drop_value(const LSPString *name, value_type_t type, param_t **out) { size_t index; param_t *v = lookup_by_name(name, &index); if (v == NULL) return STATUS_NOT_FOUND; else if (v->value.type != type) return STATUS_BAD_TYPE; vParams.remove(index); *out = v; modified(); return STATUS_OK; } status_t Parameters::remove_int(size_t index, ssize_t *value) { param_t *pv; status_t res = drop_value(index, VT_INT, &pv); if (res != STATUS_OK) return res; if (value != NULL) *value = pv->value.v_int; destroy(pv); return STATUS_OK; } status_t Parameters::remove_float(size_t index, double *value) { param_t *pv; status_t res = drop_value(index, VT_FLOAT, &pv); if (res != STATUS_OK) return res; if (value != NULL) *value = pv->value.v_float; destroy(pv); return STATUS_OK; } status_t Parameters::remove_bool(size_t index, bool *value) { param_t *pv; status_t res = drop_value(index, VT_BOOL, &pv); if (res != STATUS_OK) return res; if (value != NULL) *value = pv->value.v_bool; destroy(pv); return STATUS_OK; } status_t Parameters::remove_string(size_t index, LSPString *value) { param_t *pv; status_t res = drop_value(index, VT_STRING, &pv); if (res != STATUS_OK) return res; if (value != NULL) value->swap(pv->value.v_str); destroy(pv); return STATUS_OK; } status_t Parameters::remove_null(size_t index) { param_t *pv; status_t res = drop_value(index, VT_NULL, &pv); if (res != STATUS_OK) return res; destroy(pv); return STATUS_OK; } status_t Parameters::remove_undef(size_t index) { param_t *pv; status_t res = drop_value(index, VT_UNDEF, &pv); if (res != STATUS_OK) return res; destroy(pv); return STATUS_OK; } status_t Parameters::remove_int(const char *name, ssize_t *value) { param_t *pv; status_t res = drop_value(name, VT_INT, &pv); if (res != STATUS_OK) return res; if (value != NULL) *value = pv->value.v_int; destroy(pv); return STATUS_OK; } status_t Parameters::remove_float(const char *name, double *value) { param_t *pv; status_t res = drop_value(name, VT_FLOAT, &pv); if (res != STATUS_OK) return res; if (value != NULL) *value = pv->value.v_float; destroy(pv); return STATUS_OK; } status_t Parameters::remove_bool(const char *name, bool *value) { param_t *pv; status_t res = drop_value(name, VT_BOOL, &pv); if (res != STATUS_OK) return res; if (value != NULL) *value = pv->value.v_bool; destroy(pv); return STATUS_OK; } status_t Parameters::remove_string(const char *name, LSPString *value) { param_t *pv; status_t res = drop_value(name, VT_STRING, &pv); if (res != STATUS_OK) return res; if (value != NULL) value->swap(pv->value.v_str); destroy(pv); return STATUS_OK; } status_t Parameters::remove_null(const char *name) { param_t *pv; status_t res = drop_value(name, VT_NULL, &pv); if (res != STATUS_OK) return res; destroy(pv); return STATUS_OK; } status_t Parameters::remove_undef(const char *name) { param_t *pv; status_t res = drop_value(name, VT_UNDEF, &pv); if (res != STATUS_OK) return res; destroy(pv); return STATUS_OK; } status_t Parameters::remove_int(const LSPString *name, ssize_t *value) { param_t *pv; status_t res = drop_value(name, VT_INT, &pv); if (res != STATUS_OK) return res; if (value != NULL) *value = pv->value.v_int; destroy(pv); return STATUS_OK; } status_t Parameters::remove_float(const LSPString *name, double *value) { param_t *pv; status_t res = drop_value(name, VT_FLOAT, &pv); if (res != STATUS_OK) return res; if (value != NULL) *value = pv->value.v_float; destroy(pv); return STATUS_OK; } status_t Parameters::remove_bool(const LSPString *name, bool *value) { param_t *pv; status_t res = drop_value(name, VT_BOOL, &pv); if (res != STATUS_OK) return res; if (value != NULL) *value = pv->value.v_bool; destroy(pv); return STATUS_OK; } status_t Parameters::remove_string(const LSPString *name, LSPString *value) { param_t *pv; status_t res = drop_value(name, VT_STRING, &pv); if (res != STATUS_OK) return res; if (value != NULL) value->swap(pv->value.v_str); destroy(pv); return STATUS_OK; } status_t Parameters::remove_null(const LSPString *name) { param_t *pv; status_t res = drop_value(name, VT_NULL, &pv); if (res != STATUS_OK) return res; destroy(pv); return STATUS_OK; } status_t Parameters::remove_undef(const LSPString *name) { param_t *pv; status_t res = drop_value(name, VT_UNDEF, &pv); if (res != STATUS_OK) return res; destroy(pv); return STATUS_OK; } } /* namespace expr */ } /* namespace lsp */