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

	DEPTH_WRITE_MASK DepthWriteMaskFromString(const char* str)	{		if (!str)			return DEPTH_WRITE_MASK_ALL;		if (_stricmp(str, "DEPTH_WRITE_MASK_ZERO") == 0)		{			return DEPTH_WRITE_MASK_ZERO;		}		if (_stricmp(str, "DEPTH_WRITE_MASK_ALL") == 0)		{			return DEPTH_WRITE_MASK_ALL;		}		Logger::Log(FB_ERROR_LOG_ARG, FormatString("%s is not valid DepthWriteMask", str).c_str());		return DEPTH_WRITE_MASK_ALL;	}

void T3DObjectClock::render_exec_calendar(Trendercontext *rc, TSC_time &disptime, double size){	try{		QString content,monthstring;		monthnames->get(disptime.G_month()-1)->tostring(monthstring,0);		FormatString(content,_qstr("^1 "),disptime.G_day());		content+=_TRL(monthstring);		render_exec_string(rc,content);	}	catch(QError &)	{		throw QError(_text("Error while constructing calendar info"));	}}

int python_call_function(void){    if( !python_is_initialised_check() )        return 0;    if( check_args( 1, 1+EmacsPythonCallCommand::MAX_ARGS ) )        return 0;    EmacsPythonCallCommand py_command;    if( !string_arg( 1 ) )        return 0;    py_command.python_function = ml_value.asString();    const int first_arg = 2;    py_command.num_args = cur_exec->p_nargs - 1;    for( int arg=first_arg; !ml_err && arg<=cur_exec->p_nargs; arg++ )    {        if( !eval_arg( arg ) )            return 0;        switch( ml_value.exp_type() )        {        case ISINTEGER:        case ISSTRING:            py_command.python_args[ arg - first_arg ] = ml_value;            break;        case ISVOID:        case ISMARKER:        case ISWINDOWS:        case ISARRAY:            error( FormatString("Python-call - unsupported expression type for arg %d") << arg );            return 0;        }    }    py_command.executeCommand();    if( py_command.failed() )        error( py_command.failureReason() );    else        ml_value = py_command.getResult();    return 0;}

static void output(bool traceInDebugOnly, DebugTraceOutputType outputType, const char *format, va_list vararg){#if defined(ANGLE_ENABLE_DEBUG_ANNOTATIONS)    static std::vector<char> buffer(512);    if (perfActive())    {        size_t len = FormatStringIntoVector(format, vararg, buffer);        std::wstring formattedWideMessage(buffer.begin(), buffer.begin() + len);        switch (outputType)        {            case DebugTraceOutputTypeNone:                break;            case DebugTraceOutputTypeBeginEvent:                g_DebugAnnotationWrapper->beginEvent(formattedWideMessage);                break;            case DebugTraceOutputTypeSetMarker:                g_DebugAnnotationWrapper->setMarker(formattedWideMessage);                break;        }    }#endif // ANGLE_ENABLE_DEBUG_ANNOTATIONS#if defined(ANGLE_ENABLE_DEBUG_TRACE)#if defined(NDEBUG)    if (traceInDebugOnly)    {        return;    }#endif // NDEBUG    std::string formattedMessage = FormatString(format, vararg);    static std::ofstream file(TRACE_OUTPUT_FILE, std::ofstream::app);    if (file)    {        file.write(formattedMessage.c_str(), formattedMessage.length());        file.flush();    }#if defined(ANGLE_ENABLE_DEBUG_TRACE_TO_DEBUGGER)    OutputDebugStringA(formattedMessage.c_str());#endif // ANGLE_ENABLE_DEBUG_TRACE_TO_DEBUGGER#endif // ANGLE_ENABLE_DEBUG_TRACE}

bool C4Network2IRCClient::OnConn(const C4NetIO::addr_t &AddrPeer, const C4NetIO::addr_t &AddrConnect, const addr_t *pOwnAddr, C4NetIO *pNetIO)	{	// Security checks	if(!fConnecting || fConnected || !AddrEqual(AddrConnect, ServerAddr)) return false;	CStdLock Lock(&CSec);	// Save connection data	fConnected = true;	fConnecting = false;	C4Network2IRCClient::PeerAddr = AddrPeer;	// Send welcome message	if(!Password.isNull())		Send("PASS", Password.getData());	Send("NICK", Nick.getData());	Send("USER", FormatString("clonk x x :%s", RealName.getData()).getData());	// Okay	return true;	}

C4Value C4Effect::DoCall(C4PropList *pObj, const char *szFn, const C4Value &rVal1, const C4Value &rVal2, const C4Value &rVal3, const C4Value &rVal4, const C4Value &rVal5, const C4Value &rVal6, const C4Value &rVal7){	C4PropList * p = GetCallbackScript();	if (!p)	{		C4AulFunc * fn = GetFunc(szFn);		if (fn) return fn->Exec(this, &C4AulParSet(rVal1, rVal2, rVal3, rVal4, rVal5, rVal6, rVal7));	}	else	{		// old variant		// compose function name		C4AulFunc * fn = p->GetFunc(FormatString(PSF_FxCustom, GetName(), szFn).getData());		if (fn) return fn->Exec(p, &C4AulParSet(Obj(pObj), this, rVal1, rVal2, rVal3, rVal4, rVal5, rVal6, rVal7));	}	return C4Value();}

void CapturedAPICalls::PlayOverride(CaptureOverride* pCO){    unsigned int i = 0;    try    {        for (CaptureList::iterator iter = m_captureList.begin(); iter != m_captureList.end(); ++iter)        {            (*iter)->PlayOverride(pCO);            ++i;        }    }    catch (...)    {        OSWrappers::MessageBox(FormatString("Exception on %i", i).c_str(), (const char*)"exception!", 0);    }}

C4GUI::Edit::InputResult C4ChatInputDialog::OnChatInput(C4GUI::Edit *edt,                                                        bool fPasting,                                                        bool fPastingMore) {  // no double processing  if (fProcessed) return C4GUI::Edit::IR_CloseDlg;  // get edit text  C4GUI::Edit *pEdt = reinterpret_cast<C4GUI::Edit *>(edt);  char *szInputText = const_cast<char *>(pEdt->GetText());  // Store to back buffer  Game.MessageInput.StoreBackBuffer(szInputText);  // script queried input?  if (fObjInput) {    fProcessed = true;    // check if the target input is still valid    C4Player *pPlr = Game.Players.Get(iPlr);    if (!pPlr) return C4GUI::Edit::IR_CloseDlg;    if (!pPlr->MarkMessageBoardQueryAnswered(pTarget)) {      // there was no associated query!      return C4GUI::Edit::IR_CloseDlg;    }    // then do a script callback, incorporating the input into the answer    if (fUppercase) SCapitalize(szInputText);    StdStrBuf sInput;    sInput.Copy(szInputText);    sInput.EscapeString();    Game.Control.DoInput(        CID_Script,        new C4ControlScript(            FormatString("OnMessageBoardAnswer(Object(%d), %d, /"%s/")",                         pTarget ? pTarget->Number : 0, iPlr,                         sInput.getData()).getData()),        CDT_Decide);    return C4GUI::Edit::IR_CloseDlg;  } else    // reroute to message input class    Game.MessageInput.ProcessInput(szInputText);  // safety: message board commands may do strange things  if (!C4GUI::IsGUIValid() || this != pInstance) return C4GUI::Edit::IR_Abort;  // select all text to be removed with next keypress  // just for pasting mode; usually the dlg will be closed now anyway  pEdt->SelectAll();  // avoid dlg close, if more content is to be pasted  if (fPastingMore) return C4GUI::Edit::IR_None;  fProcessed = true;  return C4GUI::Edit::IR_CloseDlg;}

GraphicEngine::GraphicEngine(Game *game){	this->game = game;	needSaveScreenShot = false;	renderWhireFrame = false;	  	registrateMethods("game");	blockDebugTexts = false;	lightingEnabled = true;	renderFilter = new PlatformerRenderFilter(CVector(500, 400));#ifndef IPHONE_OS	GLenum err = glewInit();	if (GLEW_OK != err) {	  Log::error(FormatString("Error: %s/n", glewGetErrorString(err)));	}#endif}

C4PortraitSelDlg::C4PortraitSelDlg(C4FileSel_BaseCB *pSelCallback,                                   bool fSetPicture, bool fSetBigIcon)    : C4FileSelDlg(Config.General.ExePath,                   FormatString(LoadResStr("IDS_MSG_SELECT"),                                LoadResStr("IDS_TYPE_PORTRAIT")).getData(),                   pSelCallback, false),      pCheckSetPicture(NULL),      pCheckSetBigIcon(NULL),      fDefSetPicture(fSetPicture),      fDefSetBigIcon(fSetBigIcon) {  char path[_MAX_PATH + 1];  // add common picture locations  StdStrBuf strLocation;  SCopy(Config.AtUserPath(""), path, _MAX_PATH);  TruncateBackslash(path);  strLocation.Format("%s %s", C4ENGINECAPTION, LoadResStr("IDS_TEXT_USERPATH"));  AddLocation(strLocation.getData(), path);  SCopy(Config.AtExePath(""), path, _MAX_PATH);  TruncateBackslash(path);  strLocation.Format("%s %s", C4ENGINECAPTION,                     LoadResStr("IDS_TEXT_PROGRAMDIRECTORY"));  AddCheckedLocation(strLocation.getData(), Config.General.ExePath);#ifdef _WIN32  if (SHGetSpecialFolderPath(NULL, path, CSIDL_PERSONAL, FALSE))    AddCheckedLocation(LoadResStr("IDS_TEXT_MYDOCUMENTS"), path);  if (SHGetSpecialFolderPath(NULL, path, CSIDL_MYPICTURES, FALSE))    AddCheckedLocation(LoadResStr("IDS_TEXT_MYPICTURES"), path);  if (SHGetSpecialFolderPath(NULL, path, CSIDL_DESKTOPDIRECTORY, FALSE))    AddCheckedLocation(LoadResStr("IDS_TEXT_DESKTOP"), path);#endif#ifdef __APPLE__  AddCheckedLocation(LoadResStr("IDS_TEXT_HOME"), getenv("HOME"));#else  AddCheckedLocation(LoadResStr("IDS_TEXT_HOMEFOLDER"), getenv("HOME"));#endif#ifndef _WIN32  sprintf(path, "%s%c%s", getenv("HOME"), (char)DirectorySeparator,          (const char *)"Desktop");  AddCheckedLocation(LoadResStr("IDS_TEXT_DESKTOP"), path);#endif  // build dialog  InitElements();  // select last location  SetCurrentLocation(Config.Startup.LastPortraitFolderIdx, false);}

bool C4Shader::Refresh(const char *szWhat, const char **szUniforms){	// Find a slice where the source file has updated	ShaderSliceList::iterator pSlice;	for (pSlice = FragmentSlices.begin(); pSlice != FragmentSlices.end(); pSlice++)		if (pSlice->Source.getLength() &&			FileExists(pSlice->Source.getData()) &&			FileTime(pSlice->Source.getData()) > pSlice->SourceTime)			break;	if (pSlice == FragmentSlices.end()) return true;	StdCopyStrBuf Source = pSlice->Source;	// Okay, remove all slices that came from this file	ShaderSliceList::iterator pNext;	for (; pSlice != FragmentSlices.end(); pSlice = pNext)	{		pNext = pSlice; pNext++;		if (SEqual(pSlice->Source.getData(), Source.getData()))			FragmentSlices.erase(pSlice);	}	// Load new shader	char szParentPath[_MAX_PATH+1]; C4Group Group;	StdStrBuf Shader;	GetParentPath(Source.getData(),szParentPath);	if(!Group.Open(szParentPath) ||	   !Group.LoadEntryString(GetFilename(Source.getData()),&Shader) ||	   !Group.Close())	{		ShaderLogF("  gl: Failed to refresh %s shader from %s!", szWhat, Source.getData());		return Refresh(szWhat, szUniforms);	}	// Load slices	int iSourceTime = FileTime(Source.getData());	StdStrBuf WhatSrc = FormatString("file %s", Config.AtRelativePath(Source.getData()));	AddFragmentSlices(WhatSrc.getData(), Shader.getData(), Source.getData(), iSourceTime);	// Reinitialise	if (!Init(szWhat, szUniforms))		return false;	// Retry	return Refresh(szWhat, szUniforms);}

bool C4PlayerList::RemoveLocal(bool fDisconnect, bool fNoCalls){	// (used by league system the set local fate)	C4Player *pPlr;	do		for (pPlr = First; pPlr; pPlr = pPlr->Next)			if (pPlr->LocalControl)			{				// Log				Log(FormatString(LoadResStr("IDS_PRC_REMOVEPLR"),pPlr->GetName()).getData());				// Remove				Remove(pPlr, fDisconnect, fNoCalls);				break;			}	while (pPlr);	return true;}

int re_search_reverse_helper( EmacsSearch::sea_type RE ){    int np;    EmacsString str;    if( arg <= 0 )        arg = 1;    if( RE == EmacsSearch::sea_type__RE_extended )        str = getstr("Reverse ERE search for: ");    else        str = getstr("Reverse RE search for: ");    np = sea_glob.search( str, -arg, dot, RE );    if( np == 0 && ! ml_err )        error(FormatString("Cannot find /"%s/"") << last_search_string.asString() );    else        if( np > 0 )            set_dot( np );    return 0;}

int erase_region( void ){    if( !bf_cur->b_mark.isSet() )        error( FormatString(no_mark_set_str) << bf_cur->b_buf_name);    else    {        int n = bf_cur->b_mark.to_mark() - dot;        if( n < 0 )        {            n = -n;            dot_left (n);        }        bf_cur->del_frwd( dot, n );    }    return 0;}

static int left_or_right_marker( int right ){    if( !eval_arg( 1 ) )        return 0;    if( ml_value.exp_type() != ISMARKER )    {        error( FormatString("%s expects its argument to be a marker") <<            cur_exec->p_proc->b_proc_name );        return 0;    }    int n = ml_value.asMarker()->get_mark();    Marker *m = EMACS_NEW Marker( bf_cur, n, right );    ml_value = m;    return 0;}

	TEXTURE_ADDRESS_MODE AddressModeFromString(const char* sz)	{		if (!sz)			return TEXTURE_ADDRESS_CLAMP;		if (_stricmp(sz, "Wrap") == 0)			return TEXTURE_ADDRESS_WRAP;		if (_stricmp(sz, "Mirror") == 0)			return TEXTURE_ADDRESS_MIRROR;		if (_stricmp(sz, "Clamp") == 0)			return TEXTURE_ADDRESS_CLAMP;		if (_stricmp(sz, "Border") == 0)			return TEXTURE_ADDRESS_BORDER;		if (_stricmp(sz, "Mirror_Once") == 0)			return TEXTURE_ADDRESS_MIRROR_ONCE;		Logger::Log(FB_ERROR_LOG_ARG, FormatString("%s is not valid TEXTURE_ADDRESS_MODE", sz).c_str());		return TEXTURE_ADDRESS_CLAMP;	}

QLineEdit *C4ConsoleQtLocalizeStringDlg::AddEditor(const char *language, const char *language_name){	assert(!GetEditorByLanguage(language));	// Add editor widgets	int32_t row = edited_languages.size();	QString language_label_text(language);	if (language_name) language_label_text.append(FormatString(" (%s)", language_name).getData());	QLabel *language_label = new QLabel(language_label_text, this);	ui.mainGrid->addWidget(language_label, row, 0);	QLineEdit *value_editor = new QLineEdit(this);	ui.mainGrid->addWidget(value_editor, row, 1);	// Add to list	EditedLanguage new_editor;	SCopy(language, new_editor.language, 2);	new_editor.value_editor = value_editor;	edited_languages.push_back(new_editor);	return value_editor;}

void EmacsView::moveLine    (    int old_line_num,    int new_line_num    ){#if DBG_CALC_INS_DEL    if( dbg_flags&DBG_CALC_INS_DEL )    {        const EmacsChar_t nul( 0 );        EmacsLinePtr &old_line = t_phys_screen[ old_line_num ];        EmacsLinePtr &new_line = t_desired_screen[ new_line_num ];        const int dump_size = 30;        const EmacsChar_t *old_line_start = &nul;        int old_line_len = 0;        if( !old_line.isNull() )        {            old_line_start = old_line->line_body;            old_line_len = old_line->line_length;        }        const EmacsChar_t *new_line_start = &nul;        int new_line_len = 0;        if( !new_line.isNull() )        {            new_line_start = new_line->line_body;            new_line_len = new_line->line_length;        }        _dbg_msg( FormatString( "         moveLine( Ln:%2d Sz%3d:'%.*s'%*s, Ln:%2d Sz%3d:'%.*s'%*s )" )            << old_line_num            << old_line_len                << std::min( old_line_len, dump_size ) << old_line_start                    << std::max( dump_size-old_line_len, 0 ) << ""            << new_line_num            << new_line_len                << std::min( new_line_len, dump_size ) << new_line_start                    << std::max( dump_size-new_line_len, 0 ) << ""            );    }#endif    t_move_line( old_line_num, new_line_num );}

	TEXTURE_FILTER FilterFromString(const char* sz)	{		if (!sz)			return TEXTURE_FILTER_MIN_MAG_MIP_LINEAR;		if (_stricmp(sz, "MIN_MAG_MIP_POINT") == 0)			return TEXTURE_FILTER_MIN_MAG_MIP_POINT;		if (_stricmp(sz, "MIN_MAG_POINT_MIP_LINEAR") == 0)			return TEXTURE_FILTER_MIN_MAG_POINT_MIP_LINEAR;		if (_stricmp(sz, "MIN_POINT_MAG_LINEAR_MIP_POINT") == 0)			return TEXTURE_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT;		if (_stricmp(sz, "MIN_POINT_MAG_MIP_LINEAR") == 0)			return TEXTURE_FILTER_MIN_POINT_MAG_MIP_LINEAR;		if (_stricmp(sz, "MIN_LINEAR_MAG_MIP_POINT") == 0)			return TEXTURE_FILTER_MIN_LINEAR_MAG_MIP_POINT;		if (_stricmp(sz, "MIN_LINEAR_MAG_POINT_MIP_LINEAR") == 0)			return TEXTURE_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR;		if (_stricmp(sz, "MIN_MAG_LINEAR_MIP_POINT") == 0)			return TEXTURE_FILTER_MIN_MAG_LINEAR_MIP_POINT;		if (_stricmp(sz, "MIN_MAG_MIP_LINEAR") == 0)			return TEXTURE_FILTER_MIN_MAG_MIP_LINEAR;		if (_stricmp(sz, "ANISOTROPIC") == 0)			return TEXTURE_FILTER_ANISOTROPIC;		if (_stricmp(sz, "COMPARISON_MIN_MAG_MIP_POINT") == 0)			return TEXTURE_FILTER_COMPARISON_MIN_MAG_MIP_POINT;		if (_stricmp(sz, "COMPARISON_MIN_MAG_POINT_MIP_LINEAR") == 0)			return TEXTURE_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR;		if (_stricmp(sz, "COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT") == 0)			return TEXTURE_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT;		if (_stricmp(sz, "COMPARISON_MIN_POINT_MAG_MIP_LINEAR") == 0)			return TEXTURE_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR;		if (_stricmp(sz, "COMPARISON_MIN_LINEAR_MAG_MIP_POINT") == 0)			return TEXTURE_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT;		if (_stricmp(sz, "COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR") == 0)			return TEXTURE_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR;		if (_stricmp(sz, "COMPARISON_MIN_MAG_LINEAR_MIP_POINT") == 0)			return TEXTURE_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT;		if (_stricmp(sz, "COMPARISON_MIN_MAG_MIP_LINEAR") == 0)			return TEXTURE_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR;		if (_stricmp(sz, "COMPARISON_ANISOTROPIC") == 0)			return TEXTURE_FILTER_COMPARISON_ANISOTROPIC;		Logger::Log(FB_ERROR_LOG_ARG, FormatString("%s is not vaild TEXTURE_FILTER", sz).c_str());		return TEXTURE_FILTER_MIN_MAG_MIP_LINEAR;	}

void Filesets_ShowProperties (LPIDENT lpiFileset, size_t nAlerts, BOOL fJumpToThreshold){   HWND hCurrent;   if ((hCurrent = PropCache_Search (pcSET_PROP, lpiFileset)) != NULL)      {      SetFocus (hCurrent);      if (fJumpToThreshold)         {         HWND hTab;         if ((hTab = GetDlgItem (hCurrent, IDC_PROPSHEET_TABCTRL)) != NULL)            {            int nTabs = TabCtrl_GetItemCount (hTab);            TabCtrl_SetCurSel (hTab, nTabs-1);            NMHDR nm;            nm.hwndFrom = hTab;            nm.idFrom = IDC_PROPSHEET_TABCTRL;            nm.code = TCN_SELCHANGE;            SendMessage (hCurrent, WM_NOTIFY, 0, (LPARAM)&nm);            }         }      }   else      {      TCHAR szCell[ cchNAME ];      lpiFileset->GetCellName (szCell);      TCHAR szFileset[ cchNAME ];      lpiFileset->GetFilesetName (szFileset);      LPTSTR pszTitle = FormatString (IDS_SET_PROP_TITLE, TEXT("%s"), szFileset);      LPPROPSHEET psh = PropSheet_Create (pszTitle, FALSE);      psh->fMadeCaption = TRUE;      if (PropSheet_AddProblemsTab (psh, IDD_SET_PROBLEMS, lpiFileset, nAlerts) &&          PropSheet_AddTab (psh, IDS_SET_GENERAL_TAB, IDD_SET_GENERAL, (DLGPROC)Filesets_General_DlgProc, (LPARAM)lpiFileset, TRUE))         {         if (fJumpToThreshold)            psh->sh.nStartPage = psh->sh.nPages-1;         PropSheet_ShowModeless (psh);         }      }}

void ChangeAddr_OnInitDialog (HWND hDlg, LPSVR_CHANGEADDR_PARAMS lpp){   TCHAR szName[ cchNAME ];   lpp->lpiServer->GetServerName (szName);   TCHAR szText[ cchRESOURCE ];   GetDlgItemText (hDlg, IDC_TITLE, szText, cchRESOURCE);   LPTSTR pszTitle = FormatString (szText, TEXT("%s"), szName);   SetDlgItemText (hDlg, IDC_TITLE, pszTitle);   FreeString (pszTitle);   HWND hList = GetDlgItem (hDlg, IDC_SVR_ADDRESSES);   LB_StartChange (hList, TRUE);   LB_AddItem (hList, IDS_QUERYING, 0);   LB_EndChange (hList, 0);   ChangeAddr_Enable (hDlg, FALSE);}

void Filesets_Release_OnInitDialog (HWND hDlg, LPIDENT lpi){   TCHAR szServer[ cchNAME ];   TCHAR szAggregate[ cchNAME ];   TCHAR szFileset[ cchNAME ];   lpi->GetServerName (szServer);   lpi->GetAggregateName (szAggregate);   lpi->GetFilesetName (szFileset);   TCHAR szOld[ cchRESOURCE ];   GetDlgItemText (hDlg, IDC_RELSET_DESC, szOld, cchRESOURCE);   LPTSTR pszText = FormatString (szOld, TEXT("%s%s%s"), szServer, szAggregate, szFileset);   SetDlgItemText (hDlg, IDC_RELSET_DESC, pszText);   FreeString (pszText);   CheckDlgButton (hDlg, IDC_RELSET_NORMAL, TRUE);   CheckDlgButton (hDlg, IDC_RELSET_FORCE, FALSE);}

static unsigned intRLEConstrainColormapIndex(Image *image, unsigned int index,                          unsigned int colormap_entries){    if (index >= colormap_entries)    {        char        colormapIndexBuffer[MaxTextExtent];        FormatString(colormapIndexBuffer,"index %u >= %u, %.1024s",                     (unsigned int) index, colormap_entries, image->filename);        errno=0;        index=0U;        ThrowException(&image->exception,CorruptImageError,                       InvalidColormapIndex,colormapIndexBuffer);    }    return index;}

    void CTaskMethod::SetTaskParams(behaviac::Agent* pAgent)    {        if (this->m_paramTypes.size() > 0)        {            BEHAVIAC_ASSERT(this->m_paramTypes.size() == this->m_params.size());            const char* agentType = pAgent->GetObjectTypeName();            AgentProperties* agentT = AgentProperties::Get(agentType);            for (uint32_t i = 0; i < this->m_paramTypes.size(); ++i)            {                behaviac::Property* valueProperty = this->m_params[i];                BEHAVIAC_ASSERT(valueProperty);                behaviac::string paramName = FormatString("%s%d", BEHAVIAC_LOCAL_TASK_PARAM_PRE, i);                this->SetTaskParam(pAgent, agentT, paramName.c_str(), valueProperty);            }        }    }

MEDUSA_NAMESPACE_BEGIN  bool Architecture::FormatCell(  Document      const& rDoc,  BinaryStream  const& rBinStrm,  Address       const& rAddr,  Cell          const& rCell,  std::string        & rStrCell,  Cell::Mark::List   & rMarks) const{  switch (rCell.GetType())  {  case Cell::InstructionType: return FormatInstruction(rDoc, rBinStrm, rAddr, static_cast<Instruction const&>(rCell), rStrCell, rMarks);  case Cell::ValueType:       return FormatValue      (rDoc, rBinStrm, rAddr, static_cast<Value       const&>(rCell), rStrCell, rMarks);  case Cell::CharacterType:   return FormatCharacter  (rDoc, rBinStrm, rAddr, static_cast<Character   const&>(rCell), rStrCell, rMarks);  case Cell::StringType:      return FormatString     (rDoc, rBinStrm, rAddr, static_cast<String      const&>(rCell), rStrCell, rMarks);  default:                    return false;  }}

	CULL_MODE CullModeFromString(const char* str)	{		if (!str)			return CULL_MODE_BACK;		if (_stricmp(str, "CULL_MODE_NONE") == 0)		{			return CULL_MODE_NONE;		}		if (_stricmp(str, "CULL_MODE_FRONT") == 0)		{			return CULL_MODE_FRONT;		}		if (_stricmp(str, "CULL_MODE_BACK") == 0)		{			return CULL_MODE_BACK;		}		Logger::Log(FB_ERROR_LOG_ARG, FormatString("%s is not vaild CULL_MODE", str).c_str());		return CULL_MODE_BACK;	}

	int TextureTypeFromString(const char* str)	{		if (!str)			return TEXTURE_TYPE_DEFAULT;		if (_stricmp(str, "ColorRamp") == 0)			return TEXTURE_TYPE_COLOR_RAMP;		if (_stricmp(str, "Default") == 0)			return TEXTURE_TYPE_DEFAULT;		if (_stricmp(str, "RenderTarget") == 0)			return TEXTURE_TYPE_RENDER_TARGET;		if (_stricmp(str, "DepthStencil") == 0)			return TEXTURE_TYPE_DEPTH_STENCIL;		if (_stricmp(str, "1D") == 0) {			return TEXTURE_TYPE_DEFAULT | TEXTURE_TYPE_1D;		}		Logger::Log(FB_ERROR_LOG_ARG, FormatString("%s is not vaild TEXTURE_TYPE", str).c_str());		return TEXTURE_TYPE_DEFAULT;	}

void PostgreSQLInterface::EncodeQueryUpdate(const char *colName, const char *str, RakNet::RakString &valueStr, int &numParams, char **paramData, int *paramLength, int *paramFormat, const char *type){	if (str==0 || str[0]==0)		return;	if (valueStr.IsEmpty()==false)	{		valueStr += ", ";	}	valueStr += colName;	valueStr+=" = ";	valueStr+=FormatString("$%i::%s", numParams+1, type);	paramData[numParams]=(char*) str;	paramLength[numParams]=(int) strlen(str);	paramFormat[numParams]=PQEXECPARAM_FORMAT_TEXT;	numParams++;}

    void Planner::LogPlanEnd(Agent* a, Task* root)    {        BEHAVIAC_UNUSED_VAR(a);        BEHAVIAC_UNUSED_VAR(root);#if !BEHAVIAC_RELEASE        if (Config::IsLoggingOrSocketing())        {            behaviac::string agentClassName(a->GetObjectTypeName());            behaviac::string agentInstanceName(a->GetName());            behaviac::string ni = BehaviorTask::GetTickInfo(a, root, NULL);            behaviac::string buffer = FormatString("[plan_end]%s#%s %s/n", agentClassName.c_str(), agentInstanceName.c_str(), ni.c_str());            LogManager::GetInstance()->Log(buffer.c_str());        }#endif    }