ZFXml.h

Go to the documentation of this file.

 
#ifndef _ZFI_ZFXml_h_
#define _ZFI_ZFXml_h_
 
#include "ZFAlgorithmDef.h"
ZF_NAMESPACE_GLOBAL_BEGIN
 
/*
 * all types:
 *     Null
 *     Element
 *     Text
 *     Comment
 *     Document
 *     Declaration
 *     DocType
 *     PI
 * has name:
 *     Element, PI
 * has value:
 *     Text, Comment, DocType, PI
 * has attribute:
 *     Element, Declaration
 * has child:
 *     Element, Document
 *
 * a typical xml to test:
    <?xml type="declaration"?>
    <!DOCTYPE TYPE "DOCTYPE">
    <?pi ProcessingInstruction?>
    <element0 attribute0="attribute value0">
        <!-- here is a comment -->
        <element1 attribute0="attribute value0" />
        <element2 attribute0="attribute value0" attribute1="attribute value1"
            attribute2="attribute value2" attribute3="attribute value3" />
        <element3>text0</element3>
        <element4><![CDATA[cdata & < > [ ] text]]></element4>
        <element5><![CDATA[
        cdata & < > [ ] text
        cdata text 2
        ]]></element5>
        <element6>text with escaped chars: &lt; &gt; &amp; &apos; &quot;</element5>
        <element7 attr="attr with escaped chars: &lt; &gt; &amp; &apos; &quot;" />
    </element0>
 */
zfclassFwd ZFXml;
 
// ============================================================
// ZFXmlType
ZFENUM_BEGIN(ZFLIB_ZFAlgorithm, ZFXmlType)
    ZFENUM_VALUE(Null)
    ZFENUM_VALUE(Element)
    ZFENUM_VALUE(Text)
    ZFENUM_VALUE(Comment)
    ZFENUM_VALUE(Document)
    ZFENUM_VALUE(Declaration)
    ZFENUM_VALUE(DocType)
    ZFENUM_VALUE(PI)
ZFENUM_SEPARATOR()
    ZFENUM_VALUE_REGISTER(Null)
    ZFENUM_VALUE_REGISTER(Element)
    ZFENUM_VALUE_REGISTER(Text)
    ZFENUM_VALUE_REGISTER(Comment)
    ZFENUM_VALUE_REGISTER(Document)
    ZFENUM_VALUE_REGISTER(Declaration)
    ZFENUM_VALUE_REGISTER(DocType)
    ZFENUM_VALUE_REGISTER(PI)
ZFENUM_END(ZFLIB_ZFAlgorithm, ZFXmlType)
ZFENUM_REG(ZFLIB_ZFAlgorithm, ZFXmlType)
 
// ============================================================
zffinal zfclassLikePOD ZFLIB_ZFAlgorithm ZFXmlOutputToken {
public:
    zfstring xmlNewLineToken; 
    zfstring xmlIndentToken; 
 
    zfstring xmlDeclarationTagLeft; 
    zfstring xmlDeclarationTagRight; 
    zfstring xmlDocTypeTagLeft; 
    zfstring xmlDocTypeTagRight; 
    zfstring xmlPITagLeft; 
    zfstring xmlPITagRight; 
    zfstring xmlElementBeginTagLeft; 
    zfstring xmlElementBeginTagRight; 
    zfstring xmlElementEndTagLeft; 
    zfstring xmlElementEndTagRight; 
    zfstring xmlElementSingleTagLeft; 
    zfstring xmlElementSingleTagRight; 
    zfstring xmlAttrEqualTag; 
    zfstring xmlAttrQuoteTagLeft; 
    zfstring xmlAttrQuoteTagRight; 
    zfstring xmlTextCDATATagLeft; 
    zfstring xmlTextCDATATagRight; 
    zfstring xmlCommentTagLeft; 
    zfstring xmlCommentTagRight; 
 
public:
    zfstring xmlGlobalLineBeginToken;

    zfindex xmlElementAttrCountBeforeAddNewLine;
    zfbool xmlElementAddNewLineAtHeadIfNotSingleLine;
    zfbool xmlElementTrimTagIfNoChildren;
    zfbool xmlElementEndTagAtSameLineIfNoChildElement;
 
public:
    ZFXmlOutputToken(void)
    : xmlNewLineToken("\n")
    , xmlIndentToken("    ")
    , xmlDeclarationTagLeft("<?xml")
    , xmlDeclarationTagRight("?>")
    , xmlDocTypeTagLeft("<!DOCTYPE")
    , xmlDocTypeTagRight(">")
    , xmlPITagLeft("<?")
    , xmlPITagRight("?>")
    , xmlElementBeginTagLeft("<")
    , xmlElementBeginTagRight(">")
    , xmlElementEndTagLeft("</")
    , xmlElementEndTagRight(">")
    , xmlElementSingleTagLeft("<")
    , xmlElementSingleTagRight("/>")
    , xmlAttrEqualTag("=")
    , xmlAttrQuoteTagLeft("\"")
    , xmlAttrQuoteTagRight("\"")
    , xmlTextCDATATagLeft("<![CDATA[")
    , xmlTextCDATATagRight("]]>")
    , xmlCommentTagLeft("<!--")
    , xmlCommentTagRight("-->")
    , xmlGlobalLineBeginToken()
    , xmlElementAttrCountBeforeAddNewLine(3)
    , xmlElementAddNewLineAtHeadIfNotSingleLine(zffalse)
    , xmlElementTrimTagIfNoChildren(zftrue)
    , xmlElementEndTagAtSameLineIfNoChildElement(zftrue)
    {
    }
    zfbool operator == (ZF_IN ZFXmlOutputToken const &ref) const;
    zfbool operator != (ZF_IN ZFXmlOutputToken const &ref) const {
        return !this->operator == (ref);
    }
};
ZFTYPEID_ACCESS_ONLY_DECLARE(ZFLIB_ZFAlgorithm, ZFXmlOutputToken, ZFXmlOutputToken)
ZFTYPEID_ACCESS_ONLY_REG(ZFLIB_ZFAlgorithm, ZFXmlOutputToken, ZFXmlOutputToken)
 

ZFEXPORT_VAR_DECLARE(ZFLIB_ZFAlgorithm, ZFXmlOutputToken, ZFXmlOutputTokenTrim)
ZFEXPORT_VAR_DECLARE(ZFLIB_ZFAlgorithm, ZFXmlOutputToken, ZFXmlOutputTokenDetail)
ZFEXPORT_VAR_DECLARE(ZFLIB_ZFAlgorithm, ZFXmlOutputToken, ZFXmlOutputTokenDefault)
 
// ============================================================
// ZFXml
zfclassFwd _ZFP_ZFXmlPrivate;
zffinal zfclassLikePOD ZFLIB_ZFAlgorithm ZFXml {
    // ============================================================
public:
    ZFXml(void);
    ZFXml(ZF_IN const zfnullT &dummy);
    ZFXml(ZF_IN ZFXmlType type);
    ZFXml(ZF_IN const ZFXml &ref);
    virtual ~ZFXml(void);
 
    ZFXml &operator = (ZF_IN const ZFXml &ref);
    ZFXml &operator = (ZF_IN const zfnullT &dummy);
    inline zfbool operator == (ZF_IN const zfnullT &dummy) const {return !this->valid();}
    inline zfbool operator != (ZF_IN const zfnullT &dummy) const {return this->valid();}
    zfbool operator == (ZF_IN const ZFXml &ref) const;
    inline zfbool operator != (ZF_IN const ZFXml &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_ZFXml_xmlType(ZF_IN ZFXmlType type);
    ZFXmlType type(void) const;
    inline zfbool valid(void) const {
        return (this->type() != v_ZFXmlType::e_Null);
    }
 
public:
    ZFXml &name(ZF_IN const zfstring &name);
    const zfstring &name(void) const;

    ZFXml &value(ZF_IN const zfstring &value);
    const zfstring &value(void) const;
 
    // ============================================================
public:
    ZFXml copy(void) const;
 
    // ============================================================
public:
    zfindex attrCount(void) const;
    ZFXml &attr(
            ZF_IN const zfstring &key
            , ZF_IN const zfstring &value
            );
    zfstring attr(ZF_IN const zfstring &key) const;
    zfbool attrExist(ZF_IN const zfstring &key) const;
    ZFXml &attrRemove(ZF_IN const zfstring &key);
    ZFXml &attrRemoveAll(void);
 
public:
    zfiter attrIter(void) const;
    zfiter attrIterFind(ZF_IN const zfstring &key) const;
    zfstring attrIterKey(ZF_IN const zfiter &it) const;
    zfstring attrIterValue(ZF_IN const zfiter &it) const;

    void attrIterValue(
            ZF_IN_OUT zfiter &it
            , ZF_IN const zfstring &value
            );
    void attrIterRemove(ZF_IN_OUT zfiter &it);
 
    // ============================================================
public:
    zfindex childCount(void) const;
    ZFXml childAt(ZF_IN zfindex index) const;
    ZFXml &child(
            ZF_IN const ZFXml &item
            , ZF_IN_OPT zfindex index = zfindexMax()
            );
    ZFXml &childRemoveAt(ZF_IN zfindex index);
    ZFXml &childRemoveAll(void);
    zfindex childFind(ZF_IN const ZFXml &item) const;

    ZFXml childElement(void) const;
    ZFXml childElementAt(ZF_IN zfindex index) const;
 
    // ============================================================
public:
    void CDATA(ZF_IN zfbool CDATA);
    zfbool CDATA(void) const;
 
    // ============================================================
    // quick access
public:
    inline operator zfstring (void) const {return this->toString();}
    inline operator zfbool (void) const {return this->valid();}
    inline zfstring operator [] (ZF_IN const zfchar *key) const {return this->attr(key);}
    inline zfstring operator [] (ZF_IN const zfstring &key) const {return this->attr(key);}
    inline ZFXml operator [] (ZF_IN zfindex index) const {return this->childAt(index);}

    zfstring toString(ZF_IN_OPT const ZFXmlOutputToken &token = ZFXmlOutputTokenDefault()) const;
 
private:
    _ZFP_ZFXmlPrivate *d;
private:
    ZFXml(ZF_IN _ZFP_ZFXmlPrivate *ref);
};
ZFTYPEID_DECLARE(ZFLIB_ZFAlgorithm, ZFXml, ZFXml)
ZFTYPEID_REG(ZFLIB_ZFAlgorithm, ZFXml, ZFXml)
ZFOUTPUT_TYPE(ZFXml, {v.objectInfoT(s);})

ZFMETHOD_FUNC_DECLARE_1(ZFLIB_ZFAlgorithm, ZFXml, ZFXmlElement
        , ZFMP_IN(const zfstring &, name)
        )
ZFMETHOD_FUNC_DECLARE_1(ZFLIB_ZFAlgorithm, ZFXml, ZFXmlText
        , ZFMP_IN(const zfstring &, value)
        )
ZFMETHOD_FUNC_DECLARE_1(ZFLIB_ZFAlgorithm, ZFXml, ZFXmlComment
        , ZFMP_IN(const zfstring &, value)
        )
ZFMETHOD_FUNC_DECLARE_0(ZFLIB_ZFAlgorithm, ZFXml, ZFXmlDocument)
ZFMETHOD_FUNC_DECLARE_0(ZFLIB_ZFAlgorithm, ZFXml, ZFXmlDeclaration)
ZFMETHOD_FUNC_DECLARE_1(ZFLIB_ZFAlgorithm, ZFXml, ZFXmlDocType
        , ZFMP_IN(const zfstring &, value)
        )
ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFAlgorithm, ZFXml, ZFXmlPI
        , ZFMP_IN(const zfstring &, name)
        , ZFMP_IN(const zfstring &, value)
        )
 
// ============================================================
ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFAlgorithm, ZFXml, ZFXmlFromInput
        , ZFMP_IN(const ZFInput &, callback)
        , ZFMP_OUT_OPT(zfstring *, errorHint, zfnull)
        )
 
// ============================================================
ZFMETHOD_FUNC_DECLARE_3(ZFLIB_ZFAlgorithm, zfbool, ZFXmlToOutput
        , ZFMP_IN_OUT(const ZFOutput &, output)
        , ZFMP_IN(const ZFXml &, xmlItem)
        , ZFMP_IN_OPT(const ZFXmlOutputToken &, token, ZFXmlOutputTokenDefault())
        )
ZFMETHOD_FUNC_DECLARE_3(ZFLIB_ZFAlgorithm, zfbool, ZFXmlToStringT
        , ZFMP_IN_OUT(zfstring &, ret)
        , ZFMP_IN(const ZFXml &, xmlItem)
        , ZFMP_IN(const ZFXmlOutputToken &, token)
        )
ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFAlgorithm, zfstring, ZFXmlToString
        , ZFMP_IN(const ZFXml &, xmlItem)
        , ZFMP_IN(const ZFXmlOutputToken &, token)
        )
 
// ============================================================
// escape chars
ZFMETHOD_FUNC_DECLARE_3(ZFLIB_ZFAlgorithm, void, ZFXmlEscapeCharEncode
        , ZFMP_OUT(zfstring &, dst)
        , ZFMP_IN(const zfchar *, src)
        , ZFMP_IN_OPT(zfindex, count, zfindexMax())
        )
ZFMETHOD_FUNC_DECLARE_3(ZFLIB_ZFAlgorithm, void, ZFXmlEscapeCharEncode
        , ZFMP_OUT(const ZFOutput &, dst)
        , ZFMP_IN(const zfchar *, src)
        , ZFMP_IN_OPT(zfindex, count, zfindexMax())
        )

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