// ---------------------------------------------------------------------------- | |
// Copyright (C) 2002-2006 Marcin Kalicinski | |
// | |
// Distributed under the Boost Software License, Version 1.0. | |
// (See accompanying file LICENSE_1_0.txt or copy at | |
// http://www.boost.org/LICENSE_1_0.txt) | |
// | |
// For more information, see www.boost.org | |
// ---------------------------------------------------------------------------- | |
#ifndef BOOST_PROPERTY_TREE_DETAIL_JSON_PARSER_WRITE_HPP_INCLUDED | |
#define BOOST_PROPERTY_TREE_DETAIL_JSON_PARSER_WRITE_HPP_INCLUDED | |
#include <boost/property_tree/ptree.hpp> | |
#include <boost/next_prior.hpp> | |
#include <boost/type_traits/make_unsigned.hpp> | |
#include <string> | |
#include <ostream> | |
#include <iomanip> | |
namespace boost { namespace property_tree { namespace json_parser | |
{ | |
// Create necessary escape sequences from illegal characters | |
template<class Ch> | |
std::basic_string<Ch> create_escapes(const std::basic_string<Ch> &s) | |
{ | |
std::basic_string<Ch> result; | |
typename std::basic_string<Ch>::const_iterator b = s.begin(); | |
typename std::basic_string<Ch>::const_iterator e = s.end(); | |
while (b != e) | |
{ | |
// This assumes an ASCII superset. But so does everything in PTree. | |
// We escape everything outside ASCII, because this code can't | |
// handle high unicode characters. | |
if (*b == 0x20 || *b == 0x21 || (*b >= 0x23 && *b <= 0x2E) || | |
(*b >= 0x30 && *b <= 0x5B) || (*b >= 0x5D && *b <= 0xFF)) | |
result += *b; | |
else if (*b == Ch('\b')) result += Ch('\\'), result += Ch('b'); | |
else if (*b == Ch('\f')) result += Ch('\\'), result += Ch('f'); | |
else if (*b == Ch('\n')) result += Ch('\\'), result += Ch('n'); | |
else if (*b == Ch('\r')) result += Ch('\\'), result += Ch('r'); | |
else if (*b == Ch('/')) result += Ch('\\'), result += Ch('/'); | |
else if (*b == Ch('"')) result += Ch('\\'), result += Ch('"'); | |
else if (*b == Ch('\\')) result += Ch('\\'), result += Ch('\\'); | |
else | |
{ | |
const char *hexdigits = "0123456789ABCDEF"; | |
typedef typename make_unsigned<Ch>::type UCh; | |
unsigned long u = (std::min)(static_cast<unsigned long>( | |
static_cast<UCh>(*b)), | |
0xFFFFul); | |
int d1 = u / 4096; u -= d1 * 4096; | |
int d2 = u / 256; u -= d2 * 256; | |
int d3 = u / 16; u -= d3 * 16; | |
int d4 = u; | |
result += Ch('\\'); result += Ch('u'); | |
result += Ch(hexdigits[d1]); result += Ch(hexdigits[d2]); | |
result += Ch(hexdigits[d3]); result += Ch(hexdigits[d4]); | |
} | |
++b; | |
} | |
return result; | |
} | |
template<class Ptree> | |
void write_json_helper(std::basic_ostream<typename Ptree::key_type::value_type> &stream, | |
const Ptree &pt, | |
int indent, bool pretty) | |
{ | |
typedef typename Ptree::key_type::value_type Ch; | |
typedef typename std::basic_string<Ch> Str; | |
// Value or object or array | |
if (indent > 0 && pt.empty()) | |
{ | |
// Write value | |
Str data = create_escapes(pt.template get_value<Str>()); | |
stream << Ch('"') << data << Ch('"'); | |
} | |
else if (indent > 0 && pt.count(Str()) == pt.size()) | |
{ | |
// Write array | |
stream << Ch('['); | |
if (pretty) stream << Ch('\n'); | |
typename Ptree::const_iterator it = pt.begin(); | |
for (; it != pt.end(); ++it) | |
{ | |
if (pretty) stream << Str(4 * (indent + 1), Ch(' ')); | |
write_json_helper(stream, it->second, indent + 1, pretty); | |
if (boost::next(it) != pt.end()) | |
stream << Ch(','); | |
if (pretty) stream << Ch('\n'); | |
} | |
stream << Str(4 * indent, Ch(' ')) << Ch(']'); | |
} | |
else | |
{ | |
// Write object | |
stream << Ch('{'); | |
if (pretty) stream << Ch('\n'); | |
typename Ptree::const_iterator it = pt.begin(); | |
for (; it != pt.end(); ++it) | |
{ | |
if (pretty) stream << Str(4 * (indent + 1), Ch(' ')); | |
stream << Ch('"') << create_escapes(it->first) << Ch('"') << Ch(':'); | |
if (pretty) { | |
if (it->second.empty()) | |
stream << Ch(' '); | |
else | |
stream << Ch('\n') << Str(4 * (indent + 1), Ch(' ')); | |
} | |
write_json_helper(stream, it->second, indent + 1, pretty); | |
if (boost::next(it) != pt.end()) | |
stream << Ch(','); | |
if (pretty) stream << Ch('\n'); | |
} | |
if (pretty) stream << Str(4 * indent, Ch(' ')); | |
stream << Ch('}'); | |
} | |
} | |
// Verify if ptree does not contain information that cannot be written to json | |
template<class Ptree> | |
bool verify_json(const Ptree &pt, int depth) | |
{ | |
typedef typename Ptree::key_type::value_type Ch; | |
typedef typename std::basic_string<Ch> Str; | |
// Root ptree cannot have data | |
if (depth == 0 && !pt.template get_value<Str>().empty()) | |
return false; | |
// Ptree cannot have both children and data | |
if (!pt.template get_value<Str>().empty() && !pt.empty()) | |
return false; | |
// Check children | |
typename Ptree::const_iterator it = pt.begin(); | |
for (; it != pt.end(); ++it) | |
if (!verify_json(it->second, depth + 1)) | |
return false; | |
// Success | |
return true; | |
} | |
// Write ptree to json stream | |
template<class Ptree> | |
void write_json_internal(std::basic_ostream<typename Ptree::key_type::value_type> &stream, | |
const Ptree &pt, | |
const std::string &filename, | |
bool pretty) | |
{ | |
if (!verify_json(pt, 0)) | |
BOOST_PROPERTY_TREE_THROW(json_parser_error("ptree contains data that cannot be represented in JSON format", filename, 0)); | |
write_json_helper(stream, pt, 0, pretty); | |
stream << std::endl; | |
if (!stream.good()) | |
BOOST_PROPERTY_TREE_THROW(json_parser_error("write error", filename, 0)); | |
} | |
} } } | |
#endif |