/*
* Copyright (C) 2024 Linux Studio Plugins Project
* (C) 2024 Vladimir Sadovnikov
*
* This file is part of lsp-runtime-lib
* Created on: 17 окт. 2019 г.
*
* 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
#include
#include
#include
#include
#include
namespace lsp
{
namespace json
{
Serializer::Serializer()
{
pOut = NULL;
nWFlags = 0;
sState.mode = WRITE_ROOT;
sState.flags = 0;
sState.ident = 0;
init_serial_flags(&sSettings);
}
Serializer::~Serializer()
{
close();
}
status_t Serializer::open(const char *path, const serial_flags_t *settings, const char *charset)
{
if (pOut != NULL)
return STATUS_BAD_STATE;
else if (path == NULL)
return STATUS_BAD_ARGUMENTS;
io::OutFileStream *ofs = new io::OutFileStream();
if (ofs == NULL)
return STATUS_NO_MEM;
status_t res = ofs->open(path, io::File::FM_WRITE | io::File::FM_TRUNC | io::File::FM_CREATE);
if (res == STATUS_OK)
{
res = wrap(ofs, settings, WRAP_CLOSE | WRAP_DELETE, charset);
if (res == STATUS_OK)
return res;
ofs->close();
}
delete ofs;
return res;
}
status_t Serializer::open(const LSPString *path, const serial_flags_t *settings, const char *charset)
{
if (pOut != NULL)
return STATUS_BAD_STATE;
else if (path == NULL)
return STATUS_BAD_ARGUMENTS;
io::OutFileStream *ofs = new io::OutFileStream();
if (ofs == NULL)
return STATUS_NO_MEM;
status_t res = ofs->open(path, io::File::FM_WRITE | io::File::FM_TRUNC | io::File::FM_CREATE);
if (res == STATUS_OK)
{
res = wrap(ofs, settings, WRAP_CLOSE | WRAP_DELETE, charset);
if (res == STATUS_OK)
return res;
ofs->close();
}
delete ofs;
return res;
}
status_t Serializer::open(const io::Path *path, const serial_flags_t *settings, const char *charset)
{
if (pOut != NULL)
return STATUS_BAD_STATE;
else if (path == NULL)
return STATUS_BAD_ARGUMENTS;
io::OutFileStream *ofs = new io::OutFileStream();
if (ofs == NULL)
return STATUS_NO_MEM;
status_t res = ofs->open(path, io::File::FM_WRITE | io::File::FM_TRUNC | io::File::FM_CREATE);
if (res == STATUS_OK)
{
res = wrap(ofs, settings, WRAP_CLOSE | WRAP_DELETE, charset);
if (res == STATUS_OK)
return res;
ofs->close();
}
delete ofs;
return res;
}
void Serializer::copy_settings(const serial_flags_t *flags)
{
if (flags == NULL)
init_serial_flags(&sSettings);
else
sSettings = *flags;
}
status_t Serializer::wrap(LSPString *str, const serial_flags_t *settings)
{
if (pOut != NULL)
return STATUS_BAD_STATE;
else if (str == NULL)
return STATUS_BAD_ARGUMENTS;
io::OutStringSequence *seq = new io::OutStringSequence(str, false);
if (seq == NULL)
return STATUS_NO_MEM;
status_t res = wrap(seq, settings, WRAP_CLOSE | WRAP_DELETE);
if (res == STATUS_OK)
return res;
seq->close();
delete seq;
return res;
}
status_t Serializer::wrap(io::IOutStream *os, const serial_flags_t *settings, size_t flags, const char *charset)
{
if (pOut != NULL)
return STATUS_BAD_STATE;
else if (os == NULL)
return STATUS_BAD_ARGUMENTS;
io::OutSequence *seq = new io::OutSequence();
if (seq == NULL)
return STATUS_NO_MEM;
status_t res = seq->wrap(os, flags, charset);
if (res == STATUS_OK)
{
if ((res = wrap(seq, settings, WRAP_CLOSE | WRAP_DELETE)) == STATUS_OK)
return res;
seq->close();
}
delete seq;
return res;
}
status_t Serializer::wrap(io::IOutSequence *seq, const serial_flags_t *settings, size_t flags)
{
if (pOut != NULL)
return STATUS_BAD_STATE;
else if (seq == NULL)
return STATUS_BAD_ARGUMENTS;
pOut = seq;
nWFlags = flags;
sState.mode = WRITE_ROOT;
sState.flags = 0;
copy_settings(settings);
return STATUS_OK;
}
status_t Serializer::close()
{
status_t res = STATUS_OK;
// Close handles
if (pOut != NULL)
{
if (nWFlags & WRAP_CLOSE)
res = pOut->close();
if (nWFlags & WRAP_DELETE)
delete pOut;
pOut = NULL;
}
sStack.flush();
return res;
}
status_t Serializer::push_state(pmode_t mode)
{
if (!sStack.add(&sState))
return STATUS_NO_MEM;
sState.mode = mode;
sState.flags = 0;
sState.ident += sSettings.padding;
return STATUS_OK;
}
status_t Serializer::pop_state()
{
state_t *st = sStack.last();
if (st == NULL)
return STATUS_BAD_STATE;
sState = *st;
return (sStack.pop()) ? STATUS_OK : STATUS_BAD_STATE;
}
status_t Serializer::write_comma()
{
if (pOut == NULL)
return STATUS_BAD_STATE;
switch (sState.mode)
{
case WRITE_ROOT:
return STATUS_INVALID_VALUE;
case WRITE_ARRAY:
case WRITE_OBJECT:
if ((sState.flags & (SF_VALUE | SF_COMMA)) != SF_VALUE)
return STATUS_INVALID_VALUE;
break;
default:
return STATUS_BAD_STATE;
}
sState.flags |= SF_COMMA;
return pOut->write(',');
}
status_t Serializer::writeln()
{
if (!sSettings.multiline)
return STATUS_OK;
sState.flags &= ~SF_CONTENT;
status_t res = pOut->write('\n');
if (res != STATUS_OK)
return res;
for (size_t i=0, n=sState.ident; iwrite(sSettings.ident)) != STATUS_OK)
break;
}
return res;
}
char Serializer::hex(int x)
{
return ((x &= 0x0f) < 10) ? (x + '0') : (x + 'A' - 10);
}
status_t Serializer::write(const event_t *event)
{
if (event == NULL)
return STATUS_BAD_ARGUMENTS;
switch (event->type)
{
case JE_OBJECT_START: return start_object();
case JE_OBJECT_END: return end_object();
case JE_ARRAY_START: return start_array();
case JE_ARRAY_END: return end_array();
case JE_PROPERTY: return write_property(&event->sValue);
case JE_STRING: return write_string(&event->sValue);
case JE_INTEGER: return write_int(lsp::fixed_int(event->iValue));
case JE_DOUBLE: return write_double(event->fValue);
case JE_BOOL: return write_bool(event->bValue);
case JE_NULL: return write_null();
default: break;
}
return STATUS_BAD_ARGUMENTS;
}
status_t Serializer::emit_comma()
{
if ((sState.flags & (SF_VALUE | SF_COMMA)) != SF_VALUE)
return STATUS_OK;
sState.flags |= SF_CONTENT;
return pOut->write(',');
}
status_t Serializer::emit_separator()
{
if ((!sSettings.separator) || (!(sState.flags & SF_CONTENT)))
return STATUS_OK;
return pOut->write(' ');
}
status_t Serializer::write_raw(const char *buf, int len)
{
status_t res = STATUS_OK;
switch (sState.mode)
{
case WRITE_ROOT:
if (sState.flags & SF_VALUE)
return STATUS_INVALID_VALUE;
break;
case WRITE_ARRAY:
if ((res = emit_comma()) == STATUS_OK)
res = writeln();
break;
case WRITE_OBJECT:
if (!(sState.flags & SF_PROPERTY))
return STATUS_INVALID_VALUE;
sState.flags &= ~SF_PROPERTY;
break;
default:
return STATUS_BAD_STATE;
}
if (res == STATUS_OK)
res = emit_separator();
sState.flags &= ~SF_COMMA;
sState.flags |= SF_VALUE | SF_CONTENT;
return (res == STATUS_OK) ? pOut->write_ascii(buf, len) : res;
}
status_t Serializer::write_int(int32_t value)
{
if (pOut == NULL)
return STATUS_BAD_STATE;
char buf[0x20];
int len = ::snprintf(buf, sizeof(buf), "%ld", (long)value);
return (len < int(sizeof(buf))) ? write_raw(buf, len) : STATUS_OVERFLOW;
}
status_t Serializer::write_int(uint32_t value)
{
if (pOut == NULL)
return STATUS_BAD_STATE;
char buf[0x20];
int len = ::snprintf(buf, sizeof(buf), "%lu", (unsigned long)value);
return (len < int(sizeof(buf))) ? write_raw(buf, len) : STATUS_OVERFLOW;
}
status_t Serializer::write_int(int64_t value)
{
if (pOut == NULL)
return STATUS_BAD_STATE;
char buf[0x20];
int len = ::snprintf(buf, sizeof(buf), "%lld", (long long)value);
return (len < int(sizeof(buf))) ? write_raw(buf, len) : STATUS_OVERFLOW;
}
status_t Serializer::write_int(uint64_t value)
{
if (pOut == NULL)
return STATUS_BAD_STATE;
char buf[0x20];
int len = ::snprintf(buf, sizeof(buf), "%llu", (unsigned long long)value);
return (len < int(sizeof(buf))) ? write_raw(buf, len) : STATUS_OVERFLOW;
}
status_t Serializer::write_hex(int32_t value)
{
if (pOut == NULL)
return STATUS_BAD_STATE;
else if (sSettings.version < JSON_VERSION5)
return STATUS_INVALID_VALUE;
char buf[0x20];
int len = (value < 0) ?
::snprintf(buf, sizeof(buf), "-0x%lx", (long)(-value)) :
::snprintf(buf, sizeof(buf), "0x%lx", (long)value);
return (len < int(sizeof(buf))) ? write_raw(buf, len) : STATUS_OVERFLOW;
}
status_t Serializer::write_hex(uint32_t value)
{
if (pOut == NULL)
return STATUS_BAD_STATE;
else if (sSettings.version < JSON_VERSION5)
return STATUS_INVALID_VALUE;
char buf[0x20];
int len = ::snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)value);
return (len < int(sizeof(buf))) ? write_raw(buf, len) : STATUS_OVERFLOW;
}
status_t Serializer::write_hex(int64_t value)
{
if (pOut == NULL)
return STATUS_BAD_STATE;
else if (sSettings.version < JSON_VERSION5)
return STATUS_INVALID_VALUE;
char buf[0x20];
int len = (value < 0) ?
::snprintf(buf, sizeof(buf), "-0x%llx", (long long)(-value)) :
::snprintf(buf, sizeof(buf), "0x%llx", (long long)value);
return (len < int(sizeof(buf))) ? write_raw(buf, len) : STATUS_OVERFLOW;
}
status_t Serializer::write_hex(uint64_t value)
{
if (pOut == NULL)
return STATUS_BAD_STATE;
else if (sSettings.version < JSON_VERSION5)
return STATUS_INVALID_VALUE;
char buf[0x20];
int len = ::snprintf(buf, sizeof(buf), "0x%llx", (unsigned long long)value);
return (len < int(sizeof(buf))) ? write_raw(buf, len) : STATUS_OVERFLOW;
}
status_t Serializer::write_double(double value)
{
if (pOut == NULL)
return STATUS_BAD_STATE;
if (isnan(value))
return write_raw("NaN", 3);
else if (isinf(value))
return (value < 0.0) ? write_raw("-Infinity", 9) : write_raw("Infinity", 8);
char buf[0x20];
const char *fmt = (sSettings.fmt_double != NULL) ? sSettings.fmt_double : "%f";
int len = ::snprintf(buf, sizeof(buf), fmt, value);
return (len < int(sizeof(buf))) ? write_raw(buf, len) : STATUS_OVERFLOW;
}
status_t Serializer::write_double(double value, const char *fmt)
{
if (pOut == NULL)
return STATUS_BAD_STATE;
if (isnan(value))
return write_raw("NaN", 3);
else if (isinf(value))
return (value < 0.0) ? write_raw("-Infinity", 9) : write_raw("Infinity", 8);
SET_LOCALE_SCOPED(LC_NUMERIC, "C"); // For proper decimal point
char *buf = NULL;
int len = asprintf(&buf, fmt, value);
if (buf == NULL)
return STATUS_NO_MEM;
status_t res = (len >= 0) ? write_raw(buf, len) : STATUS_NO_DATA;
::free(buf);
return res;
}
status_t Serializer::write_bool(bool value)
{
if (pOut == NULL)
return STATUS_BAD_STATE;
return (value) ? write_raw("true", 4) : write_raw("false", 5);
}
status_t Serializer::write_null()
{
if (pOut == NULL)
return STATUS_BAD_STATE;
return write_raw("null", 4);
}
status_t Serializer::write_string(const char *value, const char *charset)
{
if (value == NULL)
return write_null();
LSPString tmp;
return (tmp.set_native(value, charset)) ? write_string(&tmp) : STATUS_NO_MEM;
}
status_t Serializer::write_string(const char *value)
{
if (value == NULL)
return write_null();
LSPString tmp;
return (tmp.set_utf8(value)) ? write_string(&tmp) : STATUS_NO_MEM;
}
status_t Serializer::write_string(const LSPString *value)
{
if (value == NULL)
return write_null();
else if (pOut == NULL)
return STATUS_BAD_STATE;
// Analyze state
status_t res = STATUS_OK;
switch (sState.mode)
{
case WRITE_ROOT:
if (sState.flags & SF_VALUE)
return STATUS_INVALID_VALUE;
break;
case WRITE_ARRAY:
if ((res = emit_comma()) == STATUS_OK)
res = writeln();
break;
case WRITE_OBJECT:
if (!(sState.flags & SF_PROPERTY))
return STATUS_INVALID_VALUE;
sState.flags &= ~SF_PROPERTY;
break;
default:
return STATUS_BAD_STATE;
}
if (res == STATUS_OK)
res = emit_separator();
sState.flags &= ~SF_COMMA;
sState.flags |= SF_VALUE | SF_CONTENT;
return (res == STATUS_OK) ? write_literal(value) : res;
}
status_t Serializer::write_literal(const LSPString *value)
{
status_t res;
size_t last = 0, curr = 0, bl = 1;
char xb[0x10];
xb[0] = '\\';
// Output start quote
sState.flags |= SF_CONTENT;
if ((res = pOut->write('\"')) != STATUS_OK)
return res;
for (size_t n=value->length(); currchar_at(curr);
// Check that we need to escape character
switch (ch)
{
case '\0': xb[bl++] = '0'; break;
case '\b': xb[bl++] = 'b'; break;
case '\f': xb[bl++] = 'f'; break;
case '\r': xb[bl++] = 'r'; break;
case '\t': xb[bl++] = 't'; break;
case '\v': xb[bl++] = 'v'; break;
case '\n': xb[bl++] = 'n'; break;
case '\\': xb[bl++] = '\\'; break;
case '\"': xb[bl++] = '\"'; break;
default:
if (ch < 0x20)
{
xb[1] = 'u';
xb[2] = '0';
xb[3] = '0';
xb[4] = hex(ch >> 4);
xb[5] = hex(ch);
bl = 6;
}
else if (ch >= 0x10000)
{
ch -= 0x10000;
lsp_wchar_t hi = 0xd800 | (ch >> 10);
lsp_wchar_t lo = 0xdc00 | (ch & 0x3ff);
xb[1] = 'u';
xb[2] = hex(hi >> 12);
xb[3] = hex(hi >> 8);
xb[4] = hex(hi >> 4);
xb[5] = hex(hi);
xb[6] = '\\';
xb[7] = 'u';
xb[8] = hex(lo >> 12);
xb[9] = hex(lo >> 8);
xb[10] = hex(lo >> 4);
xb[11] = hex(lo);
bl = 12;
}
break;
}
// Is there extra escape sequence?
if (bl > 1)
{
// Write string directly to output
if (last < curr)
{
if ((res = pOut->write(value, last, curr)) != STATUS_OK)
return res;
}
// Append escape sequence and reset extra buffer size
if ((res = pOut->write_ascii(xb, bl)) != STATUS_OK)
return res;
last = curr+1; // Put buffer pointer to the next character
bl = 1;
}
}
// Need to emit extra data?
if (last < curr)
{
if ((res = pOut->write(value, last, curr)) != STATUS_OK)
return res;
}
// Output end quote
return pOut->write('\"');
}
status_t Serializer::write_comment(const char *value, const char *charset)
{
if (value == NULL)
return STATUS_BAD_ARGUMENTS;
LSPString tmp;
return (tmp.set_native(value, charset)) ? write_comment(&tmp) : STATUS_NO_MEM;
}
status_t Serializer::write_comment(const char *value)
{
if (value == NULL)
return STATUS_BAD_ARGUMENTS;
LSPString tmp;
return (tmp.set_utf8(value)) ? write_comment(&tmp) : STATUS_NO_MEM;
}
status_t Serializer::write_comment(const LSPString *value)
{
if (pOut == NULL)
return STATUS_BAD_STATE;
else if (value == NULL)
return STATUS_BAD_ARGUMENTS;
else if (sSettings.version < JSON_VERSION5)
return STATUS_INVALID_VALUE;
// Comment can be placed everywhere, we don't need to analyze state
status_t res;
lsp_swchar_t prev = -1;
size_t last = 0, curr = 0, bl = 4;
char xb[0x10];
xb[0] = '\\';
xb[1] = 'u';
xb[2] = '0';
xb[3] = '0';
// Output start quote
if ((res = emit_separator()) != STATUS_OK)
return res;
sState.flags |= SF_CONTENT;
if ((res = pOut->write_ascii("/*", 2)) != STATUS_OK)
return res;
for (size_t n=value->length(); currchar_at(curr);
switch (ch)
{
case '\n':
case '\r':
if (sSettings.multiline)
break;
xb[bl++] = hex(ch >> 4);
xb[bl++] = hex(ch);
break;
case '/':
if (prev != '*')
break;
// Asterisk code in unicode
xb[bl++] = '2';
xb[bl++] = 'F';
break;
case '*':
if (prev != '/')
break;
// Asterisk code in unicode
xb[bl++] = '2';
xb[bl++] = 'A';
break;
default:
if (ch < 0x20)
{
xb[bl++] = hex(ch >> 4);
xb[bl++] = hex(ch);
}
break;
}
// Is there extra escape sequence?
if (bl > 4)
{
// Write string directly to output
if (last < curr)
{
if ((res = pOut->write(value, last, curr)) != STATUS_OK)
return res;
}
// Append escape sequence and reset extra buffer size
if ((res = pOut->write_ascii(xb, bl)) != STATUS_OK)
return res;
last = curr+1; // Put buffer pointer to the next character
bl = 4;
}
// Store previous character
prev = ch;
}
// Need to emit extra data?
if (last < curr)
{
if ((res = pOut->write(value, last, curr)) != STATUS_OK)
return res;
}
// Output end quote
return pOut->write_ascii("*/", 2);
}
status_t Serializer::write_property(const char *name, const char *charset)
{
if (name == NULL)
return STATUS_BAD_ARGUMENTS;
LSPString tmp;
return (tmp.set_native(name, charset)) ? write_property(&tmp) : STATUS_NO_MEM;
}
status_t Serializer::write_property(const char *name)
{
if (name == NULL)
return STATUS_BAD_ARGUMENTS;
LSPString tmp;
return (tmp.set_utf8(name)) ? write_property(&tmp) : STATUS_NO_MEM;
}
status_t Serializer::write_property(const LSPString *name)
{
if (name == NULL)
return STATUS_BAD_ARGUMENTS;
else if (pOut == NULL)
return STATUS_BAD_STATE;
status_t res;
switch (sState.mode)
{
case WRITE_OBJECT:
if (sState.flags & SF_PROPERTY)
return STATUS_INVALID_VALUE;
if ((res = emit_comma()) == STATUS_OK)
res = writeln();
if (res != STATUS_OK)
return res;
break;
default:
return STATUS_BAD_STATE;
}
sState.flags &= ~SF_COMMA;
sState.flags |= SF_PROPERTY | SF_CONTENT;
// Do we need to prefer identifiers instead of property name?
if ((sSettings.identifiers) && (sSettings.version >= JSON_VERSION5))
res = (Tokenizer::is_valid_identifier(name)) ? pOut->write(name) : write_literal(name);
else
res = write_literal(name);
// Write queued comment, colon and spacing
return (res == STATUS_OK) ? pOut->write(':') : res;
}
status_t Serializer::start_object()
{
if (pOut == NULL)
return STATUS_BAD_STATE;
status_t res = STATUS_OK;
switch (sState.mode)
{
case WRITE_ROOT:
if (sState.flags & SF_VALUE)
return STATUS_INVALID_VALUE;
break;
case WRITE_ARRAY:
if ((res = emit_comma()) == STATUS_OK)
res = writeln();
break;
case WRITE_OBJECT:
if (!(sState.flags & SF_PROPERTY))
return STATUS_INVALID_VALUE;
sState.flags &= ~SF_PROPERTY;
break;
default:
return STATUS_BAD_STATE;
}
if (res == STATUS_OK)
res = emit_separator();
sState.flags |= SF_VALUE | SF_CONTENT;
if (res == STATUS_OK)
res = pOut->write('{');
return (res == STATUS_OK) ? push_state(WRITE_OBJECT) : res;
}
status_t Serializer::end_object()
{
if ((pOut == NULL) || (sState.mode != WRITE_OBJECT) || (sState.flags & SF_PROPERTY))
return STATUS_BAD_STATE;
else if ((sState.flags & SF_COMMA) && (sSettings.version < JSON_VERSION5))
return STATUS_INVALID_VALUE;
bool data = sState.flags & SF_VALUE;
status_t res = pop_state();
if ((res == STATUS_OK) && (data))
res = writeln();
sState.flags &= ~SF_COMMA;
sState.flags |= SF_CONTENT;
return (res == STATUS_OK) ? pOut->write('}') : res;
}
status_t Serializer::start_array()
{
if (pOut == NULL)
return STATUS_BAD_STATE;
status_t res = STATUS_OK;
switch (sState.mode)
{
case WRITE_ROOT:
if (sState.flags & SF_VALUE)
return STATUS_INVALID_VALUE;
break;
case WRITE_ARRAY:
if ((res = emit_comma()) == STATUS_OK)
res = writeln();
break;
case WRITE_OBJECT:
if (!(sState.flags & SF_PROPERTY))
return STATUS_INVALID_VALUE;
sState.flags &= ~SF_PROPERTY;
break;
default:
return STATUS_BAD_STATE;
}
if (res == STATUS_OK)
res = emit_separator();
sState.flags |= SF_VALUE | SF_CONTENT;
if (res == STATUS_OK)
res = pOut->write('[');
return (res == STATUS_OK) ? push_state(WRITE_ARRAY) : res;
}
status_t Serializer::end_array()
{
if ((pOut == NULL) || (sState.mode != WRITE_ARRAY))
return STATUS_BAD_STATE;
else if ((sState.flags & SF_COMMA) && (sSettings.version < JSON_VERSION5))
return STATUS_INVALID_VALUE;
bool data = sState.flags & SF_VALUE;
status_t res = pop_state();
if ((res == STATUS_OK) && (data))
res = writeln();
sState.flags &= ~SF_COMMA;
sState.flags |= SF_CONTENT;
return (res == STATUS_OK) ? pOut->write(']') : res;
}
status_t Serializer::prop_int(const char *key, int32_t value)
{
status_t res = write_property(key);
return (res == STATUS_OK) ? write_int(value) : res;
}
status_t Serializer::prop_int(const LSPString *key, int32_t value)
{
status_t res = write_property(key);
return (res == STATUS_OK) ? write_int(value) : res;
}
status_t Serializer::prop_int(const char *key, uint32_t value)
{
status_t res = write_property(key);
return (res == STATUS_OK) ? write_int(value) : res;
}
status_t Serializer::prop_int(const LSPString *key, uint32_t value)
{
status_t res = write_property(key);
return (res == STATUS_OK) ? write_int(value) : res;
}
status_t Serializer::prop_int(const char *key, int64_t value)
{
status_t res = write_property(key);
return (res == STATUS_OK) ? write_int(value) : res;
}
status_t Serializer::prop_int(const LSPString *key, int64_t value)
{
status_t res = write_property(key);
return (res == STATUS_OK) ? write_int(value) : res;
}
status_t Serializer::prop_int(const char *key, uint64_t value)
{
status_t res = write_property(key);
return (res == STATUS_OK) ? write_int(value) : res;
}
status_t Serializer::prop_int(const LSPString *key, uint64_t value)
{
status_t res = write_property(key);
return (res == STATUS_OK) ? write_int(value) : res;
}
status_t Serializer::prop_hex(const char *key, int32_t value)
{
status_t res = write_property(key);
return (res == STATUS_OK) ? write_hex(value) : res;
}
status_t Serializer::prop_hex(const LSPString *key, int32_t value)
{
status_t res = write_property(key);
return (res == STATUS_OK) ? write_hex(value) : res;
}
status_t Serializer::prop_hex(const char *key, uint32_t value)
{
status_t res = write_property(key);
return (res == STATUS_OK) ? write_hex(value) : res;
}
status_t Serializer::prop_hex(const LSPString *key, uint32_t value)
{
status_t res = write_property(key);
return (res == STATUS_OK) ? write_hex(value) : res;
}
status_t Serializer::prop_hex(const char *key, int64_t value)
{
status_t res = write_property(key);
return (res == STATUS_OK) ? write_hex(value) : res;
}
status_t Serializer::prop_hex(const LSPString *key, int64_t value)
{
status_t res = write_property(key);
return (res == STATUS_OK) ? write_hex(value) : res;
}
status_t Serializer::prop_hex(const char *key, uint64_t value)
{
status_t res = write_property(key);
return (res == STATUS_OK) ? write_hex(value) : res;
}
status_t Serializer::prop_hex(const LSPString *key, uint64_t value)
{
status_t res = write_property(key);
return (res == STATUS_OK) ? write_hex(value) : res;
}
status_t Serializer::prop_double(const char *key, double value)
{
status_t res = write_property(key);
return (res == STATUS_OK) ? write_double(value) : res;
}
status_t Serializer::prop_double(const LSPString *key, double value)
{
status_t res = write_property(key);
return (res == STATUS_OK) ? write_double(value) : res;
}
status_t Serializer::prop_double(const char *key, double value, const char *fmt)
{
status_t res = write_property(key);
return (res == STATUS_OK) ? write_double(value, fmt) : res;
}
status_t Serializer::prop_double(const LSPString *key, double value, const char *fmt)
{
status_t res = write_property(key);
return (res == STATUS_OK) ? write_double(value, fmt) : res;
}
status_t Serializer::prop_bool(const char *key, bool value)
{
status_t res = write_property(key);
return (res == STATUS_OK) ? write_bool(value) : res;
}
status_t Serializer::prop_bool(const LSPString *key, bool value)
{
status_t res = write_property(key);
return (res == STATUS_OK) ? write_bool(value) : res;
}
status_t Serializer::prop_string(const char *key, const char *value)
{
status_t res = write_property(key);
return (res == STATUS_OK) ? write_string(value) : res;
}
status_t Serializer::prop_string(const char *key, const LSPString *value)
{
status_t res = write_property(key);
return (res == STATUS_OK) ? write_string(value) : res;
}
status_t Serializer::prop_string(const LSPString *key, const char *value)
{
status_t res = write_property(key);
return (res == STATUS_OK) ? write_string(value) : res;
}
status_t Serializer::prop_string(const LSPString *key, const LSPString *value)
{
status_t res = write_property(key);
return (res == STATUS_OK) ? write_string(value) : res;
}
status_t Serializer::prop_null(const char *key)
{
status_t res = write_property(key);
return (res == STATUS_OK) ? write_null() : res;
}
status_t Serializer::prop_null(const LSPString *key)
{
status_t res = write_property(key);
return (res == STATUS_OK) ? write_null() : res;
}
} /* namespace json */
} /* namespace lsp */