void JsonSerializer::deserializeArrayBegin(const char* label)
{
deserializeLabel(label);
expectToken('[');
m_is_first_in_block = true;
deserializeToken();
}
void JsonSerializer::deserializeRawString(char* buffer, int max_length)
{
int size = Math::minValue(max_length - 1, m_token_size);
memcpy(buffer, m_token, size);
buffer[size] = '\0';
deserializeToken();
}
JsonSerializer::JsonSerializer(FS::IFile& file,
AccessMode access_mode,
const Path& path,
IAllocator& allocator)
: m_file(file)
, m_access_mode(access_mode)
, m_allocator(allocator)
{
m_is_error = false;
copyString(m_path, path.c_str());
m_is_first_in_block = true;
m_data = nullptr;
m_is_string_token = false;
if (m_access_mode == READ)
{
m_data_size = (int)file.size();
if (file.getBuffer() != nullptr)
{
m_data = (const char*)file.getBuffer();
m_own_data = false;
}
else
{
int size = (int)m_file.size();
char* data = (char*)m_allocator.allocate(size);
m_own_data = true;
file.read(data, m_data_size);
m_data = data;
}
m_token = m_data;
m_token_size = 0;
deserializeToken();
}
}
void JsonSerializer::deserializeRawString(char* buffer, int max_length)
{
int size = Math::minimum(max_length - 1, m_token_size);
copyMemory(buffer, m_token, size);
buffer[size] = '\0';
deserializeToken();
}
void JsonSerializer::deserialize(bool& value, bool default_value)
{
value = !m_is_string_token
? m_token_size == 4 && (strncmp(m_token, "true", 4) == 0)
: default_value;
deserializeToken();
}
void JsonSerializer::nextArrayItem()
{
if (!m_is_first_in_block)
{
expectToken(',');
deserializeToken();
}
}
void JsonSerializer::deserialize(int32& value, int32 default_value)
{
if (m_is_string_token || !fromCString(m_token, m_token_size, &value))
{
value = default_value;
}
deserializeToken();
}
void JsonSerializer::deserialize(const char* label, int32& value, int32 default_value)
{
deserializeLabel(label);
if (m_is_string_token || !fromCString(m_token, m_token_size, &value))
{
value = default_value;
}
deserializeToken();
}
void JsonSerializer::deserializeArrayItem(int64& value, int64 default_value)
{
deserializeArrayComma();
if (m_is_string_token || !fromCString(m_token, m_token_size, &value))
{
value = default_value;
}
deserializeToken();
}
void JsonSerializer::deserializeArrayItem(char* value, int max_length, const char* default_value)
{
deserializeArrayComma();
if (m_is_string_token)
{
int size = Math::minimum(max_length - 1, m_token_size);
copyMemory(value, m_token, size);
value[size] = '\0';
deserializeToken();
}
else
{
ErrorProxy(*this).log() << "Unexpected token \""
<< string(m_token, m_token_size, m_allocator)
<< "\", expected string.";
deserializeToken();
copyString(value, max_length, default_value);
}
}
void JsonSerializer::deserialize(float& value, float default_value)
{
if (!m_is_string_token)
{
value = tokenToFloat();
}
else
{
value = default_value;
}
deserializeToken();
}
xsd__Name Name::deserializeName(const AxisChar* valueAsChar) throw (AxisSoapException)
{
#ifdef ENABLE_AXISTRACE
if (axiscpp::AxisTrace::isTraceOn())
axiscpp::AxisTrace::traceEntry("Name", "deserializeName", this, 1,
TRACETYPE_STRING, 0, ((void*)&valueAsChar)); /* AUTOINSERTED TRACE */
#endif
{
#ifdef ENABLE_AXISTRACE
xsd__Name traceRet = ((AxisChar*) deserializeToken(valueAsChar));
if (axiscpp::AxisTrace::isTraceOn())
axiscpp::AxisTrace::traceExit("Name", "deserializeName", this, 0,
TRACETYPE_DATA, sizeof(xsd__Name), ((void*)&traceRet)); /* AUTOINSERTED TRACE */
return traceRet;
#else
return (AxisChar*) deserializeToken(valueAsChar);
#endif
}
}
void JsonSerializer::deserializeLabel(const char* label)
{
if (!m_is_first_in_block)
{
expectToken(',');
deserializeToken();
}
else
{
m_is_first_in_block = false;
}
if (!m_is_string_token)
{
ErrorProxy(*this).log() << "Unexpected token \""
<< string(m_token, m_token_size, m_allocator)
<< "\", expected string.";
deserializeToken();
}
if (compareStringN(label, m_token, m_token_size) != 0)
{
ErrorProxy(*this).log() << "Unexpected label \""
<< string(m_token, m_token_size, m_allocator) << "\", expected \""
<< label << "\".";
deserializeToken();
}
deserializeToken();
if (m_is_string_token || m_token_size != 1 || m_token[0] != ':')
{
ErrorProxy(*this).log() << "Unexpected label \""
<< string(m_token, m_token_size, m_allocator) << "\", expected \""
<< label << "\".";
deserializeToken();
}
deserializeToken();
}
void JsonSerializer::deserializeArrayComma()
{
if (m_is_first_in_block)
{
m_is_first_in_block = false;
}
else
{
expectToken(',');
deserializeToken();
}
}
void JsonSerializer::deserializeArrayItem(bool& value, bool default_value)
{
deserializeArrayComma();
if (m_is_string_token)
{
value = default_value;
}
else
{
value = m_token_size == 4 && compareStringN("true", m_token, m_token_size) == 0;
}
deserializeToken();
}
void JsonSerializer::deserialize(const char* label, bool& value, bool default_value)
{
deserializeLabel(label);
if (!m_is_string_token)
{
value = m_token_size == 4 && compareStringN("true", m_token, 4) == 0;
}
else
{
value = default_value;
}
deserializeToken();
}
void JsonSerializer::deserialize(const char* label, float& value, float default_value)
{
deserializeLabel(label);
if (!m_is_string_token)
{
value = tokenToFloat();
deserializeToken();
}
else
{
value = default_value;
}
}
void JsonSerializer::deserializeArrayItem(float& value, float default_value)
{
deserializeArrayComma();
if (m_is_string_token)
{
value = default_value;
}
else
{
value = tokenToFloat();
}
deserializeToken();
}
void JsonSerializer::expectToken(char expected_token)
{
if (m_is_string_token || m_token_size != 1 || m_token[0] != expected_token)
{
char tmp[2];
tmp[0] = expected_token;
tmp[1] = 0;
ErrorProxy(*this).log() << "Unexpected token \""
<< string(m_token, m_token_size, m_allocator) << "\", expected "
<< tmp << ".";
deserializeToken();
}
}
void JsonSerializer::deserializeLabel(char* label, int max_length)
{
if (!m_is_first_in_block)
{
expectToken(',');
deserializeToken();
}
else
{
m_is_first_in_block = false;
}
if (!m_is_string_token)
{
ErrorProxy(*this).log() << "Unexpected token \""
<< string(m_token, m_token_size, m_allocator)
<< "\", expected string.";
deserializeToken();
}
copyNString(label, max_length, m_token, m_token_size);
deserializeToken();
expectToken(':');
deserializeToken();
}
void JsonSerializer::deserialize(char* value, int max_length, const char* default_value)
{
if (!m_is_string_token)
{
copyString(value, max_length, default_value);
}
else
{
int size = Math::minimum(max_length - 1, m_token_size);
copyMemory(value, m_token, size);
value[size] = '\0';
deserializeToken();
}
}
void JsonSerializer::deserialize(Path& value, const Path& default_value)
{
if (!m_is_string_token)
{
value = default_value;
}
else
{
char tmp[MAX_PATH_LENGTH];
int size = Math::minimum(lengthOf(tmp) - 1, m_token_size);
copyMemory(tmp, m_token, size);
tmp[size] = '\0';
value = tmp;
deserializeToken();
}
}
void JsonSerializer::deserialize(const char* label,
char* value,
int max_length,
const char* default_value)
{
deserializeLabel(label);
if (!m_is_string_token)
{
copyString(value, max_length, default_value);
}
else
{
int size = Math::minValue(max_length - 1, m_token_size);
memcpy(value, m_token, size);
value[size] = '\0';
deserializeToken();
}
}
void JsonSerializer::deserializeArrayBegin()
{
expectToken('[');
m_is_first_in_block = true;
deserializeToken();
}
void JsonSerializer::deserializeObjectEnd()
{
expectToken('}');
m_is_first_in_block = false;
deserializeToken();
}
void JsonSerializer::deserializeObjectBegin()
{
m_is_first_in_block = true;
expectToken('{');
deserializeToken();
}
void JsonSerializer::deserializeArrayEnd()
{
expectToken(']');
m_is_first_in_block = false;
deserializeToken();
}
