tetengo::json Namespace Reference

A JSON library. More...

Classes
class	channel
	A channel. More...
class	comment_removing_reader
	A comment removing reader. More...
class	element
	An element. More...
class	file_location
	A file location. More...
class	json_grammar
	A JSON grammar. More...
class	json_parser
	A JSON parser. More...
class	line_counting_reader
	A line counting reader. More...
class	reader
	A reader. More...
class	reader_iterator
	A reader iterator. More...
class	stream_reader
	A stream reader. More...

Detailed Description

A JSON library.

Usage

Parsing JSON

C++

#include <cassert>
#include <memory>
#include <sstream>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include <tetengo/json/element.hpp>
#include <tetengo/json/json_parser.hpp>
#include <tetengo/json/reader.hpp>
#include <tetengo/json/stream_reader.hpp>
 
 
namespace usage_tetengo::json
{
    std::string to_string(const tetengo::json::element& element_);
 
    void parsing()
    {
        static const std::string json_text{
            // clang-format off
            "{\n"
            "  \"hoge\": 42,\n"
            "  \"fuga\": [ \"foo\", \"bar\" ]\n"
            "}\n"
            // clang-format on
        };
        auto p_json_stream = std::make_unique<std::istringstream>(json_text);
 
        // Creates a reader from std::stream.
        auto p_reader = std::make_unique<tetengo::json::stream_reader>(std::move(p_json_stream));
 
        // Creates a JSON parser.
        tetengo::json::json_parser parser{ std::move(p_reader) };
 
        // Iteration.
        std::vector<std::string> elements{};
        while (parser.has_next())
        {
            // Obtains the current element.
            const auto& element = parser.peek();
 
            elements.push_back(to_string(element));
 
            // Moves to the next element.
            parser.next();
        }
 
        static const std::vector<std::string> expected{
            // clang-format off
            "object:open:",
            "member:open:name=hoge:",
            "number:42",
            "member:close:",
            "member:open:name=fuga:",
            "array:open:",
            "string:foo",
            "string:bar",
            "array:close:",
            "member:close:",
            "object:close:",
            // clang-format on
        };
        assert(elements == expected);
    }
 
    std::string to_string(const tetengo::json::element& element_)
    {
        std::string result{};
 
        // Obtains the element type name.
        switch (element_.type().name)
        {
        case tetengo::json::element::type_name_type::string:
            result = "string:";
            break;
        case tetengo::json::element::type_name_type::number:
            result = "number:";
            break;
        case tetengo::json::element::type_name_type::boolean:
            result = "boolean:";
            break;
        case tetengo::json::element::type_name_type::null:
            result = "null:";
            break;
        case tetengo::json::element::type_name_type::object:
            result = "object:";
            break;
        case tetengo::json::element::type_name_type::member:
            result = "member:";
            break;
        default:
            assert(element_.type().name == tetengo::json::element::type_name_type::array);
            result = "array:";
            break;
        }
 
        // Obtains the element type category.
        switch (element_.type().category)
        {
        case tetengo::json::element::type_category_type::primitive:
            break;
        case tetengo::json::element::type_category_type::structure_open:
            result += "open:";
            break;
        default:
            assert(element_.type().category == tetengo::json::element::type_category_type::structure_close);
            result += "close:";
            break;
        }
 
        // Obtains the element attributes.
        for (const auto& attribute: element_.attributes())
        {
            result += attribute.first + "=" + attribute.second + ":";
        }
 
        // Obtains the element value.
        result += element_.value();
 
        return result;
    }
}

C

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include <tetengo/json/element.h>
#include <tetengo/json/jsonParser.h>
#include <tetengo/json/reader.h>
 
 
int         make_json_file(const char* text, const char* path);
const char* to_string(const tetengo_json_element_t* p_element);
 
void usage_tetengo_json_parsing()
{
    // clang-format off
    static const char* const json_text =
        "{\n"
        "  \"hoge\": 42,\n"
        "  \"fuga\": [ \"foo\", \"bar\" ]\n"
        "}\n";
    // clang-format on
    static const char* const json_file_path = "jsonParser_sample.json";
    if (!make_json_file(json_text, json_file_path))
    {
        return;
    }
 
    // Creates a reader from a file path.
    tetengo_json_reader_t* const p_reader =
        tetengo_json_reader_createStreamReader(json_file_path, tetengo_json_reader_streamReaderDefaultBufferCapacity());
 
    // Creates a JSON parser
    tetengo_json_jsonParser_t* const p_parser =
        tetengo_json_jsonParser_create(p_reader, tetengo_json_jsonParser_defaultBufferCapacity());
 
    // Iteration.
    char element_list_string[384] = { 0 };
    while (tetengo_json_jsonParser_hasNext(p_parser))
    {
        // Obtains the current element.
        const tetengo_json_element_t* const p_element = tetengo_json_jsonParser_peek(p_parser);
 
        strcat(element_list_string, to_string(p_element));
 
        // Moves to the next element.
        tetengo_json_jsonParser_next(p_parser);
    }
 
    // clang-format off
    static const char* const expected =
        "object:open:\n"
        "member:open:name=hoge:\n"
        "number:42\n"
        "member:close:\n"
        "member:open:name=fuga:\n"
        "array:open:\n"
        "string:foo\n"
        "string:bar\n"
        "array:close:\n"
        "member:close:\n"
        "object:close:\n";
    // clang-format on
    assert(strcmp(element_list_string, expected) == 0);
 
    // Destroys the JSON parser. The reader inside is also destroyed.
    tetengo_json_jsonParser_destroy(p_parser);
 
    remove(json_file_path);
}
 
int make_json_file(const char* const text, const char* const path)
{
    FILE* const stream = fopen(path, "w");
    if (!stream)
    {
        fprintf(stderr, "Can't create a file: %s", path);
        return 0;
    }
    fputs(text, stream);
    fclose(stream);
    return 1;
}
 
const char* to_string(const tetengo_json_element_t* const p_element)
{
    static char result[32] = { 0 };
    result[0] = '\0';
 
    // Obtains the element type name.
    const tetengo_json_element_type_t* const p_type = tetengo_json_element_type(p_element);
    if (p_type->name == tetengo_json_element_typeName_string())
    {
        strcat(result, "string:");
    }
    else if (p_type->name == tetengo_json_element_typeName_number())
    {
        strcat(result, "number:");
    }
    else if (p_type->name == tetengo_json_element_typeName_boolean())
    {
        strcat(result, "boolean:");
    }
    else if (p_type->name == tetengo_json_element_typeName_null())
    {
        strcat(result, "null:");
    }
    else if (p_type->name == tetengo_json_element_typeName_object())
    {
        strcat(result, "object:");
    }
    else if (p_type->name == tetengo_json_element_typeName_member())
    {
        strcat(result, "member:");
    }
    else
    {
        assert(p_type->name == tetengo_json_element_typeName_array());
        strcat(result, "array:");
    }
 
    // Obtains the element type category.
    if (p_type->category == tetengo_json_element_typeCategory_primitive()) {}
    else if (p_type->category == tetengo_json_element_typeCategory_structureOpen())
    {
        strcat(result, "open:");
    }
    else
    {
        assert(p_type->category == tetengo_json_element_typeCategory_structureClose());
        strcat(result, "close:");
    }
 
    // Obtains the element attributes.
    const size_t attribute_count = tetengo_json_element_attributeKeys(p_element, NULL);
    if (attribute_count > 0)
    {
        const char** const p_keys = (const char**)malloc(attribute_count * sizeof(const char*));
        if (!p_keys)
        {
            fprintf(stderr, "Failed to allocate a memory.");
            return result;
        }
        tetengo_json_element_attributeKeys(p_element, p_keys);
        for (size_t i = 0; i < attribute_count; ++i)
        {
            strcat(result, p_keys[i]);
            strcat(result, "=");
            strcat(result, tetengo_json_element_attributeValueOf(p_element, p_keys[i]));
            strcat(result, ":");
        }
        free((void*)p_keys);
    }
 
    // Obtains the element value.
    strcat(result, tetengo_json_element_value(p_element));
 
    strcat(result, "\n");
    return result;
}