GxJson.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
#include "document.h"
 
GX_CORE_NAMESPACE_BEGIN()
 
//===========================================================================
//===========================================================================
class GxJson : public GxClassBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxJson, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxJson)
 
#if GX_DEVELOP
    // new, delete定義
    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP)
 
    //===========================================================================
    //===========================================================================
    class GxJsonObject
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        friend class GxJson;
 
        enum class TYPE
        {
            OBJECT = 3, 
            ARRAY,      
        };
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    private:
        GxJsonObject(void) {}
        GxJsonObject(rapidjson::Document* pDocument, TYPE type) : _pDocument(pDocument), _value(static_cast<rapidjson::Type>(type)) {}
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        void addObject(GxJsonObject* pObject, GX_CSTR name);
        void addS32(s32 value, GX_CSTR name);
        void addU32(u32 value, GX_CSTR name);
        void addS64(s64 value, GX_CSTR name);
        void addU64(u64 value, GX_CSTR name);
        void addF32(f32 value, GX_CSTR name);
        void addF64(f64 value, GX_CSTR name);
        void addB32(b32 value, GX_CSTR name);
        void addSTR(GX_CSTR value, GX_CSTR name);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
    private:
        rapidjson::Document* _pDocument;    
        rapidjson::Value _value;            
 
    };
#endif //GX_DEVELOP
 
    //===========================================================================
    //===========================================================================
    class GxJsonNode
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        friend class GxJson;
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxJsonNode(const GxJsonNode& node) : _value(node._value) {}
    private:
        GxJsonNode(void) = delete;
        GxJsonNode(rapidjson::Value& value) : _value(value) {}
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GX_FORCE_INLINE const GxJsonNode operator[](GX_CSTR name) const { return GxJsonNode(_value[name]); }
        GX_FORCE_INLINE const GxJsonNode operator[](u32 i) const { return GxJsonNode(_value[i]); }
        GX_FORCE_INLINE b32 hasMember(GX_CSTR name) const { return _value.HasMember(name); }
        GX_FORCE_INLINE b32 isArray(void) const { return _value.IsArray(); }
        GX_FORCE_INLINE u32 getArrayCount(void) const { GX_ASSERT(isArray(), "is not array!");  return _value.Size(); }
        GX_FORCE_INLINE b32 isS32(void) const { return _value.IsInt(); }
        GX_FORCE_INLINE s32 getS32(void) const { GX_ASSERT(isS32(), "is not s32!"); return _value.GetInt(); }
        s32 getS32(GX_CSTR name, s32 defaultValue, s32 index = -1) const;
        GX_FORCE_INLINE b32 isU32(void) const { return _value.IsUint(); }
        GX_FORCE_INLINE u32 getU32(void) const { GX_ASSERT(isU32(), "is not u32!"); return _value.GetUint(); }
        u32 getU32(GX_CSTR name, u32 defaultValue, s32 index = -1) const;
        GX_FORCE_INLINE b32 isS64(void) const { return _value.IsInt64(); }
        GX_FORCE_INLINE s64 getS64(void) const { GX_ASSERT(isS64(), "is not s64!"); return _value.GetInt64(); }
        s64 getS64(GX_CSTR name, s64 defaultValue, s32 index = -1) const;
        GX_FORCE_INLINE b32 isU64(void) const { return _value.IsUint64(); }
        GX_FORCE_INLINE u64 getU64(void) const { GX_ASSERT(isU64(), "is not u64!"); return _value.GetUint64(); }
        u64 getU64(GX_CSTR name, u64 defaultValue, s32 index = -1) const;
        GX_FORCE_INLINE b32 isF32(void) const { return _value.IsFloat(); }
        GX_FORCE_INLINE f32 getF32(void) const { GX_ASSERT(isF32(), "is not f32!"); return _value.GetFloat(); }
        f32 getF32(GX_CSTR name, f32 defaultValue, s32 index = -1) const;
        GX_FORCE_INLINE b32 isF64(void) const { return _value.IsDouble(); }
        GX_FORCE_INLINE f64 getF64(void) const { GX_ASSERT(isF64(), "is not f64!"); return _value.GetDouble(); }
        f64 getF64(GX_CSTR name, f64 defaultValue, s32 index = -1) const;
        GX_FORCE_INLINE b32 isB32(void) const { return _value.IsBool(); }
        GX_FORCE_INLINE b32 getB32(void) const { GX_ASSERT(isB32(), "is not b32!"); return _value.GetBool(); }
        b32 getB32(GX_CSTR name, b32 defaultValue, s32 index = -1) const;
        GX_FORCE_INLINE b32 isString(void) const { return _value.IsString(); }
        GX_FORCE_INLINE GX_CSTR getString(void) const { GX_ASSERT(isString(), "is not string!"); return _value.GetString(); }
        GX_CSTR getString(GX_CSTR name, GX_CSTR defaultValue, s32 index = -1) const;
        GX_FORCE_INLINE u32 getStringLength(void) const { GX_ASSERT(isString(), "is not string!"); return _value.GetStringLength(); }
        GX_FORCE_INLINE b32 isObject(void) const { return _value.IsObject(); }
        GX_FORCE_INLINE b32 isNumber(void) const { return _value.IsNumber(); }
        GX_FORCE_INLINE b32 isNull(void) const { return _value.IsNull(); }
        GxSize getSize(GX_CSTR name, const GxSize& defaultValue, s32 index = -1) const;
        GxRect getRect(GX_CSTR name, const GxRect& defaultValue, s32 index = -1) const;
        GxColor getColor(GX_CSTR name, const GxColor& defaultValue, s32 index = -1) const;
        GxVector2 getVector2(GX_CSTR name, const GxVector2& defaultValue, s32 index = -1) const;
        GxPoint2 getPoint2(GX_CSTR name, const GxPoint2& defaultValue, s32 index = -1) const;
        GxFlag32Base getFlag32Base(GX_CSTR name, const GxFlag32Base& defaultValue, s32 index = -1) const;
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    private:
        rapidjson::Value& _value;   
 
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxJson(u32 memorySize = 0);
    virtual ~GxJson(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_FORCE_INLINE const GxJsonNode operator[](GX_CSTR name) const { return GxJsonNode(const_cast<rapidjson::Value&>((*_pDocument)[name])); }
    GX_FORCE_INLINE b32 hasMember(GX_CSTR name) const { return _pDocument->HasMember(name); }
#if GX_DEVELOP
    GxJsonObject* createObject(GxJsonObject::TYPE type);
    void addObject(GxJsonObject* pObject, GX_CSTR name);
    void readJson(GxStream& stream);
    void writeJson(GxStream& stream, b32 isCompress = false);
#endif //GX_DEVELOP
    GX_FORCE_INLINE void parse(GX_CHAR* pBuffer) { _pDocument->Parse(pBuffer); }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    rapidjson::Document* _pDocument;    
#if GX_DEVELOP
    GxArray _objects;                   
    void* _pBuffer;                     
#endif //GX_DEVELOP
 
};
 
GX_CORE_NAMESPACE_END()