jsonlib.h

浏览该文件的文档.

#pragma once
#ifndef MYSVAC_CPP_JSONLIB_H
#define MYSVAC_CPP_JSONLIB_H
 
#include <initializer_list>
#include <string>
#include <string_view>
#include <map>
#include <vector>
#include <variant>
#include <exception>
#include <stdexcept>
 
#ifndef JSONLIB_EXPORT
    #define JSONLIB_EXPORT
#endif
 
 
namespace Jsonlib{
    enum class JSONLIB_EXPORT JsonType{
        OBJECT, 
        ARRAY,
        STRING, 
        NUMBER, 
        BOOL, 
        ISNULL, 
    };
 

    class JSONLIB_EXPORT JsonException : public std::runtime_error {
    public:
        JsonException() : std::runtime_error("Unknown JSON Exception.\n") {}

        explicit JsonException(const std::string& message) : std::runtime_error(message) {}
    };
    
    class JSONLIB_EXPORT JsonTypeException final : public JsonException {
    public:
        JsonTypeException() : JsonException("Unknown JSON Type Exception.\n") {}

        explicit JsonTypeException(const std::string& message) : JsonException(message) {}
    };

    class JSONLIB_EXPORT JsonStructureException final : public JsonException {
    public:
        JsonStructureException() : JsonException("Unknown Json Structure.\n") {}

        explicit JsonStructureException(const std::string& message) : JsonException(message) {}
    };
 
 
    class JsonValue;

    using JsonObject = std::map<std::string,JsonValue>;

    using JsonArray = std::vector<JsonValue>;

    JSONLIB_EXPORT
    JsonValue deserialize(std::string_view str);

    class JSONLIB_EXPORT JsonValue{
    private:
        using JsonVar = std::variant<bool, std::string, JsonObject, JsonArray>;
        JsonVar content_ { false };

        JsonType type_ { JsonType::ISNULL };
 
    public:
        JsonValue(std::string_view str, std::string_view::const_iterator& it);

        JsonValue(const std::initializer_list<JsonValue>& init_list);
 

        [[nodiscard]]
        JsonType type() const noexcept { return type_; }

        void reset() noexcept {
            type_ = JsonType::ISNULL;
            content_ = false;
        }

        void clear() noexcept;

        [[nodiscard]]
        size_t size() const noexcept;

        JsonValue() = default;

        explicit JsonValue(const JsonType& jsonType);

        JsonValue(std::string_view str) noexcept;

        JsonValue& operator=(std::string_view str);
 

        JsonValue(const char* str) noexcept;

        JsonValue& operator=(const char* str) noexcept;
        
        JsonValue(const bool& bl) noexcept: type_(JsonType::BOOL) {
            content_ = bl;
        }

        JsonValue(const int& num) noexcept: type_(JsonType::NUMBER) {
            content_ = std::to_string(num);
        }

        JsonValue(const long long& num) noexcept: type_(JsonType::NUMBER) {
            content_ = std::to_string(num);
        }

        JsonValue(const double& num) noexcept: type_(JsonType::NUMBER) {
            content_ = std::to_string(num);
        }

        JsonValue(const long double& num) noexcept: type_(JsonType::NUMBER) {
            content_ = std::to_string(num);
        }

        JsonValue(const std::nullptr_t&) noexcept{}

        JsonValue(const JsonArray& jsonArray) noexcept;
        JsonValue(JsonArray&& jsonArray) noexcept;
        JsonValue(const JsonObject& jsonObject) noexcept;
        JsonValue(JsonObject&& jsonObject) noexcept;

        JsonValue& operator=(const JsonArray& jsonArray) noexcept;
        JsonValue& operator=(JsonArray&& jsonArray) noexcept;
        JsonValue& operator=(const JsonObject& jsonObject) noexcept;
        JsonValue& operator=(JsonObject&& jsonObject) noexcept;

        JsonValue& operator=(const bool& bl) noexcept {
            type_ = JsonType::BOOL;
            content_ = bl;
            return *this;
        }

        JsonValue& operator=(const int& num) noexcept {
            type_ = JsonType::NUMBER;
            content_ = std::to_string(num);
            return *this;
        }

        JsonValue& operator=(const long long& num) noexcept{
            type_ = JsonType::NUMBER;
            content_ = std::to_string(num);
            return *this;
        }

        JsonValue& operator=(const double& num) noexcept {
            type_ = JsonType::NUMBER;
            content_ = std::to_string(num);
            return *this;
        }

        JsonValue& operator=(const long double& num) noexcept{
            type_ = JsonType::NUMBER;
            content_ = std::to_string(num);
            return *this;
        }

        JsonValue& operator=(const std::nullptr_t& ) noexcept{
            type_ = JsonType::ISNULL;
            content_ = false;
            return *this;
        }

        JsonValue(const JsonValue& jsonValue) noexcept;

        JsonValue(JsonValue&& jsonValue) noexcept;

        JsonValue& operator=(const JsonValue& jsonValue) noexcept;

        JsonValue& operator=(JsonValue&& jsonValue) noexcept;

        [[nodiscard]]
        std::string serialize() const noexcept;

        [[nodiscard]]
        std::string serialize_pretty(const size_t& space_num = 2,const size_t& depth = 0) const noexcept;

        [[nodiscard]]
        bool is_object() const noexcept { return type_ == JsonType::OBJECT; }

        [[nodiscard]]
        bool is_array() const noexcept { return type_ == JsonType::ARRAY; }

        [[nodiscard]]
        bool is_string() const noexcept { return type_ == JsonType::STRING; }

        [[nodiscard]]
        bool is_bool() const noexcept { return type_ == JsonType::BOOL; }

        [[nodiscard]]
        bool is_number() const noexcept { return type_ == JsonType::NUMBER; }

        [[nodiscard]]
        bool is_int64() const noexcept { return type_ == JsonType::NUMBER && std::get<std::string>(content_).find('.') == std::string::npos; }

        [[nodiscard]]
        bool is_double() const noexcept { return type_ == JsonType::NUMBER && std::get<std::string>(content_).find('.') != std::string::npos; }

        [[nodiscard]]
        bool is_null() const noexcept { return type_ == JsonType::ISNULL; }

        [[nodiscard]]
        bool is_value() const noexcept { return type_ != JsonType::OBJECT && type_ != JsonType::ARRAY; }

        [[nodiscard]]
        long long as_int64() const;
        [[nodiscard]]
        double as_double() const;
        [[nodiscard]]
        long double as_ldouble() const;
        [[nodiscard]]
        bool as_bool() const;

        [[nodiscard]]
        std::string as_string() const;

        JsonObject& as_object();

        [[nodiscard]]
        const JsonObject& as_object() const;

        JsonArray& as_array();

        [[nodiscard]]
        const JsonArray& as_array() const;

        JsonValue& at(const size_t& index);
        JsonValue& at(const std::string& key);
        JsonValue& operator[](const size_t& index);
        JsonValue& operator[](const std::string& key);

        [[nodiscard]]
        bool hasKey(const std::string& key) const noexcept;
 

        void push_back(const JsonValue& jsonBasic);

        void push_back(JsonValue&& jsonBasic);

        void pop_back();

        void insert(const size_t& index, const JsonValue& jsonBasic);

        void insert(const size_t& index, JsonValue&& jsonBasic);

        void insert(const std::string& key,const JsonValue& jsonBasic);

        void insert(const std::string& key,JsonValue&& jsonBasic);
 

        void erase(const size_t& index);
        void erase(const std::string& key);
    };
 
}
 
#endif