json.hpp

Go to the documentation of this file.

#pragma once
 
#include "json/json.h"
 
#include "std/map.h"
 
#include "base/panic.h"
 
#include <string_view>
 
typedef struct logger_t logger_t;
typedef struct io_t io_t;
 
 
namespace ctu::json {
    class Json;
    class Object;
    class Array;
 
    class ObjectIterator;
    class ArrayIterator;
 
    class CT_JSON_API Object {
        friend class Json;
 
        const map_t *m_object;
 
        constexpr Object(const map_t *object)
            : m_object(object)
        { }
 
    public:
        Json get(const char *key) const;
 
        Json operator[](const char *key) const;
 
        ObjectIterator begin() const;
 
        ObjectIterator end() const;
 
        ObjectIterator iter() const;
    };
 
    class CT_JSON_API Array {
        friend class Json;
 
        const typevec_t m_array;
 
        constexpr Array(typevec_t array)
            : m_array(array)
        { }
 
    public:
        Json get(size_t index) const;
 
        Json operator[](size_t index) const;
 
        size_t length() const;
 
        ArrayIterator begin() const;
 
        ArrayIterator end() const;
    };
 
    class CT_JSON_API Json {
        friend class JsonParser;
        friend class Object;
        friend class Array;
        friend class ObjectIterator;
        friend class ArrayIterator;
 
        json_t *m_ast;
 
    public:
        constexpr Json(json_t *ast)
            : m_ast(ast)
        { }
 
        constexpr Json()
            : m_ast(nullptr)
        { }
 
        CT_PUREFN bool is_string() const;
 
        CT_PUREFN bool is_integer() const;
 
        CT_PUREFN bool is_float() const;
 
        CT_PUREFN bool is_bool() const;
 
        CT_PUREFN bool is_array() const;
 
        CT_PUREFN bool is_object() const;
 
        CT_PUREFN bool is_null() const;
 
        CT_PUREFN constexpr bool is_valid() const { return m_ast != nullptr; }
 
        constexpr operator bool() const { return is_valid(); }
 
        CT_PUREFN json_kind_t get_kind() const;
 
        CT_PUREFN bool is_kind(json_kind_t kind) const;
 
        CT_PUREFN std::string_view as_string() const;
 
        void as_integer(mpz_t integer) const;
 
        CT_PUREFN float as_float() const;
 
        CT_PUREFN bool as_bool() const;
 
        CT_PUREFN Array as_array() const;
 
        CT_PUREFN Object as_object() const;
 
        CT_PUREFN size_t length() const;
 
        Json get(const char *key) const;
 
        Json get(size_t index) const;
 
        constexpr json_t *get_ast() const { return m_ast; }
 
        Json operator[](const char *key) const;
 
        Json operator[](size_t index) const;
 
        template<typename F>
        auto visit(F&& func) const {
            switch (get_kind()) {
            case eJsonString: return func(as_string());
            case eJsonInteger: return func(m_ast->integer);
            case eJsonFloat: return func(as_float());
            case eJsonBoolean: return func(as_bool());
            case eJsonArray: return func(as_array());
            case eJsonObject: return func(as_object());
            case eJsonNull: return func(nullptr);
            default: CT_NEVER("invalid json kind %d", get_kind());
            }
        }
    };
 
    struct CT_JSON_API member_t {
        std::string_view key;
 
        Json value;
    };
 
    class CT_JSON_API ObjectIterator {
        friend class Object;
 
        map_iter_t m_iter;
        map_entry_t m_entry;
 
        constexpr ObjectIterator(map_iter_t iter)
            : m_iter(iter)
        { }
 
        constexpr ObjectIterator()
            : m_iter()
        { }
 
    public:
        bool operator!=(const ObjectIterator& other) const;
        ObjectIterator &operator++();
        member_t operator*() const;
 
        bool has_next() const;
        member_t next();
    };
 
    class CT_JSON_API ArrayIterator {
        friend class Array;
 
        typevec_t m_array;
        size_t m_index;
 
        constexpr ArrayIterator(typevec_t array, size_t index)
            : m_array(array)
            , m_index(index)
        { }
 
    public:
        bool operator!=(const ArrayIterator& other) const;
        ArrayIterator &operator++();
        Json operator*() const;
    };
 
    class CT_JSON_API JsonParser {
        arena_t *m_arena;
        logger_t *m_logger;
 
    public:
        JsonParser(arena_t *arena);
 
        Json parse(io_t *io);
 
        logger_t *get_logger() const { return m_logger; }
    };
}