YAML documents

Functions
void	sample_docs ()
	deal with YAML docs

Detailed Description

Function Documentation

sample_docs()

void sample_docs

(

)

deal with YAML docs

Definition at line 6275 of file quickstart.cpp.

{
    ryml::csubstr yml = ""
        "---"        "\n"
        "a: 0"       "\n"
        "b: 1"       "\n"
        "---"        "\n"
        "c: 2"       "\n"
        "d: 3"       "\n"
        "---"        "\n"
        "- 4"        "\n"
        "- 5"        "\n"
        "- 6"        "\n"
        "- 7"        "\n"
        "";
    ryml::Tree tree = ryml::parse_in_arena(yml);
    CHECK(ryml::emitrs_yaml<std::string>(tree) == yml);
 
    // iteration through docs
    {
        // using the node API
        const ryml::ConstNodeRef stream = tree.rootref();
        CHECK(stream.is_root());
        CHECK(stream.is_stream());
        CHECK(!stream.is_doc());
        CHECK(stream.num_children() == 3);
        for(const ryml::ConstNodeRef doc : stream.children())
            CHECK(doc.is_doc());
        CHECK(tree.docref(0).id() == stream.child(0).id());
        CHECK(tree.docref(1).id() == stream.child(1).id());
        CHECK(tree.docref(2).id() == stream.child(2).id());
        // equivalent: using the lower level index API
        const ryml::id_type stream_id = tree.root_id();
        CHECK(tree.is_root(stream_id));
        CHECK(tree.is_stream(stream_id));
        CHECK(!tree.is_doc(stream_id));
        CHECK(tree.num_children(stream_id) == 3);
        for(ryml::id_type doc_id = tree.first_child(stream_id);
            doc_id != ryml::NONE;
            doc_id = tree.next_sibling(stream_id))
            CHECK(tree.is_doc(doc_id));
        CHECK(tree.doc(0) == tree.child(stream_id, 0));
        CHECK(tree.doc(1) == tree.child(stream_id, 1));
        CHECK(tree.doc(2) == tree.child(stream_id, 2));
 
        // using the node API
        CHECK(stream[0].is_doc());
        CHECK(stream[0].is_map());
        CHECK(stream[0]["a"].val() == "0");
        CHECK(stream[0]["b"].val() == "1");
        // equivalent: using the index API
        const ryml::id_type doc0_id = tree.first_child(stream_id);
        CHECK(tree.is_doc(doc0_id));
        CHECK(tree.is_map(doc0_id));
        CHECK(tree.val(tree.find_child(doc0_id, "a")) == "0");
        CHECK(tree.val(tree.find_child(doc0_id, "b")) == "1");
 
        // using the node API
        CHECK(stream[1].is_doc());
        CHECK(stream[1].is_map());
        CHECK(stream[1]["c"].val() == "2");
        CHECK(stream[1]["d"].val() == "3");
        // equivalent: using the index API
        const ryml::id_type doc1_id = tree.next_sibling(doc0_id);
        CHECK(tree.is_doc(doc1_id));
        CHECK(tree.is_map(doc1_id));
        CHECK(tree.val(tree.find_child(doc1_id, "c")) == "2");
        CHECK(tree.val(tree.find_child(doc1_id, "d")) == "3");
 
        // using the node API
        CHECK(stream[2].is_doc());
        CHECK(stream[2].is_seq());
        CHECK(stream[2][0].val() == "4");
        CHECK(stream[2][1].val() == "5");
        CHECK(stream[2][2].val() == "6");
        CHECK(stream[2][3].val() == "7");
        // equivalent: using the index API
        const ryml::id_type doc2_id = tree.next_sibling(doc1_id);
        CHECK(tree.is_doc(doc2_id));
        CHECK(tree.is_seq(doc2_id));
        CHECK(tree.val(tree.child(doc2_id, 0)) == "4");
        CHECK(tree.val(tree.child(doc2_id, 1)) == "5");
        CHECK(tree.val(tree.child(doc2_id, 2)) == "6");
        CHECK(tree.val(tree.child(doc2_id, 3)) == "7");
    }
 
    // Note: ryml emits streams as a JSON seq by default:
    CHECK(ryml::emitrs_json<std::string>(tree) ==
          "["              "\n"
          "  {"            "\n"
          "    \"a\": 0,"  "\n"
          "    \"b\": 1"   "\n"
          "  },"           "\n"
          "  {"            "\n"
          "    \"c\": 2,"  "\n"
          "    \"d\": 3"   "\n"
          "  },"           "\n"
          "  ["            "\n"
          "    4,"         "\n"
          "    5,"         "\n"
          "    6,"         "\n"
          "    7"          "\n"
          "  ]"            "\n"
          "]\n"
          "");
    // ... but you can use EmitOptions{} to set the emitter to fail if
    // it finds a stream:
    {
        ScopedErrorHandlerExample errh; // calls ryml::set_callbacks()
        ryml::Tree err_tree = ryml::parse_in_arena(yml);
        CHECK(err_tree.callbacks() == errh.callbacks());
        auto err_opts = ryml::EmitOptions{}.json_err_on_stream(true);
        CHECK(errh.check_error_occurs([&]{
            return ryml::emitrs_json<std::string>(err_tree, err_opts);
        }));
        // in which case, you can avoid the error by emitting the
        // documents one-by-one:
        const std::string expected_json[] = {
            "{"            "\n"
            "  \"a\": 0,"  "\n"
            "  \"b\": 1"   "\n"
            "}"            "\n"
            ,
            "{"            "\n"
            "  \"c\": 2,"  "\n"
            "  \"d\": 3"   "\n"
            "}"            "\n"
            ,
            "["            "\n"
            "  4,"         "\n"
            "  5,"         "\n"
            "  6,"         "\n"
            "  7"          "\n"
            "]"            "\n"
        };
        ryml::id_type count = 0;
        const ryml::ConstNodeRef stream = err_tree;
        CHECK(stream.num_children() == (ryml::id_type)C4_COUNTOF(expected_json));
        for(ryml::ConstNodeRef doc : stream.children())
            CHECK(ryml::emitrs_json<std::string>(doc, err_opts) == expected_json[count++]);
    }
}

Referenced by main().