コード例 #1
0
const zfchar *ZFFilterCallbackResultFromString(ZF_OUT ZFFilterCallbackResult &ret,
                                               ZF_IN const zfchar *src,
                                               ZF_IN_OPT zfindex srcLen /* = zfindexMax */)
{
    const zfchar *tokens[] = {
        ZFTOKEN_ZFFilterCallbackResultNotSpecified,
        ZFTOKEN_ZFFilterCallbackResultActive,
        ZFTOKEN_ZFFilterCallbackResultNotActive,
    };
    zfindex matched = ZFCoreStringCheckMatch(tokens, ZFMACRO_ARRAY_SIZE(tokens), src, srcLen);
    ret = ZFFilterCallbackResultNotSpecified;
    switch(matched)
    {
        case 0:
            ret = ZFFilterCallbackResultNotSpecified;
            return zfnull;
        case 1:
            ret = ZFFilterCallbackResultActive;
            return zfnull;
        case 2:
            ret = ZFFilterCallbackResultNotActive;
            return zfnull;
        default:
            return src;
    }
}
コード例 #2
0
ファイル: ZFMethodDef.cpp プロジェクト: nifh80s/ZFFramework
const zfchar *ZFMethodPrivilegeTypeFromString(ZF_OUT ZFMethodPrivilegeType &ret,
                                              ZF_IN const zfchar *src,
                                              ZF_IN_OPT zfindex srcLen /* = zfindexMax */)
{
    const zfchar *tokens[] = {
        ZFTOKEN_ZFMethodPrivilegeTypePublic,
        ZFTOKEN_ZFMethodPrivilegeTypeProtected,
        ZFTOKEN_ZFMethodPrivilegeTypePrivate,
    };
    zfindex matched = ZFCoreStringCheckMatch(tokens, ZFMACRO_ARRAY_SIZE(tokens), src, srcLen);
    ret = ZFMethodPrivilegeTypePublic;
    switch(matched)
    {
        case 0:
            ret = ZFMethodPrivilegeTypePublic;
            return zfnull;
        case 1:
            ret = ZFMethodPrivilegeTypeProtected;
            return zfnull;
        case 2:
            ret = ZFMethodPrivilegeTypePrivate;
            return zfnull;
        default:
            return src;
    }
}
コード例 #3
0
ファイル: ZFMethodDef.cpp プロジェクト: nifh80s/ZFFramework
const zfchar *ZFMethodTypeFromString(ZF_OUT ZFMethodType &ret,
                                     ZF_IN const zfchar *src,
                                     ZF_IN_OPT zfindex srcLen /* = zfindexMax */)
{
    const zfchar *tokens[] = {
        ZFTOKEN_ZFMethodTypeClassStatic,
        ZFTOKEN_ZFMethodTypeClassMember,
        ZFTOKEN_ZFMethodTypeRawFunction,
    };
    zfindex matched = ZFCoreStringCheckMatch(tokens, ZFMACRO_ARRAY_SIZE(tokens), src, srcLen);
    ret = ZFMethodTypeRawFunction;
    switch(matched)
    {
        case 0:
            ret = ZFMethodTypeClassStatic;
            return zfnull;
        case 1:
            ret = ZFMethodTypeClassMember;
            return zfnull;
        case 2:
            ret = ZFMethodTypeRawFunction;
            return zfnull;
        default:
            return src;
    }
}
コード例 #4
0
const zfchar *ZFClassFilterTypeFromString(ZF_OUT ZFClassFilterType &ret,
                                          ZF_IN const zfchar *src,
                                          ZF_IN_OPT zfindex srcLen /* = zfindexMax */)
{
    const zfchar *tokens[] = {
        ZFTOKEN_ZFClassFilterTypeInclude,
        ZFTOKEN_ZFClassFilterTypeExclude,
        ZFTOKEN_ZFClassFilterTypeIncludeChildOf,
        ZFTOKEN_ZFClassFilterTypeIncludeChildTypeOf,
        ZFTOKEN_ZFClassFilterTypeIncludeParentOf,
        ZFTOKEN_ZFClassFilterTypeIncludeParentTypeOf,
        ZFTOKEN_ZFClassFilterTypeExcludeChildOf,
        ZFTOKEN_ZFClassFilterTypeExcludeChildTypeOf,
        ZFTOKEN_ZFClassFilterTypeExcludeParentOf,
        ZFTOKEN_ZFClassFilterTypeExcludeParentTypeOf,
    };
    zfindex matched = ZFCoreStringCheckMatch(tokens, ZFMACRO_ARRAY_SIZE(tokens), src, srcLen);
    ret = ZFClassFilterTypeInclude;
    switch(matched)
    {
        case 0:
            ret = ZFClassFilterTypeInclude;
            return zfnull;
        case 1:
            ret = ZFClassFilterTypeExclude;
            return zfnull;
        case 2:
            ret = ZFClassFilterTypeIncludeChildOf;
            return zfnull;
        case 3:
            ret = ZFClassFilterTypeIncludeChildTypeOf;
            return zfnull;
        case 4:
            ret = ZFClassFilterTypeIncludeParentOf;
            return zfnull;
        case 5:
            ret = ZFClassFilterTypeIncludeParentTypeOf;
            return zfnull;
        case 6:
            ret = ZFClassFilterTypeExcludeChildOf;
            return zfnull;
        case 7:
            ret = ZFClassFilterTypeExcludeChildTypeOf;
            return zfnull;
        case 8:
            ret = ZFClassFilterTypeExcludeParentOf;
            return zfnull;
        case 9:
            ret = ZFClassFilterTypeExcludeParentTypeOf;
            return zfnull;
        default:
            return src;
    }
}
コード例 #5
0
static zfbool _ZFP_zfboolFromInput(ZF_OUT zfbool &v,
                                   ZF_IN const ZFInputCallback &input)
{
    const zfchar *tokens[] = {
        ZFTOKEN_zfbool_zftrue,
        ZFTOKEN_zfbool_zffalse,
    };
    zfindex matched = ZFInputCallbackCheckMatch(tokens, ZFMACRO_ARRAY_SIZE(tokens), input);
    v = zffalse;
    switch(matched)
    {
        case 0:
            v = zftrue;
            return zftrue;
        case 1:
            v = zffalse;
            return zftrue;
        default:
            return zffalse;
    }
}
コード例 #6
0
const zfchar *ZFFilterTypeFromString(ZF_OUT ZFFilterType &ret,
                                     ZF_IN const zfchar *src,
                                     ZF_IN_OPT zfindex srcLen /* = zfindexMax */)
{
    const zfchar *tokens[] = {
        ZFTOKEN_ZFFilterTypeInclude,
        ZFTOKEN_ZFFilterTypeExclude,
    };
    zfindex matched = ZFCoreStringCheckMatch(tokens, ZFMACRO_ARRAY_SIZE(tokens), src, srcLen);
    ret = ZFFilterTypeInclude;
    switch(matched)
    {
        case 0:
            ret = ZFFilterTypeInclude;
            return zfnull;
        case 1:
            ret = ZFFilterTypeExclude;
            return zfnull;
        default:
            return src;
    }
}