fc::json Class Reference

#include <json.hpp>

Collaboration diagram for fc::json:

Public Types
enum class	parse_type : unsigned char { legacy_parser = 0 , strict_parser = 1 , relaxed_parser = 2 , legacy_parser_with_string_doubles = 3 }
enum class	output_formatting : unsigned char { stringify_large_ints_and_doubles = 0 , legacy_generator = 1 }
using	yield_function_t = fc::optional_delegate<void(size_t)>

Static Public Member Functions
static variant	from_string (const string &utf8_str, const parse_type ptype=parse_type::legacy_parser, uint32_t max_depth=DEFAULT_MAX_RECURSION_DEPTH)
static variants	variants_from_string (const string &utf8_str, const parse_type ptype=parse_type::legacy_parser, uint32_t max_depth=DEFAULT_MAX_RECURSION_DEPTH)
static string	to_string (const variant &v, const yield_function_t &yield, const output_formatting format=output_formatting::stringify_large_ints_and_doubles)
static string	to_pretty_string (const variant &v, const yield_function_t &yield, const output_formatting format=output_formatting::stringify_large_ints_and_doubles)
static bool	is_valid (const std::string &json_str, const parse_type ptype=parse_type::legacy_parser, const uint32_t max_depth=DEFAULT_MAX_RECURSION_DEPTH)
template<typename T >
static bool	save_to_file (const T &v, const fc::path &fi, const bool pretty=true, const output_formatting format=output_formatting::stringify_large_ints_and_doubles)
static bool	save_to_file (const variant &v, const fc::path &fi, const bool pretty=true, const output_formatting format=output_formatting::stringify_large_ints_and_doubles)
static variant	from_file (const fc::path &p, const parse_type ptype=parse_type::legacy_parser, const uint32_t max_depth=DEFAULT_MAX_RECURSION_DEPTH)
template<typename T >
static T	from_file (const fc::path &p, const parse_type ptype=parse_type::legacy_parser, const uint32_t max_depth=DEFAULT_MAX_RECURSION_DEPTH)
template<typename T >
static string	to_string (const T &v, const fc::time_point &deadline, const output_formatting format=output_formatting::stringify_large_ints_and_doubles, const uint64_t max_len=max_length_limit)
template<typename T >
static string	to_pretty_string (const T &v, const fc::time_point &deadline=fc::time_point::maximum(), const output_formatting format=output_formatting::stringify_large_ints_and_doubles, const uint64_t max_len=max_length_limit)
template<typename T >
static bool	save_to_file (const T &v, const std::string &p, const bool pretty=true, const output_formatting format=output_formatting::stringify_large_ints_and_doubles)

Static Public Attributes
static constexpr uint64_t	max_length_limit = std::numeric_limits<uint64_t>::max()
static constexpr size_t	escape_string_yield_check_count = 128

Detailed Description

Provides interface for json serialization.

json strings are always UTF8

Definition at line 19 of file json.hpp.

Member Typedef Documentation

yield_function_t

using fc::json::yield_function_t = fc::optional_delegate<void(size_t)>

Definition at line 34 of file json.hpp.

Member Enumeration Documentation

output_formatting

enum class fc::json::output_formatting : unsigned char

strong

Enumerator
stringify_large_ints_and_doubles
legacy_generator

Definition at line 29 of file json.hpp.

         {
            stringify_large_ints_and_doubles = 0,
            legacy_generator = 1
         };

parse_type

enum class fc::json::parse_type : unsigned char

strong

Enumerator
legacy_parser
strict_parser
relaxed_parser
legacy_parser_with_string_doubles

Definition at line 22 of file json.hpp.

         {
            legacy_parser         = 0,
            strict_parser         = 1,
            relaxed_parser        = 2,
            legacy_parser_with_string_doubles = 3
         };

Member Function Documentation

from_file() [1/2]

variant fc::json::from_file ( const fc::path & p, const parse_type ptype = parse_type::legacy_parser, const uint32_t max_depth = DEFAULT_MAX_RECURSION_DEPTH )

static

Definition at line 797 of file json.cpp.

   {
      //auto tmp = std::make_shared<fc::ifstream>( p, ifstream::binary );
      //auto tmp = std::make_shared<std::ifstream>( p.generic_string().c_str(), std::ios::binary );
      //buffered_istream bi( tmp );
      boost::filesystem::ifstream bi( p, std::ios::binary );
      switch( ptype )
      {
          case json::parse_type::legacy_parser:
             return variant_from_stream<boost::filesystem::ifstream, json::parse_type::legacy_parser>( bi, max_depth );
          case json::parse_type::legacy_parser_with_string_doubles:
              return variant_from_stream<boost::filesystem::ifstream, json::parse_type::legacy_parser_with_string_doubles>( bi, max_depth );
          case json::parse_type::strict_parser:
              return json_relaxed::variant_from_stream<boost::filesystem::ifstream, true>( bi, max_depth );
          case json::parse_type::relaxed_parser:
              return json_relaxed::variant_from_stream<boost::filesystem::ifstream, false>( bi, max_depth );
          default:
              FC_ASSERT( false, "Unknown JSON parser type {ptype}", ("ptype", static_cast<int>(ptype)) );
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

from_file() [2/2]

template<typename T >

static T fc::json::from_file ( const fc::path & p, const parse_type ptype = parse_type::legacy_parser, const uint32_t max_depth = DEFAULT_MAX_RECURSION_DEPTH )

inlinestatic

Definition at line 54 of file json.hpp.

         {
            return json::from_file(p, ptype, max_depth).as<T>();
         }

Here is the call graph for this function:

from_string()

variant fc::json::from_string ( const string & utf8_str, const parse_type ptype = parse_type::legacy_parser, uint32_t max_depth = DEFAULT_MAX_RECURSION_DEPTH )

static

Definition at line 442 of file json.cpp.

   { try {
      std::stringstream in( utf8_str );
      //in.exceptions( std::ifstream::eofbit );
      switch( ptype )
      {
          case parse_type::legacy_parser:
             return variant_from_stream<std::stringstream, json::parse_type::legacy_parser>( in, max_depth );
          case parse_type::legacy_parser_with_string_doubles:
              return variant_from_stream<std::stringstream, json::parse_type::legacy_parser_with_string_doubles>( in, max_depth );
          case parse_type::strict_parser:
              return json_relaxed::variant_from_stream<std::stringstream, true>( in, max_depth );
          case parse_type::relaxed_parser:
              return json_relaxed::variant_from_stream<std::stringstream, false>( in, max_depth );
          default:
              FC_ASSERT( false, "Unknown JSON parser type {ptype}", ("ptype", static_cast<int>(ptype)) );
      }
   } FC_RETHROW_EXCEPTIONS( warn, "", ("str",utf8_str) ) }

Here is the call graph for this function:

Here is the caller graph for this function:

is_valid()

bool fc::json::is_valid ( const std::string & json_str, const parse_type ptype = parse_type::legacy_parser, const uint32_t max_depth = DEFAULT_MAX_RECURSION_DEPTH )

static

Definition at line 836 of file json.cpp.

   {
      if( utf8_str.size() == 0 ) return false;
      std::stringstream in( utf8_str );
      switch( ptype )
      {
          case json::parse_type::legacy_parser:
             variant_from_stream<std::stringstream, json::parse_type::legacy_parser>( in, max_depth );
              break;
          case json::parse_type::legacy_parser_with_string_doubles:
             variant_from_stream<std::stringstream, json::parse_type::legacy_parser_with_string_doubles>( in, max_depth );
              break;
          case json::parse_type::strict_parser:
             json_relaxed::variant_from_stream<std::stringstream, true>( in, max_depth );
              break;
          case json::parse_type::relaxed_parser:
             json_relaxed::variant_from_stream<std::stringstream, false>( in, max_depth );
              break;
          default:
              FC_ASSERT( false, "Unknown JSON parser type {ptype}", ("ptype", static_cast<int>(ptype)) );
      }
      try { in.peek(); } catch ( const eof_exception& e ) { return true; }
      return false;
   }

Here is the call graph for this function:

save_to_file() [1/3]

template<typename T >

static bool fc::json::save_to_file ( const T & v, const fc::path & fi, const bool pretty = true, const output_formatting format = output_formatting::stringify_large_ints_and_doubles )

inlinestatic

Definition at line 45 of file json.hpp.

         {
            return save_to_file( variant(v), fi, pretty, format );
         }

Here is the call graph for this function:

Here is the caller graph for this function:

save_to_file() [2/3]

template<typename T >

static bool fc::json::save_to_file ( const T & v, const std::string & p, const bool pretty = true, const output_formatting format = output_formatting::stringify_large_ints_and_doubles )

inlinestatic

Definition at line 80 of file json.hpp.

         {
            return save_to_file( variant(v), fc::path(p), pretty, format );
         }

Here is the call graph for this function:

save_to_file() [3/3]

bool fc::json::save_to_file ( const variant & v, const fc::path & fi, const bool pretty = true, const output_formatting format = output_formatting::stringify_large_ints_and_doubles )

static

Definition at line 781 of file json.cpp.

   {
      if( pretty ) {
         auto str = json::to_pretty_string( v, fc::time_point::maximum(), format, max_length_limit );
         std::ofstream o(fi.generic_string().c_str());
         o.write( str.c_str(), str.size() );
         return o.good();
      } else {
         std::ofstream o(fi.generic_string().c_str());
         const auto yield = [&](size_t s) {
            // no limitation
         };
         fc::to_stream( o, v, yield, format );
         return o.good();
      }
   }

Here is the call graph for this function:

to_pretty_string() [1/2]

template<typename T >

static string fc::json::to_pretty_string ( const T & v, const fc::time_point & deadline = fc::time_point::maximum(), const output_formatting format = output_formatting::stringify_large_ints_and_doubles, const uint64_t max_len = max_length_limit )

inlinestatic

Definition at line 70 of file json.hpp.

         {
            const auto yield = [&](size_t s) {
               FC_CHECK_DEADLINE(deadline);
               FC_ASSERT( s <= max_len );
            };
            return to_pretty_string( variant(v), yield, format );
         }

Here is the call graph for this function:

to_pretty_string() [2/2]

std::string fc::json::to_pretty_string ( const variant & v, const yield_function_t & yield, const output_formatting format = output_formatting::stringify_large_ints_and_doubles )

static

Definition at line 775 of file json.cpp.

                                                                                                                             {
 
      auto s = to_string(v, yield, format);
      return pretty_print( std::move( s ), 2);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

to_string() [1/2]

template<typename T >

static string fc::json::to_string ( const T & v, const fc::time_point & deadline, const output_formatting format = output_formatting::stringify_large_ints_and_doubles, const uint64_t max_len = max_length_limit )

inlinestatic

Definition at line 60 of file json.hpp.

         {
            const auto yield = [&](size_t s) {
               FC_CHECK_DEADLINE(deadline);
               FC_ASSERT(s <= max_len);
            };
            return to_string( variant(v), yield, format );
         }

Here is the call graph for this function:

to_string() [2/2]

std::string fc::json::to_string ( const variant & v, const yield_function_t & yield, const output_formatting format = output_formatting::stringify_large_ints_and_doubles )

static

Definition at line 674 of file json.cpp.

   {
      std::stringstream ss;
      fc::to_stream( ss, v, yield, format );
      yield(ss.tellp());
      return ss.str();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

variants_from_string()

variants fc::json::variants_from_string ( const string & utf8_str, const parse_type ptype = parse_type::legacy_parser, uint32_t max_depth = DEFAULT_MAX_RECURSION_DEPTH )

static

Definition at line 461 of file json.cpp.

   { try {
      variants result;
      std::stringstream in( utf8_str );
      //in.exceptions( std::ifstream::eofbit );
      try {
         while( true )
         {
           // result.push_back( variant_from_stream( in ));
           result.push_back(json_relaxed::variant_from_stream<std::stringstream, false>( in, max_depth ));
         }
      } catch ( const fc::eof_exception& ){}
      return result;
   } FC_RETHROW_EXCEPTIONS( warn, "", ("str",utf8_str) ) }

Here is the call graph for this function:

Member Data Documentation

escape_string_yield_check_count

size_t fc::json::escape_string_yield_check_count = 128

staticconstexpr

Definition at line 36 of file json.hpp.

max_length_limit

uint64_t fc::json::max_length_limit = std::numeric_limits<uint64_t>::max()

staticconstexpr

Definition at line 35 of file json.hpp.

---

The documentation for this class was generated from the following files:

• libraries/fc/include/fc/io/json.hpp
• libraries/fc/src/io/json.cpp