/* * Copyright (C) 2021 Linux Studio Plugins Project * (C) 2021 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 31 янв. 2021 г. * * 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 #include namespace lsp { namespace json { Node::Node(node_t *node) { pNode = node; if (node != NULL) node->refs++; } Node::Node(const Node &src) { pNode = NULL; copy_ref(&src); } Node::Node(const Node *src) { pNode = NULL; copy_ref(src); } Node::~Node() { if (pNode != NULL) { release_ref(pNode); pNode = NULL; } } status_t Node::create() { node_t *node = new node_t(); if (node == NULL) return STATUS_NO_MEM; node->refs = 1; node->type = JN_NULL; node->pData = NULL; release_ref(pNode); pNode = node; return STATUS_OK; } Node Node::build() { Node res; res.create(); return res; } Node *Node::allocate() { Node *res = new Node(); if (res == NULL) return NULL; else if (res->create() == STATUS_OK) return res; delete res; return NULL; } void Node::copy_ref(const Node *src) { if (this == src) return; else if (this->pNode == src->pNode) return; // Increment number of references for source node node_t *ref = src->make_ref(); // Release self reference and replace with new one release_ref(pNode); pNode = ref; } Node::node_t *Node::make_ref() const { if (pNode != NULL) { pNode->refs ++; return pNode; } // Need to allocate the node if ((pNode = new node_t()) == NULL) return NULL; pNode->refs = 2; // self and exported pNode->type = JN_NULL; pNode->pData= NULL; return pNode; } void Node::undef_node(node_t *node) { if (node == NULL) return; // Destroy object switch (node->type) { case JN_NULL: break; case JN_INT: node->nValue = 0; break; case JN_DOUBLE: node->fValue = 0.0; break; case JN_BOOL: node->bValue = false; break; case JN_STRING: { LSPString *s = node->sValue; if (s == NULL) break; node->sValue = NULL; delete s; break; } case JN_ARRAY: { lltl::parray *v = node->pArray; if (v == NULL) break; node->pArray = NULL; for (size_t i=0, n=v->size(); iuget(i)); delete v; break; } case JN_OBJECT: { lltl::pphash *h = node->pObject; if (h == NULL) break; node->pObject = NULL; lltl::parray v; if (h->values(&v)) { for (size_t i=0, n=v.size(); itype = JN_NULL; } Node::node_t *Node::clear_node(node_t *node) { if (node != NULL) { undef_node(node); return node; } node = new node_t; if (node != NULL) { node->type = JN_NULL; node->refs = 1; node->pData = NULL; } return node; } void Node::release_ref(node_t *node) { // Check the value if ((node == NULL) || (--node->refs) > 0) return; // Undef node data and free node undef_node(node); delete node; } bool Node::of_type(const Node *src) const { return type() == src->type(); } bool Node::of_type(const Node &src) const { return type() == src.type(); } bool Node::of_type(node_type_t ntype) const { return type() == ntype; } void Node::move_data(node_t *dst, node_t *src) { switch (src->type) { case JN_NULL: dst->pData = src->pData; break; case JN_INT: dst->nValue = src->nValue; break; case JN_DOUBLE: dst->fValue = src->fValue; break; case JN_BOOL: dst->bValue = src->bValue; break; case JN_STRING: dst->sValue = src->sValue; break; case JN_ARRAY: dst->pArray = src->pArray; break; case JN_OBJECT: dst->pObject = src->pObject; break; default: break; } dst->type = src->type; src->pData = NULL; src->type = JN_NULL; } status_t Node::cast_to(node_type_t dtype) { // Check that type matches switch (dtype) { case JN_NULL: undef_node(pNode); return STATUS_OK; case JN_INT: return cast_to_int(); case JN_DOUBLE: return cast_to_double(); case JN_BOOL: return cast_to_bool(); case JN_STRING: return cast_to_string(); case JN_ARRAY: return cast_to_array(); case JN_OBJECT: return cast_to_object(); default: break; } return STATUS_BAD_TYPE; } status_t Node::cast_to_int() { ssize_t ivalue; switch (type()) { case JN_NULL: ivalue = 0; break; case JN_INT: return STATUS_OK; case JN_DOUBLE: ivalue = pNode->fValue; break; case JN_BOOL: ivalue = (pNode->bValue) ? 1 : 0; break; case JN_STRING: { // Parse integer/float number as string and cast to integer io::InStringSequence s(pNode->sValue); expr::Tokenizer t(&s); switch (t.get_token(expr::TF_GET)) { case expr::TT_IVALUE: ivalue = t.int_value(); break; case expr::TT_FVALUE: ivalue = t.float_value(); break; case expr::TT_TRUE: ivalue = 1; break; case expr::TT_FALSE: ivalue = 0; break; default: return STATUS_BAD_FORMAT; } if (t.get_token(expr::TF_GET) != expr::TT_EOF) return STATUS_BAD_FORMAT; break; } case JN_ARRAY: ivalue = pNode->pArray->size(); break; case JN_OBJECT: ivalue = pNode->pObject->size(); break; default: return STATUS_BAD_TYPE; } // Update node value node_t *node = clear_node(pNode); if (node == NULL) return STATUS_NO_MEM; pNode = node; pNode->type = JN_INT; pNode->nValue = ivalue; return STATUS_OK; } status_t Node::cast_to_double() { double fvalue; switch (type()) { case JN_NULL: fvalue = 0.0f; break; case JN_INT: fvalue = pNode->nValue; break; case JN_DOUBLE: return STATUS_OK; case JN_BOOL: fvalue = (pNode->bValue) ? 1.0f : 0.0f; break; case JN_STRING: { // Parse integer/float number as string and cast to integer io::InStringSequence s(pNode->sValue); expr::Tokenizer t(&s); switch (t.get_token(expr::TF_GET)) { case expr::TT_IVALUE: fvalue = t.int_value(); break; case expr::TT_FVALUE: fvalue = t.float_value(); break; case expr::TT_TRUE: fvalue = 1.0f; break; case expr::TT_FALSE: fvalue = 0.0f; break; default: return STATUS_BAD_FORMAT; } if (t.get_token(expr::TF_GET) != expr::TT_EOF) return STATUS_BAD_FORMAT; break; } case JN_ARRAY: fvalue = pNode->pArray->size(); break; case JN_OBJECT: fvalue = pNode->pObject->size(); break; default: return STATUS_BAD_TYPE; } // Update node value node_t *node = clear_node(pNode); if (node == NULL) return STATUS_NO_MEM; pNode->type = JN_DOUBLE; pNode->fValue = fvalue; return STATUS_OK; } status_t Node::cast_to_bool() { bool bvalue; switch (type()) { case JN_NULL: bvalue = false; break; case JN_INT: bvalue = pNode->nValue != 0; break; case JN_DOUBLE: bvalue = (pNode->fValue >= 0.5) || (pNode->fValue <= -0.5); break; case JN_BOOL: return STATUS_OK; case JN_STRING: { // Parse integer/float number as string and cast to integer io::InStringSequence s(pNode->sValue); expr::Tokenizer t(&s); switch (t.get_token(expr::TF_GET)) { case expr::TT_IVALUE: bvalue = t.int_value() != 0; break; case expr::TT_FVALUE: bvalue = (t.float_value() >= 0.5) || (t.float_value() <= -0.5); break; case expr::TT_TRUE: bvalue = true; break; case expr::TT_FALSE: bvalue = false; break; default: return STATUS_BAD_FORMAT; } if (t.get_token(expr::TF_GET) != expr::TT_EOF) return STATUS_BAD_FORMAT; break; } case JN_ARRAY: bvalue = pNode->pArray->size() > 0; break; case JN_OBJECT: bvalue = pNode->pObject->size() > 0; break; default: return STATUS_BAD_TYPE; } // Update node value node_t *node = clear_node(pNode); if (node == NULL) return STATUS_NO_MEM; pNode->type = JN_BOOL; pNode->bValue = bvalue; return STATUS_OK; } status_t Node::cast_to_string() { LSPString tmp; switch (type()) { case JN_NULL: break; case JN_INT: if (!tmp.fmt_ascii("%ld", long(pNode->nValue))) return STATUS_NO_MEM; break; case JN_DOUBLE: { SET_LOCALE_SCOPED(LC_NUMERIC, "C"); if (!tmp.fmt_ascii("%f", double(pNode->fValue))) return STATUS_NO_MEM; break; } case JN_BOOL: if (!tmp.set_ascii((pNode->bValue) ? "true" : "false")) return STATUS_NO_MEM; break; case JN_STRING: return STATUS_OK; case JN_ARRAY: return STATUS_BAD_TYPE; // TODO case JN_OBJECT: return STATUS_BAD_TYPE; // TODO default: return STATUS_BAD_TYPE; } LSPString *ns = tmp.release(); if (ns == NULL) return STATUS_NO_MEM; // Update node value node_t *node = clear_node(pNode); if (node == NULL) return STATUS_NO_MEM; pNode->type = JN_STRING; pNode->sValue = ns; return STATUS_OK; } status_t Node::cast_to_array() { lltl::parray *tmp; node_t *child; switch (type()) { case JN_ARRAY: return STATUS_OK; default: break; } // Create array and add new node to array child = new node_t; if (child == NULL) return STATUS_NO_MEM; tmp = new lltl::parray(); if (tmp == NULL) { delete child; return STATUS_NO_MEM; } if (!tmp->add(child)) { delete child; delete tmp; return STATUS_NO_MEM; } // Transfer data if (pNode != NULL) move_data(child, pNode); else { // Update node value node_t *node = clear_node(pNode); if (node == NULL) { delete child; delete tmp; return STATUS_NO_MEM; } pNode = node; } // Update node value pNode->type = JN_ARRAY; pNode->pArray = tmp; return STATUS_OK; } status_t Node::cast_to_object() { LSPString key; lltl::pphash *tmp; node_t *child; switch (type()) { case JN_ARRAY: return STATUS_OK; default: break; } // Create array and add new node to array child = new node_t; if (child == NULL) return STATUS_NO_MEM; tmp = new lltl::pphash(); if (tmp == NULL) { delete child; return STATUS_NO_MEM; } if (!tmp->create(&key, child)) { delete child; delete tmp; return STATUS_NO_MEM; } // Transfer data if (pNode != NULL) move_data(child, pNode); else { // Update node value node_t *node = clear_node(pNode); if (node == NULL) { delete child; delete tmp; return STATUS_NO_MEM; } pNode = node; } // Update node value pNode->type = JN_OBJECT; pNode->pObject = tmp; return STATUS_OK; } Integer Node::as_int() const { return Integer(this); } Double Node::as_double() const { return Double(this); } Boolean Node::as_bool() const { return Boolean(this); } String Node::as_string() const { return String(this); } Array Node::as_array() const { return Array(this); } Object Node::as_object() const { return Object(this); } const char *Node::stype() const { size_t type = (pNode == NULL) ? JN_NULL : pNode->type; switch (type) { case JN_NULL: return "NULL"; case JN_INT: return "INT"; case JN_DOUBLE: return "DOUBLE"; case JN_BOOL: return "BOOL"; case JN_STRING: return "STRING"; case JN_ARRAY: return "ARRAY"; case JN_OBJECT: return "OBJECT"; default: break; } return "UNKNOWN (corrupted)"; } } /* namespace json */ } /* namespace lsp */