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

void Foam::combustionModels::EDC<ReactionThermo>::correct(){    tmp<volScalarField> tepsilon(this->turbulence().epsilon());    const volScalarField& epsilon = tepsilon();    tmp<volScalarField> tmu(this->turbulence().mu());    const volScalarField& mu = tmu();    tmp<volScalarField> tk(this->turbulence().k());    const volScalarField& k = tk();    tmp<volScalarField> trho(this->rho());    const volScalarField& rho = trho();    scalarField tauStar(epsilon.size(), 0);    if (version_ == EDCversions::v2016)    {        tmp<volScalarField> ttc(this->chemistryPtr_->tc());        const volScalarField& tc = ttc();        forAll(tauStar, i)        {            const scalar nu = mu[i]/(rho[i] + small);            const scalar Da =                max(min(sqrt(nu/(epsilon[i] + small))/tc[i], 10), 1e-10);            const scalar ReT = sqr(k[i])/(nu*epsilon[i] + small);            const scalar CtauI = min(C1_/(Da*sqrt(ReT + 1)), 2.1377);            const scalar CgammaI =                max(min(C2_*sqrt(Da*(ReT + 1)), 5), 0.4082);            const scalar gammaL =                CgammaI*pow025(nu*epsilon[i]/(sqr(k[i]) + small));            tauStar[i] = CtauI*sqrt(nu/(epsilon[i] + small));            if (gammaL >= 1)            {                kappa_[i] = 1;            }            else            {                kappa_[i] =                    max                    (                        min                        (                            pow(gammaL, exp1_)/(1 - pow(gammaL, exp2_)),                            1                        ),                        0                    );            }        }    }

void ppPragma::ParsePragma( const std::string &args){    Tokenizer tk(args, &hash);    const Token *id = tk.Next();    if (id->IsIdentifier())    {        if (*id == "STDC")            HandleSTDC(tk);        else if (*id == "AUX")            HandleAlias(tk);        else if (*id == "PACK")            HandlePack(tk);        else if (*id == "LIBRARY")            HandleLibrary(tk);        else if (*id == "STARTUP")            HandleStartup(tk);        else if (*id == "RUNDOWN")            HandleRundown(tk);        else if (*id == "WARNING")            HandleWarning(tk);        else if (*id == "ERROR")            HandleError(tk);        else if (*id == "FARKEYWORD")            HandleFar(tk);        // unmatched is not an error                }}

wxFileType * wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& ext){    if (ext.empty() )        return NULL;    InitIfNeeded();    size_t count = m_aExtensions.GetCount();    for ( size_t n = 0; n < count; n++ )    {        wxStringTokenizer tk(m_aExtensions[n], wxT(' '));        while ( tk.HasMoreTokens() )        {            // consider extensions as not being case-sensitive            if ( tk.GetNextToken().IsSameAs(ext, false /* no case */) )            {                // found                wxFileType *fileType = new wxFileType;                fileType->m_impl->Init(this, n);                return fileType;            }        }    }    return NULL;}

void Macros::process_autobits(Macuse & mu, Autobits & autobits){    Unumber val = autobits.val(mu);    string name = autobits.name();    Pnode macdef = root->macdefs[name];    if (!macdef)    {        // obtain bit macuse names        if (mu.children.size() != 4) throw Err(LNFUN);        string bit0 = autobits.getid(mu.children[2]);        string bit1 = autobits.getid(mu.children[3]);        Pnode md(new Macdef(mu.tok()));        while (val != 0)        {            string bit = bit0;            if (val.getbit(0)) bit = bit1;            val >>= 1;            Token tk(mu.tok());            tk.s = bit;            Macuse * u = new Macuse(tk, Pnode(new Labels(mu.tok())));            md->addChild(Pnode(u));        }        root->macdefs[name] = md;    }    // remove arguments    mu.children.pop_back();    mu.children.pop_back();    mu.children.pop_back();}

  void _buildIndex()  {    LOG_DEBUG(SystemInfo::getMemoryUsageString());    LOG_DEBUG("Creating index. (node count: " << _map->getNodeMap().size() << ")");    vector<TreeKey> keys;    vector<long> nids;    // reserve some space to reduce reallocs    keys.reserve(_map->getNodeMap().size() * 2);    nids.reserve(_map->getNodeMap().size() * 2);    for (OsmMap::NodeMap::const_iterator it = _map->getNodeMap().begin();         it != _map->getNodeMap().end(); ++it)    {      const shared_ptr<const Node>& n = it.value();      set<QString> allNames = _getNamePermutations(n->getTags().getNames());      for (set<QString>::iterator it = allNames.begin(); it != allNames.end(); ++it)      {        TreeKey tk(n->toCoordinate(), *it);        keys.push_back(tk);        nids.push_back(n->getId());      }    }    LOG_DEBUG(SystemInfo::getMemoryUsageString());    LOG_DEBUG("Calling build index.");    _index.reset(new hybrid::RFqHybridTree<TreeKey, long, LevenshteinDistance>());    _index->buildIndex(keys, nids);    LOG_DEBUG("Built index with " << keys.size() << " keys and " << _map->getNodeMap().size() <<             " nodes.");    LOG_DEBUG(SystemInfo::getMemoryUsageString());  }

void ppCond::HandleDef(std::string &line, bool Else, bool negate, int lineno){    Tokenizer tk(line, NULL);    const Token *t = tk.Next();    if (!t->IsIdentifier())    {        Errors::Error("Identifier expected");        if (Else)            HandleElif(false,""); // FIXME 1st arg is bool!         else            HandleIf(false,"", lineno);// FIXME 1st arg is bool!    }    else    {        int v = !!define->Lookup(t->GetId());        if (asmpp && !v)        {            std::string one = UTF8::ToUpper(t->GetId());            Symbol *t = define->Lookup(one);            if (t)            {                ppDefine::Definition *p = static_cast<ppDefine::Definition *>(t);                v = p->IsCaseInsensitive();            }        }        if (negate)            v = !v;        if (Else)            HandleElif(v,tk.GetString());        else            HandleIf(v, tk.GetString(), lineno);    }}

void pgDatabase::UpdateDefaultSchema(){	searchPath = connection()->ExecuteScalar(wxT("SHOW search_path"));	if (!searchPath.IsEmpty())	{		wxStringTokenizer tk(searchPath, wxT(","));		pgSet *set = ExecuteSet(wxT("SELECT nspname, session_user=nspname AS isuser FROM pg_namespace"));		if (set)		{			while (tk.HasMoreTokens())			{				wxString str = tk.GetNextToken();				str.Strip(wxString::both);				if (str.IsEmpty())					continue;				long row;				for (row = 1 ; row <= set->NumRows() ; row++)				{					set->Locate(row);					defaultSchema = set->GetVal(wxT("nspname"));					if (str == defaultSchema ||					        ((str == wxT("$user") || str == wxT("/"$user/"")) && set->GetBool(wxT("isuser"))))					{						delete set;						return;					}				}			}			delete set;		}	}	defaultSchema = wxEmptyString;}

	unsigned Process(uint64_t &processed)	{		int64_t staleTime;		{			int64_t k = m_kernelSession.LastTS();			int64_t h = m_heapSession.LastTS();			staleTime = max(k, h);			staleTime = g_QPCHelper.GetQPCFrom(staleTime, -SESSION_CACHE_TIME_MS);		}		EventQueue::BlockList blk, blh;		m_kernelSession.PopStales(staleTime, blk);		m_heapSession.PopStales(staleTime, blh);		EventQueue::BlockListTraver tk(&blk), th(&blh);		while (!tk.end() && !th.end())		{			Event &ek = tk.elem();			Event &eh = th.elem();			if (ek.createtime() <= eh.createtime())			{				ek.inner()->consume();				ek.inner()->destroy();				tk.next();			}			else			{				eh.inner()->consume();				eh.inner()->destroy();				th.next();			}			++processed;		}		while (!tk.end())		{			Event &ek = tk.elem();			ek.inner()->consume();			ek.inner()->destroy();			tk.next();			++processed;		}		while (!th.end())		{			Event &eh = th.elem();			eh.inner()->consume();			eh.inner()->destroy();			th.next();			++processed;		}		m_lastTS = staleTime;		if (!m_kernelSession.IsRunning())			return m_kernelSession.ExitCode();		if (!m_heapSession.IsRunning())			return m_heapSession.ExitCode();		return 0;	}

void run_iter(int n){   int i;   for (i = 0; i < n; i++) {      setup_state();      tk();   }}

wxArrayStringwxGridCellAutoWrapStringRenderer::GetTextLines(wxGrid& grid,                                               wxDC& dc,                                               const wxGridCellAttr& attr,                                               const wxRect& rect,                                               int row, int col){    wxString  data = grid.GetCellValue(row, col);    wxArrayString lines;    dc.SetFont(attr.GetFont());    //Taken from wxGrid again!    wxCoord x = 0, y = 0, curr_x = 0;    wxCoord max_x = rect.GetWidth();    dc.SetFont(attr.GetFont());    wxStringTokenizer tk(data , wxT(" /n/t/r"));    wxString thisline = wxEmptyString;    while ( tk.HasMoreTokens() )    {        wxString tok = tk.GetNextToken();        //FIXME: this causes us to print an extra unnecesary        //       space at the end of the line. But it        //       is invisible , simplifies the size calculation        //       and ensures tokens are separated in the display        tok += wxT(" ");        dc.GetTextExtent(tok, &x, &y);        if ( curr_x + x > max_x)        {            if ( curr_x == 0 )            {                // this means that a single token is wider than the maximal                // width -- still use it as is as we need to show at least the                // part of it which fits                lines.Add(tok);            }            else            {                lines.Add(thisline);                thisline = tok;                curr_x = x;            }        }        else        {            thisline+= tok;            curr_x += x;        }    }    //Add last line    lines.Add( wxString(thisline) );    return lines;}

void Cfg::setAdminAllowedIP( const char * str ){    StringTokenizer tk(str, " ");    for(size_t i = 0; i < tk.count(); ++ i)    {        IPMask ipm = parseAddress(tk[i]);        if(ipm.mask < 32)            _adminIPAllowed.push_back(ipm);    }}

void CColorRichEditView::SetAccentFromThisLineToTheEndofParadigm(){	CRichEditCtrl& re = GetRichEditCtrl();	int lineInd = re.LineIndex();	CString Paradigm = GetText();	int line_no = re.LineFromChar(lineInd);	lineInd += line_no; // delete '/r'	DWORD wordEnd = lineInd;	while (wordEnd < Paradigm.GetLength() && !isspace((BYTE)Paradigm.GetAt(wordEnd) ))		wordEnd++;	int acc= Paradigm.Find("'",lineInd);	if ( (acc <= 0) || (acc >=wordEnd)) return; 	StringTokenizer tok((const char*)Paradigm, "/r/n");	int curr_line_no = 0;	CString NewParadigm;	while (tok())	{		curr_line_no++;		if (curr_line_no  <= line_no+1) 		{			NewParadigm += tok.val();			NewParadigm += "/r/n";			continue;		}		else		{			StringTokenizer tk(tok.val(), " /t/r/n");			if (tk())			{				string wrd = tk.val();				int ind = wrd.find("'");				if (ind != string::npos)					wrd.erase(ind,1);				wrd.insert(acc-lineInd, "'");				NewParadigm += CString(wrd.c_str())+CString(" ")+CString(tk.get_rest())+CString("/r/n");			}			else				NewParadigm += tok.val()+CString("/r/n");		};	};	SetText(NewParadigm);}

void testTextDocExtra(){    const char* TT = "blablablablablablba";    tkTextDocumentExtra tk(TT);    QVariant q;    q.setValue(tk);    qWarning() << tk.toHtml();    qWarning() << tk.toXml();    qWarning() << q.value<tkTextDocumentExtra>().toHtml();}

tmp<volScalarField> LESeddyViscosity<BasicTurbulenceModel>::epsilon() const{    tmp<volScalarField> tk(this->k());    return tmp<volScalarField>    (        new volScalarField        (            IOobject            (                IOobject::groupName("epsilon", this->U_.group()),                this->runTime_.timeName(),                this->mesh_,                IOobject::NO_READ,                IOobject::NO_WRITE            ),            Ce_*tk()*sqrt(tk())/this->delta()        )    );}

IGL_INLINE void igl::GeneralPolyVectorFieldFinder<DerivedV, DerivedF>::getGeneralCoeffConstraints(const Eigen::VectorXi &isConstrained,                                                       const Eigen::Matrix<typename DerivedV::Scalar, Eigen::Dynamic, Eigen::Dynamic> &cfW,                                                       int k,                                                       const Eigen::VectorXi &rootsIndex,                                                       Eigen::Matrix<std::complex<typename DerivedV::Scalar>, Eigen::Dynamic,1> &Ck){  int numConstrained = isConstrained.sum();  Ck.resize(numConstrained,1);  // int n = rootsIndex.cols();  Eigen::MatrixXi allCombs;  {    Eigen::VectorXi V = Eigen::VectorXi::LinSpaced(n,0,n-1);    igl::nchoosek(V,k+1,allCombs);  }  int ind = 0;  for (int fi = 0; fi <numF; ++fi)  {    const Eigen::Matrix<typename DerivedV::Scalar, 1, 3> &b1 = B1.row(fi);    const Eigen::Matrix<typename DerivedV::Scalar, 1, 3> &b2 = B2.row(fi);    if(isConstrained[fi])    {      std::complex<typename DerivedV::Scalar> ck(0);      for (int j = 0; j < allCombs.rows(); ++j)      {        std::complex<typename DerivedV::Scalar> tk(1.);        //collect products        for (int i = 0; i < allCombs.cols(); ++i)        {          int index = allCombs(j,i);          int ri = rootsIndex[index];          Eigen::Matrix<typename DerivedV::Scalar, 1, 3> w;          if (ri>0)            w = cfW.block(fi,3*(ri-1),1,3);          else            w = -cfW.block(fi,3*(-ri-1),1,3);          typename DerivedV::Scalar w0 = w.dot(b1);          typename DerivedV::Scalar w1 = w.dot(b2);          std::complex<typename DerivedV::Scalar> u(w0,w1);          tk*= u;        }        //collect sum        ck += tk;      }      Ck(ind) = ck;      ind ++;    }  }}

 void Fighter::SetSkill(std::string skill) {      StringTokenizer tk(skill, ";");     if(!tk.count())         return ;     for(UInt8 i = 0; i < tk.count(); ++i)     {         UInt32 skillId = atoi(tk[i].c_str());         m_baseSkills.push_back(skillId)  ;     } } 

void wxSheetCellEnumRendererRefData::SetParameters(const wxString& params){    if ( params.IsEmpty() )        return; // what can we do?    m_choices.Empty();    wxStringTokenizer tk(params, _T(','));    while ( tk.HasMoreTokens() )        m_choices.Add(tk.GetNextToken());}

//------------------------------------------------------static void compileAndRun(Context *ctx, Reader *r) {	Tokenizer tk(r);	Cons *res;	while(parseCons(&tk, &res)) {		if(res != NULL) {			res->cdr = NULL;			//cons_println(res);			runCons(ctx, res);			cons_free(res);		}	}}

Foam::tmp<Foam::volSymmTensorField>Foam::eddyViscosity<BasicTurbulenceModel>::R() const{    tmp<volScalarField> tk(k());    // Get list of patchField type names from k    wordList patchFieldTypes(tk().boundaryField().types());    // For k patchField types which do not have an equivalent for symmTensor    // set to calculated    forAll(patchFieldTypes, i)    {        if        (           !fvPatchField<symmTensor>::patchConstructorTablePtr_                ->found(patchFieldTypes[i])        )        {            patchFieldTypes[i] = calculatedFvPatchField<symmTensor>::typeName;        }    }    return tmp<volSymmTensorField>    (        new volSymmTensorField        (            IOobject            (                IOobject::groupName("R", this->U_.group()),                this->runTime_.timeName(),                this->mesh_,                IOobject::NO_READ,                IOobject::NO_WRITE,                false            ),            ((2.0/3.0)*I)*tk() - (nut_)*dev(twoSymm(fvc::grad(this->U_))),            patchFieldTypes        )    );}

tmp<volSymmTensorField>continuousGasKEpsilon<BasicTurbulenceModel>::R() const{    tmp<volScalarField> tk(this->k());    return tmp<volSymmTensorField>    (        new volSymmTensorField        (            IOobject            (                IOobject::groupName("R", this->U_.group()),                this->runTime_.timeName(),                this->mesh_,                IOobject::NO_READ,                IOobject::NO_WRITE            ),            ((2.0/3.0)*I)*tk() - (nutEff_)*dev(twoSymm(fvc::grad(this->U_))),            tk().boundaryField().types()        )    );}

void wxFastComboEditor::SetParameters(const wxString& params){    if ( !params )    {        return;    }    m_choices.Empty();    wxStringTokenizer tk(params, _T(','));    while ( tk.HasMoreTokens() )    {        m_choices.Add(tk.GetNextToken());    }}

wxArrayString wxStringTokenize(const wxString& str,                               const wxString& delims,                               wxStringTokenizerMode mode){    wxArrayString tokens;    wxStringTokenizer tk(str, delims, mode);    while ( tk.HasMoreTokens() )    {        tokens.Add(tk.GetNextToken());    }    return tokens;}

Foam::tmp<Foam::volSymmTensorField>Foam::eddyViscosity<BasicTurbulenceModel>::R() const{    tmp<volScalarField> tk(k());    return tmp<volSymmTensorField>    (        new volSymmTensorField        (            IOobject            (                IOobject::groupName("R", this->U_.group()),                this->runTime_.timeName(),                this->mesh_,                IOobject::NO_READ,                IOobject::NO_WRITE            ),            ((2.0/3.0)*I)*tk() - (nut_)*dev(twoSymm(fvc::grad(this->U_))),            tk().boundaryField().types()        )    );}

void testUserDynamicDatas(){    QVariant q(QDateTime::currentDateTime());    qWarning() << q.toString() << q.type();    q = "2009-06-22T06:29:299";    qWarning() << q.toString() << q.type() << q.toDateTime();    QHash<int, QVariant> fakeDb;    const char* TT = "<html><body><p>blablablablablablba</p></body></html>";    tkTextDocumentExtra tk(TT);    fakeDb.insert(DATAS_ID,         1 );    fakeDb.insert(DATAS_USER_UUID,  QUuid::createUuid().toString() );    fakeDb.insert(DATAS_DATANAME,   "papers.generic.header" );    fakeDb.insert(DATAS_STRING,     "" );    fakeDb.insert(DATAS_LONGSTRING, tk.toXml() );    fakeDb.insert(DATAS_FILE,       QVariant() );    fakeDb.insert(DATAS_NUMERIC,    QVariant() );    fakeDb.insert(DATAS_DATE,       QVariant() );    fakeDb.insert(DATAS_LANGUAGE,   "fr" );    fakeDb.insert(DATAS_LASTCHANGE, QVariant() );    fakeDb.insert(DATAS_TRACE_ID,   QVariant() );    UserDynamicData udd;    foreach( int k, fakeDb.keys())        udd.feedFromSql(k, fakeDb.value(k));    udd.warn();    qWarning() << "WARNING UDD.VALUE" << udd.value();//    fakeDb.insert(DATAS_ID,          );//    fakeDb.insert(DATAS_USER_UUID,   );//    fakeDb.insert(DATAS_DATANAME,    );//    fakeDb.insert(DATAS_STRING,      );//    fakeDb.insert(DATAS_LONGSTRING,  );//    fakeDb.insert(DATAS_FILE,        );//    fakeDb.insert(DATAS_NUMERIC,     );//    fakeDb.insert(DATAS_DATE,        );//    fakeDb.insert(DATAS_LANGUAGE,    );//    fakeDb.insert(DATAS_LASTCHANGE,  );//    fakeDb.insert(DATAS_TRACE_ID,    );////    fakeDb.insert(DATAS_ID,          );//    fakeDb.insert(DATAS_USER_UUID,   );//    fakeDb.insert(DATAS_DATANAME,    );//    fakeDb.insert(DATAS_STRING,      );//    fakeDb.insert(DATAS_LONGSTRING,  );//    fakeDb.insert(DATAS_FILE,        );//    fakeDb.insert(DATAS_NUMERIC,     );//    fakeDb.insert(DATAS_DATE,        );//    fakeDb.insert(DATAS_LANGUAGE,    );//    fakeDb.insert(DATAS_LASTCHANGE,  );//    fakeDb.insert(DATAS_TRACE_ID,    );}

std::string ppCtx::GetId(std::string &line){    Tokenizer tk(line, NULL);    const Token *t = tk.Next();    if (t->IsIdentifier())    {        return t->GetId();    }    else    {        Errors::Error("Identifier expected");    }    return "";}

wxSize getAndroidDisplayDimensions( void ){    wxSize sz_ret = ::wxGetDisplaySize();               // default, probably reasonable, but maybe not accurate        QAndroidJniObject activity = QAndroidJniObject::callStaticObjectMethod("org/qtproject/qt5/android/QtNative",                                                                           "activity", "()Landroid/app/Activity;");        if ( !activity.isValid() ){        qDebug() << "Activity is not valid";        return sz_ret;    }        //  Call the desired method    QAndroidJniObject data = activity.callObjectMethod("getDisplayMetrics", "()Ljava/lang/String;");        wxString return_string;    jstring s = data.object<jstring>();        //  Need a Java environment to decode the resulting string    if (java_vm->GetEnv( (void **) &jenv, JNI_VERSION_1_6) != JNI_OK) {        qDebug() << "GetEnv failed.";    }    else {        const char *ret_string = (jenv)->GetStringUTFChars(s, NULL);        return_string = wxString(ret_string, wxConvUTF8);    }         wxStringTokenizer tk(return_string, _T(";"));    if( tk.HasMoreTokens() ){        wxString token = tk.GetNextToken();     // xdpi        token = tk.GetNextToken();              // density        token = tk.GetNextToken();              // densityDPI                token = tk.GetNextToken();        long a = ::wxGetDisplaySize().x;        // default is wxWidgets idea        if(token.ToLong( &a ))            sz_ret.x = a;                token = tk.GetNextToken();        long b = ::wxGetDisplaySize().y;                if(token.ToLong( &b ))            sz_ret.y = b;    }    wxSize sz_wx = ::wxGetDisplaySize();               // default, probably reasonable, but maybe not accurate    qDebug() << sz_wx.x << sz_wx.y << sz_ret.x << sz_ret.y;        return sz_ret;    }

/////////////////////////////////////////////////////////////////////////////optimization enabled, data_stream, dag, peepholeint main(int argc, char* argv[]){	std::cout<<"in compile"<<std::endl;	std::cout<<"please input file name"<<std::endl;//	char name[1024];	std::stringstream ss(std::stringstream::in|std::stringstream::out);	ss<<"test.txt";//	scanf("%s",name);	FILE* in=fopen(ss.str().c_str(),"r");	if(!in) {std::cout<<"file not find"<<std::endl; return 0;}	tokenizer tk(in);	errorlist* el = new errorlist();	SSTable* table = new SSTable();	InsCtrl* ins = new InsCtrl(*table);	Parser ps(tk,*el);	TNode* node=ps.parse();//	std::cout<<*node; 	fclose(in);	if(el->getErrorNum()==0)		node->visit(*table,*ins,*el);	else	{ el->PrintError();return 0;}	ins->reorder_all_ins();	ins->print_all_ins();	if(el->getErrorNum()!=0)	{el->PrintError(); return 0;}	el->PrintWarning();		std::ofstream file("block.txt",std::ios::out);	std::vector<FBlock*> blo=ins->get_all_func_block();	for(int i=0;i<blo.size();i++)	{		file<<*blo[i];	}	Dag da(ins);		Data_stream* ds=NULL;	ds=new Data_stream(ins);		asm_translator tl(table,ins,ds);	std::ofstream ff("test.asm",std::ios::out);	tl.translate(ff);	system("ml /c /coff test.asm");	system("link /subsystem:console test.obj");	std::cout<<"---------------------running-----------------------"<<std::endl;	system("test.exe");	return 0;	}

void wxGridCellChoiceEditor::SetParameters(const wxString& params){    if ( !params )    {        // what can we do?        return;    }    m_choices.Empty();    wxStringTokenizer tk(params, wxT(','));    while ( tk.HasMoreTokens() )    {        m_choices.Add(tk.GetNextToken());    }}