kvazar
/
kevacoin
mirror of https://github.com/kvazar-network/kevacoin.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Revert "JSON Spirit updated to v4.06" 

This reverts commit 2227389fa8.
0.10
Jeff Garzik 11 years ago
parent
0db9a805bd
commit
406b1f05f6
14 changed files with 382 additions and 681 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      src/bitcoinrpc.cpp
  2. 2
      src/json/LICENSE.txt
  3. 4
      src/json/json_spirit.h
  4. 6
      src/json/json_spirit_error_position.h
  5. 248
      src/json/json_spirit_reader.cpp
  6. 16
      src/json/json_spirit_reader.h
  7. 114
      src/json/json_spirit_reader_template.h
  8. 4
      src/json/json_spirit_stream_reader.h
  9. 8
      src/json/json_spirit_utils.h
  10. 203
      src/json/json_spirit_value.h
  11. 169
      src/json/json_spirit_writer.cpp
  12. 53
      src/json/json_spirit_writer.h
  13. 33
      src/json/json_spirit_writer_options.h
  14. 201
      src/json/json_spirit_writer_template.h

2
src/bitcoinrpc.cpp
Unescape 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

2
src/json/LICENSE.txt
Unescape 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
Unescape 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
Unescape 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

248
src/json/json_spirit_reader.cpp
Unescape 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 )
void json_spirit::read_or_throw( const std::string& s, Value& value ) {
{ read_string_or_throw( s, value );
read_string_or_throw( s, value ); }
}
bool json_spirit::read( std::istream& is, Value& value )
bool json_spirit::read( std::istream& is, Value& value ) {
{ return read_stream( is, value );
return read_stream( is, value ); }
}
void json_spirit::read_or_throw( std::istream& is, Value& value )
void json_spirit::read_or_throw( std::istream& is, Value& value ) {
{ read_stream_or_throw( is, value );
read_stream_or_throw( is, value ); }
}
bool json_spirit::read( std::string::const_iterator& begin, std::string::const_iterator end, Value& value )
bool json_spirit::read( std::string::const_iterator& begin, std::string::const_iterator end, Value& 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, Value& 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 );
begin = read_range_or_throw( begin, end, value ); }
}
#endif #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 );
}
#if defined( JSON_SPIRIT_WVALUE_ENABLED ) && !defined( 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 );
}
#endif #endif
#ifdef JSON_SPIRIT_MVALUE_ENABLED bool json_spirit::read( const std::string& s, mValue& value )
bool json_spirit::read( const std::string& s, mValue& value ) {
{ return read_string( s, value );
return read_string( s, value ); }
}
void json_spirit::read_or_throw( const std::string& s, mValue& 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::istream& is, mValue& 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::istream& is, mValue& 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::string::const_iterator& begin, std::string::const_iterator end, mValue& 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 )
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 );
begin = read_range_or_throw( begin, end, value ); }
}
#endif #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 );
}
#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
Unescape 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
} }

114
src/json/json_spirit_reader_template.h
Unescape 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,44 +514,6 @@ namespace json_spirit
Semantic_actions_t& actions_; Semantic_actions_t& actions_;
}; };
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 )
{
typedef spirit_namespace::position_iterator< Iter_type > Posn_iter_t;
const Posn_iter_t posn_begin( begin, end );
const Posn_iter_t posn_end( end, end );
read_range_or_throw( posn_begin, posn_end, value );
}
template< class Istream_type >
struct Multi_pass_iters
{
typedef typename Istream_type::char_type Char_type;
typedef std::istream_iterator< Char_type, Char_type > istream_iter;
typedef spirit_namespace::multi_pass< istream_iter > Mp_iter;
Multi_pass_iters( Istream_type& is )
{
is.unsetf( std::ios::skipws );
begin_ = spirit_namespace::make_multi_pass( istream_iter( is ) );
end_ = spirit_namespace::make_multi_pass( istream_iter() );
}
Mp_iter begin_;
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 > template< class Iter_type, class Value_type >
Iter_type read_range_or_throw( Iter_type begin, Iter_type end, Value_type& value ) Iter_type read_range_or_throw( Iter_type begin, Iter_type end, Value_type& value )
{ {
@ -564,9 +522,7 @@ namespace json_spirit
const spirit_namespace::parse_info< Iter_type > info = const spirit_namespace::parse_info< Iter_type > info =
spirit_namespace::parse( begin, end, spirit_namespace::parse( begin, end,
Json_grammer< Value_type, Iter_type >( semantic_actions ), Json_grammer< Value_type, Iter_type >( semantic_actions ),
spirit_namespace::space_p | spirit_namespace::space_p );
spirit_namespace::comment_p("//") |
spirit_namespace::comment_p("/*", "*/") );
if( !info.hit ) if( !info.hit )
{ {
@ -577,14 +533,17 @@ namespace json_spirit
return info.stop; return info.stop;
} }
// reads a JSON Value from a pair of input iterators, e.g. 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 )
// string::const_iterator start = str.begin(); {
// const bool success = read_string( start, str.end(), value ); typedef spirit_namespace::position_iterator< Iter_type > Posn_iter_t;
//
// The iterator 'start' will point to the character past the const Posn_iter_t posn_begin( begin, end );
// last one read. const Posn_iter_t posn_end( end, end );
//
read_range_or_throw( posn_begin, posn_end, value );
}
template< class Iter_type, class Value_type > template< class Iter_type, class Value_type >
bool read_range( Iter_type& begin, Iter_type end, Value_type& value ) bool read_range( Iter_type& begin, Iter_type end, Value_type& value )
{ {
@ -600,10 +559,12 @@ namespace json_spirit
} }
} }
// reads a JSON Value from a string, e.g. template< class String_type, class Value_type >
// void read_string_or_throw( const String_type& s, Value_type& value )
// const bool success = read_string( str, value ); {
// add_posn_iter_and_read_range_or_throw( s.begin(), s.end(), value );
}
template< class String_type, class Value_type > template< class String_type, class Value_type >
bool read_string( const String_type& s, Value_type& value ) bool read_string( const String_type& s, Value_type& value )
{ {
@ -612,20 +573,25 @@ namespace json_spirit
return read_range( begin, s.end(), value ); return read_range( begin, s.end(), value );
} }
// reads a JSON Value from a string throwing an exception on invalid input, e.g. template< class Istream_type >
// struct Multi_pass_iters
// 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 ); typedef typename Istream_type::char_type Char_type;
} typedef std::istream_iterator< Char_type, Char_type > istream_iter;
typedef spirit_namespace::multi_pass< istream_iter > Mp_iter;
Multi_pass_iters( Istream_type& is )
{
is.unsetf( std::ios::skipws );
begin_ = spirit_namespace::make_multi_pass( istream_iter( is ) );
end_ = spirit_namespace::make_multi_pass( istream_iter() );
}
Mp_iter begin_;
Mp_iter end_;
};
// 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
Unescape 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
Unescape 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
Unescape 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

169
src/json/json_spirit_writer.cpp
Unescape 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 )
{
#ifdef JSON_SPIRIT_VALUE_ENABLED write_stream( value, os, false );
void json_spirit::write( const Value& value, std::ostream& os, unsigned int options ) }
{
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 )
{
write_stream( value, os, pretty_print );
}
std::string json_spirit::write_formatted( const Value& value )
{
return write_string( value, pretty_print );
}
#endif
#ifdef JSON_SPIRIT_MVALUE_ENABLED void json_spirit::write_formatted( const Value& value, std::ostream& os )
void json_spirit::write( const mValue& 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 )
std::string json_spirit::write( const mValue& value, unsigned int options ) {
{ return write_string( value, false );
return write_string( value, options ); }
}
std::string json_spirit::write_formatted( const Value& value )
void json_spirit::write_formatted( const mValue& value, std::ostream& os ) {
{ return write_string( value, true );
write_stream( value, os, pretty_print ); }
}
#ifndef BOOST_NO_STD_WSTRING
std::string json_spirit::write_formatted( const mValue& value )
{ void json_spirit::write( const wValue& value, std::wostream& os )
return write_string( value, pretty_print ); {
} write_stream( value, os, false );
#endif }
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 );
}
#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 #endif
#if defined( JSON_SPIRIT_WMVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING ) void json_spirit::write( const mValue& value, std::ostream& os )
void json_spirit::write_formatted( const wmValue& value, std::wostream& os ) {
{ write_stream( value, os, false );
write_stream( value, os, pretty_print ); }
}
void json_spirit::write_formatted( const mValue& value, std::ostream& os )
std::wstring json_spirit::write_formatted( const wmValue& value ) {
{ write_stream( value, os, true );
return write_string( value, pretty_print ); }
}
std::string json_spirit::write( const mValue& value )
void json_spirit::write( const wmValue& value, std::wostream& os, unsigned int options ) {
{ return write_string( value, false );
write_stream( value, os, options ); }
}
std::string json_spirit::write_formatted( const mValue& value )
std::wstring json_spirit::write( const wmValue& value, unsigned int options ) {
{ return write_string( value, true );
return write_string( value, options ); }
}
#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 );
}
#endif #endif

53
src/json/json_spirit_writer.h
Unescape 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 ); void write_formatted( const Value& value, std::ostream& os );
std::string write( const Value& value, unsigned int options = 0 ); std::string write ( const Value& value );
#endif std::string write_formatted( const Value& value );
#ifdef JSON_SPIRIT_MVALUE_ENABLED #ifndef BOOST_NO_STD_WSTRING
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 );
void write( const wValue& value, std::wostream& os, unsigned int options = 0 ); void write_formatted( const wValue& value, std::wostream& os );
std::wstring write( const wValue& value, unsigned int options = 0 ); std::wstring write ( const wValue& value );
#endif std::wstring write_formatted( const wValue& value );
#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 #endif
// these "formatted" versions of the "write" functions are the equivalent of the above functions void write ( const mValue& value, std::ostream& os );
// with option "pretty_print"
#ifdef JSON_SPIRIT_VALUE_ENABLED
void write_formatted( const Value& value, std::ostream& os );
std::string write_formatted( const Value& value );
#endif
#ifdef JSON_SPIRIT_MVALUE_ENABLED
void write_formatted( const mValue& value, std::ostream& os ); void write_formatted( const mValue& value, std::ostream& os );
std::string write ( const mValue& value );
std::string write_formatted( const mValue& value ); std::string write_formatted( const mValue& value );
#endif
#if defined( JSON_SPIRIT_WVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING ) #ifndef BOOST_NO_STD_WSTRING
void write_formatted( const wValue& value, std::wostream& os );
std::wstring write_formatted( const wValue& value ); void write ( const wmValue& value, std::wostream& os );
#endif
#if defined( JSON_SPIRIT_WMVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
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
Unescape 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
Unescape 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;
}
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; 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();
} }

Write Preview
Loading…
Cancel
Save