JSON

Functions
void	sample_json ()
	JSON parsing and emitting.

Detailed Description

Function Documentation

sample_json()

void sample_json

(

)

JSON parsing and emitting.

shows how to parse and emit JSON.

To emit YAML parsed from JSON, see also sample_style() for info on clearing the style flags (example below).

Definition at line 5825 of file quickstart.cpp.

{
    ryml::csubstr json = ""
        "{"                                         "\n"
        "  \"doe\": \"a deer, a female deer\","     "\n"
        "  \"ray\": \"a drop of golden sun\","      "\n"
        "  \"me\": \"a name, I call myself\","      "\n"
        "  \"far\": \"a long long way to go\""      "\n"
        "}"                                         "\n"
        "";
    // Since JSON is a subset of YAML, parsing JSON is just the
    // same as YAML:
    ryml::Tree tree = ryml::parse_in_arena(json);
    // If you are sure the source is valid json, you can use the
    // appropriate parse_json overload, which is stricter and faster
    // because json has a much smaller grammar:
    ryml::Tree json_tree = ryml::parse_json_in_arena(json);
    // to emit JSON:
    CHECK(ryml::emitrs_json<std::string>(tree) == json);
    CHECK(ryml::emitrs_json<std::string>(json_tree) == json);
    // to emit JSON to a stream:
    std::stringstream ss;
    ss << ryml::as_json(tree);  // <- mark it like this
    CHECK(ss.str() == json);
    // Note the following limitations on the json emitter:
    //
    // - YAML streams are emitted as seqs by default. If you want to
    //   flag this, and want it to be an error, there is a setting to
    //   control this in EmitOptions.
    //
    // - YAML tags cannot be emitted as JSON, and are allowed only if the
    //   relevant setting is enabled in EmitOptions.
    //
    // - Likewise, anchors and references cannot be emitted as JSON
    //   and are allowed only if the relevant setting is enabled in
    //   EmitOptions.
    //
 
    // Note that when parsing JSON, ryml will set the style of each
    // node in the JSON. This means that if you emit YAML from a tree
    // parsed from JSON, it will look mostly the same as the original
    // JSON:
    CHECK(ryml::emitrs_yaml<std::string>(json_tree) == json);
    // If you want to avoid this, you will need to clear the style.
    json_tree.rootref().clear_style(); // clear the style of the map (without recursing)
    // note that this is now block mode. That is because when no
    // style is set, ryml defaults to emitting in block mode.
    CHECK(ryml::emitrs_yaml<std::string>(json_tree) == ""
          "\"doe\": \"a deer, a female deer\""   "\n"
          "\"ray\": \"a drop of golden sun\""    "\n"
          "\"me\": \"a name, I call myself\""    "\n"
          "\"far\": \"a long long way to go\""   "\n"
          "");
    // if you don't want the double quotes in the scalar, you can
    // recurse:
    json_tree.rootref().clear_style(/*recurse*/true);
    // so now when emitting you will get this:
    CHECK(ryml::emitrs_yaml<std::string>(json_tree) == ""
          "doe: a deer, a female deer"      "\n"
          "ray: a drop of golden sun"       "\n"
          "me: a name, I call myself"       "\n"
          "far: a long long way to go"      "\n"
          "");
    // see in particular sample_style() for more examples
}

Referenced by main().