Peerplays_Blockchain/peerplays-fc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge pull request #41 from emfrias/json_parser_mods

Browse source 
Json parser mods
This commit is contained in:
Vikram Rajkumar 2015-06-15 15:30:35 -04:00
commit c09035dba0
4 changed files with 95 additions and 73 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

36
include/fc/io/json.hpp
View file

@ -19,30 +19,36 @@ namespace fc
{ {
legacy_parser = 0, legacy_parser = 0,
strict_parser = 1, strict_parser = 1,
relaxed_parser = 2 relaxed_parser = 2,
legacy_parser_with_string_doubles = 3
};
enum output_formatting
{
stringify_large_ints_and_doubles = 0,
legacy_generator = 1
}; };
static ostream& to_stream( ostream& out, const fc::string& ); static ostream& to_stream( ostream& out, const fc::string&);
static ostream& to_stream( ostream& out, const variant& v ); static ostream& to_stream( ostream& out, const variant& v, output_formatting format = stringify_large_ints_and_doubles );
static ostream& to_stream( ostream& out, const variants& v ); static ostream& to_stream( ostream& out, const variants& v, output_formatting format = stringify_large_ints_and_doubles );
static ostream& to_stream( ostream& out, const variant_object& v ); static ostream& to_stream( ostream& out, const variant_object& v, output_formatting format = stringify_large_ints_and_doubles );
static variant from_stream( buffered_istream& in, parse_type ptype = legacy_parser ); static variant from_stream( buffered_istream& in, parse_type ptype = legacy_parser );
static variant from_string( const string& utf8_str, parse_type ptype = legacy_parser ); static variant from_string( const string& utf8_str, parse_type ptype = legacy_parser );
static variants variants_from_string( const string& utf8_str, parse_type ptype = legacy_parser ); static variants variants_from_string( const string& utf8_str, parse_type ptype = legacy_parser );
static string to_string( const variant& v ); static string to_string( const variant& v, output_formatting format = stringify_large_ints_and_doubles );
static string to_pretty_string( const variant& v ); static string to_pretty_string( const variant& v, output_formatting format = stringify_large_ints_and_doubles );
static bool is_valid( const std::string& json_str, parse_type ptype = legacy_parser ); static bool is_valid( const std::string& json_str, parse_type ptype = legacy_parser );
template<typename T> template<typename T>
static void save_to_file( const T& v, const fc::path& fi, bool pretty = true ) static void save_to_file( const T& v, const fc::path& fi, bool pretty = true, output_formatting format = stringify_large_ints_and_doubles )
{ {
save_to_file( variant(v), fi, pretty ); save_to_file( variant(v), fi, pretty, format );
} }
static void save_to_file( const variant& v, const fc::path& fi, bool pretty = true ); static void save_to_file( const variant& v, const fc::path& fi, bool pretty = true, output_formatting format = stringify_large_ints_and_doubles );
static variant from_file( const fc::path& p, parse_type ptype = legacy_parser ); static variant from_file( const fc::path& p, parse_type ptype = legacy_parser );
template<typename T> template<typename T>
@ -52,19 +58,19 @@ namespace fc
} }
template<typename T> template<typename T>
static string to_string( const T& v ) static string to_string( const T& v, output_formatting format = stringify_large_ints_and_doubles )
{ {
return to_string( variant(v) ); return to_string( variant(v), format );
} }
template<typename T> template<typename T>
static string to_pretty_string( const T& v ) static string to_pretty_string( const T& v, output_formatting format = stringify_large_ints_and_doubles )
{ {
return to_pretty_string( variant(v) ); return to_pretty_string( variant(v), format );
} }
template<typename T> template<typename T>
static void save_to_file( const T& v, const std::string& p, bool pretty = true ) static void save_to_file( const T& v, const std::string& p, bool pretty = true, output_formatting format = stringify_large_ints_and_doubles )
{ {
save_to_file( variant(v), fc::path(p), pretty ); save_to_file( variant(v), fc::path(p), pretty );
} }

18
include/fc/io/json_relaxed.hpp
View file

@ -581,7 +581,7 @@ namespace fc { namespace json_relaxed
continue; continue;
} }
if( skip_white_space(in) ) continue; if( skip_white_space(in) ) continue;
string key = stringFromStream<T, strict>( in ); string key = json_relaxed::stringFromStream<T, strict>( in );
skip_white_space(in); skip_white_space(in);
if( in.peek() != ':' ) if( in.peek() != ':' )
{ {
@ -589,7 +589,7 @@ namespace fc { namespace json_relaxed
("key", key) ); ("key", key) );
} }
in.get(); in.get();
auto val = variant_from_stream<T, strict>( in ); auto val = json_relaxed::variant_from_stream<T, strict>( in );
obj(std::move(key),std::move(val)); obj(std::move(key),std::move(val));
skip_white_space(in); skip_white_space(in);
@ -630,7 +630,7 @@ namespace fc { namespace json_relaxed
continue; continue;
} }
if( skip_white_space(in) ) continue; if( skip_white_space(in) ) continue;
ar.push_back( variant_from_stream<T, strict>(in) ); ar.push_back( json_relaxed::variant_from_stream<T, strict>(in) );
skip_white_space(in); skip_white_space(in);
} }
if( in.peek() != ']' ) if( in.peek() != ']' )
@ -647,7 +647,7 @@ namespace fc { namespace json_relaxed
variant numberFromStream( T& in ) variant numberFromStream( T& in )
{ try { { try {
fc::string token = tokenFromStream(in); fc::string token = tokenFromStream(in);
variant result = parseNumberOrStr<strict>( token ); variant result = json_relaxed::parseNumberOrStr<strict>( token );
if( strict && !(result.is_int64() || result.is_uint64() || result.is_double()) ) if( strict && !(result.is_int64() || result.is_uint64() || result.is_double()) )
FC_THROW_EXCEPTION( parse_error_exception, "expected: number" ); FC_THROW_EXCEPTION( parse_error_exception, "expected: number" );
return result; return result;
@ -700,11 +700,11 @@ namespace fc { namespace json_relaxed
in.get(); in.get();
continue; continue;
case '"': case '"':
return stringFromStream<T, strict>( in ); return json_relaxed::stringFromStream<T, strict>( in );
case '{': case '{':
return objectFromStream<T, strict>( in ); return json_relaxed::objectFromStream<T, strict>( in );
case '[': case '[':
return arrayFromStream<T, strict>( in ); return json_relaxed::arrayFromStream<T, strict>( in );
case '-': case '-':
case '+': case '+':
case '.': case '.':
@ -718,7 +718,7 @@ namespace fc { namespace json_relaxed
case '7': case '7':
case '8': case '8':
case '9': case '9':
return numberFromStream<T, strict>( in ); return json_relaxed::numberFromStream<T, strict>( in );
// null, true, false, or 'warning' / string // null, true, false, or 'warning' / string
case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g': case 'h': case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g': case 'h':
case 'i': case 'j': case 'k': case 'l': case 'm': case 'n': case 'o': case 'p': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n': case 'o': case 'p':
@ -729,7 +729,7 @@ namespace fc { namespace json_relaxed
case 'Q': case 'R': case 'S': case 'T': case 'U': case 'V': case 'W': case 'X': case 'Q': case 'R': case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
case 'Y': case 'Z': case 'Y': case 'Z':
case '_': case '/': case '_': case '/':
return wordFromStream<T, strict>( in ); return json_relaxed::wordFromStream<T, strict>( in );
case 0x04: // ^D end of transmission case 0x04: // ^D end of transmission
case EOF: case EOF:
FC_THROW_EXCEPTION( eof_exception, "unexpected end of file" ); FC_THROW_EXCEPTION( eof_exception, "unexpected end of file" );

104
src/io/json.cpp
View file

@ -15,20 +15,19 @@
namespace fc namespace fc
{ {
// forward declarations of provided functions // forward declarations of provided functions
template<typename T> variant variant_from_stream( T& in ); template<typename T, json::parse_type parser_type> variant variant_from_stream( T& in );
template<typename T> char parseEscape( T& in ); template<typename T> char parseEscape( T& in );
template<typename T> fc::string stringFromStream( T& in ); template<typename T> fc::string stringFromStream( T& in );
template<typename T> bool skip_white_space( T& in ); template<typename T> bool skip_white_space( T& in );
template<typename T> fc::string stringFromToken( T& in ); template<typename T> fc::string stringFromToken( T& in );
template<typename T> variant_object objectFromStream( T& in ); template<typename T, json::parse_type parser_type> variant_object objectFromStream( T& in );
template<typename T> variants arrayFromStream( T& in ); template<typename T, json::parse_type parser_type> variants arrayFromStream( T& in );
template<typename T> variant number_from_stream( T& in ); template<typename T, json::parse_type parser_type> variant number_from_stream( T& in );
template<typename T> variant token_from_stream( T& in ); template<typename T> variant token_from_stream( T& in );
template<typename T> variant variant_from_stream( T& in );
void escape_string( const string& str, ostream& os ); void escape_string( const string& str, ostream& os );
template<typename T> void to_stream( T& os, const variants& a ); template<typename T> void to_stream( T& os, const variants& a, json::output_formatting format );
template<typename T> void to_stream( T& os, const variant_object& o ); template<typename T> void to_stream( T& os, const variant_object& o, json::output_formatting format );
template<typename T> void to_stream( T& os, const variant& v ); template<typename T> void to_stream( T& os, const variant& v, json::output_formatting format );
fc::string pretty_print( const fc::string& v, uint8_t indent ); fc::string pretty_print( const fc::string& v, uint8_t indent );
} }
@ -168,7 +167,7 @@ namespace fc
("token", token.str() ) ); ("token", token.str() ) );
} }
template<typename T> template<typename T, json::parse_type parser_type>
variant_object objectFromStream( T& in ) variant_object objectFromStream( T& in )
{ {
mutable_variant_object obj; mutable_variant_object obj;
@ -197,7 +196,7 @@ namespace fc
("key", key) ); ("key", key) );
} }
in.get(); in.get();
auto val = variant_from_stream( in ); auto val = variant_from_stream<T, parser_type>( in );
obj(std::move(key),std::move(val)); obj(std::move(key),std::move(val));
skip_white_space(in); skip_white_space(in);
@ -219,7 +218,7 @@ namespace fc
} FC_RETHROW_EXCEPTIONS( warn, "Error parsing object" ); } FC_RETHROW_EXCEPTIONS( warn, "Error parsing object" );
} }
template<typename T> template<typename T, json::parse_type parser_type>
variants arrayFromStream( T& in ) variants arrayFromStream( T& in )
{ {
variants ar; variants ar;
@ -238,7 +237,7 @@ namespace fc
continue; continue;
} }
if( skip_white_space(in) ) continue; if( skip_white_space(in) ) continue;
ar.push_back( variant_from_stream(in) ); ar.push_back( variant_from_stream<T, parser_type>(in) );
skip_white_space(in); skip_white_space(in);
} }
if( in.peek() != ']' ) if( in.peek() != ']' )
@ -251,7 +250,7 @@ namespace fc
return ar; return ar;
} }
template<typename T> template<typename T, json::parse_type parser_type>
variant number_from_stream( T& in ) variant number_from_stream( T& in )
{ {
fc::stringstream ss; fc::stringstream ss;
@ -309,7 +308,7 @@ namespace fc
if (str == "-." || str == ".") // check the obviously wrong things we could have encountered if (str == "-." || str == ".") // check the obviously wrong things we could have encountered
FC_THROW_EXCEPTION(parse_error_exception, "Can't parse token \"${token}\" as a JSON numeric constant", ("token", str)); FC_THROW_EXCEPTION(parse_error_exception, "Can't parse token \"${token}\" as a JSON numeric constant", ("token", str));
if( dot ) if( dot )
return to_double(str); return parser_type == json::legacy_parser_with_string_doubles ? variant(str) : variant(to_double(str));
if( neg ) if( neg )
return to_int64(str); return to_int64(str);
return to_uint64(str); return to_uint64(str);
@ -386,7 +385,7 @@ namespace fc
} }
template<typename T> template<typename T, json::parse_type parser_type>
variant variant_from_stream( T& in ) variant variant_from_stream( T& in )
{ {
skip_white_space(in); skip_white_space(in);
@ -404,9 +403,9 @@ namespace fc
case '"': case '"':
return stringFromStream( in ); return stringFromStream( in );
case '{': case '{':
return objectFromStream( in ); return objectFromStream<T, parser_type>( in );
case '[': case '[':
return arrayFromStream( in ); return arrayFromStream<T, parser_type>( in );
case '-': case '-':
case '.': case '.':
case '0': case '0':
@ -419,7 +418,7 @@ namespace fc
case '7': case '7':
case '8': case '8':
case '9': case '9':
return number_from_stream( in ); return number_from_stream<T, parser_type>( in );
// null, true, false, or 'warning' / string // null, true, false, or 'warning' / string
case 'n': case 'n':
case 't': case 't':
@ -466,7 +465,9 @@ namespace fc
switch( ptype ) switch( ptype )
{ {
case legacy_parser: case legacy_parser:
return variant_from_stream( in ); return variant_from_stream<fc::stringstream, legacy_parser>( in );
case legacy_parser_with_string_doubles:
return variant_from_stream<fc::stringstream, legacy_parser_with_string_doubles>( in );
case strict_parser: case strict_parser:
return json_relaxed::variant_from_stream<fc::stringstream, true>( in ); return json_relaxed::variant_from_stream<fc::stringstream, true>( in );
case relaxed_parser: case relaxed_parser:
@ -548,14 +549,14 @@ namespace fc
} }
template<typename T> template<typename T>
void to_stream( T& os, const variants& a ) void to_stream( T& os, const variants& a, json::output_formatting format )
{ {
os << '['; os << '[';
auto itr = a.begin(); auto itr = a.begin();
while( itr != a.end() ) while( itr != a.end() )
{ {
to_stream( os, *itr ); to_stream( os, *itr, format );
++itr; ++itr;
if( itr != a.end() ) if( itr != a.end() )
os << ','; os << ',';
@ -563,7 +564,7 @@ namespace fc
os << ']'; os << ']';
} }
template<typename T> template<typename T>
void to_stream( T& os, const variant_object& o ) void to_stream( T& os, const variant_object& o, json::output_formatting format )
{ {
os << '{'; os << '{';
auto itr = o.begin(); auto itr = o.begin();
@ -572,7 +573,7 @@ namespace fc
{ {
escape_string( itr->key(), os ); escape_string( itr->key(), os );
os << ':'; os << ':';
to_stream( os, itr->value() ); to_stream( os, itr->value(), format );
++itr; ++itr;
if( itr != o.end() ) if( itr != o.end() )
os << ','; os << ',';
@ -581,7 +582,7 @@ namespace fc
} }
template<typename T> template<typename T>
void to_stream( T& os, const variant& v ) void to_stream( T& os, const variant& v, json::output_formatting format )
{ {
switch( v.get_type() ) switch( v.get_type() )
{ {
@ -591,24 +592,30 @@ namespace fc
case variant::int64_type: case variant::int64_type:
{ {
int64_t i = v.as_int64(); int64_t i = v.as_int64();
if( i > 0xffffffff ) if( format == json::stringify_large_ints_and_doubles &&
i > 0xffffffff )
os << '"'<<v.as_string()<<'"'; os << '"'<<v.as_string()<<'"';
else else
os << i; os << i;
return; return;
} }
case variant::uint64_type: case variant::uint64_type:
{ {
uint64_t i = v.as_uint64(); uint64_t i = v.as_uint64();
if( i > 0xffffffff ) if( format == json::stringify_large_ints_and_doubles &&
i > 0xffffffff )
os << '"'<<v.as_string()<<'"'; os << '"'<<v.as_string()<<'"';
else else
os << i; os << i;
return; return;
} }
case variant::double_type: case variant::double_type:
//os << v.as_string(); if (format == json::stringify_large_ints_and_doubles)
os << '"'<<v.as_string()<<'"'; os << '"'<<v.as_string()<<'"';
else
os << v.as_string();
return; return;
case variant::bool_type: case variant::bool_type:
os << v.as_string(); os << v.as_string();
@ -622,22 +629,22 @@ namespace fc
case variant::array_type: case variant::array_type:
{ {
const variants& a = v.get_array(); const variants& a = v.get_array();
to_stream( os, a ); to_stream( os, a, format );
return; return;
} }
case variant::object_type: case variant::object_type:
{ {
const variant_object& o = v.get_object(); const variant_object& o = v.get_object();
to_stream(os, o ); to_stream(os, o, format );
return; return;
} }
} }
} }
fc::string json::to_string( const variant& v ) fc::string json::to_string( const variant& v, output_formatting format /* = stringify_large_ints_and_doubles */ )
{ {
fc::stringstream ss; fc::stringstream ss;
fc::to_stream( ss, v ); fc::to_stream( ss, v, format );
return ss.str(); return ss.str();
} }
@ -732,23 +739,23 @@ namespace fc
fc::string json::to_pretty_string( const variant& v ) fc::string json::to_pretty_string( const variant& v, output_formatting format /* = stringify_large_ints_and_doubles */ )
{ {
return pretty_print(to_string(v), 2); return pretty_print(to_string(v, format), 2);
} }
void json::save_to_file( const variant& v, const fc::path& fi, bool pretty ) void json::save_to_file( const variant& v, const fc::path& fi, bool pretty, output_formatting format /* = stringify_large_ints_and_doubles */ )
{ {
if( pretty ) if( pretty )
{ {
auto str = json::to_pretty_string( v ); auto str = json::to_pretty_string( v, format );
fc::ofstream o(fi); fc::ofstream o(fi);
o.write( str.c_str(), str.size() ); o.write( str.c_str(), str.size() );
} }
else else
{ {
fc::ofstream o(fi); fc::ofstream o(fi);
fc::to_stream( o, v ); fc::to_stream( o, v, format );
} }
} }
variant json::from_file( const fc::path& p, parse_type ptype ) variant json::from_file( const fc::path& p, parse_type ptype )
@ -760,7 +767,9 @@ namespace fc
switch( ptype ) switch( ptype )
{ {
case legacy_parser: case legacy_parser:
return variant_from_stream( bi ); return variant_from_stream<boost::filesystem::ifstream, legacy_parser>( bi );
case legacy_parser_with_string_doubles:
return variant_from_stream<boost::filesystem::ifstream, legacy_parser_with_string_doubles>( bi );
case strict_parser: case strict_parser:
return json_relaxed::variant_from_stream<boost::filesystem::ifstream, true>( bi ); return json_relaxed::variant_from_stream<boost::filesystem::ifstream, true>( bi );
case relaxed_parser: case relaxed_parser:
@ -774,7 +783,9 @@ namespace fc
switch( ptype ) switch( ptype )
{ {
case legacy_parser: case legacy_parser:
return variant_from_stream( in ); return variant_from_stream<fc::buffered_istream, legacy_parser>( in );
case legacy_parser_with_string_doubles:
return variant_from_stream<fc::buffered_istream, legacy_parser_with_string_doubles>( in );
case strict_parser: case strict_parser:
return json_relaxed::variant_from_stream<buffered_istream, true>( in ); return json_relaxed::variant_from_stream<buffered_istream, true>( in );
case relaxed_parser: case relaxed_parser:
@ -784,19 +795,19 @@ namespace fc
} }
} }
ostream& json::to_stream( ostream& out, const variant& v ) ostream& json::to_stream( ostream& out, const variant& v, output_formatting format /* = stringify_large_ints_and_doubles */ )
{ {
fc::to_stream( out, v ); fc::to_stream( out, v, format );
return out; return out;
} }
ostream& json::to_stream( ostream& out, const variants& v ) ostream& json::to_stream( ostream& out, const variants& v, output_formatting format /* = stringify_large_ints_and_doubles */ )
{ {
fc::to_stream( out, v ); fc::to_stream( out, v, format );
return out; return out;
} }
ostream& json::to_stream( ostream& out, const variant_object& v ) ostream& json::to_stream( ostream& out, const variant_object& v, output_formatting format /* = stringify_large_ints_and_doubles */ )
{ {
fc::to_stream( out, v ); fc::to_stream( out, v, format );
return out; return out;
} }
@ -807,7 +818,10 @@ namespace fc
switch( ptype ) switch( ptype )
{ {
case legacy_parser: case legacy_parser:
variant_from_stream( in ); variant_from_stream<fc::stringstream, legacy_parser>( in );
break;
case legacy_parser_with_string_doubles:
variant_from_stream<fc::stringstream, legacy_parser_with_string_doubles>( in );
break; break;
case strict_parser: case strict_parser:
json_relaxed::variant_from_stream<fc::stringstream, true>( in ); json_relaxed::variant_from_stream<fc::stringstream, true>( in );

10
src/string.cpp
View file

@ -9,6 +9,7 @@
#include <sstream> #include <sstream>
#include <iomanip> #include <iomanip>
#include <locale> #include <locale>
#include <limits>
/** /**
* Implemented with std::string for now. * Implemented with std::string for now.
@ -127,11 +128,12 @@ namespace fc {
FC_RETHROW_EXCEPTIONS( warn, "${i} => double", ("i",i) ) FC_RETHROW_EXCEPTIONS( warn, "${i} => double", ("i",i) )
} }
fc::string to_string( double d) fc::string to_string(double d)
{ {
std::stringstream ss; // +2 is required to ensure that the double is rounded correctly when read back in. http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html
ss << std::setprecision(12) << std::fixed << d; std::stringstream ss;
return ss.str(); //boost::lexical_cast<std::string>(d); ss << std::setprecision(std::numeric_limits<double>::digits10 + 2) << std::fixed << d;
return ss.str();
} }
fc::string to_string( uint64_t d) fc::string to_string( uint64_t d)