C++ ct函数代码示例

eventhandler* parse_eventhandler(char* line) {
	char *token = NULL;
	char *sptr = NULL;
	char *cp = strdup(line);

	/* ignore everything behind # */
	char *comment = strchr(line, '#');
	if ( comment != NULL ) {
		*comment = '\0';
	}

	char *delim = " \t\n";

	char *evname = ct( strtok_r(cp, delim, &sptr) );
	int value = strint( strtok_r(NULL, delim, &sptr) );
	char *cmd = ct( strtok_r(NULL, "\n", &sptr) );
	free(cp);

	/* all fields filled? */
	if (evname && cmd && (value >= 0)) {
		eventhandler *eh = malloc( sizeof(eventhandler) );
		eh->type = lookup_event_type( evname );
		eh->code = lookup_event_code( evname );
		eh->value = value;
		eh->cmdline = cmd;
		eh->next = NULL;
		return eh;
	} else {
		free(evname);
		free(cmd);
		return NULL;
	}
}

    int ct(char *s, char *t) {
        if (0 == *t) return 1;
        if (0 == *s) return 0; // end of s, but not end of t.

        if (*s == *t) {
            return ct(s+1, t+1) + ct(s+1, t);
        }
        else {
            return ct(s+1, t);
        }
    }

 TreeNode* ct(vector<int>& preorder, vector<int> &inorder, int pst, int ist, int ied) {
     if(ist > ied) return NULL;
     int mid = 0;
     TreeNode* root = new TreeNode(preorder[pst]);
     for(int i = ist; i <= ied; i++){
         if(preorder[pst] == inorder[i])
         {    mid = i;break;}
     }
     root->left = ct(preorder, inorder,pst+1 , ist,mid-1 ); // pst+1 !!! easy for forget
     root->right = ct(preorder, inorder,pst+(mid-ist+1) , mid+1, ied);
     return root;
     
 }

 TreeNode *ct(vector<int> &preorder, vector<int> &inorder, int ist, int ied, int pst){
     if(ist > ied) return NULL;
     TreeNode *res = new TreeNode(preorder[pst]);
     int mid;
     for(int i = ist; i <= ied; i++){
         if(inorder[i] == res->val){
             mid = i;
             break;
         }
     }
     res->right = ct(preorder, inorder, mid+1, ied, pst+1+mid-ist);
     res->left = ct(preorder, inorder, ist, mid-1, pst+1);
     return res;
 }

QgsRectangle QgsProcessingUtils::combineLayerExtents( const QList<QgsMapLayer *> &layers, const QgsCoordinateReferenceSystem &crs )
{
  QgsRectangle extent;
  for ( const QgsMapLayer *layer : layers )
  {
    if ( !layer )
      continue;

    if ( crs.isValid() )
    {
      //transform layer extent to target CRS
      Q_NOWARN_DEPRECATED_PUSH
      QgsCoordinateTransform ct( layer->crs(), crs );
      Q_NOWARN_DEPRECATED_POP
      try
      {
        QgsRectangle reprojExtent = ct.transformBoundingBox( layer->extent() );
        extent.combineExtentWith( reprojExtent );
      }
      catch ( QgsCsException & )
      {
        // can't reproject... what to do here? hmmm?
        // let's ignore this layer for now, but maybe we should just use the original extent?
      }
    }
    else
    {

/**
 * \brief get details about a specific calibration
 */
Calibration	GuiderFactoryI::getCalibration(int id,
			const Ice::Current& /* current */) {
	// use the database to retrieve the complete calibration data
	Calibration	calibration;
	try {
		astro::guiding::CalibrationTable	ct(database);
		astro::guiding::CalibrationRecord	r = ct.byid(id);
		calibration.id = r.id();
		calibration.timeago = converttime(r.when);
		calibration.guider.cameraname = r.camera;
		calibration.guider.ccdid = r.ccdid;
		calibration.guider.guiderportname = r.guiderport;
		for (int i = 0; i < 6; i++) {
			calibration.coefficients.push_back(r.a[i]);
		}

		// add calibration points
		astro::guiding::CalibrationStore	store(database);
		std::list<astro::guiding::CalibrationPointRecord>	points
			= store.getCalibrationPoints(id);
		std::list<astro::guiding::CalibrationPointRecord>::iterator i;
		for (i = points.begin(); i != points.end(); i++) {
			calibration.points.push_back(convert(*i));
		}
		return calibration;
	} catch (std::exception& ex) {
		std::string	msg = astro::stringprintf("calibrationd run %d "
			"not found: %s", id, ex.what());
		debug(LOG_ERR, DEBUG_LOG, 0, "%s", msg.c_str());
		throw NotFound(msg);
	}
}

void CharAllPrestigeTasks::load()
{
    Query q(GetDb());
    m_all_prestige_tasks.clear();
    //从数据库读任务记录
    q.get_result("select tid,cur,state from char_prestige_tasks where cid=" + LEX_CAST_STR(m_charData.m_id) + " order by tid");
    while (q.fetch_row())
    {
        int tid = q.getval();
        int cur = q.getval();
        int state = q.getval();
        boost::shared_ptr<basePrestigeTask> bt = Singleton<PrestigeTaskMgr>::Instance().getPrestigeTask(tid);
        if (!bt.get())
        {
            continue;
        }
        boost::shared_ptr<CharPrestigeTask> ct(new CharPrestigeTask(m_charData));
        ct->tid = tid;
        ct->m_task = bt;
        ct->cur = cur;
        ct->state = state;
        m_all_prestige_tasks[bt->id] = ct;
    }
    q.free_result();
}

QString QgsCoordinateUtils::formatCoordinateForProject( const QgsPoint& point, const QgsCoordinateReferenceSystem& destCrs, int precision )
{
  QString format = QgsProject::instance()->readEntry( "PositionPrecision", "/DegreeFormat", "MU" );

  QgsPoint geo = point;
  if ( format == "DM" || format == "DMS" || format == "D" )
  {
    // degrees
    if ( destCrs.isValid() && !destCrs.geographicFlag() )
    {
      // need to transform to geographic coordinates
      QgsCoordinateTransform ct( destCrs, QgsCoordinateReferenceSystem( GEOSRID ) );
      try
      {
        geo = ct.transform( point );
      }
      catch ( QgsCsException& )
      {
        return QString();
      }
    }

    if ( format == "DM" )
      return geo.toDegreesMinutes( precision, true, true );
    else if ( format == "DMS" )
      return geo.toDegreesMinutesSeconds( precision, true, true );
    else
      return geo.toString( precision );
  }
  else
  {
    // coordinates in map units
    return point.toString( precision );
  }
}

void DisplayData(void)
{
	int iTask;

	printf("Display of the instance:\n");
	printf("\t Time Horizon T: %ld\n",T());
	printf("\t Number of Tasks N: %ld\n",N());
	printf("\t Number of Machines M: %ld\n",M());
	ConsoleTable ct("Tasks", N(), 6);
	ct.SetColHeader(0, "QtyCPU")
		.SetColHeader(1, "QtyGPU")
		.SetColHeader(2, "QtyRAM")
		.SetColHeader(3, "QtyHDD")
		.SetColHeader(4, "IsPreemp")
		.SetColHeader(5, "CostPreemp");
	for (iTask=0;iTask<N();iTask++) 
	{
		ct.Print(nc(iTask));
		ct.Print(ng(iTask));
		ct.Print(nr(iTask));
		ct.Print(nh(iTask));
		ct.Print(R(iTask));
		ct.Print(rho(iTask));
	}
}

complex_t BiquadBase::response (double normalizedFrequency) const
{
  const double a0 = getA0 ();
  const double a1 = getA1 ();
  const double a2 = getA2 ();
  const double b0 = getB0 ();
  const double b1 = getB1 ();
  const double b2 = getB2 ();

  const double w = 2 * doublePi * normalizedFrequency;
  const complex_t czn1 = std::polar (1., -w);
  const complex_t czn2 = std::polar (1., -2 * w);
  complex_t ch (1);
  complex_t cbot (1);

  complex_t ct (b0/a0);
  complex_t cb (1);
  ct = addmul (ct, b1/a0, czn1);
  ct = addmul (ct, b2/a0, czn2);
  cb = addmul (cb, a1/a0, czn1);
  cb = addmul (cb, a2/a0, czn2);
  ch   *= ct;
  cbot *= cb;

  return ch / cbot;
}

	void TWS_TLServer::tickPrice( TickerId tickerId, TickType tickType, double price, int canAutoExecute) 
	{ 
		if ((tickerId>=0)&&(tickerId<(TickerId)stockticks.size()) && needStock(stockticks[tickerId].sym))
		{
			time_t now;
			time(&now);
			CTime ct(now);
			TLTick k;
			k.date = (ct.GetYear()*10000) + (ct.GetMonth()*100) + ct.GetDay();
			k.time = (ct.GetHour()*10000)+(ct.GetMinute()*100)+ct.GetSecond();
			k.sym = stockticks[tickerId].sym;
			if (tickType==LAST)
			{
				stockticks[tickerId].trade = price;
				k.trade = price;
				k.size = stockticks[tickerId].size;
			}
			else if (tickType==BID)
			{
				stockticks[tickerId].bid = price;
				k.bid = stockticks[tickerId].bid;
				k.bs = stockticks[tickerId].bs;
			}
			else if (tickType==ASK)
			{
				stockticks[tickerId].ask = price;
				k.ask = stockticks[tickerId].ask;
				k.os = stockticks[tickerId].os;
			}
			else return; // not relevant tick info
			if (k.isValid() && needStock(k.sym))
				this->SrvGotTick(k);
		}
	
	}

void TDistribution::_calculateNewV(const Mat& m, const vector<double>& EH, const vector<double>& ELogH)
{
  // Use Line Search to search for the best v.
  CostT ct(this, m, EH, ELogH);
  GoldenSectionSearch gss(0.1);
  _v = gss.argmin(ct, 0, 10000);
}

void QgsMapCanvasAnnotationItem::setFeatureForMapPosition()
{
  if ( !mAnnotation || !mAnnotation->hasFixedMapPosition() )
    return;

  QgsVectorLayer *vectorLayer = qobject_cast< QgsVectorLayer * >( mAnnotation->mapLayer() );
  if ( !vectorLayer )
    return;

  double halfIdentifyWidth = QgsMapTool::searchRadiusMU( mMapCanvas );
  QgsPointXY mapPosition = mAnnotation->mapPosition();

  try
  {
    QgsCoordinateTransform ct( mAnnotation->mapPositionCrs(), mMapCanvas->mapSettings().destinationCrs(), QgsProject::instance() );
    if ( ct.isValid() )
      mapPosition = ct.transform( mapPosition );
  }
  catch ( QgsCsException & )
  {
  }

  QgsRectangle searchRect( mapPosition.x() - halfIdentifyWidth, mapPosition.y() - halfIdentifyWidth,
                           mapPosition.x() + halfIdentifyWidth, mapPosition.y() + halfIdentifyWidth );

  searchRect = mMapCanvas->mapSettings().mapToLayerCoordinates( vectorLayer, searchRect );

  QgsFeatureIterator fit = vectorLayer->getFeatures( QgsFeatureRequest().setFilterRect( searchRect ).setFlags( QgsFeatureRequest::ExactIntersect ).setLimit( 1 ) );

  QgsFeature currentFeature;
  ( void )fit.nextFeature( currentFeature );
  mAnnotation->setAssociatedFeature( currentFeature );
}

CSonTime::CSonTime(LPCTSTR mstr)
{
	CString css(mstr);
	CTokenizer ctt(mstr," /:,");
	int i,j[6];

	if ((css=="0000 00 00 00:00:00")|(css=="")|(mstr == NULL))
	{
		CTime ct = CTime::GetCurrentTime();		
		CTime *pt = this;
		*pt = ct;
	}
	else
	{
		for (i=0;i<6;i++)
		{
			if (ctt.Next(css))
				j[i] = atoi(css);
			else 
				j[i] = 0;
		}

		CTime ct(j[0],j[1],j[2],j[3],j[4],j[5]);
		CTime *pt = this;
		*pt = ct;
	}
	m_pfnV = & VS_MainNum;
}

int main(int argc, char* argv[]) {

    START_EASYLOGGINGPP(argc, argv);
    parseArgs(argc, argv);

    LOG(INFO) << "Initializing alignment provider";
    DazAlnProvider* ap;
    ap = new DazAlnProvider(popts);
    TrgBuf trgBuf(20);
    CnsBuf cnsBuf(10);

    std::thread writerThread(Writer, std::ref(cnsBuf));

    std::vector<std::thread> cnsThreads;
    for (int i=0; i < popts.threads; i++) {
        std::thread ct(Consensus, i, std::ref(trgBuf), std::ref(cnsBuf));
        cnsThreads.push_back(std::move(ct));
    }

    std::thread readerThread(Reader, std::ref(trgBuf), ap);

    writerThread.join();

    std::vector<std::thread>::iterator it;
    for (it = cnsThreads.begin(); it != cnsThreads.end(); ++it)
        it->join();

    readerThread.join();

    delete ap;

    return 0;
}