JsonValue.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include "AstUtil/StringView.hpp"
#include <string>
#include <vector>
#include <map>
 
AST_NAMESPACE_BEGIN
 
enum class EJsonValueType
{
    eNull,      
    eBool,      
    eNumber,    
    eString,    
    eArray,     
    eObject     
};
 
class AST_UTIL_API JsonValue
{
public:
    static JsonValue FromString(StringView json);
 
    static JsonValue FromFile(const StringView filePath);
 
    JsonValue();
    
    explicit JsonValue(bool value);
    
    explicit JsonValue(int value);
    
    explicit JsonValue(double value);
    
    explicit JsonValue(const char* value);
    
    explicit JsonValue(const std::string& value);
    
    explicit JsonValue(StringView value);
    
    explicit JsonValue(const std::vector<JsonValue>& values);
    
    explicit JsonValue(const std::map<std::string, JsonValue>& values);
    
    JsonValue(const JsonValue& other);
    
    JsonValue(JsonValue&& other) noexcept;
    
    JsonValue& operator=(const JsonValue& other);
    
    JsonValue& operator=(JsonValue&& other) noexcept;
 
    template<typename T>
    JsonValue& operator=(T value)
    {
        return this->operator=(JsonValue(value));
    }
 
    
    ~JsonValue();
    
    EJsonValueType type() const;
    
    bool isNull() const;
    
    bool isBool() const;
    
    bool isNumber() const;
    
    bool isString() const;
    
    bool isArray() const;
    
    bool isObject() const;
    
    bool toBool(bool defaultValue = false) const;
    
    int toInt(int defaultValue = 0) const;
    
    double toDouble(double defaultValue = 0.0) const;
    
    std::string toString(StringView defaultValue = StringView()) const;
    
    const std::vector<JsonValue>& getArray(const std::vector<JsonValue>& defaultValue = std::vector<JsonValue>()) const;
    
    const std::map<std::string, JsonValue>& getObject(const std::map<std::string, JsonValue>& defaultValue = std::map<std::string, JsonValue>()) const;
    
    size_t size() const;
    
    operator bool() const;
    
    operator int() const;
    
    operator double() const;
    
    operator std::string() const;
 
    
    JsonValue& operator[](size_t index);
    JsonValue& operator[](int index);
    
    const JsonValue& operator[](size_t index) const;
    const JsonValue& operator[](int index) const;
 
    
    JsonValue& operator[](const std::string& key);
    JsonValue& operator[](const char* key);
    
    const JsonValue& operator[](const std::string& key) const;
    const JsonValue& operator[](const char* key) const;
    
    void setNull();
    
    void setBool(bool value);
    
    void setInt(int value);
    
    void setDouble(double value);
    
    void setString(StringView value);
    
    void setArray(const std::vector<JsonValue>& values={});
    
    void setObject(const std::map<std::string, JsonValue>& values={});
    
    void clear();
 
    void insert(const std::string& name, JsonValue value);
 
    template<typename T>
    void insert(const std::string& name, T value)
    {
        return insert(name, JsonValue(value));
    }
 
    void prepend(JsonValue value);
 
    void append(JsonValue value);
 
    template<typename T>
    void append(T value)
    {
        return append(JsonValue(value));
    }
    
    std::string toJsonString(int indent = 0) const;
    
    errc_t parseFromString(StringView json);
 
    errc_t parseFromFile(StringView filepath);
private:
    EJsonValueType type_;  
    
    union
    {
        bool boolean_;                          
        double number_;                         
        std::string* string_;                   
        std::vector<JsonValue>* array_;         
        std::map<std::string, JsonValue>* object_; 
    } value_;  
    
    static JsonValue& NullValue();
    
    void destroy();
    
    std::string formatString(int indent, int indentSize) const;
};
 
 
inline JsonValue operator ""_json(const char* str, size_t len)
{
    return JsonValue::FromString(StringView(str, len));
}
 
AST_NAMESPACE_END