diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/bitcoinrpc.cpp | 2 | ||||
| -rw-r--r-- | src/json/LICENSE.txt | 2 | ||||
| -rw-r--r-- | src/json/json_spirit.h | 4 | ||||
| -rw-r--r-- | src/json/json_spirit_error_position.h | 6 | ||||
| -rw-r--r-- | src/json/json_spirit_reader.cpp | 248 | ||||
| -rw-r--r-- | src/json/json_spirit_reader.h | 16 | ||||
| -rw-r--r-- | src/json/json_spirit_reader_template.h | 114 | ||||
| -rw-r--r-- | src/json/json_spirit_stream_reader.h | 4 | ||||
| -rw-r--r-- | src/json/json_spirit_utils.h | 8 | ||||
| -rw-r--r-- | src/json/json_spirit_value.h | 203 | ||||
| -rw-r--r-- | src/json/json_spirit_writer.cpp | 169 | ||||
| -rw-r--r-- | src/json/json_spirit_writer.h | 53 | ||||
| -rw-r--r-- | src/json/json_spirit_writer_options.h | 33 | ||||
| -rw-r--r-- | src/json/json_spirit_writer_template.h | 201 |
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(); } |