ZFFilter.h

Go to the documentation of this file.

 
#ifndef _ZFI_ZFFilter_h_
#define _ZFI_ZFFilter_h_
 
#include "ZFCoreArray.h"
#include "ZFCoreStringConvert.h"
#include "ZFCoreUtilMacro.h"
 
ZF_NAMESPACE_GLOBAL_BEGIN
 
// ============================================================
typedef enum {
    ZFFilterTypeInclude,
    ZFFilterTypeExclude,
} ZFFilterType;

#define ZFTOKEN_ZFFilterTypeInclude "Include"
#define ZFTOKEN_ZFFilterTypeExclude "Exclude"
 
ZFOUTPUT_TYPE(ZFFilterType, {
    switch(v) {
        case ZFFilterTypeInclude:
            s += ZFTOKEN_ZFFilterTypeInclude;
            break;
        case ZFFilterTypeExclude:
            s += ZFTOKEN_ZFFilterTypeExclude;
            break;
        default:
            break;
    }
})

typedef enum {
    ZFFilterResultNotSpecified,
    ZFFilterResultActive,
    ZFFilterResultNotActive,
} ZFFilterResult;

#define ZFTOKEN_ZFFilterResultNotSpecified "NotSpecified"
#define ZFTOKEN_ZFFilterResultActive "Active"
#define ZFTOKEN_ZFFilterResultNotActive "NotActive"
 
ZFOUTPUT_TYPE(ZFFilterResult, {
    switch(v) {
        case ZFFilterResultNotSpecified:
            s += ZFTOKEN_ZFFilterResultNotSpecified;
            break;
        case ZFFilterResultActive:
            s += ZFTOKEN_ZFFilterResultActive;
            break;
        case ZFFilterResultNotActive:
            s += ZFTOKEN_ZFFilterResultNotActive;
            break;
        default:
            break;
    }
})

#define ZFFILTER_DECLARE(ChildClass, SuperClass) \
    protected: \ \
        typedef SuperClass zfsuper; \ \
        typedef ChildClass zfself; \
    public:
 
// ============================================================
template<typename T_Element>
zfclassLikePOD _ZFP_ZFFilterData {
public:
    T_Element element;
    ZFFilterType filterType;
};

template<typename T_Public, typename T_Internal = T_Public>
zfclassLikePOD ZFFilterBase {
protected:
    typedef ZFFilterBase<T_Public, T_Internal> zfself;
 
public:
    typedef ZFFilterResult (*CustomFilterCallback)(ZF_IN T_Public const &e);
 
public:
    ZFFilterBase(void)
    : _filters()
    , _customFilters(zfnull)
    {
    }

    ZFFilterBase(ZF_IN const ZFFilterBase<T_Public, T_Internal> &ref)
    : _filters(ref._filters)
    , _customFilters(zfnull)
    {
        if(ref._customFilters != zfnull) {
            this->_customFilters = zfnew(
                _CustomFilterCallbacksType,
                *ref._customFilters);
        }
    }

    virtual ZFFilterBase<T_Public, T_Internal> &operator = (ZF_IN const ZFFilterBase<T_Public, T_Internal> &ref) {
        if(this != &ref) {
            this->_filters = ref._filters;
            if(this->_customFilters != zfnull) {
                zfdelete(this->_customFilters);
                this->_customFilters = zfnull;
            }
            if(ref._customFilters != zfnull) {
                this->_customFilters = zfnew(
                    _CustomFilterCallbacksType,
                    *ref._customFilters);
            }
        }
        return *this;
    }

    virtual inline zfbool operator == (ZF_IN const ZFFilterBase<T_Public, T_Internal> &ref) const {
        return this->_filters == ref._filters;
    }
    virtual inline zfbool operator != (ZF_IN const ZFFilterBase<T_Public, T_Internal> &ref) const {return !this->operator == (ref);}
    virtual ~ZFFilterBase(void) {
    }
public:
    virtual void copyFrom(ZF_IN ZFFilterBase<T_Public, T_Internal> const &ref) {
        this->_filters.copyFrom(ref._filters);
        if(ref._customFilters != zfnull) {
            if(this->_customFilters == zfnull) {
                this->_customFilters = zfnew(_CustomFilterCallbacksType);
            }
            this->_customFilters->copyFrom(*ref._customFilters);
        }
        else {
            if(this->_customFilters != zfnull) {
                zfdelete(this->_customFilters);
            }
        }
    }
 
public:
    virtual ZFFilterBase<T_Public, T_Internal> &filter(
            ZF_IN T_Public const &e
            , ZF_IN_OPT ZFFilterType filterType = ZFFilterTypeExclude
            ) {
        if(this->filterOnCheckValid(e)) {
            _ZFP_ZFFilterData<T_Internal> filterData;
            this->filterOnStore(filterData.element, e);
            filterData.filterType = filterType;
            this->_filters.add(filterData);
        }
        return *this;
    }

    virtual ZFFilterBase<T_Public, T_Internal> &filterRemove(
            ZF_IN T_Public const &e
            , ZF_IN_OPT ZFFilterType filterType = ZFFilterTypeExclude
            ) {
        if(this->filterOnCheckValid(e)) {
            for(zfindex i = 0; i < this->_filters.count(); ++i) {
                if(this->filterOnCheckEqual(this->_filters.get(i).element, e)
                        && this->_filters.get(i).filterType == filterType
                        ) {
                    this->filterOnRemove(this->_filters.get(i).element);
                    this->_filters.remove(i);
                    break;
                }
            }
        }
        return *this;
    }

    virtual ZFFilterBase<T_Public, T_Internal> &filterRemoveAt(ZF_IN zfindex index) {
        this->filterOnRemove(this->_filters.get(index).element);
        this->_filters.remove(index);
        return *this;
    }

    virtual void filterRemoveAll(void) {
        for(zfindex i = 0; i < this->_filters.count(); ++i) {
            this->filterOnRemove(this->_filters.get(i).element);
        }
        this->_filters.removeAll();
        zfdelete(this->_customFilters);
        this->_customFilters = zfnull;
    }

    virtual zfindex filterCount(void) const {
        return this->_filters.count();
    }

    virtual T_Public filterElementAt(ZF_IN zfindex index) const {
        T_Public t;
        this->filterOnAccess(t, this->_filters.get(index).element);
        return t;
    }

    virtual T_Internal const &filterInternalAt(ZF_IN zfindex index) const {
        return this->_filters.get(index).element;
    }

    virtual ZFFilterType filterTypeAt(ZF_IN zfindex index) const {
        return this->_filters.get(index).filterType;
    }

    virtual ZFFilterBase<T_Public, T_Internal> &customFilterCallbackAdd(ZF_IN typename ZFFilterBase<T_Public, T_Internal>::CustomFilterCallback customFilterCallback) {
        if(this->_customFilters == zfnull) {
            this->_customFilters = zfnew(_CustomFilterCallbacksType);
        }
        this->_customFilters->add(customFilterCallback);
        return *this;
    }

    virtual ZFFilterBase<T_Public, T_Internal> &customFilterCallbackRemove(ZF_IN typename ZFFilterBase<T_Public, T_Internal>::CustomFilterCallback customFilterCallback) {
        if(this->_customFilters != zfnull) {
            for(zfindex i = 0; i < this->_customFilters->count(); ++i) {
                if(this->_customFilters->get(i) == customFilterCallback) {
                    this->_customFilters->remove(i);
                    break;
                }
            }
        }
        return *this;
    }

    virtual ZFFilterBase<T_Public, T_Internal> &customFilterCallbackRemove(ZF_IN zfindex index) {
        if(this->_customFilters != zfnull) {
            this->_customFilters->remove(index);
        }
        return *this;
    }

    virtual zfindex customFilterCallbackCount(void) const {
        if(this->_customFilters != zfnull) {
            return this->_customFilters->count();
        }
        return 0;
    }

    virtual typename ZFFilterBase<T_Public, T_Internal>::CustomFilterCallback customFilterCallbackAt(ZF_IN zfindex index) const {
        return this->_customFilters->get(index);
    }

    virtual zfbool filterPassed(ZF_IN T_Public const &e) const {
        if(!this->filterOnCheckValid(e)) {
            return zffalse;
        }
        if(this->_customFilters != zfnull) {
            for(zfindex i = 0; i < this->_customFilters->count(); ++i) {
                switch(this->_customFilters->get(i)(e)) {
                    case ZFFilterResultNotSpecified:
                        break;
                    case ZFFilterResultActive:
                        return zftrue;
                    case ZFFilterResultNotActive:
                        return zffalse;
                    default:
                        ZFCoreCriticalShouldNotGoHere();
                        break;
                }
            }
        }
        return this->filterOnCheckActive(e);
    }
 
private:
    static void _ZFP_ZFFilterBase_contentInfoGetter(
            ZF_IN_OUT zfstring &ret
            , ZF_IN const _ZFP_ZFFilterData<T_Internal> &v
            ) {
        ret += '(';
        switch(v.filterType) {
            case ZFFilterTypeInclude:
                ret += "include ";
                break;
            case ZFFilterTypeExclude:
                ret += "exclude ";
                break;
            default:
                ZFCoreCriticalShouldNotGoHere();
                return;
        }
        zfsFromPointerT(ret, &(v.element));
        ret += ')';
    }
public:
    virtual void objectInfoT(ZF_IN_OUT zfstring &ret) const {
        this->_filters.objectInfoOfContentT(ret,
            5, // max count
            ZFTokenForContainerDefault(),
            _ZFP_ZFFilterBase_contentInfoGetter);
    }

    virtual inline zfstring objectInfo(void) const {
        zfstring ret;
        this->objectInfoT(ret);
        return ret;
    }
 
protected:
    virtual zfbool filterOnCheckValid(ZF_IN T_Public const &e) const {
        return zftrue;
    }

    virtual void filterOnStore(
            ZF_IN_OUT T_Internal &to
            , ZF_IN T_Public const &from
            ) const zfpurevirtual;
    virtual void filterOnRemove(ZF_IN_OUT T_Internal &value) const {}
    virtual void filterOnAccess(
            ZF_IN_OUT T_Public &to
            , ZF_IN T_Internal const &from
            ) const zfpurevirtual;
    virtual zfbool filterOnCheckEqual(
            ZF_IN T_Internal const &e1
            , ZF_IN T_Public const &e2
            ) const zfpurevirtual;
    virtual zfbool filterOnCheckActive(ZF_IN T_Public const &e) const {
        zfbool hasIncludeMode = zffalse;
        zfbool included = zffalse;
        for(zfindex i = 0; i < this->_filters.count(); ++i) {
            const _ZFP_ZFFilterData<T_Internal> &filter = this->_filters.get(i);
            switch(filter.filterType) {
                case ZFFilterTypeInclude:
                    hasIncludeMode = zftrue;
                    if(this->filterOnCheckEqual(filter.element, e)) {
                        included = zftrue;
                    }
                    break;
                case ZFFilterTypeExclude:
                    if(this->filterOnCheckEqual(filter.element, e)) {
                        return zffalse;
                    }
                    break;
                default:
                    ZFCoreCriticalShouldNotGoHere();
                    return zffalse;
            }
        }
        return (!hasIncludeMode || included);
    }
 
private:
    typedef ZFCoreArray<_ZFP_ZFFilterData<T_Internal> > _FiltersType;
    typedef ZFCoreArray<typename ZFFilterBase<T_Public, T_Internal>::CustomFilterCallback> _CustomFilterCallbacksType;
    _FiltersType _filters;
    _CustomFilterCallbacksType *_customFilters;
};
ZFOUTPUT_TYPE_TEMPLATE(ZFM_EXPAND(typename T_Public, typename T_Internal), ZFM_EXPAND(ZFFilterBase<T_Public, T_Internal>), {v.objectInfoT(s);})
 
// ============================================================
template<typename T_Public, typename T_Internal = T_Public>
zfclassLikePOD ZFFilterBasic : zfextend ZFFilterBase<T_Public, T_Internal> {
    ZFFILTER_DECLARE(
        ZFM_EXPAND(ZFFilterBasic<T_Public, T_Internal>),
        ZFM_EXPAND(ZFFilterBase<T_Public, T_Internal>))
 
public:
    ZFFilterBasic(void)
    : zfsuper()
    {
    }

    ZFFilterBasic(ZF_IN const ZFFilterBasic<T_Public, T_Internal> &ref)
    : zfsuper(ref)
    {
    }

    virtual ZFFilterBasic<T_Public, T_Internal> &operator = (ZF_IN const ZFFilterBasic<T_Public, T_Internal> &ref) {
        zfsuper::operator = (ref);
        return *this;
    }
    virtual ~ZFFilterBasic(void) {}
 
protected:
    zfoverride
    virtual void filterOnStore(
            ZF_IN_OUT T_Internal &to
            , ZF_IN T_Public const &from
            ) const {
        to = from;
    }
    zfoverride
    virtual void filterOnAccess(
            ZF_IN_OUT T_Public &to
            , ZF_IN T_Internal const &from
            ) const {
        to = from;
    }
    zfoverride
    virtual zfbool filterOnCheckEqual(
            ZF_IN T_Internal const &e1
            , ZF_IN T_Public const &e2
            ) const {
        return (e1 == e2);
    }
};
ZFOUTPUT_TYPE_TEMPLATE(ZFM_EXPAND(typename T_Public, typename T_Internal), ZFM_EXPAND(ZFFilterBasic<T_Public, T_Internal>), {v.objectInfoT(s);})

typedef ZFFilterBasic<zfint> ZFFilterForNumber;

typedef ZFFilterBasic<zfindex> ZFFilterForIndex;

typedef ZFFilterBasic<zfidentity> ZFFilterForIdentity;
 
// ============================================================
template<typename T_Public, typename T_Internal>
zfclassLikePOD ZFFilterForStringBase : zfextend ZFFilterBase<T_Public, T_Internal> {
    ZFFILTER_DECLARE(
        ZFM_EXPAND(ZFFilterForStringBase<T_Public, T_Internal>),
        ZFM_EXPAND(ZFFilterBase<T_Public, T_Internal>))
 
public:
    ZFFilterForStringBase(void)
    : zfsuper()
    {
    }

    ZFFilterForStringBase(ZF_IN const ZFFilterForStringBase<T_Public, T_Internal> &ref)
    : zfsuper(ref)
    {
    }

    virtual ZFFilterForStringBase<T_Public, T_Internal> &operator = (ZF_IN const ZFFilterForStringBase<T_Public, T_Internal> &ref) {
        zfsuper::operator = (ref);
        return *this;
    }
    virtual ~ZFFilterForStringBase(void) {}
 
protected:
    zfoverride
    virtual zfbool filterOnCheckValid(ZF_IN T_Public const &e) const {
        return (e != zfnull);
    }
    zfoverride
    virtual void filterOnStore(
            ZF_IN_OUT T_Internal &to
            , ZF_IN T_Public const &from
            ) const {
        to = from;
    }
    zfoverride
    virtual void filterOnAccess(
            ZF_IN_OUT T_Public &to
            , ZF_IN T_Internal const &from
            ) const {
        to = from;
    }
    zfoverride
    virtual zfbool filterOnCheckEqual(
            ZF_IN T_Internal const &e1
            , ZF_IN T_Public const &e2
            ) const {
        return (e1.compare(e2) == 0);
    }
};
ZFOUTPUT_TYPE_TEMPLATE(ZFM_EXPAND(typename T_Public, typename T_Internal), ZFM_EXPAND(ZFFilterForStringBase<T_Public, T_Internal>), {v.objectInfoT(s);})

typedef ZFFilterForStringBase<const zfchar *, zfstring> ZFFilterForString;
 
ZF_NAMESPACE_GLOBAL_END
 
#endif // #ifndef _ZFI_ZFFilter_h_