LBRYCommunity/lbrycrd
1
0
Fork 0
Code Issues 29 Pull requests 1 Projects Releases 32 Packages Wiki Activity

Merge pull request #3127 from jgarzik/smells-like-json-spirit

Browse source 
Revert recent json-spirit changes
This commit is contained in:
Jeff Garzik 2013-10-22 07:25:54 -07:00
commit fcb9f26466
18 changed files with 404 additions and 703 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
src/bitcoinrpc.cpp
View file

@ -31,8 +31,6 @@ using namespace boost;
using namespace boost::asio; using namespace boost::asio;
using namespace json_spirit; using namespace json_spirit;
static const char* Value_type_name[]={"obj", "array", "str", "bool", "int", "real", "null"};
static std::string strRPCUserColonPass; static std::string strRPCUserColonPass;
// These are created by StartRPCThreads, destroyed in StopRPCThreads // These are created by StartRPCThreads, destroyed in StopRPCThreads
@ -533,7 +531,7 @@ string JSONRPCRequest(const string& strMethod, const Array& params, const Value&
request.push_back(Pair("method", strMethod)); request.push_back(Pair("method", strMethod));
request.push_back(Pair("params", params)); request.push_back(Pair("params", params));
request.push_back(Pair("id", id)); request.push_back(Pair("id", id));
return write_string(Value(request), raw_utf8) + "\n"; return write_string(Value(request), false) + "\n";
} }
Object JSONRPCReplyObj(const Value& result, const Value& error, const Value& id) Object JSONRPCReplyObj(const Value& result, const Value& error, const Value& id)
@ -551,7 +549,7 @@ Object JSONRPCReplyObj(const Value& result, const Value& error, const Value& id)
string JSONRPCReply(const Value& result, const Value& error, const Value& id) string JSONRPCReply(const Value& result, const Value& error, const Value& id)
{ {
Object reply = JSONRPCReplyObj(result, error, id); Object reply = JSONRPCReplyObj(result, error, id);
return write_string(Value(reply), raw_utf8) + "\n"; return write_string(Value(reply), false) + "\n";
} }
void ErrorReply(std::ostream& stream, const Object& objError, const Value& id) void ErrorReply(std::ostream& stream, const Object& objError, const Value& id)
@ -982,7 +980,7 @@ static string JSONRPCExecBatch(const Array& vReq)
for (unsigned int reqIdx = 0; reqIdx < vReq.size(); reqIdx++) for (unsigned int reqIdx = 0; reqIdx < vReq.size(); reqIdx++)
ret.push_back(JSONRPCExecOne(vReq[reqIdx])); ret.push_back(JSONRPCExecOne(vReq[reqIdx]));
return write_string(Value(ret), raw_utf8) + "\n"; return write_string(Value(ret), false) + "\n";
} }
void ServiceConnection(AcceptedConnection *conn) void ServiceConnection(AcceptedConnection *conn)
@ -1284,7 +1282,7 @@ int CommandLineRPC(int argc, char *argv[])
if (error.type() != null_type) if (error.type() != null_type)
{ {
// Error // Error
strPrint = "error: " + write_string(error, raw_utf8); strPrint = "error: " + write_string(error, false);
int code = find_value(error.get_obj(), "code").get_int(); int code = find_value(error.get_obj(), "code").get_int();
nRet = abs(code); nRet = abs(code);
} }
@ -1296,7 +1294,7 @@ int CommandLineRPC(int argc, char *argv[])
else if (result.type() == str_type) else if (result.type() == str_type)
strPrint = result.get_str(); strPrint = result.get_str();
else else
strPrint = write_string(result, pretty_print | raw_utf8); strPrint = write_string(result, true);
} }
} }
catch (boost::thread_interrupted) { catch (boost::thread_interrupted) {

2
src/json/LICENSE.txt
View file

@ -1,6 +1,6 @@
The MIT License The MIT License
Copyright (c) 2007 - 2010 John W. Wilkinson Copyright (c) 2007 - 2009 John W. Wilkinson
Permission is hereby granted, free of charge, to any person Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation obtaining a copy of this software and associated documentation

4
src/json/json_spirit.h
View file

@ -1,10 +1,10 @@
#ifndef JSON_SPIRIT #ifndef JSON_SPIRIT
#define JSON_SPIRIT #define JSON_SPIRIT
// Copyright John W. Wilkinson 2007 - 2013 // Copyright John W. Wilkinson 2007 - 2009.
// Distributed under the MIT License, see accompanying file LICENSE.txt // Distributed under the MIT License, see accompanying file LICENSE.txt
// json spirit version 4.06 // json spirit version 4.03
#if defined(_MSC_VER) && (_MSC_VER >= 1020) #if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once # pragma once

6
src/json/json_spirit_error_position.h
View file

@ -1,10 +1,10 @@
#ifndef JSON_SPIRIT_ERROR_POSITION #ifndef JSON_SPIRIT_ERROR_POSITION
#define JSON_SPIRIT_ERROR_POSITION #define JSON_SPIRIT_ERROR_POSITION
// Copyright John W. Wilkinson 2007 - 2013 // Copyright John W. Wilkinson 2007 - 2009.
// Distributed under the MIT License, see accompanying file LICENSE.txt // Distributed under the MIT License, see accompanying file LICENSE.txt
// json spirit version 4.06 // json spirit version 4.03
#if defined(_MSC_VER) && (_MSC_VER >= 1020) #if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once # pragma once
@ -48,7 +48,7 @@ namespace json_spirit
return ( reason_ == lhs.reason_ ) && return ( reason_ == lhs.reason_ ) &&
( line_ == lhs.line_ ) && ( line_ == lhs.line_ ) &&
( column_ == lhs.column_ ); ( column_ == lhs.column_ );
} }
} }
#endif #endif

234
src/json/json_spirit_reader.cpp
View file

@ -1,137 +1,137 @@
// Copyright John W. Wilkinson 2007 - 2013 // Copyright John W. Wilkinson 2007 - 2009.
// Distributed under the MIT License, see accompanying file LICENSE.txt // Distributed under the MIT License, see accompanying file LICENSE.txt
// json spirit version 4.06 // json spirit version 4.03
#include "json_spirit_reader.h" #include "json_spirit_reader.h"
#include "json_spirit_reader_template.h" #include "json_spirit_reader_template.h"
using namespace json_spirit; using namespace json_spirit;
#ifdef JSON_SPIRIT_VALUE_ENABLED bool json_spirit::read( const std::string& s, Value& value )
bool json_spirit::read( const std::string& s, Value& value ) {
{ return read_string( s, value );
return read_string( s, value ); }
}
void json_spirit::read_or_throw( const std::string& s, Value& value )
{
read_string_or_throw( s, value );
}
bool json_spirit::read( std::istream& is, Value& value ) void json_spirit::read_or_throw( const std::string& s, Value& value )
{ {
return read_stream( is, value ); read_string_or_throw( s, value );
} }
void json_spirit::read_or_throw( std::istream& is, Value& value ) bool json_spirit::read( std::istream& is, Value& value )
{ {
read_stream_or_throw( is, value ); return read_stream( is, value );
} }
bool json_spirit::read( std::string::const_iterator& begin, std::string::const_iterator end, Value& value ) void json_spirit::read_or_throw( std::istream& is, Value& value )
{ {
return read_range( begin, end, value ); read_stream_or_throw( is, value );
} }
bool json_spirit::read( std::string::const_iterator& begin, std::string::const_iterator end, Value& value )
{
return read_range( begin, end, value );
}
void json_spirit::read_or_throw( std::string::const_iterator& begin, std::string::const_iterator end, Value& value )
{
begin = read_range_or_throw( begin, end, value );
}
#ifndef BOOST_NO_STD_WSTRING
bool json_spirit::read( const std::wstring& s, wValue& value )
{
return read_string( s, value );
}
void json_spirit::read_or_throw( const std::wstring& s, wValue& value )
{
read_string_or_throw( s, value );
}
bool json_spirit::read( std::wistream& is, wValue& value )
{
return read_stream( is, value );
}
void json_spirit::read_or_throw( std::wistream& is, wValue& value )
{
read_stream_or_throw( is, value );
}
bool json_spirit::read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wValue& value )
{
return read_range( begin, end, value );
}
void json_spirit::read_or_throw( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wValue& value )
{
begin = read_range_or_throw( begin, end, value );
}
void json_spirit::read_or_throw( std::string::const_iterator& begin, std::string::const_iterator end, Value& value )
{
begin = read_range_or_throw( begin, end, value );
}
#endif #endif
#if defined( JSON_SPIRIT_WVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING ) bool json_spirit::read( const std::string& s, mValue& value )
bool json_spirit::read( const std::wstring& s, wValue& value ) {
{ return read_string( s, value );
return read_string( s, value ); }
}
void json_spirit::read_or_throw( const std::wstring& s, wValue& value ) void json_spirit::read_or_throw( const std::string& s, mValue& value )
{ {
read_string_or_throw( s, value ); read_string_or_throw( s, value );
} }
bool json_spirit::read( std::wistream& is, wValue& value ) bool json_spirit::read( std::istream& is, mValue& value )
{ {
return read_stream( is, value ); return read_stream( is, value );
} }
void json_spirit::read_or_throw( std::wistream& is, wValue& value ) void json_spirit::read_or_throw( std::istream& is, mValue& value )
{ {
read_stream_or_throw( is, value ); read_stream_or_throw( is, value );
} }
bool json_spirit::read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wValue& value ) bool json_spirit::read( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value )
{ {
return read_range( begin, end, value ); return read_range( begin, end, value );
} }
void json_spirit::read_or_throw( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value )
{
begin = read_range_or_throw( begin, end, value );
}
#ifndef BOOST_NO_STD_WSTRING
bool json_spirit::read( const std::wstring& s, wmValue& value )
{
return read_string( s, value );
}
void json_spirit::read_or_throw( const std::wstring& s, wmValue& value )
{
read_string_or_throw( s, value );
}
bool json_spirit::read( std::wistream& is, wmValue& value )
{
return read_stream( is, value );
}
void json_spirit::read_or_throw( std::wistream& is, wmValue& value )
{
read_stream_or_throw( is, value );
}
bool json_spirit::read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wmValue& value )
{
return read_range( begin, end, value );
}
void json_spirit::read_or_throw( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wmValue& value )
{
begin = read_range_or_throw( begin, end, value );
}
void json_spirit::read_or_throw( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wValue& value )
{
begin = read_range_or_throw( begin, end, value );
}
#endif
#ifdef JSON_SPIRIT_MVALUE_ENABLED
bool json_spirit::read( const std::string& s, mValue& value )
{
return read_string( s, value );
}
void json_spirit::read_or_throw( const std::string& s, mValue& value )
{
read_string_or_throw( s, value );
}
bool json_spirit::read( std::istream& is, mValue& value )
{
return read_stream( is, value );
}
void json_spirit::read_or_throw( std::istream& is, mValue& value )
{
read_stream_or_throw( is, value );
}
bool json_spirit::read( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value )
{
return read_range( begin, end, value );
}
void json_spirit::read_or_throw( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value )
{
begin = read_range_or_throw( begin, end, value );
}
#endif
#if defined( JSON_SPIRIT_WMVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
bool json_spirit::read( const std::wstring& s, wmValue& value )
{
return read_string( s, value );
}
void json_spirit::read_or_throw( const std::wstring& s, wmValue& value )
{
read_string_or_throw( s, value );
}
bool json_spirit::read( std::wistream& is, wmValue& value )
{
return read_stream( is, value );
}
void json_spirit::read_or_throw( std::wistream& is, wmValue& value )
{
read_stream_or_throw( is, value );
}
bool json_spirit::read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wmValue& value )
{
return read_range( begin, end, value );
}
void json_spirit::read_or_throw( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wmValue& value )
{
begin = read_range_or_throw( begin, end, value );
}
#endif #endif

16
src/json/json_spirit_reader.h
View file

@ -1,10 +1,10 @@
#ifndef JSON_SPIRIT_READER #ifndef JSON_SPIRIT_READER
#define JSON_SPIRIT_READER #define JSON_SPIRIT_READER
// Copyright John W. Wilkinson 2007 - 2013 // Copyright John W. Wilkinson 2007 - 2009.
// Distributed under the MIT License, see accompanying file LICENSE.txt // Distributed under the MIT License, see accompanying file LICENSE.txt
// json spirit version 4.06 // json spirit version 4.03
#if defined(_MSC_VER) && (_MSC_VER >= 1020) #if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once # pragma once
@ -18,7 +18,6 @@ namespace json_spirit
{ {
// functions to reads a JSON values // functions to reads a JSON values
#ifdef JSON_SPIRIT_VALUE_ENABLED
bool read( const std::string& s, Value& value ); bool read( const std::string& s, Value& value );
bool read( std::istream& is, Value& value ); bool read( std::istream& is, Value& value );
bool read( std::string::const_iterator& begin, std::string::const_iterator end, Value& value ); bool read( std::string::const_iterator& begin, std::string::const_iterator end, Value& value );
@ -26,9 +25,9 @@ namespace json_spirit
void read_or_throw( const std::string& s, Value& value ); void read_or_throw( const std::string& s, Value& value );
void read_or_throw( std::istream& is, Value& value ); void read_or_throw( std::istream& is, Value& value );
void read_or_throw( std::string::const_iterator& begin, std::string::const_iterator end, Value& value ); void read_or_throw( std::string::const_iterator& begin, std::string::const_iterator end, Value& value );
#endif
#if defined( JSON_SPIRIT_WVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING ) #ifndef BOOST_NO_STD_WSTRING
bool read( const std::wstring& s, wValue& value ); bool read( const std::wstring& s, wValue& value );
bool read( std::wistream& is, wValue& value ); bool read( std::wistream& is, wValue& value );
bool read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wValue& value ); bool read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wValue& value );
@ -36,9 +35,9 @@ namespace json_spirit
void read_or_throw( const std::wstring& s, wValue& value ); void read_or_throw( const std::wstring& s, wValue& value );
void read_or_throw( std::wistream& is, wValue& value ); void read_or_throw( std::wistream& is, wValue& value );
void read_or_throw( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wValue& value ); void read_or_throw( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wValue& value );
#endif #endif
#ifdef JSON_SPIRIT_MVALUE_ENABLED
bool read( const std::string& s, mValue& value ); bool read( const std::string& s, mValue& value );
bool read( std::istream& is, mValue& value ); bool read( std::istream& is, mValue& value );
bool read( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value ); bool read( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value );
@ -46,9 +45,9 @@ namespace json_spirit
void read_or_throw( const std::string& s, mValue& value ); void read_or_throw( const std::string& s, mValue& value );
void read_or_throw( std::istream& is, mValue& value ); void read_or_throw( std::istream& is, mValue& value );
void read_or_throw( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value ); void read_or_throw( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value );
#endif
#if defined( JSON_SPIRIT_WMVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING ) #ifndef BOOST_NO_STD_WSTRING
bool read( const std::wstring& s, wmValue& value ); bool read( const std::wstring& s, wmValue& value );
bool read( std::wistream& is, wmValue& value ); bool read( std::wistream& is, wmValue& value );
bool read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wmValue& value ); bool read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wmValue& value );
@ -56,6 +55,7 @@ namespace json_spirit
void read_or_throw( const std::wstring& s, wmValue& value ); void read_or_throw( const std::wstring& s, wmValue& value );
void read_or_throw( std::wistream& is, wmValue& value ); void read_or_throw( std::wistream& is, wmValue& value );
void read_or_throw( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wmValue& value ); void read_or_throw( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wmValue& value );
#endif #endif
} }

140
src/json/json_spirit_reader_template.h
View file

@ -1,14 +1,10 @@
#ifndef JSON_SPIRIT_READER_TEMPLATE #ifndef JSON_SPIRIT_READER_TEMPLATE
#define JSON_SPIRIT_READER_TEMPLATE #define JSON_SPIRIT_READER_TEMPLATE
// Copyright John W. Wilkinson 2007 - 2013 // Copyright John W. Wilkinson 2007 - 2009.
// Distributed under the MIT License, see accompanying file LICENSE.txt // Distributed under the MIT License, see accompanying file LICENSE.txt
// json spirit version 4.06 // json spirit version 4.03
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include "json_spirit_value.h" #include "json_spirit_value.h"
#include "json_spirit_error_position.h" #include "json_spirit_error_position.h"
@ -488,7 +484,7 @@ namespace json_spirit
; ;
string_ string_
= lexeme_d // this causes white space and what would appear to be comments inside a string to be retained = lexeme_d // this causes white space inside a string to be retained
[ [
confix_p confix_p
( (
@ -518,6 +514,25 @@ namespace json_spirit
Semantic_actions_t& actions_; Semantic_actions_t& actions_;
}; };
template< class Iter_type, class Value_type >
Iter_type read_range_or_throw( Iter_type begin, Iter_type end, Value_type& value )
{
Semantic_actions< Value_type, Iter_type > semantic_actions( value );
const spirit_namespace::parse_info< Iter_type > info =
spirit_namespace::parse( begin, end,
Json_grammer< Value_type, Iter_type >( semantic_actions ),
spirit_namespace::space_p );
if( !info.hit )
{
assert( false ); // in theory exception should already have been thrown
throw_error( info.stop, "error" );
}
return info.stop;
}
template< class Iter_type, class Value_type > template< class Iter_type, class Value_type >
void add_posn_iter_and_read_range_or_throw( Iter_type begin, Iter_type end, Value_type& value ) void add_posn_iter_and_read_range_or_throw( Iter_type begin, Iter_type end, Value_type& value )
{ {
@ -529,6 +544,35 @@ namespace json_spirit
read_range_or_throw( posn_begin, posn_end, value ); read_range_or_throw( posn_begin, posn_end, value );
} }
template< class Iter_type, class Value_type >
bool read_range( Iter_type& begin, Iter_type end, Value_type& value )
{
try
{
begin = read_range_or_throw( begin, end, value );
return true;
}
catch( ... )
{
return false;
}
}
template< class String_type, class Value_type >
void read_string_or_throw( const String_type& s, Value_type& value )
{
add_posn_iter_and_read_range_or_throw( s.begin(), s.end(), value );
}
template< class String_type, class Value_type >
bool read_string( const String_type& s, Value_type& value )
{
typename String_type::const_iterator begin = s.begin();
return read_range( begin, s.end(), value );
}
template< class Istream_type > template< class Istream_type >
struct Multi_pass_iters struct Multi_pass_iters
{ {
@ -548,84 +592,6 @@ namespace json_spirit
Mp_iter end_; Mp_iter end_;
}; };
// reads a JSON Value from a pair of input iterators throwing an exception on invalid input, e.g.
//
// string::const_iterator start = str.begin();
// const string::const_iterator next = read_range_or_throw( str.begin(), str.end(), value );
//
// The iterator 'next' will point to the character past the
// last one read.
//
template< class Iter_type, class Value_type >
Iter_type read_range_or_throw( Iter_type begin, Iter_type end, Value_type& value )
{
Semantic_actions< Value_type, Iter_type > semantic_actions( value );
const spirit_namespace::parse_info< Iter_type > info =
spirit_namespace::parse( begin, end,
Json_grammer< Value_type, Iter_type >( semantic_actions ),
spirit_namespace::space_p |
spirit_namespace::comment_p("//") |
spirit_namespace::comment_p("/*", "*/") );
if( !info.hit )
{
assert( false ); // in theory exception should already have been thrown
throw_error( info.stop, "error" );
}
return info.stop;
}
// reads a JSON Value from a pair of input iterators, e.g.
//
// string::const_iterator start = str.begin();
// const bool success = read_string( start, str.end(), value );
//
// The iterator 'start' will point to the character past the
// last one read.
//
template< class Iter_type, class Value_type >
bool read_range( Iter_type& begin, Iter_type end, Value_type& value )
{
try
{
begin = read_range_or_throw( begin, end, value );
return true;
}
catch( ... )
{
return false;
}
}
// reads a JSON Value from a string, e.g.
//
// const bool success = read_string( str, value );
//
template< class String_type, class Value_type >
bool read_string( const String_type& s, Value_type& value )
{
typename String_type::const_iterator begin = s.begin();
return read_range( begin, s.end(), value );
}
// reads a JSON Value from a string throwing an exception on invalid input, e.g.
//
// read_string_or_throw( is, value );
//
template< class String_type, class Value_type >
void read_string_or_throw( const String_type& s, Value_type& value )
{
add_posn_iter_and_read_range_or_throw( s.begin(), s.end(), value );
}
// reads a JSON Value from a stream, e.g.
//
// const bool success = read_stream( is, value );
//
template< class Istream_type, class Value_type > template< class Istream_type, class Value_type >
bool read_stream( Istream_type& is, Value_type& value ) bool read_stream( Istream_type& is, Value_type& value )
{ {
@ -634,10 +600,6 @@ namespace json_spirit
return read_range( mp_iters.begin_, mp_iters.end_, value ); return read_range( mp_iters.begin_, mp_iters.end_, value );
} }
// reads a JSON Value from a stream throwing an exception on invalid input, e.g.
//
// read_stream_or_throw( is, value );
//
template< class Istream_type, class Value_type > template< class Istream_type, class Value_type >
void read_stream_or_throw( Istream_type& is, Value_type& value ) void read_stream_or_throw( Istream_type& is, Value_type& value )
{ {

4
src/json/json_spirit_stream_reader.h
View file

@ -1,10 +1,10 @@
#ifndef JSON_SPIRIT_READ_STREAM #ifndef JSON_SPIRIT_READ_STREAM
#define JSON_SPIRIT_READ_STREAM #define JSON_SPIRIT_READ_STREAM
// Copyright John W. Wilkinson 2007 - 2013 // Copyright John W. Wilkinson 2007 - 2009.
// Distributed under the MIT License, see accompanying file LICENSE.txt // Distributed under the MIT License, see accompanying file LICENSE.txt
// json spirit version 4.06 // json spirit version 4.03
#if defined(_MSC_VER) && (_MSC_VER >= 1020) #if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once # pragma once

8
src/json/json_spirit_utils.h
View file

@ -1,10 +1,10 @@
#ifndef JSON_SPIRIT_UTILS #ifndef JSON_SPIRIT_UTILS
#define JSON_SPIRIT_UTILS #define JSON_SPIRIT_UTILS
// Copyright John W. Wilkinson 2007 - 2013 // Copyright John W. Wilkinson 2007 - 2009.
// Distributed under the MIT License, see accompanying file LICENSE.txt // Distributed under the MIT License, see accompanying file LICENSE.txt
// json spirit version 4.06 // json spirit version 4.03
#if defined(_MSC_VER) && (_MSC_VER >= 1020) #if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once # pragma once
@ -37,11 +37,9 @@ namespace json_spirit
} }
} }
#ifdef JSON_SPIRIT_VALUE_ENABLED
typedef std::map< std::string, Value > Mapped_obj; typedef std::map< std::string, Value > Mapped_obj;
#endif
#if defined( JSON_SPIRIT_WVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING ) #ifndef BOOST_NO_STD_WSTRING
typedef std::map< std::wstring, wValue > wMapped_obj; typedef std::map< std::wstring, wValue > wMapped_obj;
#endif #endif

203
src/json/json_spirit_value.h
View file

@ -1,10 +1,10 @@
#ifndef JSON_SPIRIT_VALUE #ifndef JSON_SPIRIT_VALUE
#define JSON_SPIRIT_VALUE #define JSON_SPIRIT_VALUE
// Copyright John W. Wilkinson 2007 - 2013 // Copyright John W. Wilkinson 2007 - 2009.
// Distributed under the MIT License, see accompanying file LICENSE.txt // Distributed under the MIT License, see accompanying file LICENSE.txt
// json spirit version 4.06 // json spirit version 4.03
#if defined(_MSC_VER) && (_MSC_VER >= 1020) #if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once # pragma once
@ -21,20 +21,11 @@
#include <boost/shared_ptr.hpp> #include <boost/shared_ptr.hpp>
#include <boost/variant.hpp> #include <boost/variant.hpp>
// comment out the value types you don't need to reduce build times and intermediate file sizes
#define JSON_SPIRIT_VALUE_ENABLED
#define JSON_SPIRIT_WVALUE_ENABLED
#define JSON_SPIRIT_MVALUE_ENABLED
#define JSON_SPIRIT_WMVALUE_ENABLED
namespace json_spirit namespace json_spirit
{ {
enum Value_type{ obj_type, array_type, str_type, bool_type, int_type, real_type, null_type }; enum Value_type{ obj_type, array_type, str_type, bool_type, int_type, real_type, null_type };
static const char* Value_type_name[]={"obj", "array", "str", "bool", "int", "real", "null"};
static std::string value_type_to_string( Value_type vtype );
struct Null{};
template< class Config > // Config determines whether the value uses std::string or std::wstring and template< class Config > // Config determines whether the value uses std::string or std::wstring and
// whether JSON Objects are represented as vectors or maps // whether JSON Objects are represented as vectors or maps
class Value_impl class Value_impl
@ -58,12 +49,6 @@ namespace json_spirit
Value_impl( boost::uint64_t value ); Value_impl( boost::uint64_t value );
Value_impl( double value ); Value_impl( double value );
template< class Iter >
Value_impl( Iter first, Iter last ); // constructor from containers, e.g. std::vector or std::list
template< BOOST_VARIANT_ENUM_PARAMS( typename T ) >
Value_impl( const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& variant ); // constructor for compatible variant types
Value_impl( const Value_impl& other ); Value_impl( const Value_impl& other );
bool operator==( const Value_impl& lhs ) const; bool operator==( const Value_impl& lhs ) const;
@ -96,32 +81,13 @@ namespace json_spirit
void check_type( const Value_type vtype ) const; void check_type( const Value_type vtype ) const;
typedef boost::variant< boost::recursive_wrapper< Object >, boost::recursive_wrapper< Array >, typedef boost::variant< String_type,
String_type, bool, boost::int64_t, double, Null, boost::uint64_t > Variant; boost::recursive_wrapper< Object >, boost::recursive_wrapper< Array >,
bool, boost::int64_t, double > Variant;
Value_type type_;
Variant v_; Variant v_;
bool is_uint64_;
class Variant_converter_visitor : public boost::static_visitor< Variant >
{
public:
template< typename T, typename A, template< typename, typename > class Cont >
Variant operator()( const Cont< T, A >& cont ) const
{
return Array( cont.begin(), cont.end() );
}
Variant operator()( int i ) const
{
return static_cast< boost::int64_t >( i );
}
template<class T>
Variant operator()( const T& t ) const
{
return t;
}
};
}; };
// vector objects // vector objects
@ -132,10 +98,6 @@ namespace json_spirit
typedef typename Config::String_type String_type; typedef typename Config::String_type String_type;
typedef typename Config::Value_type Value_type; typedef typename Config::Value_type Value_type;
Pair_impl()
{
}
Pair_impl( const String_type& name, const Value_type& value ); Pair_impl( const String_type& name, const Value_type& value );
bool operator==( const Pair_impl& lhs ) const; bool operator==( const Pair_impl& lhs ) const;
@ -144,7 +106,6 @@ namespace json_spirit
Value_type value_; Value_type value_;
}; };
#if defined( JSON_SPIRIT_VALUE_ENABLED ) || defined( JSON_SPIRIT_WVALUE_ENABLED )
template< class String > template< class String >
struct Config_vector struct Config_vector
{ {
@ -161,32 +122,30 @@ namespace json_spirit
return obj.back().value_; return obj.back().value_;
} }
static const String_type& get_name( const Pair_type& pair ) static String_type get_name( const Pair_type& pair )
{ {
return pair.name_; return pair.name_;
} }
static const Value_type& get_value( const Pair_type& pair ) static Value_type get_value( const Pair_type& pair )
{ {
return pair.value_; return pair.value_;
} }
}; };
#endif
// typedefs for ASCII // typedefs for ASCII
#ifdef JSON_SPIRIT_VALUE_ENABLED
typedef Config_vector< std::string > Config; typedef Config_vector< std::string > Config;
typedef Config::Value_type Value; typedef Config::Value_type Value;
typedef Config::Pair_type Pair; typedef Config::Pair_type Pair;
typedef Config::Object_type Object; typedef Config::Object_type Object;
typedef Config::Array_type Array; typedef Config::Array_type Array;
#endif
// typedefs for Unicode // typedefs for Unicode
#if defined( JSON_SPIRIT_WVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING ) #ifndef BOOST_NO_STD_WSTRING
typedef Config_vector< std::wstring > wConfig; typedef Config_vector< std::wstring > wConfig;
typedef wConfig::Value_type wValue; typedef wConfig::Value_type wValue;
@ -197,7 +156,6 @@ namespace json_spirit
// map objects // map objects
#if defined( JSON_SPIRIT_MVALUE_ENABLED ) || defined( JSON_SPIRIT_WMVALUE_ENABLED )
template< class String > template< class String >
struct Config_map struct Config_map
{ {
@ -205,134 +163,135 @@ namespace json_spirit
typedef Value_impl< Config_map > Value_type; typedef Value_impl< Config_map > Value_type;
typedef std::vector< Value_type > Array_type; typedef std::vector< Value_type > Array_type;
typedef std::map< String_type, Value_type > Object_type; typedef std::map< String_type, Value_type > Object_type;
typedef std::pair< const String_type, Value_type > Pair_type; typedef typename Object_type::value_type Pair_type;
static Value_type& add( Object_type& obj, const String_type& name, const Value_type& value ) static Value_type& add( Object_type& obj, const String_type& name, const Value_type& value )
{ {
return obj[ name ] = value; return obj[ name ] = value;
} }
static const String_type& get_name( const Pair_type& pair ) static String_type get_name( const Pair_type& pair )
{ {
return pair.first; return pair.first;
} }
static const Value_type& get_value( const Pair_type& pair ) static Value_type get_value( const Pair_type& pair )
{ {
return pair.second; return pair.second;
} }
}; };
#endif
// typedefs for ASCII // typedefs for ASCII
#ifdef JSON_SPIRIT_MVALUE_ENABLED
typedef Config_map< std::string > mConfig; typedef Config_map< std::string > mConfig;
typedef mConfig::Value_type mValue; typedef mConfig::Value_type mValue;
typedef mConfig::Object_type mObject; typedef mConfig::Object_type mObject;
typedef mConfig::Array_type mArray; typedef mConfig::Array_type mArray;
#endif
// typedefs for Unicode // typedefs for Unicode
#if defined( JSON_SPIRIT_WMVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING ) #ifndef BOOST_NO_STD_WSTRING
typedef Config_map< std::wstring > wmConfig; typedef Config_map< std::wstring > wmConfig;
typedef wmConfig::Value_type wmValue; typedef wmConfig::Value_type wmValue;
typedef wmConfig::Object_type wmObject; typedef wmConfig::Object_type wmObject;
typedef wmConfig::Array_type wmArray; typedef wmConfig::Array_type wmArray;
#endif #endif
/////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////
// //
// implementation // implementation
inline bool operator==( const Null&, const Null& )
{
return true;
}
template< class Config > template< class Config >
const Value_impl< Config > Value_impl< Config >::null; const Value_impl< Config > Value_impl< Config >::null;
template< class Config > template< class Config >
Value_impl< Config >::Value_impl() Value_impl< Config >::Value_impl()
: v_( Null() ) : type_( null_type )
, is_uint64_( false )
{ {
} }
template< class Config > template< class Config >
Value_impl< Config >::Value_impl( const Const_str_ptr value ) Value_impl< Config >::Value_impl( const Const_str_ptr value )
: v_( String_type( value ) ) : type_( str_type )
, v_( String_type( value ) )
, is_uint64_( false )
{ {
} }
template< class Config > template< class Config >
Value_impl< Config >::Value_impl( const String_type& value ) Value_impl< Config >::Value_impl( const String_type& value )
: v_( value ) : type_( str_type )
, v_( value )
, is_uint64_( false )
{ {
} }
template< class Config > template< class Config >
Value_impl< Config >::Value_impl( const Object& value ) Value_impl< Config >::Value_impl( const Object& value )
: v_( value ) : type_( obj_type )
, v_( value )
, is_uint64_( false )
{ {
} }
template< class Config > template< class Config >
Value_impl< Config >::Value_impl( const Array& value ) Value_impl< Config >::Value_impl( const Array& value )
: v_( value ) : type_( array_type )
, v_( value )
, is_uint64_( false )
{ {
} }
template< class Config > template< class Config >
Value_impl< Config >::Value_impl( bool value ) Value_impl< Config >::Value_impl( bool value )
: v_( value ) : type_( bool_type )
, v_( value )
, is_uint64_( false )
{ {
} }
template< class Config > template< class Config >
Value_impl< Config >::Value_impl( int value ) Value_impl< Config >::Value_impl( int value )
: v_( static_cast< boost::int64_t >( value ) ) : type_( int_type )
, v_( static_cast< boost::int64_t >( value ) )
, is_uint64_( false )
{ {
} }
template< class Config > template< class Config >
Value_impl< Config >::Value_impl( boost::int64_t value ) Value_impl< Config >::Value_impl( boost::int64_t value )
: v_( value ) : type_( int_type )
, v_( value )
, is_uint64_( false )
{ {
} }
template< class Config > template< class Config >
Value_impl< Config >::Value_impl( boost::uint64_t value ) Value_impl< Config >::Value_impl( boost::uint64_t value )
: v_( value ) : type_( int_type )
, v_( static_cast< boost::int64_t >( value ) )
, is_uint64_( true )
{ {
} }
template< class Config > template< class Config >
Value_impl< Config >::Value_impl( double value ) Value_impl< Config >::Value_impl( double value )
: v_( value ) : type_( real_type )
, v_( value )
, is_uint64_( false )
{ {
} }
template< class Config > template< class Config >
Value_impl< Config >::Value_impl( const Value_impl< Config >& other ) Value_impl< Config >::Value_impl( const Value_impl< Config >& other )
: v_( other.v_ ) : type_( other.type() )
{ , v_( other.v_ )
} , is_uint64_( other.is_uint64_ )
template< class Config >
template< class Iter >
Value_impl< Config >::Value_impl( Iter first, Iter last )
: v_( Array( first, last ) )
{
}
template< class Config >
template< BOOST_VARIANT_ENUM_PARAMS( typename T ) >
Value_impl< Config >::Value_impl( const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& variant )
: v_( boost::apply_visitor( Variant_converter_visitor(), variant) )
{ {
} }
@ -341,7 +300,9 @@ namespace json_spirit
{ {
Value_impl tmp( lhs ); Value_impl tmp( lhs );
std::swap( type_, tmp.type_ );
std::swap( v_, tmp.v_ ); std::swap( v_, tmp.v_ );
std::swap( is_uint64_, tmp.is_uint64_ );
return *this; return *this;
} }
@ -359,18 +320,13 @@ namespace json_spirit
template< class Config > template< class Config >
Value_type Value_impl< Config >::type() const Value_type Value_impl< Config >::type() const
{ {
if( is_uint64() ) return type_;
{
return int_type;
}
return static_cast< Value_type >( v_.which() );
} }
template< class Config > template< class Config >
bool Value_impl< Config >::is_uint64() const bool Value_impl< Config >::is_uint64() const
{ {
return v_.which() == null_type + 1; return is_uint64_;
} }
template< class Config > template< class Config >
@ -386,7 +342,8 @@ namespace json_spirit
{ {
std::ostringstream os; std::ostringstream os;
os << "get_value< " << value_type_to_string( vtype ) << " > called on " << value_type_to_string( type() ) << " Value"; ///// Bitcoin: Tell the types by name instead of by number
os << "value is type " << Value_type_name[type()] << ", expected " << Value_type_name[vtype];
throw std::runtime_error( os.str() ); throw std::runtime_error( os.str() );
} }
@ -395,7 +352,7 @@ namespace json_spirit
template< class Config > template< class Config >
const typename Config::String_type& Value_impl< Config >::get_str() const const typename Config::String_type& Value_impl< Config >::get_str() const
{ {
check_type( str_type ); check_type( str_type );
return *boost::get< String_type >( &v_ ); return *boost::get< String_type >( &v_ );
} }
@ -411,7 +368,7 @@ namespace json_spirit
template< class Config > template< class Config >
const typename Value_impl< Config >::Array& Value_impl< Config >::get_array() const const typename Value_impl< Config >::Array& Value_impl< Config >::get_array() const
{ {
check_type( array_type ); check_type( array_type );
return *boost::get< Array >( &v_ ); return *boost::get< Array >( &v_ );
} }
@ -419,7 +376,7 @@ namespace json_spirit
template< class Config > template< class Config >
bool Value_impl< Config >::get_bool() const bool Value_impl< Config >::get_bool() const
{ {
check_type( bool_type ); check_type( bool_type );
return boost::get< bool >( v_ ); return boost::get< bool >( v_ );
} }
@ -427,7 +384,7 @@ namespace json_spirit
template< class Config > template< class Config >
int Value_impl< Config >::get_int() const int Value_impl< Config >::get_int() const
{ {
check_type( int_type ); check_type( int_type );
return static_cast< int >( get_int64() ); return static_cast< int >( get_int64() );
} }
@ -435,12 +392,7 @@ namespace json_spirit
template< class Config > template< class Config >
boost::int64_t Value_impl< Config >::get_int64() const boost::int64_t Value_impl< Config >::get_int64() const
{ {
check_type( int_type ); check_type( int_type );
if( is_uint64() )
{
return static_cast< boost::int64_t >( get_uint64() );
}
return boost::get< boost::int64_t >( v_ ); return boost::get< boost::int64_t >( v_ );
} }
@ -448,14 +400,9 @@ namespace json_spirit
template< class Config > template< class Config >
boost::uint64_t Value_impl< Config >::get_uint64() const boost::uint64_t Value_impl< Config >::get_uint64() const
{ {
check_type( int_type ); check_type( int_type );
if( !is_uint64() ) return static_cast< boost::uint64_t >( get_int64() );
{
return static_cast< boost::uint64_t >( get_int64() );
}
return boost::get< boost::uint64_t >( v_ );
} }
template< class Config > template< class Config >
@ -467,7 +414,7 @@ namespace json_spirit
: static_cast< double >( get_int64() ); : static_cast< double >( get_int64() );
} }
check_type( real_type ); check_type( real_type );
return boost::get< double >( v_ ); return boost::get< double >( v_ );
} }
@ -475,7 +422,7 @@ namespace json_spirit
template< class Config > template< class Config >
typename Value_impl< Config >::Object& Value_impl< Config >::get_obj() typename Value_impl< Config >::Object& Value_impl< Config >::get_obj()
{ {
check_type( obj_type ); check_type( obj_type );
return *boost::get< Object >( &v_ ); return *boost::get< Object >( &v_ );
} }
@ -483,7 +430,7 @@ namespace json_spirit
template< class Config > template< class Config >
typename Value_impl< Config >::Array& Value_impl< Config >::get_array() typename Value_impl< Config >::Array& Value_impl< Config >::get_array()
{ {
check_type( array_type ); check_type( array_type );
return *boost::get< Array >( &v_ ); return *boost::get< Array >( &v_ );
} }
@ -582,24 +529,6 @@ namespace json_spirit
{ {
return internal_::get_value( *this, internal_::Type_to_type< T >() ); return internal_::get_value( *this, internal_::Type_to_type< T >() );
} }
static std::string value_type_to_string( const Value_type vtype )
{
switch( vtype )
{
case obj_type: return "Object";
case array_type: return "Array";
case str_type: return "string";
case bool_type: return "boolean";
case int_type: return "integer";
case real_type: return "real";
case null_type: return "null";
}
assert( false );
return "unknown type";
}
} }
#endif #endif

161
src/json/json_spirit_writer.cpp
View file

@ -1,96 +1,95 @@
// Copyright John W. Wilkinson 2007 - 2013 // Copyright John W. Wilkinson 2007 - 2009.
// Distributed under the MIT License, see accompanying file LICENSE.txt // Distributed under the MIT License, see accompanying file LICENSE.txt
// json spirit version 4.06 // json spirit version 4.03
#include "json_spirit_writer.h" #include "json_spirit_writer.h"
#include "json_spirit_writer_template.h" #include "json_spirit_writer_template.h"
using namespace json_spirit; void json_spirit::write( const Value& value, std::ostream& os )
{
write_stream( value, os, false );
}
#ifdef JSON_SPIRIT_VALUE_ENABLED void json_spirit::write_formatted( const Value& value, std::ostream& os )
void json_spirit::write( const Value& value, std::ostream& os, unsigned int options ) {
{ write_stream( value, os, true );
write_stream( value, os, options ); }
}
std::string json_spirit::write( const Value& value, unsigned int options )
{
return write_string( value, options );
}
void json_spirit::write_formatted( const Value& value, std::ostream& os ) std::string json_spirit::write( const Value& value )
{ {
write_stream( value, os, pretty_print ); return write_string( value, false );
} }
std::string json_spirit::write_formatted( const Value& value )
{
return write_string( value, true );
}
#ifndef BOOST_NO_STD_WSTRING
void json_spirit::write( const wValue& value, std::wostream& os )
{
write_stream( value, os, false );
}
void json_spirit::write_formatted( const wValue& value, std::wostream& os )
{
write_stream( value, os, true );
}
std::wstring json_spirit::write( const wValue& value )
{
return write_string( value, false );
}
std::wstring json_spirit::write_formatted( const wValue& value )
{
return write_string( value, true );
}
std::string json_spirit::write_formatted( const Value& value )
{
return write_string( value, pretty_print );
}
#endif #endif
#ifdef JSON_SPIRIT_MVALUE_ENABLED void json_spirit::write( const mValue& value, std::ostream& os )
void json_spirit::write( const mValue& value, std::ostream& os, unsigned int options ) {
{ write_stream( value, os, false );
write_stream( value, os, options ); }
}
std::string json_spirit::write( const mValue& value, unsigned int options ) void json_spirit::write_formatted( const mValue& value, std::ostream& os )
{ {
return write_string( value, options ); write_stream( value, os, true );
} }
void json_spirit::write_formatted( const mValue& value, std::ostream& os ) std::string json_spirit::write( const mValue& value )
{ {
write_stream( value, os, pretty_print ); return write_string( value, false );
} }
std::string json_spirit::write_formatted( const mValue& value )
{
return write_string( value, true );
}
#ifndef BOOST_NO_STD_WSTRING
void json_spirit::write( const wmValue& value, std::wostream& os )
{
write_stream( value, os, false );
}
void json_spirit::write_formatted( const wmValue& value, std::wostream& os )
{
write_stream( value, os, true );
}
std::wstring json_spirit::write( const wmValue& value )
{
return write_string( value, false );
}
std::wstring json_spirit::write_formatted( const wmValue& value )
{
return write_string( value, true );
}
std::string json_spirit::write_formatted( const mValue& value )
{
return write_string( value, pretty_print );
}
#endif
#if defined( JSON_SPIRIT_WVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
void json_spirit::write( const wValue& value, std::wostream& os, unsigned int options )
{
write_stream( value, os, options );
}
std::wstring json_spirit::write( const wValue& value, unsigned int options )
{
return write_string( value, options );
}
void json_spirit::write_formatted( const wValue& value, std::wostream& os )
{
write_stream( value, os, pretty_print );
}
std::wstring json_spirit::write_formatted( const wValue& value )
{
return write_string( value, pretty_print );
}
#endif
#if defined( JSON_SPIRIT_WMVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
void json_spirit::write_formatted( const wmValue& value, std::wostream& os )
{
write_stream( value, os, pretty_print );
}
std::wstring json_spirit::write_formatted( const wmValue& value )
{
return write_string( value, pretty_print );
}
void json_spirit::write( const wmValue& value, std::wostream& os, unsigned int options )
{
write_stream( value, os, options );
}
std::wstring json_spirit::write( const wmValue& value, unsigned int options )
{
return write_string( value, options );
}
#endif #endif

61
src/json/json_spirit_writer.h
View file

@ -1,62 +1,49 @@
#ifndef JSON_SPIRIT_WRITER #ifndef JSON_SPIRIT_WRITER
#define JSON_SPIRIT_WRITER #define JSON_SPIRIT_WRITER
// Copyright John W. Wilkinson 2007 - 2013 // Copyright John W. Wilkinson 2007 - 2009.
// Distributed under the MIT License, see accompanying file LICENSE.txt // Distributed under the MIT License, see accompanying file LICENSE.txt
// json spirit version 4.06 // json spirit version 4.03
#if defined(_MSC_VER) && (_MSC_VER >= 1020) #if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once # pragma once
#endif #endif
#include "json_spirit_value.h" #include "json_spirit_value.h"
#include "json_spirit_writer_options.h"
#include <iostream> #include <iostream>
namespace json_spirit namespace json_spirit
{ {
// these functions to convert JSON Values to text // functions to convert JSON Values to text,
// the "formatted" versions add whitespace to format the output nicely
#ifdef JSON_SPIRIT_VALUE_ENABLED void write ( const Value& value, std::ostream& os );
void write( const Value& value, std::ostream& os, unsigned int options = 0 );
std::string write( const Value& value, unsigned int options = 0 );
#endif
#ifdef JSON_SPIRIT_MVALUE_ENABLED
void write( const mValue& value, std::ostream& os, unsigned int options = 0 );
std::string write( const mValue& value, unsigned int options = 0 );
#endif
#if defined( JSON_SPIRIT_WVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
void write( const wValue& value, std::wostream& os, unsigned int options = 0 );
std::wstring write( const wValue& value, unsigned int options = 0 );
#endif
#if defined( JSON_SPIRIT_WMVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
void write( const wmValue& value, std::wostream& os, unsigned int options = 0 );
std::wstring write( const wmValue& value, unsigned int options = 0 );
#endif
// these "formatted" versions of the "write" functions are the equivalent of the above functions
// with option "pretty_print"
#ifdef JSON_SPIRIT_VALUE_ENABLED
void write_formatted( const Value& value, std::ostream& os ); void write_formatted( const Value& value, std::ostream& os );
std::string write ( const Value& value );
std::string write_formatted( const Value& value ); std::string write_formatted( const Value& value );
#endif
#ifdef JSON_SPIRIT_MVALUE_ENABLED #ifndef BOOST_NO_STD_WSTRING
void write_formatted( const mValue& value, std::ostream& os );
std::string write_formatted( const mValue& value ); void write ( const wValue& value, std::wostream& os );
void write_formatted( const wValue& value, std::wostream& os );
std::wstring write ( const wValue& value );
std::wstring write_formatted( const wValue& value );
#endif #endif
#if defined( JSON_SPIRIT_WVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING ) void write ( const mValue& value, std::ostream& os );
void write_formatted( const wValue& value, std::wostream& os ); void write_formatted( const mValue& value, std::ostream& os );
std::wstring write_formatted( const wValue& value ); std::string write ( const mValue& value );
#endif std::string write_formatted( const mValue& value );
#if defined( JSON_SPIRIT_WMVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
#ifndef BOOST_NO_STD_WSTRING
void write ( const wmValue& value, std::wostream& os );
void write_formatted( const wmValue& value, std::wostream& os ); void write_formatted( const wmValue& value, std::wostream& os );
std::wstring write ( const wmValue& value );
std::wstring write_formatted( const wmValue& value ); std::wstring write_formatted( const wmValue& value );
#endif #endif
} }

33
src/json/json_spirit_writer_options.h
View file

@ -1,33 +0,0 @@
#ifndef JSON_SPIRIT_WRITER_OPTIONS
#define JSON_SPIRIT_WRITER_OPTIONS
// Copyright John W. Wilkinson 2007 - 2013
// Distributed under the MIT License, see accompanying file LICENSE.txt
// json spirit version 4.06
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
namespace json_spirit
{
enum Output_options{ pretty_print = 0x01, // Add whitespace to format the output nicely.
raw_utf8 = 0x02, // This prevents non-printable characters from being escapted using "\uNNNN" notation.
// Note, this is an extension to the JSON standard. It disables the escaping of
// non-printable characters allowing UTF-8 sequences held in 8 bit char strings
// to pass through unaltered.
remove_trailing_zeros = 0x04,
// outputs e.g. "1.200000000000000" as "1.2"
single_line_arrays = 0x08,
// pretty printing except that arrays printed on single lines unless they contain
// composite elements, i.e. objects or arrays
always_escape_nonascii = 0x10,
// all unicode wide characters are escaped, i.e. outputed as "\uXXXX", even if they are
// printable under the current locale, ascii printable chars are not escaped
};
}
#endif

201
src/json/json_spirit_writer_template.h
View file

@ -1,22 +1,16 @@
#ifndef JSON_SPIRIT_WRITER_TEMPLATE #ifndef JSON_SPIRIT_WRITER_TEMPLATE
#define JSON_SPIRIT_WRITER_TEMPLATE #define JSON_SPIRIT_WRITER_TEMPLATE
// Copyright John W. Wilkinson 2007 - 2013 // Copyright John W. Wilkinson 2007 - 2009.
// Distributed under the MIT License, see accompanying file LICENSE.txt // Distributed under the MIT License, see accompanying file LICENSE.txt
// json spirit version 4.06 // json spirit version 4.03
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include "json_spirit_value.h" #include "json_spirit_value.h"
#include "json_spirit_writer_options.h"
#include <cassert> #include <cassert>
#include <sstream> #include <sstream>
#include <iomanip> #include <iomanip>
#include <boost/io/ios_state.hpp>
namespace json_spirit namespace json_spirit
{ {
@ -66,7 +60,7 @@ namespace json_spirit
} }
template< class String_type > template< class String_type >
String_type add_esc_chars( const String_type& s, bool raw_utf8, bool esc_nonascii ) String_type add_esc_chars( const String_type& s )
{ {
typedef typename String_type::const_iterator Iter_type; typedef typename String_type::const_iterator Iter_type;
typedef typename String_type::value_type Char_type; typedef typename String_type::value_type Char_type;
@ -81,80 +75,21 @@ namespace json_spirit
if( add_esc_char( c, result ) ) continue; if( add_esc_char( c, result ) ) continue;
if( raw_utf8 ) const wint_t unsigned_c( ( c >= 0 ) ? c : 256 + c );
if( iswprint( unsigned_c ) )
{ {
result += c; result += c;
} }
else else
{ {
const wint_t unsigned_c( ( c >= 0 ) ? c : 256 + c ); result += non_printable_to_string< String_type >( unsigned_c );
if( !esc_nonascii && iswprint( unsigned_c ) )
{
result += c;
}
else
{
result += non_printable_to_string< String_type >( unsigned_c );
}
} }
} }
return result; return result;
} }
template< class Ostream >
void append_double( Ostream& os, const double d, const int precision )
{
os << std::showpoint << std::setprecision( precision ) << d;
}
template< class String_type >
void erase_and_extract_exponent( String_type& str, String_type& exp )
{
const typename String_type::size_type exp_start= str.find( 'e' );
if( exp_start != String_type::npos )
{
exp = str.substr( exp_start );
str.erase( exp_start );
}
}
template< class String_type >
typename String_type::size_type find_first_non_zero( const String_type& str )
{
typename String_type::size_type result = str.size() - 1;
for( ; result != 0; --result )
{
if( str[ result ] != '0' )
{
break;
}
}
return result;
}
template< class String_type >
void remove_trailing( String_type& str )
{
String_type exp;
erase_and_extract_exponent( str, exp );
const typename String_type::size_type first_non_zero = find_first_non_zero( str );
if( first_non_zero != 0 )
{
const int offset = str[first_non_zero] == '.' ? 2 : 1; // note zero digits following a decimal point is non standard
str.erase( first_non_zero + offset );
}
str += exp;
}
// this class generates the JSON text, // this class generates the JSON text,
// it keeps track of the indentation level etc. // it keeps track of the indentation level etc.
// //
@ -170,15 +105,10 @@ namespace json_spirit
public: public:
Generator( const Value_type& value, Ostream_type& os, unsigned int options ) Generator( const Value_type& value, Ostream_type& os, bool pretty )
: os_( os ) : os_( os )
, indentation_level_( 0 ) , indentation_level_( 0 )
, pretty_( ( options & pretty_print ) != 0 || ( options & single_line_arrays ) != 0 ) , pretty_( pretty )
, raw_utf8_( ( options & raw_utf8 ) != 0 )
, esc_nonascii_( ( options & always_escape_nonascii ) != 0 )
, remove_trailing_zeros_( ( options & remove_trailing_zeros ) != 0 )
, single_line_arrays_( ( options & single_line_arrays ) != 0 )
, ios_saver_( os )
{ {
output( value ); output( value );
} }
@ -193,8 +123,12 @@ namespace json_spirit
case array_type: output( value.get_array() ); break; case array_type: output( value.get_array() ); break;
case str_type: output( value.get_str() ); break; case str_type: output( value.get_str() ); break;
case bool_type: output( value.get_bool() ); break; case bool_type: output( value.get_bool() ); break;
case real_type: output( value.get_real() ); break;
case int_type: output_int( value ); break; case int_type: output_int( value ); break;
/// Bitcoin: Added std::fixed and changed precision from 16 to 8
case real_type: os_ << std::showpoint << std::fixed << std::setprecision(8)
<< value.get_real(); break;
case null_type: os_ << "null"; break; case null_type: os_ << "null"; break;
default: assert( false ); default: assert( false );
} }
@ -205,6 +139,11 @@ namespace json_spirit
output_array_or_obj( obj, '{', '}' ); output_array_or_obj( obj, '{', '}' );
} }
void output( const Array_type& arr )
{
output_array_or_obj( arr, '[', ']' );
}
void output( const Obj_member_type& member ) void output( const Obj_member_type& member )
{ {
output( Config_type::get_name( member ) ); space(); output( Config_type::get_name( member ) ); space();
@ -226,7 +165,7 @@ namespace json_spirit
void output( const String_type& s ) void output( const String_type& s )
{ {
os_ << '"' << add_esc_chars( s, raw_utf8_, esc_nonascii_ ) << '"'; os_ << '"' << add_esc_chars( s ) << '"';
} }
void output( bool b ) void output( bool b )
@ -234,75 +173,6 @@ namespace json_spirit
os_ << to_str< String_type >( b ? "true" : "false" ); os_ << to_str< String_type >( b ? "true" : "false" );
} }
void output( double d )
{
if( remove_trailing_zeros_ )
{
std::basic_ostringstream< Char_type > os;
append_double( os, d, 16 ); // note precision is 16 so that we get some trailing space that we can remove,
// otherwise, 0.1234 gets converted to "0.12399999..."
String_type str = os.str();
remove_trailing( str );
os_ << str;
}
else
{
append_double( os_, d, 17 );
}
}
static bool contains_composite_elements( const Array_type& arr )
{
for( typename Array_type::const_iterator i = arr.begin(); i != arr.end(); ++i )
{
const Value_type& val = *i;
if( val.type() == obj_type ||
val.type() == array_type )
{
return true;
}
}
return false;
}
template< class Iter >
void output_composite_item( Iter i, Iter last )
{
output( *i );
if( ++i != last )
{
os_ << ',';
}
}
void output( const Array_type& arr )
{
if( single_line_arrays_ && !contains_composite_elements( arr ) )
{
os_ << '['; space();
for( typename Array_type::const_iterator i = arr.begin(); i != arr.end(); ++i )
{
output_composite_item( i, arr.end() );
space();
}
os_ << ']';
}
else
{
output_array_or_obj( arr, '[', ']' );
}
}
template< class T > template< class T >
void output_array_or_obj( const T& t, Char_type start_char, Char_type end_char ) void output_array_or_obj( const T& t, Char_type start_char, Char_type end_char )
{ {
@ -312,9 +182,14 @@ namespace json_spirit
for( typename T::const_iterator i = t.begin(); i != t.end(); ++i ) for( typename T::const_iterator i = t.begin(); i != t.end(); ++i )
{ {
indent(); indent(); output( *i );
output_composite_item( i, t.end() ); typename T::const_iterator next = i;
if( ++next != t.end())
{
os_ << ',';
}
new_line(); new_line();
} }
@ -349,36 +224,22 @@ namespace json_spirit
Ostream_type& os_; Ostream_type& os_;
int indentation_level_; int indentation_level_;
bool pretty_; bool pretty_;
bool raw_utf8_;
bool esc_nonascii_;
bool remove_trailing_zeros_;
bool single_line_arrays_;
boost::io::basic_ios_all_saver< Char_type > ios_saver_; // so that ostream state is reset after control is returned to the caller
}; };
// writes JSON Value to a stream, e.g.
//
// write_stream( value, os, pretty_print );
//
template< class Value_type, class Ostream_type > template< class Value_type, class Ostream_type >
void write_stream( const Value_type& value, Ostream_type& os, unsigned int options = 0 ) void write_stream( const Value_type& value, Ostream_type& os, bool pretty )
{ {
os << std::dec; Generator< Value_type, Ostream_type >( value, os, pretty );
Generator< Value_type, Ostream_type >( value, os, options );
} }
// writes JSON Value to a stream, e.g.
//
// const string json_str = write( value, pretty_print );
//
template< class Value_type > template< class Value_type >
typename Value_type::String_type write_string( const Value_type& value, unsigned int options = 0 ) typename Value_type::String_type write_string( const Value_type& value, bool pretty )
{ {
typedef typename Value_type::String_type::value_type Char_type; typedef typename Value_type::String_type::value_type Char_type;
std::basic_ostringstream< Char_type > os; std::basic_ostringstream< Char_type > os;
write_stream( value, os, options ); write_stream( value, os, pretty );
return os.str(); return os.str();
} }

4
src/qt/rpcconsole.cpp
View file

@ -159,7 +159,7 @@ void RPCExecutor::request(const QString &command)
else if (result.type() == json_spirit::str_type) else if (result.type() == json_spirit::str_type)
strPrint = result.get_str(); strPrint = result.get_str();
else else
strPrint = write_string(result, json_spirit::pretty_print | json_spirit::raw_utf8); strPrint = write_string(result, true);
emit reply(RPCConsole::CMD_REPLY, QString::fromStdString(strPrint)); emit reply(RPCConsole::CMD_REPLY, QString::fromStdString(strPrint));
} }
@ -173,7 +173,7 @@ void RPCExecutor::request(const QString &command)
} }
catch(std::runtime_error &) // raised when converting to invalid type, i.e. missing code or message catch(std::runtime_error &) // raised when converting to invalid type, i.e. missing code or message
{ // Show raw JSON object { // Show raw JSON object
emit reply(RPCConsole::CMD_ERROR, QString::fromStdString(write_string(json_spirit::Value(objError), json_spirit::raw_utf8))); emit reply(RPCConsole::CMD_ERROR, QString::fromStdString(write_string(json_spirit::Value(objError), false)));
} }
} }
catch (std::exception& e) catch (std::exception& e)

10
src/test/base58_tests.cpp
View file

@ -20,7 +20,7 @@ BOOST_AUTO_TEST_CASE(base58_EncodeBase58)
BOOST_FOREACH(Value& tv, tests) BOOST_FOREACH(Value& tv, tests)
{ {
Array test = tv.get_array(); Array test = tv.get_array();
std::string strTest = write_string(tv, raw_utf8); std::string strTest = write_string(tv, false);
if (test.size() < 2) // Allow for extra stuff (useful for comments) if (test.size() < 2) // Allow for extra stuff (useful for comments)
{ {
BOOST_ERROR("Bad test: " << strTest); BOOST_ERROR("Bad test: " << strTest);
@ -43,7 +43,7 @@ BOOST_AUTO_TEST_CASE(base58_DecodeBase58)
BOOST_FOREACH(Value& tv, tests) BOOST_FOREACH(Value& tv, tests)
{ {
Array test = tv.get_array(); Array test = tv.get_array();
std::string strTest = write_string(tv, raw_utf8); std::string strTest = write_string(tv, false);
if (test.size() < 2) // Allow for extra stuff (useful for comments) if (test.size() < 2) // Allow for extra stuff (useful for comments)
{ {
BOOST_ERROR("Bad test: " << strTest); BOOST_ERROR("Bad test: " << strTest);
@ -113,7 +113,7 @@ BOOST_AUTO_TEST_CASE(base58_keys_valid_parse)
BOOST_FOREACH(Value& tv, tests) BOOST_FOREACH(Value& tv, tests)
{ {
Array test = tv.get_array(); Array test = tv.get_array();
std::string strTest = write_string(tv, raw_utf8); std::string strTest = write_string(tv, false);
if (test.size() < 3) // Allow for extra stuff (useful for comments) if (test.size() < 3) // Allow for extra stuff (useful for comments)
{ {
BOOST_ERROR("Bad test: " << strTest); BOOST_ERROR("Bad test: " << strTest);
@ -169,7 +169,7 @@ BOOST_AUTO_TEST_CASE(base58_keys_valid_gen)
BOOST_FOREACH(Value& tv, tests) BOOST_FOREACH(Value& tv, tests)
{ {
Array test = tv.get_array(); Array test = tv.get_array();
std::string strTest = write_string(tv, raw_utf8); std::string strTest = write_string(tv, false);
if (test.size() < 3) // Allow for extra stuff (useful for comments) if (test.size() < 3) // Allow for extra stuff (useful for comments)
{ {
BOOST_ERROR("Bad test: " << strTest); BOOST_ERROR("Bad test: " << strTest);
@ -240,7 +240,7 @@ BOOST_AUTO_TEST_CASE(base58_keys_invalid)
BOOST_FOREACH(Value& tv, tests) BOOST_FOREACH(Value& tv, tests)
{ {
Array test = tv.get_array(); Array test = tv.get_array();
std::string strTest = write_string(tv, raw_utf8); std::string strTest = write_string(tv, false);
if (test.size() < 1) // Allow for extra stuff (useful for comments) if (test.size() < 1) // Allow for extra stuff (useful for comments)
{ {
BOOST_ERROR("Bad test: " << strTest); BOOST_ERROR("Bad test: " << strTest);

4
src/test/script_tests.cpp
View file

@ -118,7 +118,7 @@ BOOST_AUTO_TEST_CASE(script_valid)
BOOST_FOREACH(Value& tv, tests) BOOST_FOREACH(Value& tv, tests)
{ {
Array test = tv.get_array(); Array test = tv.get_array();
string strTest = write_string(tv, raw_utf8); string strTest = write_string(tv, false);
if (test.size() < 2) // Allow size > 2; extra stuff ignored (useful for comments) if (test.size() < 2) // Allow size > 2; extra stuff ignored (useful for comments)
{ {
BOOST_ERROR("Bad test: " << strTest); BOOST_ERROR("Bad test: " << strTest);
@ -142,7 +142,7 @@ BOOST_AUTO_TEST_CASE(script_invalid)
BOOST_FOREACH(Value& tv, tests) BOOST_FOREACH(Value& tv, tests)
{ {
Array test = tv.get_array(); Array test = tv.get_array();
string strTest = write_string(tv, raw_utf8); string strTest = write_string(tv, false);
if (test.size() < 2) // Allow size > 2; extra stuff ignored (useful for comments) if (test.size() < 2) // Allow size > 2; extra stuff ignored (useful for comments)
{ {
BOOST_ERROR("Bad test: " << strTest); BOOST_ERROR("Bad test: " << strTest);

4
src/test/transaction_tests.cpp
View file

@ -29,7 +29,7 @@ BOOST_AUTO_TEST_CASE(tx_valid)
BOOST_FOREACH(Value& tv, tests) BOOST_FOREACH(Value& tv, tests)
{ {
Array test = tv.get_array(); Array test = tv.get_array();
string strTest = write_string(tv, raw_utf8); string strTest = write_string(tv, false);
if (test[0].type() == array_type) if (test[0].type() == array_type)
{ {
if (test.size() != 3 || test[1].type() != str_type || test[2].type() != bool_type) if (test.size() != 3 || test[1].type() != str_type || test[2].type() != bool_type)
@ -98,7 +98,7 @@ BOOST_AUTO_TEST_CASE(tx_invalid)
BOOST_FOREACH(Value& tv, tests) BOOST_FOREACH(Value& tv, tests)
{ {
Array test = tv.get_array(); Array test = tv.get_array();
string strTest = write_string(tv, raw_utf8); string strTest = write_string(tv, false);
if (test[0].type() == array_type) if (test[0].type() == array_type)
{ {
if (test.size() != 3 || test[1].type() != str_type || test[2].type() != bool_type) if (test.size() != 3 || test[1].type() != str_type || test[2].type() != bool_type)