506 lines
15 KiB
C++
506 lines
15 KiB
C++
#include "json.h"
|
|
|
|
using std::map;
|
|
using std::deque;
|
|
using std::string;
|
|
using std::enable_if;
|
|
using std::initializer_list;
|
|
using std::is_same;
|
|
using std::is_convertible;
|
|
using std::is_integral;
|
|
using std::is_floating_point;
|
|
|
|
std::string json_escape(const string &str) {
|
|
string output;
|
|
for( unsigned i = 0; i < str.length(); ++i )
|
|
switch( str[i] ) {
|
|
case '\"': output += "\\\""; break;
|
|
case '\\': output += "\\\\"; break;
|
|
case '\b': output += "\\b"; break;
|
|
case '\f': output += "\\f"; break;
|
|
case '\n': output += "\\n"; break;
|
|
case '\r': output += "\\r"; break;
|
|
case '\t': output += "\\t"; break;
|
|
default : output += str[i]; break;
|
|
}
|
|
return std::move( output );
|
|
}
|
|
|
|
JSON::JSON() : Internal(), Type( Class::Null ){}
|
|
|
|
JSON::JSON(std::initializer_list<JSON> list)
|
|
: JSON()
|
|
{
|
|
SetType( Class::Object );
|
|
for( auto i = list.begin(), e = list.end(); i != e; ++i, ++i )
|
|
operator[]( i->toString() ) = *std::next( i );
|
|
}
|
|
|
|
JSON::JSON(JSON &&other)
|
|
: Internal( other.Internal )
|
|
, Type( other.Type )
|
|
{ other.Type = Class::Null; other.Internal.Map = nullptr; }
|
|
|
|
JSON::JSON(const JSON &other) {
|
|
switch( other.Type ) {
|
|
case Class::Object:
|
|
Internal.Map =
|
|
new map<string,JSON>( other.Internal.Map->begin(),
|
|
other.Internal.Map->end() );
|
|
break;
|
|
case Class::Array:
|
|
Internal.List =
|
|
new deque<JSON>( other.Internal.List->begin(),
|
|
other.Internal.List->end() );
|
|
break;
|
|
case Class::String:
|
|
Internal.String =
|
|
new string( *other.Internal.String );
|
|
break;
|
|
default:
|
|
Internal = other.Internal;
|
|
}
|
|
Type = other.Type;
|
|
}
|
|
|
|
JSON JSON::Make(Class type) {
|
|
JSON ret; ret.SetType( type );
|
|
return ret;
|
|
}
|
|
|
|
JSON &JSON::operator[](unsigned int index) {
|
|
SetType( Class::Array );
|
|
if( index >= Internal.List->size() ) Internal.List->resize( index + 1 );
|
|
return Internal.List->operator[]( index );
|
|
}
|
|
|
|
JSON &JSON::at(const std::string &key) {
|
|
return operator[]( key );
|
|
}
|
|
|
|
const JSON &JSON::at(const std::string &key) const {
|
|
return Internal.Map->at( key );
|
|
}
|
|
|
|
JSON &JSON::at(unsigned int index) {
|
|
return operator[]( index );
|
|
}
|
|
|
|
const JSON &JSON::at(unsigned int index) const {
|
|
return Internal.List->at( index );
|
|
}
|
|
|
|
int JSON::length() const {
|
|
if( Type == Class::Array )
|
|
return Internal.List->size();
|
|
else
|
|
return -1;
|
|
}
|
|
|
|
bool JSON::hasKey(const std::string &key) const {
|
|
if( Type == Class::Object )
|
|
return Internal.Map->find( key ) != Internal.Map->end();
|
|
return false;
|
|
}
|
|
|
|
int JSON::size() const {
|
|
if( Type == Class::Object )
|
|
return Internal.Map->size();
|
|
else if( Type == Class::Array )
|
|
return Internal.List->size();
|
|
else
|
|
return -1;
|
|
}
|
|
|
|
JSON::Class JSON::JSONType() const { return Type; }
|
|
|
|
bool JSON::IsNull() const { return Type == Class::Null; }
|
|
|
|
string JSON::toString() const { bool b; return std::move( toString( b ) ); }
|
|
|
|
string JSON::toString(bool &ok) const {
|
|
ok = (Type == Class::String);
|
|
return ok ? std::move( json_escape( *Internal.String ) ): string("");
|
|
}
|
|
|
|
double JSON::toFloat() const { bool b; return toFloat( b ); }
|
|
|
|
double JSON::toFloat(bool &ok) const {
|
|
ok = (Type == Class::Floating);
|
|
return ok ? Internal.Float : 0.0;
|
|
}
|
|
|
|
long JSON::toInt() const { bool b; return toInt( b ); }
|
|
|
|
long JSON::toInt(bool &ok) const {
|
|
ok = (Type == Class::Integral);
|
|
return ok ? Internal.Int : 0;
|
|
}
|
|
|
|
bool JSON::toBool() const { bool b; return toBool( b ); }
|
|
|
|
bool JSON::toBool(bool &ok) const {
|
|
ok = (Type == Class::Boolean);
|
|
return ok ? Internal.Bool : false;
|
|
}
|
|
|
|
JSON::JSONWrapper<std::map<string, JSON> > JSON::ObjectRange() {
|
|
if( Type == Class::Object )
|
|
return JSONWrapper<std::map<std::string,JSON>>( Internal.Map );
|
|
return JSONWrapper<std::map<std::string,JSON>>( nullptr );
|
|
}
|
|
|
|
JSON::JSONWrapper<std::deque<JSON> > JSON::ArrayRange() {
|
|
if( Type == Class::Array )
|
|
return JSONWrapper<std::deque<JSON>>( Internal.List );
|
|
return JSONWrapper<std::deque<JSON>>( nullptr );
|
|
}
|
|
|
|
JSON::JSONConstWrapper<std::map<string, JSON> > JSON::ObjectRange() const {
|
|
if( Type == Class::Object )
|
|
return JSONConstWrapper<std::map<std::string,JSON>>( Internal.Map );
|
|
return JSONConstWrapper<std::map<std::string,JSON>>( nullptr );
|
|
}
|
|
|
|
JSON::JSONConstWrapper<std::deque<JSON> > JSON::ArrayRange() const {
|
|
if( Type == Class::Array )
|
|
return JSONConstWrapper<std::deque<JSON>>( Internal.List );
|
|
return JSONConstWrapper<std::deque<JSON>>( nullptr );
|
|
}
|
|
|
|
string JSON::dump(int depth, const std::string &tab) const {
|
|
std::string pad = "";
|
|
for( int i = 0; i < depth; ++i, pad += tab );
|
|
|
|
switch( Type ) {
|
|
case Class::Null:
|
|
return "null";
|
|
case Class::Object: {
|
|
std::string s = "{ ";
|
|
bool skip = true;
|
|
for( auto &p : *Internal.Map ) {
|
|
if( !skip ) s += ", ";
|
|
s += ( pad + "\"" + p.first + "\" : " + p.second.dump( depth + 1, tab ) );
|
|
skip = false;
|
|
}
|
|
s += ( " " + pad.erase( 0, 2 ) + "}" ) ;
|
|
return s;
|
|
}
|
|
case Class::Array: {
|
|
std::string s = "[";
|
|
bool skip = true;
|
|
for( auto &p : *Internal.List ) {
|
|
if( !skip ) s += ", ";
|
|
s += p.dump( depth + 1, tab );
|
|
skip = false;
|
|
}
|
|
s += "]";
|
|
return s;
|
|
}
|
|
case Class::String:
|
|
return "\"" + json_escape( *Internal.String ) + "\"";
|
|
case Class::Floating:
|
|
return std::to_string( Internal.Float );
|
|
case Class::Integral:
|
|
return std::to_string( Internal.Int );
|
|
case Class::Boolean:
|
|
return Internal.Bool ? "true" : "false";
|
|
default:
|
|
return "";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
void JSON::SetType(Class type) {
|
|
if( type == Type )
|
|
return;
|
|
|
|
ClearInternal();
|
|
|
|
switch( type ) {
|
|
case Class::Null: Internal.Map = nullptr; break;
|
|
case Class::Object: Internal.Map = new std::map<std::string,JSON>(); break;
|
|
case Class::Array: Internal.List = new std::deque<JSON>(); break;
|
|
case Class::String: Internal.String = new std::string(); break;
|
|
case Class::Floating: Internal.Float = 0.0; break;
|
|
case Class::Integral: Internal.Int = 0; break;
|
|
case Class::Boolean: Internal.Bool = false; break;
|
|
}
|
|
|
|
Type = type;
|
|
}
|
|
|
|
void JSON::ClearInternal() {
|
|
switch( Type ) {
|
|
case Class::Object: delete Internal.Map; break;
|
|
case Class::Array: delete Internal.List; break;
|
|
case Class::String: delete Internal.String; break;
|
|
default:;
|
|
}
|
|
}
|
|
|
|
JSON &JSON::operator[](const std::string &key) {
|
|
SetType( Class::Object ); return Internal.Map->operator[]( key );
|
|
}
|
|
|
|
JSON &JSON::operator=(const JSON &other) {
|
|
|
|
if (&other == this) { return *this; }
|
|
|
|
ClearInternal();
|
|
switch( other.Type ) {
|
|
case Class::Object:
|
|
Internal.Map =
|
|
new map<string,JSON>( other.Internal.Map->begin(),
|
|
other.Internal.Map->end() );
|
|
break;
|
|
case Class::Array:
|
|
Internal.List =
|
|
new deque<JSON>( other.Internal.List->begin(),
|
|
other.Internal.List->end() );
|
|
break;
|
|
case Class::String:
|
|
Internal.String =
|
|
new string( *other.Internal.String );
|
|
break;
|
|
default:
|
|
Internal = other.Internal;
|
|
}
|
|
Type = other.Type;
|
|
return *this;
|
|
}
|
|
|
|
JSON &JSON::operator=(JSON &&other) {
|
|
ClearInternal();
|
|
Internal = other.Internal;
|
|
Type = other.Type;
|
|
other.Internal.Map = nullptr;
|
|
other.Type = Class::Null;
|
|
return *this;
|
|
}
|
|
|
|
JSON Array() {
|
|
return std::move( JSON::Make( JSON::Class::Array ) );
|
|
}
|
|
|
|
//JSON Object() { return std::move(JSON::Make(JSON::Class::Object)); }
|
|
|
|
JSON Object() {
|
|
return std::move( JSON::Make( JSON::Class::Object ) );
|
|
}
|
|
|
|
std::ostream &operator<<(std::ostream &os, const JSON &json) {
|
|
os << json.dump();
|
|
return os;
|
|
}
|
|
|
|
// Private functions.
|
|
|
|
static JSON parse_next( const std::string &, size_t &, std::function<void(const std::string &err)> );
|
|
|
|
|
|
static void consume_ws( const std::string &str, size_t &offset ) {
|
|
while( isspace( str[offset] ) ) ++offset;
|
|
}
|
|
|
|
static JSON parse_object( const string &str, size_t &offset, std::function<void(const std::string &err)> on_error ) {
|
|
JSON Object = JSON::Make( JSON::Class::Object );
|
|
|
|
++offset;
|
|
consume_ws( str, offset );
|
|
if( str[offset] == '}' ) {
|
|
++offset; return std::move( Object );
|
|
}
|
|
|
|
while( true ) {
|
|
JSON Key = parse_next( str, offset, on_error );
|
|
consume_ws( str, offset );
|
|
if( str[offset] != ':' ) {
|
|
on_error(std::string("Error: Object: Expected colon, found '") + str[offset] + "'");
|
|
break;
|
|
}
|
|
consume_ws( str, ++offset );
|
|
JSON Value = parse_next( str, offset, on_error );
|
|
Object[Key.toString()] = Value;
|
|
|
|
consume_ws( str, offset );
|
|
if( str[offset] == ',' ) {
|
|
++offset; continue;
|
|
}
|
|
else if( str[offset] == '}' ) {
|
|
++offset; break;
|
|
}
|
|
else {
|
|
on_error(std::string("ERROR: Object: Expected comma, found '") + str[offset] + "'");
|
|
break;
|
|
}
|
|
}
|
|
|
|
return std::move( Object );
|
|
}
|
|
|
|
static JSON parse_array( const string &str, size_t &offset, std::function<void(const std::string &err)> on_error ) {
|
|
JSON Array = JSON::Make( JSON::Class::Array );
|
|
unsigned index = 0;
|
|
|
|
++offset;
|
|
consume_ws( str, offset );
|
|
if( str[offset] == ']' ) {
|
|
++offset; return std::move( Array );
|
|
}
|
|
|
|
while( true ) {
|
|
Array[index++] = parse_next( str, offset, on_error );
|
|
consume_ws( str, offset );
|
|
|
|
if( str[offset] == ',' ) {
|
|
++offset; continue;
|
|
}
|
|
else if( str[offset] == ']' ) {
|
|
++offset; break;
|
|
}
|
|
else {
|
|
on_error(std::string("ERROR: Array: Expected ',' or ']', found '") + str[offset] + "'");
|
|
return std::move( JSON::Make( JSON::Class::Array ) );
|
|
}
|
|
}
|
|
|
|
return std::move( Array );
|
|
}
|
|
|
|
static JSON parse_string( const string &str, size_t &offset, std::function<void(const std::string &err)> on_error ) {
|
|
JSON String;
|
|
string val;
|
|
for( char c = str[++offset]; c != '\"' ; c = str[++offset] ) {
|
|
if( c == '\\' ) {
|
|
switch( str[ ++offset ] ) {
|
|
case '\"': val += '\"'; break;
|
|
case '\\': val += '\\'; break;
|
|
case '/' : val += '/' ; break;
|
|
case 'b' : val += '\b'; break;
|
|
case 'f' : val += '\f'; break;
|
|
case 'n' : val += '\n'; break;
|
|
case 'r' : val += '\r'; break;
|
|
case 't' : val += '\t'; break;
|
|
case 'u' : {
|
|
val += "\\u" ;
|
|
for( unsigned i = 1; i <= 4; ++i ) {
|
|
c = str[offset+i];
|
|
if( (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F') )
|
|
val += c;
|
|
else {
|
|
on_error(std::string("ERROR: String: Expected hex character in unicode escape, found '") + c + "'");
|
|
return std::move( JSON::Make( JSON::Class::String ) );
|
|
}
|
|
}
|
|
offset += 4;
|
|
} break;
|
|
default : val += '\\'; break;
|
|
}
|
|
}
|
|
else
|
|
val += c;
|
|
}
|
|
++offset;
|
|
String = val;
|
|
return std::move( String );
|
|
}
|
|
|
|
static JSON parse_number( const string &str, size_t &offset, std::function<void(const std::string &err)> on_error ) {
|
|
JSON Number;
|
|
string val, exp_str;
|
|
char c;
|
|
bool isDouble = false;
|
|
long exp = 0;
|
|
while( true ) {
|
|
c = str[offset++];
|
|
if( (c == '-') || (c >= '0' && c <= '9') )
|
|
val += c;
|
|
else if( c == '.' ) {
|
|
val += c;
|
|
isDouble = true;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
if( c == 'E' || c == 'e' ) {
|
|
c = str[ offset++ ];
|
|
if( c == '-' ){ ++offset; exp_str += '-';}
|
|
while( true ) {
|
|
c = str[ offset++ ];
|
|
if( c >= '0' && c <= '9' )
|
|
exp_str += c;
|
|
else if( !isspace( c ) && c != ',' && c != ']' && c != '}' ) {
|
|
on_error(std::string("ERROR: Number: Expected a number for exponent, found '") + c + "'");
|
|
return std::move( JSON::Make( JSON::Class::Null ) );
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
exp = std::stol( exp_str );
|
|
}
|
|
else if( !isspace( c ) && c != ',' && c != ']' && c != '}' ) {
|
|
on_error(std::string("ERROR: Number: unexpected character '") + c + "'");
|
|
return std::move( JSON::Make( JSON::Class::Null ) );
|
|
}
|
|
--offset;
|
|
|
|
if( isDouble )
|
|
Number = std::stod( val ) * std::pow( 10, exp );
|
|
else {
|
|
if( !exp_str.empty() )
|
|
Number = std::stol( val ) * std::pow( 10, exp );
|
|
else
|
|
Number = std::stol( val );
|
|
}
|
|
return std::move( Number );
|
|
}
|
|
|
|
static JSON parse_bool( const string &str, size_t &offset, std::function<void(const std::string &err)> on_error ) {
|
|
JSON Bool;
|
|
if( str.substr( offset, 4 ) == "true" )
|
|
Bool = true;
|
|
else if( str.substr( offset, 5 ) == "false" )
|
|
Bool = false;
|
|
else {
|
|
on_error(std::string("ERROR: Bool: Expected 'true' or 'false', found '") + str.substr( offset, 5 ) + "'");
|
|
return std::move( JSON::Make( JSON::Class::Null ) );
|
|
}
|
|
offset += (Bool.toBool() ? 4 : 5);
|
|
return std::move( Bool );
|
|
}
|
|
|
|
static JSON parse_null( const string &str, size_t &offset, std::function<void(const std::string &err)> on_error ) {
|
|
JSON Null;
|
|
if( str.substr( offset, 4 ) != "null" ) {
|
|
on_error(std::string("ERROR: Null: Expected 'null', found '") + str.substr( offset, 4 ) + "'" );
|
|
return std::move( JSON::Make( JSON::Class::Null ) );
|
|
}
|
|
offset += 4;
|
|
return std::move( Null );
|
|
}
|
|
|
|
static JSON parse_next( const string &str, size_t &offset, std::function<void(const std::string &err)> on_error ) {
|
|
char value;
|
|
consume_ws( str, offset );
|
|
value = str[offset];
|
|
switch( value ) {
|
|
case '[' : return std::move( parse_array( str, offset, on_error ) );
|
|
case '{' : return std::move( parse_object( str, offset, on_error ) );
|
|
case '\"': return std::move( parse_string( str, offset, on_error ) );
|
|
case 't' :
|
|
case 'f' : return std::move( parse_bool( str, offset, on_error ) );
|
|
case 'n' : return std::move( parse_null( str, offset, on_error ) );
|
|
default : if( ( value <= '9' && value >= '0' ) || value == '-' )
|
|
return std::move( parse_number( str, offset, on_error ) );
|
|
}
|
|
on_error(std::string("ERROR: Parse: Unknown starting character '") + value + "'");
|
|
return JSON();
|
|
}
|
|
|
|
JSON JSON::Load( const string &str, std::function<void(const std::string &err)> on_error) {
|
|
size_t offset = 0;
|
|
return std::move( parse_next( str, offset, on_error ) );
|
|
}
|
|
|