ZFRegExp.h

Go to the documentation of this file.

 
#ifndef _ZFI_ZFRegExp_h_
#define _ZFI_ZFRegExp_h_
 
#include "ZFAlgorithmDef.h"
ZF_NAMESPACE_GLOBAL_BEGIN
 
// ============================================================
ZFENUM_BEGIN(ZFLIB_ZFAlgorithm, ZFRegExpOption)
    ZFENUM_VALUE_WITH_INIT(None, 0)
    ZFENUM_VALUE_WITH_INIT(IgnoreCase, 1 << 0)
    ZFENUM_VALUE_WITH_INIT(SingleLine, 1 << 1)
    ZFENUM_VALUE_WITH_INIT(MultiLine, 1 << 2)
ZFENUM_SEPARATOR()
    ZFENUM_VALUE_REGISTER(None)
    ZFENUM_VALUE_REGISTER(IgnoreCase)
    ZFENUM_VALUE_REGISTER(SingleLine)
    ZFENUM_VALUE_REGISTER(MultiLine)
ZFENUM_END_FLAGS(ZFLIB_ZFAlgorithm, ZFRegExpOption, ZFRegExpOptionFlags)
ZFENUM_REG_FLAGS(ZFLIB_ZFAlgorithm, ZFRegExpOption, ZFRegExpOptionFlags)
 
// ============================================================
zfclassLikePOD ZFLIB_ZFAlgorithm ZFRegExpResult {
public:
    zfbool matched;
    ZFIndexRange matchedRange;
    ZFCoreArray<ZFIndexRange> namedGroups;
 
public:
    void objectInfoT(ZF_IN_OUT zfstring &ret) const;
    inline zfstring objectInfo(void) const {
        zfstring ret;
        this->objectInfoT(ret);
        return ret;
    }
 
public:
    zfbool operator == (ZF_IN const ZFRegExpResult &ref) const {
        return (this->matched == ref.matched
                && this->matchedRange == ref.matchedRange
                && this->namedGroups.objectCompare(ref.namedGroups) == ZFCompareEqual);
    }
    inline zfbool operator != (ZF_IN const ZFRegExpResult &ref) const {return !this->operator == (ref);}
};

#define ZFSerializableKeyword_ZFRegExpResult_matched "matched"
#define ZFSerializableKeyword_ZFRegExpResult_matchedRange "matchedRange"
#define ZFSerializableKeyword_ZFRegExpResult_namedGroups "namedGroups"

ZFTYPEID_DECLARE(ZFLIB_ZFAlgorithm, ZFRegExpResult, ZFRegExpResult)
ZFTYPEID_REG(ZFLIB_ZFAlgorithm, ZFRegExpResult, ZFRegExpResult)
ZFOUTPUT_TYPE(ZFRegExpResult, {v.objectInfoT(s);})
 
// ============================================================
#define ZFSerializableKeyword_ZFRegExp_pattern "pattern"
#define ZFSerializableKeyword_ZFRegExp_flag "flag"
 
zfclassFwd _ZFP_ZFRegExpPrivate;
zfclass ZFLIB_ZFAlgorithm ZFRegExp : zfextend ZFObject, zfimplement ZFSerializable, zfimplement ZFCopyable {
    ZFOBJECT_DECLARE(ZFRegExp, ZFObject)
    ZFIMPLEMENT_DECLARE(ZFSerializable, ZFCopyable)
 
protected:
    zfoverride
    virtual zfbool serializableOnSerializeFromData(
            ZF_IN const ZFSerializableData &serializableData
            , ZF_OUT_OPT zfstring *outErrorHint = zfnull
            , ZF_OUT_OPT ZFSerializableData *outErrorPos = zfnull
            );
    zfoverride
    virtual zfbool serializableOnSerializeToData(
            ZF_IN_OUT ZFSerializableData &serializableData
            , ZF_OUT_OPT zfstring *outErrorHint = zfnull
            , ZF_IN_OPT ZFSerializable *refOwner = zfnull
            );
    zfoverride
    virtual zfbool serializableOnSerializeFromString(
            ZF_IN const zfchar *src
            , ZF_IN_OPT zfindex srcLen = zfindexMax()
            , ZF_OUT_OPT zfstring *errorHint = zfnull
            );
    zfoverride
    virtual zfbool serializableOnSerializeToString(
            ZF_IN_OUT zfstring &ret
            , ZF_OUT_OPT zfstring *errorHint = zfnull
            );
 
protected:
    zfoverride
    virtual void copyableOnCopyFrom(ZF_IN ZFObject *anotherObj) {
        zfsuperI(ZFCopyable)::copyableOnCopyFrom(anotherObj);
        ZFRegExp *another = zfcast(zfself *, anotherObj);
        this->pattern(another->pattern(), another->options());
    }
 
protected:
    ZFOBJECT_ON_INIT_DECLARE_2(
            ZFMP_IN(const zfstring &, pattern)
            , ZFMP_IN_OPT(ZFRegExpOptionFlags, flag, ZFRegExpOptionFlags::EnumDefault())
            )
 
    zfoverride
    virtual void objectOnInit(void);
    zfoverride
    virtual void objectOnDealloc(void);
 
    zfoverride
    virtual void objectInfoImplAppend(ZF_IN_OUT zfstring &ret);
 
public:
    zfoverride
    virtual zfidentity objectHashImpl(void);
    zfoverride
    virtual ZFCompareResult objectCompareImpl(ZF_IN ZFObject *anotherObj);
 
public:
    ZFMETHOD_DECLARE_0(void *, nativeRegExp)
 
public:
    ZFMETHOD_DECLARE_0(const zfstring &, pattern)
    ZFMETHOD_DECLARE_0(ZFRegExpOptionFlags, options)
    ZFMETHOD_DECLARE_1(zfindex, namedGroupIndexForName
            , ZFMP_IN(const zfstring &, name)
            )
 
public:
    ZFMETHOD_DECLARE_2(void, pattern
            , ZFMP_IN(const zfstring &, pattern)
            , ZFMP_IN_OPT(ZFRegExpOptionFlags, flag, ZFRegExpOptionFlags::EnumDefault())
            )

    ZFMETHOD_DECLARE_3(void, find
            , ZFMP_OUT(ZFRegExpResult &, result)
            , ZFMP_IN(const zfchar *, src)
            , ZFMP_IN_OPT(zfindex, srcLength, zfindexMax())
            )

    ZFMETHOD_DECLARE_6(void, replace
            , ZFMP_OUT(zfstring &, ret)
            , ZFMP_OUT(ZFRegExpResult &, result)
            , ZFMP_IN(const zfstring &, replacePattern)
            , ZFMP_IN(const zfchar *, src)
            , ZFMP_IN_OPT(zfindex, srcLength, zfindexMax())
            , ZFMP_IN_OPT(zfindex, maxReplaceCount, zfindexMax())
            )
 
private:
    _ZFP_ZFRegExpPrivate *d;
};

ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFAlgorithm, ZFIndexRange, ZFRegExpFind
        , ZFMP_IN(const zfchar *, src)
        , ZFMP_IN(ZFRegExp *, pattern)
        )
ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFAlgorithm, ZFIndexRange, ZFRegExpFind
        , ZFMP_IN(const zfchar *, src)
        , ZFMP_IN(const zfstring &, pattern)
        )

ZFMETHOD_FUNC_DECLARE_4(ZFLIB_ZFAlgorithm, zfstring, ZFRegExpReplace
        , ZFMP_IN(const zfchar *, src)
        , ZFMP_IN(ZFRegExp *, patternFrom)
        , ZFMP_IN(const zfstring &, patternTo)
        , ZFMP_IN_OPT(zfindex, maxReplaceCount, zfindexMax())
        )
ZFMETHOD_FUNC_DECLARE_4(ZFLIB_ZFAlgorithm, zfstring, ZFRegExpReplace
        , ZFMP_IN(const zfchar *, src)
        , ZFMP_IN(const zfstring &, patternFrom)
        , ZFMP_IN(const zfstring &, patternTo)
        , ZFMP_IN_OPT(zfindex, maxReplaceCount, zfindexMax())
        )

ZFMETHOD_FUNC_DECLARE_3(ZFLIB_ZFAlgorithm, ZFCoreArray<zfstring>, ZFRegExpSplit
        , ZFMP_IN(const zfchar *, src)
        , ZFMP_IN(ZFRegExp *, separatorPattern)
        , ZFMP_IN_OPT(zfbool, keepEmpty, zffalse)
        )
ZFMETHOD_FUNC_DECLARE_3(ZFLIB_ZFAlgorithm, ZFCoreArray<zfstring>, ZFRegExpSplit
        , ZFMP_IN(const zfchar *, src)
        , ZFMP_IN(const zfstring &, separatorPattern)
        , ZFMP_IN_OPT(zfbool, keepEmpty, zffalse)
        )
 
ZF_NAMESPACE_GLOBAL_END
#endif // #ifndef _ZFI_ZFRegExp_h_