aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/bitcoinrpc.cpp2
-rw-r--r--src/json/LICENSE.txt2
-rw-r--r--src/json/json_spirit.h4
-rw-r--r--src/json/json_spirit_error_position.h6
-rw-r--r--src/json/json_spirit_reader.cpp248
-rw-r--r--src/json/json_spirit_reader.h16
-rw-r--r--src/json/json_spirit_reader_template.h114
-rw-r--r--src/json/json_spirit_stream_reader.h4
-rw-r--r--src/json/json_spirit_utils.h8
-rw-r--r--src/json/json_spirit_value.h203
-rw-r--r--src/json/json_spirit_writer.cpp169
-rw-r--r--src/json/json_spirit_writer.h53
-rw-r--r--src/json/json_spirit_writer_options.h33
-rw-r--r--src/json/json_spirit_writer_template.h201
14 files changed, 681 insertions, 382 deletions
diff --git a/src/bitcoinrpc.cpp b/src/bitcoinrpc.cpp
index c99b74f183..c3c99982ba 100644
--- a/src/bitcoinrpc.cpp
+++ b/src/bitcoinrpc.cpp
@@ -30,6 +30,8 @@ using namespace boost;
using namespace boost::asio;
using namespace json_spirit;
+static const char* Value_type_name[]={"obj", "array", "str", "bool", "int", "real", "null"};
+
static std::string strRPCUserColonPass;
// These are created by StartRPCThreads, destroyed in StopRPCThreads
diff --git a/src/json/LICENSE.txt b/src/json/LICENSE.txt
index 797d5363b3..6ed66a2e69 100644
--- a/src/json/LICENSE.txt
+++ b/src/json/LICENSE.txt
@@ -1,6 +1,6 @@
The MIT License
-Copyright (c) 2007 - 2009 John W. Wilkinson
+Copyright (c) 2007 - 2010 John W. Wilkinson
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
diff --git a/src/json/json_spirit.h b/src/json/json_spirit.h
index ac1879d5b3..ef442e9fd5 100644
--- a/src/json/json_spirit.h
+++ b/src/json/json_spirit.h
@@ -1,10 +1,10 @@
#ifndef JSON_SPIRIT
#define JSON_SPIRIT
-// Copyright John W. Wilkinson 2007 - 2009.
+// Copyright John W. Wilkinson 2007 - 2013
// Distributed under the MIT License, see accompanying file LICENSE.txt
-// json spirit version 4.03
+// json spirit version 4.06
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
diff --git a/src/json/json_spirit_error_position.h b/src/json/json_spirit_error_position.h
index 17208507df..e2b59b47ae 100644
--- a/src/json/json_spirit_error_position.h
+++ b/src/json/json_spirit_error_position.h
@@ -1,10 +1,10 @@
#ifndef JSON_SPIRIT_ERROR_POSITION
#define JSON_SPIRIT_ERROR_POSITION
-// Copyright John W. Wilkinson 2007 - 2009.
+// Copyright John W. Wilkinson 2007 - 2013
// Distributed under the MIT License, see accompanying file LICENSE.txt
-// json spirit version 4.03
+// json spirit version 4.06
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
@@ -48,7 +48,7 @@ namespace json_spirit
return ( reason_ == lhs.reason_ ) &&
( line_ == lhs.line_ ) &&
( column_ == lhs.column_ );
-}
+ }
}
#endif
diff --git a/src/json/json_spirit_reader.cpp b/src/json/json_spirit_reader.cpp
index aa4f637226..7dea074736 100644
--- a/src/json/json_spirit_reader.cpp
+++ b/src/json/json_spirit_reader.cpp
@@ -1,137 +1,137 @@
-// Copyright John W. Wilkinson 2007 - 2009.
+// Copyright John W. Wilkinson 2007 - 2013
// Distributed under the MIT License, see accompanying file LICENSE.txt
-// json spirit version 4.03
+// json spirit version 4.06
#include "json_spirit_reader.h"
#include "json_spirit_reader_template.h"
using namespace json_spirit;
-bool json_spirit::read( const std::string& s, Value& 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 )
-{
- return read_stream( is, value );
-}
-
-void json_spirit::read_or_throw( std::istream& is, Value& 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 );
-}
+#ifdef JSON_SPIRIT_VALUE_ENABLED
+ bool json_spirit::read( const std::string& s, Value& 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 )
+ {
+ return read_stream( is, value );
+ }
+
+ void json_spirit::read_or_throw( std::istream& is, Value& 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 );
+ }
+#endif
+#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
-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 );
-}
-
-#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 );
-}
+#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
diff --git a/src/json/json_spirit_reader.h b/src/json/json_spirit_reader.h
index 96494a9789..f0dc5330f2 100644
--- a/src/json/json_spirit_reader.h
+++ b/src/json/json_spirit_reader.h
@@ -1,10 +1,10 @@
#ifndef JSON_SPIRIT_READER
#define JSON_SPIRIT_READER
-// Copyright John W. Wilkinson 2007 - 2009.
+// Copyright John W. Wilkinson 2007 - 2013
// Distributed under the MIT License, see accompanying file LICENSE.txt
-// json spirit version 4.03
+// json spirit version 4.06
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
@@ -18,6 +18,7 @@ namespace json_spirit
{
// functions to reads a JSON values
+#ifdef JSON_SPIRIT_VALUE_ENABLED
bool read( const std::string& s, Value& value );
bool read( std::istream& is, Value& value );
bool read( std::string::const_iterator& begin, std::string::const_iterator end, Value& value );
@@ -25,9 +26,9 @@ namespace json_spirit
void read_or_throw( const std::string& s, 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 );
+#endif
-#ifndef BOOST_NO_STD_WSTRING
-
+#if defined( JSON_SPIRIT_WVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
bool read( const std::wstring& s, wValue& value );
bool read( std::wistream& is, wValue& value );
bool read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wValue& value );
@@ -35,9 +36,9 @@ namespace json_spirit
void read_or_throw( const std::wstring& s, 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 );
-
#endif
+#ifdef JSON_SPIRIT_MVALUE_ENABLED
bool read( const std::string& s, mValue& value );
bool read( std::istream& is, mValue& value );
bool read( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value );
@@ -45,9 +46,9 @@ namespace json_spirit
void read_or_throw( const std::string& s, 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 );
+#endif
-#ifndef BOOST_NO_STD_WSTRING
-
+#if defined( JSON_SPIRIT_WMVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
bool read( const std::wstring& s, wmValue& value );
bool read( std::wistream& is, wmValue& value );
bool read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wmValue& value );
@@ -55,7 +56,6 @@ namespace json_spirit
void read_or_throw( const std::wstring& s, 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 );
-
#endif
}
diff --git a/src/json/json_spirit_reader_template.h b/src/json/json_spirit_reader_template.h
index 4dec00e6c9..d3d0cecaa5 100644
--- a/src/json/json_spirit_reader_template.h
+++ b/src/json/json_spirit_reader_template.h
@@ -1,10 +1,14 @@
#ifndef JSON_SPIRIT_READER_TEMPLATE
#define JSON_SPIRIT_READER_TEMPLATE
-// Copyright John W. Wilkinson 2007 - 2009.
+// Copyright John W. Wilkinson 2007 - 2013
// Distributed under the MIT License, see accompanying file LICENSE.txt
-// json spirit version 4.03
+// json spirit version 4.06
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
#include "json_spirit_value.h"
#include "json_spirit_error_position.h"
@@ -484,7 +488,7 @@ namespace json_spirit
;
string_
- = lexeme_d // this causes white space inside a string to be retained
+ = lexeme_d // this causes white space and what would appear to be comments inside a string to be retained
[
confix_p
(
@@ -515,6 +519,44 @@ namespace json_spirit
};
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 >
Iter_type read_range_or_throw( Iter_type begin, Iter_type end, Value_type& value )
{
Semantic_actions< Value_type, Iter_type > semantic_actions( value );
@@ -522,7 +564,9 @@ namespace json_spirit
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::space_p |
+ spirit_namespace::comment_p("//") |
+ spirit_namespace::comment_p("/*", "*/") );
if( !info.hit )
{
@@ -533,17 +577,14 @@ namespace json_spirit
return info.stop;
}
- 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 );
- }
-
+ // 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 )
{
@@ -559,12 +600,10 @@ namespace json_spirit
}
}
- 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 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 )
{
@@ -573,25 +612,20 @@ namespace json_spirit
return read_range( begin, s.end(), value );
}
- template< class Istream_type >
- struct Multi_pass_iters
+ // 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 )
{
- 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_;
- };
+ 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 >
bool read_stream( Istream_type& is, Value_type& value )
{
@@ -600,6 +634,10 @@ namespace json_spirit
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 >
void read_stream_or_throw( Istream_type& is, Value_type& value )
{
diff --git a/src/json/json_spirit_stream_reader.h b/src/json/json_spirit_stream_reader.h
index 7e59c9adc2..8bbdbc0543 100644
--- a/src/json/json_spirit_stream_reader.h
+++ b/src/json/json_spirit_stream_reader.h
@@ -1,10 +1,10 @@
#ifndef JSON_SPIRIT_READ_STREAM
#define JSON_SPIRIT_READ_STREAM
-// Copyright John W. Wilkinson 2007 - 2009.
+// Copyright John W. Wilkinson 2007 - 2013
// Distributed under the MIT License, see accompanying file LICENSE.txt
-// json spirit version 4.03
+// json spirit version 4.06
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
diff --git a/src/json/json_spirit_utils.h b/src/json/json_spirit_utils.h
index 553e3b96a4..a174ac3a98 100644
--- a/src/json/json_spirit_utils.h
+++ b/src/json/json_spirit_utils.h
@@ -1,10 +1,10 @@
#ifndef JSON_SPIRIT_UTILS
#define JSON_SPIRIT_UTILS
-// Copyright John W. Wilkinson 2007 - 2009.
+// Copyright John W. Wilkinson 2007 - 2013
// Distributed under the MIT License, see accompanying file LICENSE.txt
-// json spirit version 4.03
+// json spirit version 4.06
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
@@ -37,9 +37,11 @@ namespace json_spirit
}
}
+#ifdef JSON_SPIRIT_VALUE_ENABLED
typedef std::map< std::string, Value > Mapped_obj;
+#endif
-#ifndef BOOST_NO_STD_WSTRING
+#if defined( JSON_SPIRIT_WVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
typedef std::map< std::wstring, wValue > wMapped_obj;
#endif
diff --git a/src/json/json_spirit_value.h b/src/json/json_spirit_value.h
index 7e83a2a7e3..a5020405d4 100644
--- a/src/json/json_spirit_value.h
+++ b/src/json/json_spirit_value.h
@@ -1,10 +1,10 @@
#ifndef JSON_SPIRIT_VALUE
#define JSON_SPIRIT_VALUE
-// Copyright John W. Wilkinson 2007 - 2009.
+// Copyright John W. Wilkinson 2007 - 2013
// Distributed under the MIT License, see accompanying file LICENSE.txt
-// json spirit version 4.03
+// json spirit version 4.06
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
@@ -21,11 +21,20 @@
#include <boost/shared_ptr.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
{
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
// whether JSON Objects are represented as vectors or maps
class Value_impl
@@ -49,6 +58,12 @@ namespace json_spirit
Value_impl( boost::uint64_t 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 );
bool operator==( const Value_impl& lhs ) const;
@@ -81,13 +96,32 @@ namespace json_spirit
void check_type( const Value_type vtype ) const;
- typedef boost::variant< String_type,
- boost::recursive_wrapper< Object >, boost::recursive_wrapper< Array >,
- bool, boost::int64_t, double > Variant;
+ typedef boost::variant< boost::recursive_wrapper< Object >, boost::recursive_wrapper< Array >,
+ String_type, bool, boost::int64_t, double, Null, boost::uint64_t > Variant;
- Value_type type_;
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
@@ -98,6 +132,10 @@ namespace json_spirit
typedef typename Config::String_type String_type;
typedef typename Config::Value_type Value_type;
+ Pair_impl()
+ {
+ }
+
Pair_impl( const String_type& name, const Value_type& value );
bool operator==( const Pair_impl& lhs ) const;
@@ -106,6 +144,7 @@ namespace json_spirit
Value_type value_;
};
+#if defined( JSON_SPIRIT_VALUE_ENABLED ) || defined( JSON_SPIRIT_WVALUE_ENABLED )
template< class String >
struct Config_vector
{
@@ -122,30 +161,32 @@ namespace json_spirit
return obj.back().value_;
}
- static String_type get_name( const Pair_type& pair )
+ static const String_type& get_name( const Pair_type& pair )
{
return pair.name_;
}
- static Value_type get_value( const Pair_type& pair )
+ static const Value_type& get_value( const Pair_type& pair )
{
return pair.value_;
}
};
+#endif
// typedefs for ASCII
+#ifdef JSON_SPIRIT_VALUE_ENABLED
typedef Config_vector< std::string > Config;
typedef Config::Value_type Value;
typedef Config::Pair_type Pair;
typedef Config::Object_type Object;
typedef Config::Array_type Array;
+#endif
// typedefs for Unicode
-#ifndef BOOST_NO_STD_WSTRING
-
+#if defined( JSON_SPIRIT_WVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
typedef Config_vector< std::wstring > wConfig;
typedef wConfig::Value_type wValue;
@@ -156,6 +197,7 @@ namespace json_spirit
// map objects
+#if defined( JSON_SPIRIT_MVALUE_ENABLED ) || defined( JSON_SPIRIT_WMVALUE_ENABLED )
template< class String >
struct Config_map
{
@@ -163,135 +205,134 @@ namespace json_spirit
typedef Value_impl< Config_map > Value_type;
typedef std::vector< Value_type > Array_type;
typedef std::map< String_type, Value_type > Object_type;
- typedef typename Object_type::value_type Pair_type;
+ typedef std::pair< const String_type, Value_type > Pair_type;
static Value_type& add( Object_type& obj, const String_type& name, const Value_type& value )
{
return obj[ name ] = value;
}
- static String_type get_name( const Pair_type& pair )
+ static const String_type& get_name( const Pair_type& pair )
{
return pair.first;
}
- static Value_type get_value( const Pair_type& pair )
+ static const Value_type& get_value( const Pair_type& pair )
{
return pair.second;
}
};
+#endif
// typedefs for ASCII
+#ifdef JSON_SPIRIT_MVALUE_ENABLED
typedef Config_map< std::string > mConfig;
typedef mConfig::Value_type mValue;
typedef mConfig::Object_type mObject;
typedef mConfig::Array_type mArray;
+#endif
// typedefs for Unicode
-#ifndef BOOST_NO_STD_WSTRING
-
+#if defined( JSON_SPIRIT_WMVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
typedef Config_map< std::wstring > wmConfig;
typedef wmConfig::Value_type wmValue;
typedef wmConfig::Object_type wmObject;
typedef wmConfig::Array_type wmArray;
-
#endif
///////////////////////////////////////////////////////////////////////////////////////////////
//
// implementation
+ inline bool operator==( const Null&, const Null& )
+ {
+ return true;
+ }
+
template< class Config >
const Value_impl< Config > Value_impl< Config >::null;
template< class Config >
Value_impl< Config >::Value_impl()
- : type_( null_type )
- , is_uint64_( false )
+ : v_( Null() )
{
}
template< class Config >
Value_impl< Config >::Value_impl( const Const_str_ptr value )
- : type_( str_type )
- , v_( String_type( value ) )
- , is_uint64_( false )
+ : v_( String_type( value ) )
{
}
template< class Config >
Value_impl< Config >::Value_impl( const String_type& value )
- : type_( str_type )
- , v_( value )
- , is_uint64_( false )
+ : v_( value )
{
}
template< class Config >
Value_impl< Config >::Value_impl( const Object& value )
- : type_( obj_type )
- , v_( value )
- , is_uint64_( false )
+ : v_( value )
{
}
template< class Config >
Value_impl< Config >::Value_impl( const Array& value )
- : type_( array_type )
- , v_( value )
- , is_uint64_( false )
+ : v_( value )
{
}
template< class Config >
Value_impl< Config >::Value_impl( bool value )
- : type_( bool_type )
- , v_( value )
- , is_uint64_( false )
+ : v_( value )
{
}
template< class Config >
Value_impl< Config >::Value_impl( int value )
- : type_( int_type )
- , v_( static_cast< boost::int64_t >( value ) )
- , is_uint64_( false )
+ : v_( static_cast< boost::int64_t >( value ) )
{
}
template< class Config >
Value_impl< Config >::Value_impl( boost::int64_t value )
- : type_( int_type )
- , v_( value )
- , is_uint64_( false )
+ : v_( value )
{
}
template< class Config >
Value_impl< Config >::Value_impl( boost::uint64_t value )
- : type_( int_type )
- , v_( static_cast< boost::int64_t >( value ) )
- , is_uint64_( true )
+ : v_( value )
{
}
template< class Config >
Value_impl< Config >::Value_impl( double value )
- : type_( real_type )
- , v_( value )
- , is_uint64_( false )
+ : v_( value )
{
}
template< class Config >
Value_impl< Config >::Value_impl( const Value_impl< Config >& other )
- : type_( other.type() )
- , v_( other.v_ )
- , is_uint64_( other.is_uint64_ )
+ : v_( other.v_ )
+ {
+ }
+
+ 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) )
{
}
@@ -300,9 +341,7 @@ namespace json_spirit
{
Value_impl tmp( lhs );
- std::swap( type_, tmp.type_ );
std::swap( v_, tmp.v_ );
- std::swap( is_uint64_, tmp.is_uint64_ );
return *this;
}
@@ -320,13 +359,18 @@ namespace json_spirit
template< class Config >
Value_type Value_impl< Config >::type() const
{
- return type_;
+ if( is_uint64() )
+ {
+ return int_type;
+ }
+
+ return static_cast< Value_type >( v_.which() );
}
template< class Config >
bool Value_impl< Config >::is_uint64() const
{
- return is_uint64_;
+ return v_.which() == null_type + 1;
}
template< class Config >
@@ -342,8 +386,7 @@ namespace json_spirit
{
std::ostringstream os;
- ///// Bitcoin: Tell the types by name instead of by number
- os << "value is type " << Value_type_name[type()] << ", expected " << Value_type_name[vtype];
+ os << "get_value< " << value_type_to_string( vtype ) << " > called on " << value_type_to_string( type() ) << " Value";
throw std::runtime_error( os.str() );
}
@@ -352,7 +395,7 @@ namespace json_spirit
template< class Config >
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_ );
}
@@ -368,7 +411,7 @@ namespace json_spirit
template< class Config >
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_ );
}
@@ -376,7 +419,7 @@ namespace json_spirit
template< class Config >
bool Value_impl< Config >::get_bool() const
{
- check_type( bool_type );
+ check_type( bool_type );
return boost::get< bool >( v_ );
}
@@ -384,7 +427,7 @@ namespace json_spirit
template< class Config >
int Value_impl< Config >::get_int() const
{
- check_type( int_type );
+ check_type( int_type );
return static_cast< int >( get_int64() );
}
@@ -392,7 +435,12 @@ namespace json_spirit
template< class Config >
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_ );
}
@@ -400,9 +448,14 @@ namespace json_spirit
template< class Config >
boost::uint64_t Value_impl< Config >::get_uint64() const
{
- check_type( int_type );
+ check_type( int_type );
- return static_cast< boost::uint64_t >( get_int64() );
+ if( !is_uint64() )
+ {
+ return static_cast< boost::uint64_t >( get_int64() );
+ }
+
+ return boost::get< boost::uint64_t >( v_ );
}
template< class Config >
@@ -414,7 +467,7 @@ namespace json_spirit
: static_cast< double >( get_int64() );
}
- check_type( real_type );
+ check_type( real_type );
return boost::get< double >( v_ );
}
@@ -422,7 +475,7 @@ namespace json_spirit
template< class Config >
typename Value_impl< Config >::Object& Value_impl< Config >::get_obj()
{
- check_type( obj_type );
+ check_type( obj_type );
return *boost::get< Object >( &v_ );
}
@@ -430,7 +483,7 @@ namespace json_spirit
template< class Config >
typename Value_impl< Config >::Array& Value_impl< Config >::get_array()
{
- check_type( array_type );
+ check_type( array_type );
return *boost::get< Array >( &v_ );
}
@@ -529,6 +582,24 @@ namespace json_spirit
{
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
diff --git a/src/json/json_spirit_writer.cpp b/src/json/json_spirit_writer.cpp
index d24a632cf3..06d3f21d91 100644
--- a/src/json/json_spirit_writer.cpp
+++ b/src/json/json_spirit_writer.cpp
@@ -1,95 +1,96 @@
-// Copyright John W. Wilkinson 2007 - 2009.
+// Copyright John W. Wilkinson 2007 - 2013
// Distributed under the MIT License, see accompanying file LICENSE.txt
-// json spirit version 4.03
+// json spirit version 4.06
#include "json_spirit_writer.h"
#include "json_spirit_writer_template.h"
-void json_spirit::write( const Value& value, std::ostream& os )
-{
- write_stream( value, os, false );
-}
-
-void json_spirit::write_formatted( const Value& value, std::ostream& os )
-{
- write_stream( value, os, true );
-}
-
-std::string json_spirit::write( const Value& value )
-{
- 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 );
-}
-
+using namespace json_spirit;
+
+#ifdef JSON_SPIRIT_VALUE_ENABLED
+ 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
-void json_spirit::write( const mValue& value, std::ostream& os )
-{
- write_stream( value, os, false );
-}
-
-void json_spirit::write_formatted( const mValue& value, std::ostream& os )
-{
- write_stream( value, os, true );
-}
-
-std::string json_spirit::write( const mValue& value )
-{
- 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 );
-}
+#ifdef JSON_SPIRIT_MVALUE_ENABLED
+ void json_spirit::write( const mValue& value, std::ostream& os, unsigned int options )
+ {
+ write_stream( value, os, options );
+ }
+
+ std::string json_spirit::write( const mValue& value, unsigned int options )
+ {
+ return write_string( value, options );
+ }
+
+ void json_spirit::write_formatted( const mValue& value, std::ostream& os )
+ {
+ write_stream( value, os, pretty_print );
+ }
+
+ std::string json_spirit::write_formatted( const mValue& value )
+ {
+ return write_string( value, pretty_print );
+ }
+#endif
-std::wstring json_spirit::write_formatted( const wmValue& 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
+#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
diff --git a/src/json/json_spirit_writer.h b/src/json/json_spirit_writer.h
index 52e14068e7..18c2fd4264 100644
--- a/src/json/json_spirit_writer.h
+++ b/src/json/json_spirit_writer.h
@@ -1,49 +1,62 @@
#ifndef JSON_SPIRIT_WRITER
#define JSON_SPIRIT_WRITER
-// Copyright John W. Wilkinson 2007 - 2009.
+// Copyright John W. Wilkinson 2007 - 2013
// Distributed under the MIT License, see accompanying file LICENSE.txt
-// json spirit version 4.03
+// json spirit version 4.06
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include "json_spirit_value.h"
+#include "json_spirit_writer_options.h"
#include <iostream>
namespace json_spirit
{
- // functions to convert JSON Values to text,
- // the "formatted" versions add whitespace to format the output nicely
+ // these functions to convert JSON Values to text
- void write ( 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 );
+#ifdef JSON_SPIRIT_VALUE_ENABLED
+ void write( const Value& value, std::ostream& os, unsigned int options = 0 );
+ std::string write( const Value& value, unsigned int options = 0 );
+#endif
-#ifndef BOOST_NO_STD_WSTRING
+#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
- 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 );
+#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
- void write ( const mValue& value, std::ostream& os );
+ // 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 );
+ std::string write_formatted( const Value& value );
+#endif
+#ifdef JSON_SPIRIT_MVALUE_ENABLED
void write_formatted( const mValue& value, std::ostream& os );
- std::string write ( const mValue& value );
std::string write_formatted( const mValue& value );
+#endif
-#ifndef BOOST_NO_STD_WSTRING
-
- void write ( const wmValue& value, std::wostream& os );
+#if defined( JSON_SPIRIT_WVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
+ void write_formatted( const wValue& value, std::wostream& os );
+ std::wstring write_formatted( const wValue& value );
+#endif
+#if defined( JSON_SPIRIT_WMVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
void write_formatted( const wmValue& value, std::wostream& os );
- std::wstring write ( const wmValue& value );
std::wstring write_formatted( const wmValue& value );
-
#endif
}
diff --git a/src/json/json_spirit_writer_options.h b/src/json/json_spirit_writer_options.h
new file mode 100644
index 0000000000..ac6c57f33c
--- /dev/null
+++ b/src/json/json_spirit_writer_options.h
@@ -0,0 +1,33 @@
+#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
diff --git a/src/json/json_spirit_writer_template.h b/src/json/json_spirit_writer_template.h
index 28c49ddc64..014d9d4cd0 100644
--- a/src/json/json_spirit_writer_template.h
+++ b/src/json/json_spirit_writer_template.h
@@ -1,16 +1,22 @@
#ifndef JSON_SPIRIT_WRITER_TEMPLATE
#define JSON_SPIRIT_WRITER_TEMPLATE
-// Copyright John W. Wilkinson 2007 - 2009.
+// Copyright John W. Wilkinson 2007 - 2013
// Distributed under the MIT License, see accompanying file LICENSE.txt
-// json spirit version 4.03
+// json spirit version 4.06
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
#include "json_spirit_value.h"
+#include "json_spirit_writer_options.h"
#include <cassert>
#include <sstream>
#include <iomanip>
+#include <boost/io/ios_state.hpp>
namespace json_spirit
{
@@ -60,7 +66,7 @@ namespace json_spirit
}
template< class String_type >
- String_type add_esc_chars( const String_type& s )
+ String_type add_esc_chars( const String_type& s, bool raw_utf8, bool esc_nonascii )
{
typedef typename String_type::const_iterator Iter_type;
typedef typename String_type::value_type Char_type;
@@ -75,21 +81,80 @@ namespace json_spirit
if( add_esc_char( c, result ) ) continue;
- const wint_t unsigned_c( ( c >= 0 ) ? c : 256 + c );
-
- if( iswprint( unsigned_c ) )
+ if( raw_utf8 )
{
result += c;
}
else
{
- result += non_printable_to_string< String_type >( unsigned_c );
+ const wint_t unsigned_c( ( c >= 0 ) ? c : 256 + 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;
}
+ 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,
// it keeps track of the indentation level etc.
//
@@ -105,10 +170,15 @@ namespace json_spirit
public:
- Generator( const Value_type& value, Ostream_type& os, bool pretty )
+ Generator( const Value_type& value, Ostream_type& os, unsigned int options )
: os_( os )
, indentation_level_( 0 )
- , pretty_( pretty )
+ , pretty_( ( options & pretty_print ) != 0 || ( options & single_line_arrays ) != 0 )
+ , 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 );
}
@@ -123,12 +193,8 @@ namespace json_spirit
case array_type: output( value.get_array() ); break;
case str_type: output( value.get_str() ); break;
case bool_type: output( value.get_bool() ); break;
+ case real_type: output( value.get_real() ); 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;
default: assert( false );
}
@@ -139,11 +205,6 @@ namespace json_spirit
output_array_or_obj( obj, '{', '}' );
}
- void output( const Array_type& arr )
- {
- output_array_or_obj( arr, '[', ']' );
- }
-
void output( const Obj_member_type& member )
{
output( Config_type::get_name( member ) ); space();
@@ -165,7 +226,7 @@ namespace json_spirit
void output( const String_type& s )
{
- os_ << '"' << add_esc_chars( s ) << '"';
+ os_ << '"' << add_esc_chars( s, raw_utf8_, esc_nonascii_ ) << '"';
}
void output( bool b )
@@ -173,6 +234,75 @@ namespace json_spirit
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 >
void output_array_or_obj( const T& t, Char_type start_char, Char_type end_char )
{
@@ -182,14 +312,9 @@ namespace json_spirit
for( typename T::const_iterator i = t.begin(); i != t.end(); ++i )
{
- indent(); output( *i );
+ indent();
- typename T::const_iterator next = i;
-
- if( ++next != t.end())
- {
- os_ << ',';
- }
+ output_composite_item( i, t.end() );
new_line();
}
@@ -224,22 +349,36 @@ namespace json_spirit
Ostream_type& os_;
int indentation_level_;
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 >
- void write_stream( const Value_type& value, Ostream_type& os, bool pretty )
+ void write_stream( const Value_type& value, Ostream_type& os, unsigned int options = 0 )
{
- Generator< Value_type, Ostream_type >( value, os, pretty );
+ os << std::dec;
+ 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 >
- typename Value_type::String_type write_string( const Value_type& value, bool pretty )
+ typename Value_type::String_type write_string( const Value_type& value, unsigned int options = 0 )
{
typedef typename Value_type::String_type::value_type Char_type;
std::basic_ostringstream< Char_type > os;
- write_stream( value, os, pretty );
+ write_stream( value, os, options );
return os.str();
}