ZFJson.h

Go to the documentation of this file.

 
#ifndef _ZFI_ZFJson_h_
#define _ZFI_ZFJson_h_
 
#include "ZFAlgorithmDef.h"
ZF_NAMESPACE_GLOBAL_BEGIN
 
/*
 * all types:
 *     Null
 *     Value
 *     Object
 *     Array
 *
 * here is a typical json data:
    "{"
    "    \"k0\" : \"v0\","
    ""
    "    \"object0\" : {},"
    "    \"object1\" : {"
    "        \"k0\" : \"v0\","
    "        \"k1\" : \"v1\""
    "    },"
    "    \"object2\" : {"
    "        \"k0\" : {\"k0\" : \"v0\"}"
    "    },"
    ""
    "    \"array0\" : [],"
    "    \"array1\" : ["
    "        {\"k0\" : \"v0\"},"
    "        {\"k0\" : \"v0\"}"
    "    ],"
    ""
    "    \"k1\" : \"v1\""
    "}"
 */
 
// ============================================================
// ZFJsonType
ZFENUM_BEGIN(ZFLIB_ZFAlgorithm, ZFJsonType)
    ZFENUM_VALUE(Null)
    ZFENUM_VALUE(Value)
    ZFENUM_VALUE(Object)
    ZFENUM_VALUE(Array)
ZFENUM_SEPARATOR()
    ZFENUM_VALUE_REGISTER(Null)
    ZFENUM_VALUE_REGISTER(Value)
    ZFENUM_VALUE_REGISTER(Object)
    ZFENUM_VALUE_REGISTER(Array)
ZFENUM_END(ZFLIB_ZFAlgorithm, ZFJsonType)
ZFENUM_REG(ZFLIB_ZFAlgorithm, ZFJsonType)
 
// ============================================================
zfclassLikePOD ZFLIB_ZFAlgorithm ZFJsonOutputToken {
public:
    zfstring jsonNewLineToken; 
    zfstring jsonIndentToken; 
 
    zfstring jsonValueSeparatorToken; 
    zfstring jsonSeparatorToken; 
    zfstring jsonSeparatorInSameLineToken; 
 
    zfstring jsonKeyTagLeft; 
    zfstring jsonKeyTagRight; 
 
    zfstring jsonValueTagLeft; 
    zfstring jsonValueTagRight; 
 
    zfstring jsonObjectTagLeft; 
    zfstring jsonObjectTagRight; 
 
    zfstring jsonArrayTagLeft; 
    zfstring jsonArrayTagRight; 
 
public:
    zfstring jsonGlobalLineBeginToken;

    zfbool jsonObjectAddNewLineForContent;
    zfbool jsonObjectTagInSameLineIfNoContent;

    zfbool jsonArrayAddNewLineForContent;
    zfbool jsonArrayContentTagInSameLine;
    zfbool jsonArrayTagInSameLineIfNoContent;
 
public:
    ZFJsonOutputToken(void)
    : jsonNewLineToken("\n")
    , jsonIndentToken("  ")
    , jsonValueSeparatorToken(" : ")
    , jsonSeparatorToken(",")
    , jsonSeparatorInSameLineToken(", ")
    , jsonKeyTagLeft("\"")
    , jsonKeyTagRight("\"")
    , jsonValueTagLeft("\"")
    , jsonValueTagRight("\"")
    , jsonObjectTagLeft("{")
    , jsonObjectTagRight("}")
    , jsonArrayTagLeft("[")
    , jsonArrayTagRight("]")
    , jsonGlobalLineBeginToken()
    , jsonObjectAddNewLineForContent(zftrue)
    , jsonObjectTagInSameLineIfNoContent(zftrue)
    , jsonArrayAddNewLineForContent(zftrue)
    , jsonArrayContentTagInSameLine(zftrue)
    , jsonArrayTagInSameLineIfNoContent(zftrue)
    {
    }
    zfbool operator == (ZF_IN ZFJsonOutputToken const &ref) const;
    zfbool operator != (ZF_IN ZFJsonOutputToken const &ref) const {
        return !this->operator == (ref);
    }
};
ZFTYPEID_ACCESS_ONLY_DECLARE(ZFLIB_ZFAlgorithm, ZFJsonOutputToken, ZFJsonOutputToken)
ZFTYPEID_ACCESS_ONLY_REG(ZFLIB_ZFAlgorithm, ZFJsonOutputToken, ZFJsonOutputToken)
 

ZFEXPORT_VAR_DECLARE(ZFLIB_ZFAlgorithm, ZFJsonOutputToken, ZFJsonOutputTokenTrim)
ZFEXPORT_VAR_DECLARE(ZFLIB_ZFAlgorithm, ZFJsonOutputToken, ZFJsonOutputTokenDetail)
ZFEXPORT_VAR_DECLARE(ZFLIB_ZFAlgorithm, ZFJsonOutputToken, ZFJsonOutputTokenDefault)
 
// ============================================================
// ZFJson
zfclassFwd _ZFP_ZFJsonPrivate;
zfclassLikePOD ZFLIB_ZFAlgorithm ZFJson {
    // ============================================================
public:
    ZFJson(void);
    ZFJson(ZF_IN const zfnullT &dummy);
    ZFJson(ZF_IN ZFJsonType type);
    ZFJson(ZF_IN const ZFJson &ref);
    virtual ~ZFJson(void);
 
    ZFJson &operator = (ZF_IN const ZFJson &ref);
    ZFJson &operator = (ZF_IN const zfnullT &dummy);
    inline zfbool operator == (ZF_IN const zfnullT &ref) const {return !this->valid();}
    inline zfbool operator != (ZF_IN const zfnullT &ref) const {return this->valid();}
    zfbool operator == (ZF_IN const ZFJson &ref) const;
    inline zfbool operator != (ZF_IN const ZFJson &ref) const {return !(this->operator == (ref));}
 
    // ============================================================
public:
    void objectInfoT(ZF_IN_OUT zfstring &ret) const;
    inline zfstring objectInfo(void) const {
        zfstring ret;
        this->objectInfoT(ret);
        return ret;
    }
 
public:
    zfindex objectRetainCount(void) const;
 
    // ============================================================
public:
    void _ZFP_ZFJson_jsonType(ZF_IN ZFJsonType type);
    ZFJsonType type(void) const;
    inline zfbool valid(void) const {
        return (this->type() != v_ZFJsonType::e_Null);
    }

    ZFJson copy(void) const;

    ZFJson &merge(ZF_IN const ZFJson &other);
 
    // ============================================================
    // for value type
public:
    ZFJson &value(ZF_IN const zfstring &value);
    const zfstring &value(void) const;
 
    // ============================================================
    // for object type
public:
    zfindex attrCount(void) const;

    ZFJson &attr(
            ZF_IN const zfstring &key
            , ZF_IN const zfstring &value
            );
    ZFJson &attr(
            ZF_IN const zfstring &key
            , ZF_IN const ZFJson &item
            );
    ZFJson attr(ZF_IN const zfstring &key) const;
    zfstring attrValue(ZF_IN const zfstring &key) const;

    ZFJson &attrRemove(ZF_IN const zfstring &key);
    ZFJson &attrRemoveAll(void);
 
public:
    zfiter attrIter(void) const;
    zfiter attrIterFind(ZF_IN const zfstring &key) const;
    zfstring attrIterKey(ZF_IN const zfiter &it) const;
    ZFJson attrIterValue(ZF_IN const zfiter &it) const;

    void attrIterValue(
            ZF_IN_OUT zfiter &it
            , ZF_IN const ZFJson &item
            );
    void attrIterRemove(ZF_IN_OUT zfiter &it);
 
    // ============================================================
    // for array type
public:
    zfindex childCount(void) const;
    ZFJson childAt(ZF_IN zfindex index) const;

    ZFJson &child(
            ZF_IN const zfstring &value
            , ZF_IN_OPT zfindex index = zfindexMax()
            );
    ZFJson &child(
            ZF_IN const ZFJson &item
            , ZF_IN_OPT zfindex index = zfindexMax()
            );
    ZFJson &childRemoveAt(ZF_IN zfindex index);
    ZFJson &childRemoveAll(void);
    zfindex childFind(ZF_IN const ZFJson &item) const;
 
    // ============================================================
    // quick access
public:
    inline operator zfstring (void) const {return this->toString();}
    inline operator zfbool (void) const {return this->valid();}
    inline ZFJson operator [] (ZF_IN const zfchar *key) const {return this->attr(key);}
    inline ZFJson operator [] (ZF_IN const zfstring &key) const {return this->attr(key);}
    inline ZFJson operator [] (ZF_IN zfindex const &index) const {return this->childAt(index);}

    zfstring toString(ZF_IN_OPT const ZFJsonOutputToken &token = ZFJsonOutputTokenDefault()) const;
 
private:
    _ZFP_ZFJsonPrivate *d;
    friend zfclassFwd _ZFP_ZFJsonPrivate;
private:
    ZFJson(ZF_IN _ZFP_ZFJsonPrivate *ref);
};
ZFTYPEID_DECLARE(ZFLIB_ZFAlgorithm, ZFJson, ZFJson)
ZFTYPEID_REG(ZFLIB_ZFAlgorithm, ZFJson, ZFJson)
ZFOUTPUT_TYPE(ZFJson, {v.objectInfoT(s);})

ZFMETHOD_FUNC_DECLARE_0(ZFLIB_ZFAlgorithm, ZFJson, ZFJsonObject)
ZFMETHOD_FUNC_DECLARE_0(ZFLIB_ZFAlgorithm, ZFJson, ZFJsonArray)
 
// ============================================================
ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFAlgorithm, ZFJson, ZFJsonFromInput
        , ZFMP_IN(const ZFInput &, input)
        , ZFMP_OUT_OPT(zfstring *, errorHint, zfnull)
        )
 

ZFMETHOD_FUNC_DECLARE_3(ZFLIB_ZFAlgorithm, zfbool, ZFJsonToOutput
        , ZFMP_IN_OUT(const ZFOutput &, output)
        , ZFMP_IN(const ZFJson &, item)
        , ZFMP_IN_OPT(const ZFJsonOutputToken &, token, ZFJsonOutputTokenDefault())
        )
ZFMETHOD_FUNC_DECLARE_3(ZFLIB_ZFAlgorithm, zfbool, ZFJsonToStringT
        , ZFMP_IN_OUT(zfstring &, ret)
        , ZFMP_IN(const ZFJson &, item)
        , ZFMP_IN(const ZFJsonOutputToken &, token)
        )
ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFAlgorithm, zfstring, ZFJsonToString
        , ZFMP_IN(const ZFJson &, item)
        , ZFMP_IN(const ZFJsonOutputToken &, token)
        )
 
// ============================================================
// escape chars
ZFMETHOD_FUNC_DECLARE_3(ZFLIB_ZFAlgorithm, void, ZFJsonEscapeCharEncode
        , ZFMP_OUT(zfstring &, dst)
        , ZFMP_IN(const zfstring &, src)
        , ZFMP_IN_OPT(zfindex, count, zfindexMax())
        )
ZFMETHOD_FUNC_DECLARE_3(ZFLIB_ZFAlgorithm, void, ZFJsonEscapeCharEncode
        , ZFMP_OUT(const ZFOutput &, dst)
        , ZFMP_IN(const zfchar *, src)
        , ZFMP_IN_OPT(zfindex, count, zfindexMax())
        )

ZFMETHOD_FUNC_DECLARE_3(ZFLIB_ZFAlgorithm, void, ZFJsonEscapeCharDecode
        , ZFMP_OUT(zfstring &, dst)
        , ZFMP_IN(const zfchar *, src)
        , ZFMP_IN_OPT(zfindex, count, zfindexMax())
        )
ZFMETHOD_FUNC_DECLARE_3(ZFLIB_ZFAlgorithm, void, ZFJsonEscapeCharDecode
        , ZFMP_OUT(const ZFOutput &, dst)
        , ZFMP_IN(const zfchar *, src)
        , ZFMP_IN_OPT(zfindex, count, zfindexMax())
        )
 
ZF_NAMESPACE_GLOBAL_END
#endif // #ifndef _ZFI_ZFJson_h_