902 lines
31 KiB
C++
902 lines
31 KiB
C++
#include "TessesFramework/Serialization/Json.hpp"
|
|
#include "TessesFramework/Http/HttpUtils.hpp"
|
|
#include <functional>
|
|
|
|
#include "TessesFramework/Common.hpp"
|
|
using namespace Tesses::Framework::Http;
|
|
namespace Tesses::Framework::Serialization::Json
|
|
{
|
|
void JObject::Remove(std::string key)
|
|
{
|
|
map.erase(key);
|
|
}
|
|
void JObject::SetValue(std::string key, JToken item)
|
|
{
|
|
if(!std::holds_alternative<JUndefined>(item))
|
|
map[key] = item;
|
|
else
|
|
Remove(key);
|
|
}
|
|
JToken JObject::GetValue(std::string key)
|
|
{
|
|
if(map.count(key)>0)
|
|
return map[key];
|
|
else
|
|
return JUndefined();
|
|
}
|
|
std::map<std::string,JToken>& JObject::GetMap()
|
|
{
|
|
return map;
|
|
}
|
|
std::map<std::string,JToken>::iterator JObject::begin()
|
|
{
|
|
return map.begin();
|
|
}
|
|
std::map<std::string,JToken>::iterator JObject::end()
|
|
{
|
|
return map.end();
|
|
}
|
|
JArray::JArray()
|
|
{
|
|
|
|
}
|
|
JArray::JArray(std::initializer_list<JToken> tokens)
|
|
{
|
|
this->items = tokens;
|
|
}
|
|
std::vector<JToken>& JArray::GetVector()
|
|
{
|
|
return items;
|
|
}
|
|
void JArray::Add(JToken item)
|
|
{
|
|
if(!std::holds_alternative<JUndefined>(item))
|
|
items.push_back(item);
|
|
}
|
|
void JArray::RemoveAt(size_t index)
|
|
{
|
|
if(index < items.size())
|
|
items.erase(items.begin()+index);
|
|
}
|
|
size_t JArray::Count()
|
|
{
|
|
return items.size();
|
|
}
|
|
void JArray::SetAt(size_t index, JToken item)
|
|
{
|
|
if(index < items.size() && !std::holds_alternative<JUndefined>(item))
|
|
items[index] = item;
|
|
}
|
|
JToken JArray::GetAt(size_t index)
|
|
{
|
|
if(index < items.size())
|
|
return items.at(index);
|
|
return JUndefined();
|
|
}
|
|
void JArray::Clear()
|
|
{
|
|
items.clear();
|
|
}
|
|
|
|
std::vector<JToken>::iterator JArray::begin()
|
|
{
|
|
return items.begin();
|
|
}
|
|
std::vector<JToken>::iterator JArray::end()
|
|
{
|
|
return items.end();
|
|
}
|
|
JOItem::JOItem()
|
|
{
|
|
|
|
}
|
|
JOItem::JOItem(std::string key, JToken value)
|
|
{
|
|
this->key = key;
|
|
this->value = value;
|
|
}
|
|
|
|
JObject::JObject()
|
|
{
|
|
|
|
}
|
|
JObject::JObject(std::initializer_list<JOItem> items)
|
|
{
|
|
for(auto item : items)
|
|
this->map[item.key] = item.value;
|
|
}
|
|
|
|
std::string Json::tab(std::string txt)
|
|
{
|
|
std::string newStr="\t";
|
|
for(auto item : txt)
|
|
{
|
|
if(item == '\n')
|
|
{
|
|
newStr.append("\n\t");
|
|
}
|
|
else
|
|
{
|
|
newStr.push_back(item);
|
|
}
|
|
}
|
|
return newStr;
|
|
}
|
|
|
|
JToken Json::Decode(std::string str)
|
|
{
|
|
std::vector<std::pair<std::string,bool>> tokens;
|
|
|
|
std::string buff={};
|
|
|
|
std::function<void()> flush = [&buff,&tokens]()->void {
|
|
if(!buff.empty())
|
|
{
|
|
tokens.push_back(std::pair<std::string,bool>(buff,false));
|
|
buff={};
|
|
}
|
|
};
|
|
|
|
for(size_t i = 0; i < str.size(); i++)
|
|
{
|
|
switch(str[i])
|
|
{
|
|
case '\"':
|
|
{
|
|
flush();
|
|
i++;
|
|
std::string str2={};
|
|
for(; i < str.size() && str[i] != '\"'; i++)
|
|
{
|
|
if(str[i] == '\\')
|
|
{
|
|
i++;
|
|
if(i < str.size())
|
|
{
|
|
if(str[i] == 'n')
|
|
{
|
|
str2.push_back('\n');
|
|
}
|
|
else if(str[i] == 'r')
|
|
{
|
|
str2.push_back('\r');
|
|
}
|
|
else if(str[i] == 't')
|
|
{
|
|
str2.push_back('\t');
|
|
}
|
|
else if(str[i] == 'f')
|
|
{
|
|
str2.push_back('\f');
|
|
}
|
|
else if(str[i] == 'b')
|
|
{
|
|
str2.push_back('\b');
|
|
}
|
|
else if(str[i] == 'u')
|
|
{
|
|
i++;
|
|
//we need to get four of these
|
|
uint16_t v = 0;
|
|
if(i + 4 <= str.size())
|
|
{
|
|
for(size_t i2 = 0; i2 < 4; i2++,i++)
|
|
{
|
|
v |= HttpUtils::HexToNibble(str[i]) << ((3-i2) * 4);
|
|
}
|
|
|
|
|
|
uint32_t v2 = v;
|
|
|
|
if((v & 0xFC00) == 0xD800)
|
|
{
|
|
|
|
v2 = (v & 0x03FF) << 10;
|
|
if(i + 6 <= str.size() && str.substr(i,2) == "\\u")
|
|
{
|
|
i+=2;
|
|
v=0;
|
|
|
|
for(size_t i2 = 0; i2 < 4; i2++, i++)
|
|
{
|
|
v |= HttpUtils::HexToNibble(str[i]) << ((3-i2) * 4);
|
|
}
|
|
if((v & 0xFC00) != 0xDC00)
|
|
{
|
|
throw std::runtime_error("Not a lower utf-16 surrogate pair.");
|
|
}
|
|
|
|
|
|
v2 |= (v & 0x03FF);
|
|
|
|
v2 += 0x10000;
|
|
}
|
|
else
|
|
{
|
|
|
|
throw std::runtime_error("Could not read lower utf-16 surrogate pair.");
|
|
}
|
|
if(v2 <= 0x7F)
|
|
{
|
|
str2.push_back((char)v2);
|
|
}
|
|
else if(v2 >= 0x80 && v2 <= 0x7FF)
|
|
{
|
|
uint8_t high = 0b11000000 | ((v2 >> 6) & 0b00011111);
|
|
uint8_t low = 0b10000000 | (v2 & 0b00111111);
|
|
str2.push_back((char)high);
|
|
str2.push_back((char)low);
|
|
}
|
|
else if(v2 >= 0x800 && v2 <= 0xFFFF)
|
|
{
|
|
uint8_t highest = 0b11100000 | ((v2 >> 12) & 0b00001111);
|
|
uint8_t high = 0b10000000 | ((v2 >> 6) & 0b00111111);
|
|
uint8_t low = 0b10000000 | (v2 & 0b00111111);
|
|
str2.push_back((char)highest);
|
|
str2.push_back((char)high);
|
|
str2.push_back((char)low);
|
|
}
|
|
else if(v2 >= 0x010000 && v2 <= 0x10FFFF)
|
|
{
|
|
uint8_t highest = 0b11110000 | ((v2 >> 18) & 0b00000111);
|
|
uint8_t high = 0b10000000 | ((v2 >> 12) & 0b00111111);
|
|
uint8_t low = 0b10000000 | ((v2 >> 6) & 0b00111111);
|
|
uint8_t lowest = 0b10000000 | (v2 & 0b00111111);
|
|
str2.push_back((char)highest);
|
|
str2.push_back((char)high);
|
|
str2.push_back((char)low);
|
|
str2.push_back((char)lowest);
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
str2.push_back(str[i]);
|
|
}
|
|
}
|
|
else break;
|
|
}
|
|
else
|
|
{
|
|
str2.push_back(str[i]);
|
|
}
|
|
}
|
|
tokens.push_back(std::pair<std::string,bool>(str2,true));
|
|
}
|
|
break;
|
|
case ',':
|
|
case '[':
|
|
case ']':
|
|
case '(':
|
|
case ')':
|
|
case '{':
|
|
case '}':
|
|
case ':':
|
|
flush();
|
|
tokens.push_back(std::pair<std::string,bool>(str.substr(i,1),false));
|
|
break;
|
|
case ' ':
|
|
case '\n':
|
|
case '\r':
|
|
case '\t':
|
|
flush();
|
|
break;
|
|
default:
|
|
buff.push_back(str[i]);
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
flush();
|
|
if(tokens.size() == 0) return JUndefined();
|
|
|
|
size_t tokenIndex=0;
|
|
|
|
std::function<std::pair<std::string,bool>()> pop_token=[&tokens,&tokenIndex]()->std::pair<std::string,bool> {
|
|
if(tokenIndex >= tokens.size()) throw std::runtime_error("Json tokens out of bounds.");
|
|
return tokens[tokenIndex++];
|
|
};
|
|
|
|
std::function<JToken()> read_token;
|
|
read_token= [&pop_token,&read_token,&tokenIndex,&tokens]()->JToken{
|
|
auto tkn = pop_token();
|
|
if(tkn.second)
|
|
{
|
|
return tkn.first;
|
|
}
|
|
else
|
|
{
|
|
if(tkn.first == "{")
|
|
{
|
|
|
|
JObject obj;
|
|
while(true)
|
|
{
|
|
begin_dict:
|
|
tkn = pop_token();
|
|
if(tkn.second)
|
|
{
|
|
std::string key = tkn.first;
|
|
tkn = pop_token();
|
|
if(tkn.second || tkn.first != ":")
|
|
{
|
|
throw std::runtime_error("Invalid JSON key value seperator.");
|
|
}
|
|
|
|
auto value = read_token();
|
|
obj.SetValue(key,value);
|
|
}
|
|
else if(tkn.first == ",")
|
|
{
|
|
goto begin_dict;
|
|
}
|
|
else if(tkn.first == "}")
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
|
|
throw std::runtime_error("Invalid JSON object.");
|
|
}
|
|
}
|
|
return obj;
|
|
}
|
|
else if(tkn.first == "[")
|
|
{
|
|
JArray arr;
|
|
while(tokenIndex < tokens.size())
|
|
{
|
|
auto tkn = tokens[tokenIndex];
|
|
if(!tkn.second)
|
|
{
|
|
if(tkn.first == ",") tokenIndex++;
|
|
if(tkn.first == "]") {tokenIndex++; break;}
|
|
}
|
|
arr.Add(read_token());
|
|
}
|
|
return arr;
|
|
}
|
|
else if(tkn.first == "true")
|
|
{
|
|
return true;
|
|
}
|
|
else if(tkn.first == "false")
|
|
{
|
|
return false;
|
|
}
|
|
else if(tkn.first == "null")
|
|
{
|
|
return nullptr;
|
|
}
|
|
else {
|
|
//number
|
|
if(tkn.first.find(".") != std::string::npos)
|
|
{
|
|
return std::stod(tkn.first);
|
|
}
|
|
else
|
|
{
|
|
return (int64_t)std::stoll(tkn.first);
|
|
}
|
|
}
|
|
|
|
}
|
|
};
|
|
|
|
return read_token();
|
|
}
|
|
std::string Json::Encode(JToken tkn, bool indent)
|
|
{
|
|
int64_t i64;
|
|
double f64;
|
|
std::string str;
|
|
bool b;
|
|
JArray ls;
|
|
JObject dict;
|
|
if(std::holds_alternative<std::nullptr_t>(tkn)) return "null";
|
|
if(TryGetJToken(tkn,b)) return b ? "true" : "false";
|
|
if(TryGetJToken(tkn,f64))
|
|
{
|
|
auto str = std::to_string(f64);
|
|
|
|
if(str.find(".") != std::string::npos)
|
|
{
|
|
size_t i;
|
|
for(i = str.size()-1; str[i] != '.'; i--)
|
|
{
|
|
if(str[i] != '0')
|
|
{
|
|
i++;
|
|
break;
|
|
}
|
|
}
|
|
return str.substr(0,i);
|
|
}
|
|
return str;
|
|
}
|
|
if(TryGetJToken(tkn,i64)) return std::to_string(i64);
|
|
if(TryGetJToken(tkn,str))
|
|
{
|
|
std::string str2 = "\"";
|
|
for(auto c : str)
|
|
{
|
|
if(c == '\"')
|
|
{
|
|
str2.append("\\\"");
|
|
}
|
|
else if(c == '\n')
|
|
{
|
|
str2.append("\\n");
|
|
}
|
|
else if(c == '\t')
|
|
{
|
|
str2.append("\\t");
|
|
}
|
|
else if(c == '\r')
|
|
{
|
|
str2.append("\\r");
|
|
}
|
|
else if(c == '/')
|
|
{
|
|
str2.append("\\/");
|
|
}
|
|
else if(c == '\\')
|
|
{
|
|
str2.append("\\\\");
|
|
}
|
|
else if(c == '\f')
|
|
{
|
|
str2.append("\\f");
|
|
}
|
|
else if(c == '\b')
|
|
{
|
|
str2.append("\\b");
|
|
}
|
|
else if((c >= 0 && c < 32) || c == 127 )
|
|
{
|
|
str2.append("\\u00");
|
|
uint8_t c2 = (uint8_t)c;
|
|
|
|
str2.push_back(HttpUtils::NibbleToHex((c2 >> 4) & 0x0F));
|
|
str2.push_back(HttpUtils::NibbleToHex(c2 & 0x0F));
|
|
}
|
|
else
|
|
{
|
|
str2.push_back(c);
|
|
}
|
|
}
|
|
str2.push_back('\"');
|
|
return str2;
|
|
}
|
|
if(TryGetJToken(tkn,dict))
|
|
{
|
|
|
|
std::string str="{";
|
|
bool first=true;
|
|
for(auto item : dict)
|
|
{
|
|
if(!first) {
|
|
str.push_back(',');
|
|
}
|
|
if(indent) {
|
|
str.append("\n");
|
|
str.append(tab(Encode(item.first,true) + ": " + Encode(item.second,true)));
|
|
}
|
|
else
|
|
{
|
|
str.append(Encode(item.first,false)+":"+Encode(item.second,false));
|
|
}
|
|
first=false;
|
|
}
|
|
if(indent) str.append("\n");
|
|
str.push_back('}');
|
|
return str;
|
|
}
|
|
if(TryGetJToken(tkn,ls))
|
|
{
|
|
std::string str="[";
|
|
bool first=true;
|
|
for(auto item : ls)
|
|
{
|
|
|
|
if(!first) {
|
|
str.push_back(',');
|
|
}
|
|
if(indent) {
|
|
str.append("\n");
|
|
str.append(tab(Encode(item,true)));
|
|
}
|
|
else
|
|
{
|
|
str.append(Encode(item,false));
|
|
}
|
|
first=false;
|
|
}
|
|
if(indent) str.append("\n");
|
|
str.push_back(']');
|
|
return str;
|
|
}
|
|
return "";
|
|
}
|
|
|
|
JArray Json::DocDecode(std::string str)
|
|
{
|
|
JArray data;
|
|
std::string builder = "";
|
|
bool inSplit = false;
|
|
size_t i=0;
|
|
auto flush_builder = [&]()->void{
|
|
if(builder.empty()) return;
|
|
data.Add(builder);
|
|
builder.clear();
|
|
};
|
|
auto consume_white_space = [&]()->void {
|
|
for(; i < str.size(); i++)
|
|
{
|
|
switch(str[i])
|
|
{
|
|
case '\t':
|
|
case '\r':
|
|
case '\n':
|
|
case ' ':
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
};
|
|
auto is_keyword_of_and_consume = [&](std::string text)->bool {
|
|
if(i + text.size() <= str.size()) {
|
|
if(str.substr(i,text.size()) == text)
|
|
{
|
|
i+=text.size();
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
std::function<JToken()> json_decode_token;
|
|
json_decode_token = [&]() -> JToken {
|
|
if(i >= str.size()) return JUndefined();
|
|
if(is_keyword_of_and_consume("true")) return true;
|
|
if(is_keyword_of_and_consume("false")) return false;
|
|
if(is_keyword_of_and_consume("null")) return nullptr;
|
|
|
|
|
|
|
|
if(str[i] == '[')
|
|
{
|
|
i++;
|
|
JArray array;
|
|
//array
|
|
while(i < str.size())
|
|
{
|
|
consume_white_space();
|
|
if(i < str.size() && str[i] ==',')
|
|
{
|
|
i++;
|
|
}
|
|
|
|
consume_white_space();
|
|
if(i < str.size() && str[i] ==']')
|
|
{
|
|
i++;
|
|
return array;
|
|
}
|
|
auto val = json_decode_token();
|
|
array.Add(val);
|
|
}
|
|
return array;
|
|
}
|
|
if(str[i] == '{')
|
|
{
|
|
//dictionary
|
|
i++;
|
|
JObject dict;
|
|
while(i < str.size())
|
|
{
|
|
consume_white_space();
|
|
if(i < str.size() && str[i] ==',')
|
|
{
|
|
i++;
|
|
}
|
|
|
|
consume_white_space();
|
|
if(i < str.size() && str[i] =='}')
|
|
{
|
|
i++;
|
|
return dict;
|
|
}
|
|
auto key = json_decode_token();
|
|
consume_white_space();
|
|
if(i < str.size() && str[i] ==':')
|
|
{
|
|
i++;
|
|
}
|
|
consume_white_space();
|
|
auto value = json_decode_token();
|
|
std::string keyStr;
|
|
if(TryGetJToken(key,keyStr) && !std::holds_alternative<JUndefined>(value))
|
|
{
|
|
dict.SetValue(keyStr,value);
|
|
}
|
|
}
|
|
return dict;
|
|
}
|
|
if(str[i] == '\"')
|
|
{
|
|
i++;
|
|
std::string str2 = "";
|
|
//string
|
|
for(; i < str.size() && str[i] != '\"'; i++)
|
|
{
|
|
if(str[i] == '\\')
|
|
{
|
|
i++;
|
|
if(i < str.size())
|
|
{
|
|
if(str[i] == 'n')
|
|
{
|
|
str2.push_back('\n');
|
|
}
|
|
else if(str[i] == 'r')
|
|
{
|
|
str2.push_back('\r');
|
|
}
|
|
else if(str[i] == 't')
|
|
{
|
|
str2.push_back('\t');
|
|
}
|
|
else if(str[i] == 'f')
|
|
{
|
|
str2.push_back('\f');
|
|
}
|
|
else if(str[i] == 'b')
|
|
{
|
|
str2.push_back('\b');
|
|
}
|
|
else if(str[i] == 'u')
|
|
{
|
|
i++;
|
|
//we need to get four of these
|
|
uint16_t v = 0;
|
|
if(i + 4 <= str.size())
|
|
{
|
|
for(size_t i2 = 0; i2 < 4; i2++,i++)
|
|
{
|
|
v |= HttpUtils::HexToNibble(str[i]) << ((3-i2) * 4);
|
|
}
|
|
|
|
|
|
uint32_t v2 = v;
|
|
|
|
if((v & 0xFC00) == 0xD800)
|
|
{
|
|
|
|
v2 = (v & 0x03FF) << 10;
|
|
if(i + 6 <= str.size() && str.substr(i,2) == "\\u")
|
|
{
|
|
i+=2;
|
|
v=0;
|
|
|
|
for(size_t i2 = 0; i2 < 4; i2++, i++)
|
|
{
|
|
v |= HttpUtils::HexToNibble(str[i]) << ((3-i2) * 4);
|
|
}
|
|
if((v & 0xFC00) != 0xDC00)
|
|
{
|
|
throw std::runtime_error("Not a lower utf-16 surrogate pair.");
|
|
}
|
|
|
|
|
|
v2 |= (v & 0x03FF);
|
|
|
|
v2 += 0x10000;
|
|
}
|
|
else
|
|
{
|
|
|
|
throw std::runtime_error("Could not read lower utf-16 surrogate pair.");
|
|
}
|
|
if(v2 <= 0x7F)
|
|
{
|
|
str2.push_back((char)v2);
|
|
}
|
|
else if(v2 >= 0x80 && v2 <= 0x7FF)
|
|
{
|
|
uint8_t high = 0b11000000 | ((v2 >> 6) & 0b00011111);
|
|
uint8_t low = 0b10000000 | (v2 & 0b00111111);
|
|
str2.push_back((char)high);
|
|
str2.push_back((char)low);
|
|
}
|
|
else if(v2 >= 0x800 && v2 <= 0xFFFF)
|
|
{
|
|
uint8_t highest = 0b11100000 | ((v2 >> 12) & 0b00001111);
|
|
uint8_t high = 0b10000000 | ((v2 >> 6) & 0b00111111);
|
|
uint8_t low = 0b10000000 | (v2 & 0b00111111);
|
|
str2.push_back((char)highest);
|
|
str2.push_back((char)high);
|
|
str2.push_back((char)low);
|
|
}
|
|
else if(v2 >= 0x010000 && v2 <= 0x10FFFF)
|
|
{
|
|
uint8_t highest = 0b11110000 | ((v2 >> 18) & 0b00000111);
|
|
uint8_t high = 0b10000000 | ((v2 >> 12) & 0b00111111);
|
|
uint8_t low = 0b10000000 | ((v2 >> 6) & 0b00111111);
|
|
uint8_t lowest = 0b10000000 | (v2 & 0b00111111);
|
|
str2.push_back((char)highest);
|
|
str2.push_back((char)high);
|
|
str2.push_back((char)low);
|
|
str2.push_back((char)lowest);
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
str2.push_back(str[i]);
|
|
}
|
|
}
|
|
else break;
|
|
}
|
|
else
|
|
{
|
|
str2.push_back(str[i]);
|
|
}
|
|
}
|
|
i++;
|
|
return str2;
|
|
}
|
|
if((str[i] >= '0' && str[i] <= '9' ) || str[i] == '-')
|
|
{
|
|
//number
|
|
std::string noStr = "";
|
|
bool hasPt = false;
|
|
bool hasExponent=false;
|
|
bool hasNeg = false;
|
|
for(;i<str.size(); i++)
|
|
{
|
|
if(str[i] == 'E' || str[i] == 'e')
|
|
{
|
|
if(hasExponent) break;
|
|
hasExponent=true;
|
|
hasNeg=false;
|
|
noStr += str[i];
|
|
}
|
|
else if(str[i] == '.')
|
|
{
|
|
if(hasPt) break;
|
|
hasPt=true;
|
|
noStr += str[i];
|
|
}
|
|
else if(str[i] == '-')
|
|
{
|
|
if(hasNeg) break;
|
|
hasNeg = true;
|
|
noStr += str[i];
|
|
}
|
|
else if(str[i] == '+')
|
|
{
|
|
if(!hasExponent) break;
|
|
if(hasNeg) break;
|
|
hasNeg=true;
|
|
noStr += str[i];
|
|
}
|
|
else if(str[i] >= '0' && str[i] <= '9')
|
|
{
|
|
noStr += str[i];
|
|
}
|
|
else break;
|
|
}
|
|
if(noStr.find(".") != std::string::npos)
|
|
{
|
|
return std::stod(noStr);
|
|
}
|
|
else
|
|
{
|
|
return (int64_t)std::stoll(noStr);
|
|
}
|
|
}
|
|
return JUndefined();
|
|
};
|
|
|
|
|
|
for(; i < str.size(); i++)
|
|
{
|
|
if(inSplit)
|
|
{
|
|
consume_white_space();
|
|
std::string key = "";
|
|
for(; i < str.size() && str[i] != ' '; i++)
|
|
{
|
|
key += str[i];
|
|
}
|
|
consume_white_space();
|
|
auto value = json_decode_token();
|
|
if(!std::holds_alternative<JUndefined>(value))
|
|
{
|
|
data.Add(JObject({
|
|
JOItem("key",key),
|
|
JOItem("value", value)
|
|
}));
|
|
}
|
|
inSplit=false;
|
|
i--;
|
|
}
|
|
else {
|
|
if(str[i] == '@')
|
|
{
|
|
if(i+1<str.size() && str[i+1] == '@')
|
|
{
|
|
i++;
|
|
builder.push_back('@');
|
|
continue;
|
|
}
|
|
inSplit=true;
|
|
flush_builder();
|
|
continue;
|
|
}
|
|
builder.push_back(str[i]);
|
|
}
|
|
}
|
|
flush_builder();
|
|
return data;
|
|
}
|
|
std::string Json::DocEncode(JArray array,bool indent)
|
|
{
|
|
/*
|
|
The beautiful text
|
|
@name "John"
|
|
@list ["A","B"]
|
|
@number 42
|
|
@dict {"a": 5, "b": true}
|
|
*/
|
|
|
|
/*
|
|
[
|
|
"\tThe beautiful text\n\t",
|
|
{
|
|
"key": "name",
|
|
"value": ["A","B"]
|
|
},
|
|
"\n\t",
|
|
{
|
|
"key": "number",
|
|
"value": 42
|
|
},
|
|
"\n\t",
|
|
{
|
|
"key": "dict",
|
|
"value": {"a": 5, "b": true}
|
|
},
|
|
"\n"
|
|
]
|
|
*/
|
|
std::string text = "";
|
|
|
|
for(auto& item : array.GetVector())
|
|
{
|
|
std::string str;
|
|
JObject obj;
|
|
if(TryGetJToken(item,str)) text += HttpUtils::Replace(str,"@","@@");
|
|
if(TryGetJToken(item,obj))
|
|
{
|
|
auto value = obj.GetValue("value");
|
|
if(obj.TryGetValueAsType("key", str) && !std::holds_alternative<JUndefined>(value))
|
|
{
|
|
text += "@" + str + " " + Json::Encode(value,indent);
|
|
}
|
|
}
|
|
}
|
|
|
|
return text;
|
|
}
|
|
}
|