json11 Namespace Reference

Classes
class	Json
class	JsonArray
class	JsonBoolean
class	JsonDouble
class	JsonInt
class	JsonNull
class	JsonObject
class	JsonString
class	JsonValue
struct	NullStruct
struct	Statics
class	Value

Enumerations
enum	JsonParse { STANDARD, COMMENTS }

Functions
static void	dump (NullStruct, string &out)
static void	dump (double value, string &out)
static void	dump (int value, string &out)
static void	dump (bool value, string &out)
static void	dump (const string &value, string &out)
static void	dump (const Json::array &values, string &out)
static void	dump (const Json::object &values, string &out)
static const Statics &	statics ()
static const Json &	static_null ()
static string	esc (char c)
static bool	in_range (long x, long lower, long upper)

Variables
static const int	max_depth = 200

Enumeration Type Documentation

enum json11::JsonParse

Enumerator
STANDARD
COMMENTS

               {
    STANDARD, COMMENTS
};

Function Documentation

static void json11::dump ( NullStruct  , string &  out  )

static

                                          {
    out += "null";
}

static void json11::dump ( double  value, string &  out  )

static

                                            {
    if (std::isfinite(value)) {
        char buf[32];
        snprintf(buf, sizeof buf, "%.17g", value);
        out += buf;
    } else {
        out += "null";
    }
}

static void json11::dump ( int  value, string &  out  )

static

                                         {
    char buf[32];
    snprintf(buf, sizeof buf, "%d", value);
    out += buf;
}

static void json11::dump ( bool  value, string &  out  )

static

                                          {
    out += value ? "true" : "false";
}

static void json11::dump ( const string &  value, string &  out  )

static

                                                   {
    out += '"';
    for (size_t i = 0; i < value.length(); i++) {
        const char ch = value[i];
        if (ch == '\\') {
            out += "\\\\";
        } else if (ch == '"') {
            out += "\\\"";
        } else if (ch == '\b') {
            out += "\\b";
        } else if (ch == '\f') {
            out += "\\f";
        } else if (ch == '\n') {
            out += "\\n";
        } else if (ch == '\r') {
            out += "\\r";
        } else if (ch == '\t') {
            out += "\\t";
        } else if (static_cast<uint8_t>(ch) <= 0x1f) {
            char buf[8];
            snprintf(buf, sizeof buf, "\\u%04x", ch);
            out += buf;
        } else if (static_cast<uint8_t>(ch) == 0xe2 && static_cast<uint8_t>(value[i+1]) == 0x80
                   && static_cast<uint8_t>(value[i+2]) == 0xa8) {
            out += "\\u2028";
            i += 2;
        } else if (static_cast<uint8_t>(ch) == 0xe2 && static_cast<uint8_t>(value[i+1]) == 0x80
                   && static_cast<uint8_t>(value[i+2]) == 0xa9) {
            out += "\\u2029";
            i += 2;
        } else {
            out += ch;
        }
    }
    out += '"';
}

static void json11::dump ( const Json::array &  values, string &  out  )

static

                                                       {
    bool first = true;
    out += "[";
    for (const auto &value : values) {
        if (!first)
            out += ", ";
        value.dump(out);
        first = false;
    }
    out += "]";
}

static void json11::dump ( const Json::object &  values, string &  out  )

static

                                                        {
    bool first = true;
    out += "{";
    for (const auto &kv : values) {
        if (!first)
            out += ", ";
        dump(kv.first, out);
        out += ": ";
        kv.second.dump(out);
        first = false;
    }
    out += "}";
}

static const Statics& json11::statics ( )

static

                                 {
    static const Statics s {};
    return s;
}

static const Json& json11::static_null ( )

static

                                  {
    // This has to be separate, not in Statics, because Json() accesses statics().null.
    static const Json json_null;
    return json_null;
}

static string json11::esc ( char  c )

inlinestatic

                                 {
    char buf[12];
    if (static_cast<uint8_t>(c) >= 0x20 && static_cast<uint8_t>(c) <= 0x7f) {
        snprintf(buf, sizeof buf, "'%c' (%d)", c, c);
    } else {
        snprintf(buf, sizeof buf, "(%d)", c);
    }
    return string(buf);
}

static bool json11::in_range ( long  x, long  lower, long  upper  )

inlinestatic

                                                            {
    return (x >= lower && x <= upper);
}

Variable Documentation

const int json11::max_depth = 200

static