自学教程：C++ zfText函数代码示例

    virtual void stackTrace(ZF_IN_OUT zfstring &ret,                            ZF_IN_OPT const zfchar *prefix = zfnull,                            ZF_IN_OPT zfindex ignoreLevel = 0,                            ZF_IN_OPT zfindex maxLevel = 20)    {        const zfchar *fixedPrefix = ((prefix == zfnull) ? zfText("") : prefix);        if(maxLevel > 200)        {            maxLevel = 200;        }        void **array = (void **)zfmalloc(sizeof(void *) * (maxLevel + 1));        zfindex size = backtrace(array, (int)(maxLevel + 1));        zfcharA **strings = backtrace_symbols(array, (int)size);        ret += fixedPrefix;        ret += zfText("======================== stack begin =======================");        ret += '/n';        for(zfindex i = ignoreLevel; i < size; ++i)        {            ret += fixedPrefix;            ret += strings[i];            ret += '/n';        }        ret += fixedPrefix;        ret += zfText("========================  stack end  =======================");        zffree(strings);        zffree(array);    }

ZF_NAMESPACE_GLOBAL_BEGINvoid ZFRegExpResult::objectInfoT(ZF_IN_OUT zfstring &ret) const{    ret += ZFTOKEN_ZFObjectInfoLeft;    if(this->matched)    {        ret += zfText("matched");        if(this->matchedRange != zfindexRangeZero)        {            ret += zfText(" in ");            zfindexRangeToString(ret, this->matchedRange);        }        if(!this->namedGroups.isEmpty())        {            ret += zfText(", named groups: ");            for(zfindex i = 0; i < this->namedGroups.count(); ++i)            {                if(i != 0)                {                    ret += zfText(", ");                }                zfindexRangeToString(ret, this->namedGroups[i]);            }        }    }    else    {        ret += zfText("no match");    }    ret += ZFTOKEN_ZFObjectInfoRight;}

ZF_NAMESPACE_GLOBAL_BEGIN// ============================================================// ZFListenerDatavoid ZFListenerData::objectInfoT(ZF_IN_OUT zfstring &ret) const{    ret += ZFTOKEN_ZFObjectInfoLeft;    zfstringAppend(ret, zfText("ZFListenerData(%p)"), this);    const zfchar *eventName = ZFObserverEventGetName(this->eventId);    if(eventName != zfnull)    {        ret += zfText(", event: ");        ret += eventName;    }    if(this->sender != zfnull)    {        ret += zfText(", sender: ");        ZFobjectInfoT(ret, this->sender);    }    if(this->param0 != zfnull)    {        ret += zfText(", param0: ");        ZFobjectInfoT(ret, this->param0);    }    if(this->param1 != zfnull)    {        ret += zfText(", param1: ");        ZFobjectInfoT(ret, this->param1);    }    ret += ZFTOKEN_ZFObjectInfoRight;}

    void prepareChildren(ZF_IN ZFUILinearLayout *layout)    {        for(zfindex i = 0; i < 3; ++i)        {            zfblockedAlloc(ZFUITextView, child);            layout->childAdd(child);            child->textContentStringSet(zfstringWithFormat(zfText("text %zi"), i));            child->textAlignSet(ZFUIAlign::e_Center);            child->viewBackgroundColorSet(ZFUIColorRandom(255));        }        layout->childAtIndex(1)->layoutParam<ZFUILinearLayoutParam *>()->layoutWeightSet(1);        layout->childAtIndex(2)->layoutParam<ZFUILinearLayoutParam *>()->layoutWeightSet(2);        zfblockedAlloc(ZFUILinearLayout, l);        layout->childAdd(l);        l->layoutOrientationSet(ZFUIOrientation::e_Bottom);        for(zfindex i = 0; i < 3; ++i)        {            zfblockedAlloc(ZFUITextView, child);            l->childAdd(child);            child->textContentStringSet(zfstringWithFormat(zfText("text %zi"), 3 + i));            child->textAlignSet(ZFUIAlign::e_Center);            child->viewBackgroundColorSet(ZFUIColorRandom(255));        }    }

 void test(void) {     this->testCaseOutput(zfLang(zfText("hello")));     this->testCaseOutput(zfLang(zfText("hello with no localized string")));     this->testCaseOutput(zfLang(zfText("hello in default only")));     this->testCaseOutput(zfLang(zfText("hello in custom only")));     this->testCaseOutput(zfstringWithFormat(zfLang(zfText("hello with format: %s")).cString(), zfText("i'm passed string"))); }

void zfLangDebug(ZF_IN_OPT const ZFOutputCallback &output /* = ZFOutputCallbackDefault */){    _ZFP_ZFLangMapType &m = _ZFP_ZFLangMapGlobal();    for(_ZFP_ZFLangMapType::iterator it = m.begin(); it != m.end(); ++it)    {        output << it->first << zfText(" = /"") << it->second << zfText("/"/n");    }}

ZF_GLOBAL_INITIALIZER_INIT_WITH_LEVEL(_ZFP_ZFJsonOutputFlagsInit, ZFLevelZFFrameworkNormal){    _ZFP_ZFJsonOutputFlagsTrimInstance.jsonToken.jsonNewLineToken.removeAll();    _ZFP_ZFJsonOutputFlagsTrimInstance.jsonToken.jsonIndentToken.removeAll();    _ZFP_ZFJsonOutputFlagsTrimInstance.jsonToken.jsonValueSeparatorToken = zfText(":");    _ZFP_ZFJsonOutputFlagsTrimInstance.jsonToken.jsonSeparatorInSameLineToken = zfText(",");    _ZFP_ZFJsonOutputFlagsTrimInstance.jsonObjectAddNewLineForContent = zffalse;    _ZFP_ZFJsonOutputFlagsTrimInstance.jsonArrayAddNewLineForContent = zffalse;}

ZFPROPERTY_TYPE_DECLARE_SERIALIZE_TO_DEFINE(ZFCallback, ZFCallback){    if(v.callbackSerializeCustomType() != zfnull)    {        if(v.callbackSerializeCustomData() == zfnull)        {            ZFSerializableUtil::errorOccurred(outErrorHintToAppend, zfText("missing callback serialize custom data"));            return zffalse;        }        serializableData.itemClassSet(ZFPropertyTypeId_ZFCallback);        serializableData.attributeSet(ZFSerializableKeyword_ZFCallback_callbackType, v.callbackSerializeCustomType());        ZFSerializableData customData = v.callbackSerializeCustomData()->copy();        customData.categorySet(ZFSerializableKeyword_ZFCallback_callbackData);        serializableData.elementAdd(customData);        return zftrue;    }    switch(v.callbackType())    {        case ZFCallbackTypeDummy:            serializableData.itemClassSet(ZFSerializableKeyword_null);            break;        case ZFCallbackTypeMethod:        {            serializableData.itemClassSet(ZFPropertyTypeId_ZFCallback);            ZFSerializableData methodData;            if(!ZFMethodToSerializableData(methodData, v.callbackMethod(), outErrorHintToAppend))            {                return zffalse;            }            methodData.categorySet(ZFSerializableKeyword_ZFCallback_method);            serializableData.elementAdd(methodData);        }            break;        case ZFCallbackTypeMemberMethod:        {            ZFSerializableUtil::errorOccurred(outErrorHintToAppend,                zfText("member method callback is not supported"));            return zffalse;        }            break;        case ZFCallbackTypeRawFunction:            serializableData.itemClassSet(ZFPropertyTypeId_ZFCallback);            ZFSerializableUtil::errorOccurred(outErrorHintToAppend,                zfText("raw function is not supported"));            return zffalse;        default:            zfCoreCriticalShouldNotGoHere();            return zffalse;    }    return zftrue;}

void ZFClassFilter::objectInfoVerboseT(ZF_IN_OUT zfstring &ret) const{    this->_ZFP_ZFClassFilter_filters.objectInfoOfContentT(ret,        zfHint("max count")zfindexMax,        zfText("["),        zfText("]"),        zfText(", "),        zfText("..."),        _ZFP_ZFClassFilter_contentInfoGetter);}

void ZFUIKeyEvent::objectInfoVerboseT(ZF_IN_OUT zfstring &ret){    ret += ZFTOKEN_ZFObjectInfoLeft;    ret += zfsFromIntStr(this->keyId);    ret += zfText(" ");    ret += ZFUIKeyAction::EnumNameForValue(this->keyAction);    ret += zfText(" ");    ret += ZFUIKeyCode::EnumNameForValue(this->keyCode);    ret += ZFTOKEN_ZFObjectInfoRight;}

ZF_GLOBAL_INITIALIZER_INIT_WITH_LEVEL(ZFTextTemplateRunParamDefaultSetting, ZFLevelZFFrameworkNormal){#if 0    _ZFP_ZFTextTemplateRunParamDefault_folderNameFilterRule = zfAlloc(ZFRegExp);    ZFTextTemplateRunParamDefault.folderNameFilter.customFilterCallbackAdd(_ZFP_ZFTextTemplateRunParamDefault_folderNameFilter);    _ZFP_ZFTextTemplateRunParamDefault_folderNameFilterRule->regExpCompile(zfText(                ""            ));#endif    _ZFP_ZFTextTemplateRunParamDefault_folderContentFilterRule = zfAlloc(ZFRegExp);    ZFTextTemplateRunParamDefault.folderContentFilter.customFilterCallbackAdd(_ZFP_ZFTextTemplateRunParamDefault_folderContentFilter);    _ZFP_ZFTextTemplateRunParamDefault_folderContentFilterRule->regExpCompile(zfText(                "(^//.git$)"                "|(^//.svn$)"                "|(^//.hg$)"            ));#if 0    _ZFP_ZFTextTemplateRunParamDefault_fileNameFilterRule = zfAlloc(ZFRegExp);    ZFTextTemplateRunParamDefault.fileNameFilter.customFilterCallbackAdd(_ZFP_ZFTextTemplateRunParamDefault_fileNameFilter);    _ZFP_ZFTextTemplateRunParamDefault_fileNameFilterRule->regExpCompile(zfText(                ""            ));#endif    _ZFP_ZFTextTemplateRunParamDefault_fileContentFilterRule = zfAlloc(ZFRegExp);    ZFTextTemplateRunParamDefault.fileContentFilter.customFilterCallbackAdd(_ZFP_ZFTextTemplateRunParamDefault_fileContentFilter);    _ZFP_ZFTextTemplateRunParamDefault_fileContentFilterRule->regExpCompile(zfText(                "(//.ico$)"                "|(//.icns$)"                "|(//.png$)"                "|(//.jpg$)"                "|(//.jpeg$)"                "|(//.gif$)"                "|(//.mp2$)"                "|(//.mp3$)"                "|(//.mp4$)"                "|(//.wav$)"                "|(//.ogg$)"                "|(//.db$)"                "|(//.rar$)"                "|(//.zip$)"                "|(//.7z$)"                "|(//.a(//..*)*$)"                "|(//.o(//..*)*$)"                "|(//.so(//..*)*$)"                "|(//.dll(//..*)*$)"                "|(//.dylib(//..*)*$)"            ));}

void ZFUIOnScreenKeyboardState::objectInfoOnAppend(ZF_IN_OUT zfstring &ret){    zfsFromPointerT(ret, this->ownerSysWindow());    if(this->keyboardShowing())    {        ret += zfText(" keyboardFrame: ");        ZFUIRectToString(ret, this->keyboardFrame());    }    else    {        ret += zfText(" keyboardNotShow");    }}

const zfchar *ZFMethod::methodPrivilegeTypeString(void) const{    switch(this->_ZFP_ZFMethod_privilegeType)    {        case ZFMethodPrivilegeTypePublic:            return zfText("public");        case ZFMethodPrivilegeTypeProtected:            return zfText("protected");        case ZFMethodPrivilegeTypePrivate:            return zfText("private");    }    return zfText("<UnknownPrivilegeType>");}

 zfoverride virtual void protocolOnInit(void) {     zfsuper::protocolOnInit();     this->_resRootPath = ZFFile::modulePath();     this->_resRootPath += ZFFile::fileSeparator;     #if ZF_ENV_sys_MacOS         this->_resRootPath += zfText("..");         this->_resRootPath += ZFFile::fileSeparator;         this->_resRootPath += zfText("Resources");         this->_resRootPath += ZFFile::fileSeparator;     #endif     this->_resRootPath += zfText("res");     this->_resRootPath += ZFFile::fileSeparator; }

void ZFMethod::objectInfoT(ZF_IN_OUT zfstring &ret) const{    if(this->methodType() == ZFMethodTypeRawFunction)    {        ret += this->methodNamespace();        ret += zfText("::");        ret += this->methodName();    }    else    {        ret += this->ownerClass()->className();        ret += zfText("::");        ret += this->methodName();    }}

 ZFMETHOD_DECLARE_1(void, methodParamIsReference                           , zfstring &, param0                           ) {     zfLogT();     param0 = zfText("newString"); }

void ZFPointerHolder::objectInfoVerboseT(ZF_IN_OUT zfstring &ret){    ret += ZFTOKEN_ZFObjectInfoLeft;    ret += ZFPointerHolder::ClassData()->className();    ret += zfstringWithFormat(zfText("(%p) %p"), this, this->holdedData);    ret += ZFTOKEN_ZFObjectInfoRight;}

 zfbool onVisitXmlProcessingInstruction(ZF_IN const ZFXmlVisitData &data) {     switch(data.xmlVisitType)     {         case ZFXmlVisitType::e_Enter:             if(data.depth > 0 || data.siblingIndex > 0)             {                 this->add(flags.xmlToken.xmlNewLineToken);             }             this->add(flags.xmlGlobalLineBeginToken);             this->addIndent(flags.xmlToken.xmlIndentToken, data.depth);             this->add(flags.xmlToken.xmlPITagLeft);             this->add(data.xmlItem->xmlName());             this->add(zfText(" "));             this->add(data.xmlItem->xmlValue());             break;         case ZFXmlVisitType::e_Exit:             this->add(flags.xmlToken.xmlPITagRight);             break;         case ZFXmlVisitType::e_ExitChildren:         default:             zfCoreCriticalShouldNotGoHere();             break;     }     return zftrue; }

void ZFPointerHolder::objectInfoT(ZF_IN_OUT zfstring &ret){    ret += ZFTOKEN_ZFObjectInfoLeft;    ret += ZFPointerHolder::ClassData()->className();    ret += zfText(" ");    ret += zfsFromPointer(this->holdedData);    ret += ZFTOKEN_ZFObjectInfoRight;}

void zfSkinDebug(ZF_IN_OPT const ZFOutputCallback &output /* = ZFOutputCallbackDefault */){    _ZFP_ZFSkinMapType &m = _ZFP_ZFSkinMapGlobal;    for(_ZFP_ZFSkinMapType::iterator it = m.begin(); it != m.end(); ++it)    {        output << it->first << zfText(" = ") << it->second.toObject()->objectInfoOfInstance() << zfText("/n");    }}

void ZFEnum::objectInfoVerboseT(ZF_IN_OUT zfstring &ret){    ret += ZFTOKEN_ZFObjectInfoLeft;    ret += this->classData()->className();    ret += zfText("::");    ret += this->enumName();    ret += zfText("(");    ret += zfsFromInt(this->enumValue());    ret += zfText(")");    ret += zfText(", count: ");    ret += zfsFromInt(this->enumCount());    ret += zfText(", content: ");    const zfchar *dotToken = zfText(", ");    for(zfindex i = 0; i < this->enumCount(); ++i)    {        ret += this->enumNameAtIndex(i);        ret += zfText("=");        ret += zfsFromInt(this->enumValueAtIndex(i));        ret += dotToken;    }    if(this->enumCount() > 0)    {        ret.remove(ret.length() - zfslen(dotToken));    }    ret += ZFTOKEN_ZFObjectInfoRight;}

static ZFArrayEditable *_ZFP_ZFUIHint_hintListForWrite(ZF_IN ZFUISysWindow *inSysWindow){    if(inSysWindow == zfnull)    {        inSysWindow = ZFUISysWindow::mainWindow();    }    if(inSysWindow == zfnull)    {        return zfnull;    }    ZFArrayEditable *hintList = inSysWindow->tagGet<ZFArrayEditable *>(zfText("_ZFP_ZFUIHint_hintList"));    if(hintList == zfnull)    {        zfblockedAllocWithoutLeakTest(ZFArrayEditable, hintListTmp);        hintList = hintListTmp;        inSysWindow->tagSet(zfText("_ZFP_ZFUIHint_hintList"), hintList);    }    return hintList;}

    virtual void stackTrace(ZF_IN_OUT zfstring &ret,                            ZF_IN_OPT const zfchar *prefix = zfnull,                            ZF_IN_OPT zfindex ignoreLevel = 0,                            ZF_IN_OPT zfindex maxLevel = 20)    {        const zfchar *fixedPrefix = ((prefix == zfnull) ? zfText("") : prefix);        ret += fixedPrefix;        ret += zfText("======================== stack begin =======================");        ret += '/n';        ret += fixedPrefix;        ret += zfText("| zfLogStackTrace is currently unsupported");        ret += '/n';        ret += fixedPrefix;        ret += zfText("========================  stack end  =======================");        ret += '/n';    }

jobject ZFImpl_sys_Android_zfstringToString(ZF_IN const zfchar *s){    ZFSTRINGENCODING_SENSITIVE("use UTF8")    JNIEnv *jniEnv = JNIGetJNIEnv();    if(s == zfnull)    {        s = zfText("");    }    return JNIUtilNewStringUTF(jniEnv, s);}

 virtual const zfchar *settingPath(void) {     if(this->_settingPath.isEmpty())     {         this->_settingPath = this->modulePath();         this->_settingPath += ZFFile::fileSeparator;         this->_settingPath += zfText("zfsetting");     }     return this->_settingPath; }

void ZFCoreArgMerge(ZF_OUT zfstring &result,                    ZF_IN const ZFCoreArray<zfstring> &argList){    for(zfindex i = 0; i < argList.count(); ++i)    {        const zfstring &s = argList.get(i);        if(i != 0)        {            result += ' ';        }        zfbool containSpace = (zfstringFind(s, ' ') != zfindexMax);        if(containSpace)        {            result += '/"';        }        const zfchar *p = s.cString();        while(*p != '/0')        {            if(*p == '//')            {                result += zfText("////");            }            else if(*p == '/"')            {                result += zfText("///"");            }            else            {                zfcharAppendAndMoveNext(result, p);                continue;            }            ++p;        }        if(containSpace)        {            result += '/"';        }    }}

void ZFJsonPrint(ZF_IN const ZFSerializableData &serializableData,                 ZF_IN_OPT const ZFOutputCallback &outputCallback /* = ZFOutputCallbackDefault */,                 ZF_IN_OPT const ZFJsonOutputFlags &flags /* = ZFJsonOutputFlagsDefault */){    ZFJsonItem jsonObject = ZFJsonFromSerializableData(serializableData);    if(jsonObject.jsonType() != ZFJsonType::e_JsonNull)    {        ZFJsonToOutput(outputCallback, jsonObject, flags);        outputCallback.execute(zfText("/n"));    }}

    zfoverride    virtual void objectOnInitFinish(void)    {        zfsuper::objectOnInitFinish();        this->layoutOrientationSet(ZFUIOrientation::e_Top);        this->layoutChildSpaceSet(ZFUIGlobalStyle::DefaultStyle()->itemSpace());        this->childAdd(this->hintText());        this->hintText()->layoutParam()->layoutAlignSet(ZFUIAlign::e_LeftInner);        zfLangApplyZFUITextViewText(this->hintText(), zfText("ZF2048AutoMoveDialog_hint"));        this->childAdd(this->actionList());        this->actionList()->cellSizeHintSet(-1);        this->actionList()->viewSizeMinSet(ZFUISizeMake(0, 120));        this->actionList()->layoutParam()->sizeParamSet(ZFUISizeParamFillWidthFillHeight);        this->actionList()->layoutParam()->sizeHintSet(ZFUISizeMake(200, 150));        this->actionList()->listAdapterSet(this->actionListAdapter());        this->actionList()->cellUpdater()->add(zflineAlloc(ZFUIListCellUpdaterBasic));        this->childAdd(this->addActionLayout());        this->addActionLayout()->layoutOrientationSet(ZFUIOrientation::e_Left);        this->addActionLayout()->layoutChildSpaceSet(ZFUIGlobalStyle::DefaultStyle()->itemSpace());        this->addActionLayout()->childAdd(this->addAction_left());        this->addActionLayout()->childAdd(this->addAction_top());        this->addActionLayout()->childAdd(this->addAction_right());        this->addActionLayout()->childAdd(this->addAction_bottom());        this->addActionLayout()->childAdd(this->addAction_random());        this->childAdd(this->buttonLayout());        this->buttonLayout()->layoutChildSpaceSet(ZFUIGlobalStyle::DefaultStyle()->itemSpace());        this->buttonLayout()->layoutOrientationSet(ZFUIOrientation::e_Left);        this->buttonLayout()->childAdd(this->confirmButton());        zfLangApplyZFUIButtonBasicTextNormal(this->confirmButton(), zfText("ZF2048AutoMoveDialog_confirm"));        this->buttonLayout()->childAdd(this->cancelButton());        zfLangApplyZFUIButtonBasicTextNormal(this->cancelButton(), zfText("ZF2048AutoMoveDialog_cancel"));        this->addActionButtonSetup();        this->buttonSetup();    }