ZFToken.h

Go to the documentation of this file.

 
#ifndef _ZFI_ZFToken_h_
#define _ZFI_ZFToken_h_
 
#include "ZFCoreTypeDef.h"
 
ZF_NAMESPACE_GLOBAL_BEGIN
 
// ============================================================
zfclassLikePOD ZFLIB_ZFCore ZFTokenForContainer {
public:
    zfstring tokenLeft; 
    zfstring tokenRight; 
    zfstring tokenSeparator; 
    zfstring tokenValueLeft; 
    zfstring tokenValueRight; 
    zfstring tokenEtc; 
 
public:
    ZFTokenForContainer(void)
    : tokenLeft("[")
    , tokenRight("]")
    , tokenSeparator(", ")
    , tokenValueLeft("")
    , tokenValueRight("")
    , tokenEtc("...")
    {
    }
    ZFTokenForContainer(
          ZF_IN zfstring const &tokenLeft
        , ZF_IN zfstring const &tokenRight
        , ZF_IN zfstring const &tokenSeparator
        , ZF_IN zfstring const &tokenValueLeft
        , ZF_IN zfstring const &tokenValueRight
        , ZF_IN zfstring const &tokenEtc
        )
    : tokenLeft(tokenLeft)
    , tokenRight(tokenRight)
    , tokenSeparator(tokenSeparator)
    , tokenValueLeft(tokenValueLeft)
    , tokenValueRight(tokenValueRight)
    , tokenEtc(tokenEtc)
    {
    }
    zfbool operator == (ZF_IN const ZFTokenForContainer &ref) const {
        return (this->tokenLeft.compare(ref.tokenLeft) == 0
                && this->tokenRight.compare(ref.tokenRight) == 0
                && this->tokenSeparator.compare(ref.tokenSeparator) == 0
                && this->tokenValueLeft.compare(ref.tokenValueLeft) == 0
                && this->tokenValueRight.compare(ref.tokenValueRight) == 0
                && this->tokenEtc.compare(ref.tokenEtc) == 0
            );
    }
    inline zfbool operator != (ZF_IN const ZFTokenForContainer &ref) const {return !this->operator == (ref);}
};
extern ZFLIB_ZFCore const ZFTokenForContainer _ZFP_ZFTokenForContainerTrim;
extern ZFLIB_ZFCore const ZFTokenForContainer _ZFP_ZFTokenForContainerDetail;
extern ZFLIB_ZFCore const ZFTokenForContainer _ZFP_ZFTokenForContainerPlainList;
extern ZFLIB_ZFCore ZFTokenForContainer _ZFP_ZFTokenForContainerDefault;
#define ZFTokenForContainerTrim() _ZFP_ZFTokenForContainerTrim
#define ZFTokenForContainerDetail() _ZFP_ZFTokenForContainerDetail
#define ZFTokenForContainerPlainList() _ZFP_ZFTokenForContainerPlainList
#define ZFTokenForContainerDefault() _ZFP_ZFTokenForContainerDefault
 
// ============================================================
zfclassLikePOD ZFLIB_ZFCore ZFTokenForKeyValueContainer {
public:
    zfstring tokenLeft; 
    zfstring tokenRight; 
    zfstring tokenSeparator; 
    zfstring tokenPairLeft; 
    zfstring tokenPairRight; 
    zfstring tokenPairSeparator; 
    zfstring tokenKeyLeft; 
    zfstring tokenKeyRight; 
    zfstring tokenValueLeft; 
    zfstring tokenValueRight; 
    zfstring tokenEtc; 
 
public:
    ZFTokenForKeyValueContainer(void)
    : tokenLeft("{")
    , tokenRight("}")
    , tokenSeparator(", ")
    , tokenPairLeft("")
    , tokenPairRight("")
    , tokenPairSeparator(" = ")
    , tokenKeyLeft("")
    , tokenKeyRight("")
    , tokenValueLeft("")
    , tokenValueRight("")
    , tokenEtc("...")
    {
    }
    ZFTokenForKeyValueContainer(
          ZF_IN zfstring const &tokenLeft
        , ZF_IN zfstring const &tokenRight
        , ZF_IN zfstring const &tokenSeparator
        , ZF_IN zfstring const &tokenPairLeft
        , ZF_IN zfstring const &tokenPairRight
        , ZF_IN zfstring const &tokenPairSeparator
        , ZF_IN zfstring const &tokenKeyLeft
        , ZF_IN zfstring const &tokenKeyRight
        , ZF_IN zfstring const &tokenValueLeft
        , ZF_IN zfstring const &tokenValueRight
        , ZF_IN zfstring const &tokenEtc
        )
    : tokenLeft(tokenLeft)
    , tokenRight(tokenRight)
    , tokenSeparator(tokenSeparator)
    , tokenPairLeft(tokenPairLeft)
    , tokenPairRight(tokenPairRight)
    , tokenPairSeparator(tokenPairSeparator)
    , tokenKeyLeft(tokenKeyLeft)
    , tokenKeyRight(tokenKeyRight)
    , tokenValueLeft(tokenValueLeft)
    , tokenValueRight(tokenValueRight)
    , tokenEtc(tokenEtc)
    {
    }
    zfbool operator == (ZF_IN const ZFTokenForKeyValueContainer &ref) const {
        return (this->tokenLeft.compare(ref.tokenLeft) == 0
                && this->tokenRight.compare(ref.tokenRight) == 0
                && this->tokenSeparator.compare(ref.tokenSeparator) == 0
                && this->tokenPairLeft.compare(ref.tokenPairLeft) == 0
                && this->tokenPairRight.compare(ref.tokenPairRight) == 0
                && this->tokenPairSeparator.compare(ref.tokenPairSeparator) == 0
                && this->tokenKeyLeft.compare(ref.tokenKeyLeft) == 0
                && this->tokenKeyRight.compare(ref.tokenKeyRight) == 0
                && this->tokenValueLeft.compare(ref.tokenValueLeft) == 0
                && this->tokenValueRight.compare(ref.tokenValueRight) == 0
                && this->tokenEtc.compare(ref.tokenEtc) == 0
            );
    }
    inline zfbool operator != (ZF_IN const ZFTokenForKeyValueContainer &ref) const {return !this->operator == (ref);}
};
extern ZFLIB_ZFCore const ZFTokenForKeyValueContainer _ZFP_ZFTokenForKeyValueContainerTrim;
extern ZFLIB_ZFCore const ZFTokenForKeyValueContainer _ZFP_ZFTokenForKeyValueContainerDetail;
extern ZFLIB_ZFCore ZFTokenForKeyValueContainer _ZFP_ZFTokenForKeyValueContainerDefault;
#define ZFTokenForKeyValueContainerTrim() _ZFP_ZFTokenForKeyValueContainerTrim
#define ZFTokenForKeyValueContainerDetail() _ZFP_ZFTokenForKeyValueContainerDetail
#define ZFTokenForKeyValueContainerDefault() _ZFP_ZFTokenForKeyValueContainerDefault
 
ZF_NAMESPACE_GLOBAL_END
 
#endif // #ifndef _ZFI_ZFToken_h_