C++ curr函数代码示例

 scanner::token scanner::read_quoted_symbol() {
     SASSERT(curr() == '|');
     bool escape = false;
     m_string.reset();
     next();
     while (true) {
         char c = curr();
         if (c == EOF) {
             throw scanner_exception("unexpected end of quoted symbol", m_line, m_spos);
         }
         else if (c == '\n') {
             new_line();
         }
         else if (c == '|' && !escape) {
             next();
             m_string.push_back(0);
             m_id = m_string.begin();
             TRACE("scanner", tout << "new quoted symbol: " << m_id << "\n";);
             return SYMBOL_TOKEN;
         }

void scanner::read_comment_block() {
    unsigned nesting = 1;
    while (true) {
        char c = curr();
        check_not_eof("unexpected end of comment block");
        next();
        if (c == '/') {
            if (curr() == '-') {
                next();
                nesting++;
            }
        } else if (c == '-') {
            if (curr() == '/') {
                next();
                nesting--;
                if (nesting == 0)
                    return;
            }
        }
    }
}

char scanner::read_quoted_char(char const * error_msg) {
    lean_assert(curr() == '\\');
    next();
    check_not_eof(error_msg);
    char c = curr();
    if (c != '\\' && c != '\"' && c != 'n' && c != '\'' && c != 'x')
        throw_exception("invalid escape sequence");
    if (c == 'n') {
        return '\n';
    } else if (c == 'x') {
        next();
        char c = curr();
        unsigned v = hex_to_unsigned(c);
        next();
        c = curr();
        v = 16*v + hex_to_unsigned(c);
        return static_cast<char>(v);
    } else {
        return c;
    }
}

/**
==================== Decl =============================================
   Grammar:
      decl : type id ';' 
*/
static TreeDecl p_decl(void) {
   TreeDecl decl = 0; // set null by default
   TokenCode code = curr()->code;
   // body
   TreeType l0type = p_type();
   TreeId l1id = p_id();
   eat(';');
   decl = t_decl_type(l0type, l1id);

   
   return decl;
}

/**
==================== Block ============================================
   Grammar:
      block : '{' decls stmts '}' 
*/
static TreeBlock p_block(void) {
   TreeBlock block = 0; // set null by default
   TokenCode code = curr()->code;
   // body
   eat('{');
   TreeDecls l1decls = p_decls();
   TreeStmts l2stmts = p_stmts();
   eat('}');
   block = t_block_decls(l1decls, l2stmts);

   
   return block;
}

    //
    // Stop all movies
    //
    void StopMovies()
    {
      for (NList<Cineractive>::Iterator curr(&cineractives); *curr; curr++)
      {
        Cineractive *cin = *curr;

        if (cin->moviePrim)
        {
          delete cin->moviePrim;
          cin->moviePrim = NULL;
        }
      }
    }

bool proof_checker::check(proof* p, expr_ref_vector& side_conditions) {
    proof_ref curr(m);
    m_todo.push_back(p);
    
    bool result = true;
    while (result && !m_todo.empty()) {
        curr = m_todo.back();
        m_todo.pop_back();
        result = check1(curr.get(), side_conditions);
        if (!result) {
            IF_VERBOSE(0, ast_ll_pp(verbose_stream() << "Proof check failed\n", m, curr.get()););            
            UNREACHABLE();
        }        

void GR_skigImp::loadDataset(const string &path)
{
    train.push_back(vector< Ptr<Object> >());
    test.push_back(vector< Ptr<Object> >());
    validation.push_back(vector< Ptr<Object> >());

    for (unsigned int i=1; i<=6; ++i)
    {
        char number[2];
        sprintf(number, "%u", i);
        string pathDatasetRgb(path + "subject" + number + "_rgb/");
        string pathDatasetDep(path + "subject" + number + "_dep/");

        vector<string> fileNames;
        getDirList(pathDatasetRgb, fileNames);
        for (vector<string>::iterator it=fileNames.begin(); it!=fileNames.end(); ++it)
        {
            string &file = *it;

            Ptr<GR_skigObj> curr(new GR_skigObj);
            curr->rgb = pathDatasetRgb + file;
            curr->dep = file;
            curr->dep[0] = 'K';
            curr->dep = pathDatasetDep + curr->dep;

            size_t posPerson = file.find("person_");
            size_t posBackground = file.find("backgroud_");
            size_t posIllumination = file.find("illumination_");
            size_t posPose = file.find("pose_");
            size_t posType = file.find("actionType_");
            if (string::npos != posPerson &&
                string::npos != posBackground &&
                string::npos != posIllumination &&
                string::npos != posPose &&
                string::npos != posType)
            {
                curr->person = (unsigned char)atoi( file.substr(posPerson + strlen("person_"), 1).c_str() );
                curr->background = (backgroundType)atoi( file.substr(posBackground + strlen("backgroud_"), 1).c_str() );
                curr->illumination = (illuminationType)atoi( file.substr(posIllumination + strlen("illumination_"), 1).c_str() );
                curr->pose = (poseType)atoi( file.substr(posPose + strlen("pose_"), 1).c_str() );
                curr->type = (actionType)atoi( file.substr(posType + strlen("actionType_"), 2).c_str() );

                train.back().push_back(curr);
            } else
            {
                printf("incorrect file name: %s", file.c_str());
            }
        }
    }
}

  void IpoptData::SetTrialBoundMultipliersFromStep(Number alpha,
      const Vector& delta_z_L,
      const Vector& delta_z_U,
      const Vector& delta_v_L,
      const Vector& delta_v_U)
  {
    DBG_ASSERT(have_prototypes_);

    SmartPtr<IteratesVector> newvec = trial()->MakeNewContainer();
    newvec->create_new_z_L();
    newvec->z_L_NonConst()->AddTwoVectors(1., *curr()->z_L(), alpha, delta_z_L, 0.);

    newvec->create_new_z_U();
    newvec->z_U_NonConst()->AddTwoVectors(1., *curr()->z_U(), alpha, delta_z_U, 0.);

    newvec->create_new_v_L();
    newvec->v_L_NonConst()->AddTwoVectors(1., *curr()->v_L(), alpha, delta_v_L, 0.);

    newvec->create_new_v_U();
    newvec->v_U_NonConst()->AddTwoVectors(1., *curr()->v_U(), alpha, delta_v_U, 0.);

    set_trial(newvec);
  }

void firstAndOthers(const string &line, string &first, string &others)
{ // skip whitespace before first
  string::const_iterator curr(line.begin()), cue(line.end());
  for(; (curr!=cue) && (*curr<=' '); curr++);

  // find the end of first
  string::const_iterator fbeg=curr;
  for(; (curr!=cue) && (*curr>' '); curr++);
  first=string(fbeg, curr);

  // skip the whitespace before others
  for(; (curr!=cue) && (*curr<=' '); curr++);
  others=string(curr, cue);
}

static ssize_t store_charge_property(struct device *dev,
				     struct device_attribute *attr,
				     const char *buf, size_t count)
{
	struct charge_control *control = (struct charge_control*)(attr);
	unsigned int val;

	if (sscanf(buf, "%u", &val) != 1)
		return -EINVAL;

	switch (control->type) {
		case INPUT:
			curr(control->index).input_current_limit = val;
			break;
		case CHARGE:
			curr(control->index).fast_charging_current = val;
			break;
		default:
			break;
	}

	return count;
}

    DiskLoc RocksRecordStore::Iterator::getNext() {
        if ( !_iterator->Valid() ) {
            return DiskLoc();
        }

        DiskLoc toReturn = curr();

        if ( _forward() )
            _iterator->Next();
        else
            _iterator->Prev();

        return toReturn;
    }

 vector<vector<int>> generate(int numRows) {
     if (numRows < 1) { return result; }
     for (int i = 0; i < numRows; ++i) {
         vector<int> curr(1, 1);
         if (i > 0) {
             for (int j = 0; j < result[i - 1].size() - 1; ++j) {
                 curr.push_back(result[i - 1][j] + result[i - 1][j + 1]);
             }
             curr.push_back(1);
         }
         result.push_back(curr);
     }
     return result;
 }

   TemplateTracker::Result TemplateTracker::track(const Img8u &image, 
                                                  const Result *initialResult,
                                                  std::vector<Result> *allResults){
     Result last = initialResult ? *initialResult : data->lastResult;
     if(last.pos == Point32f(-1,-1)){
       last.pos = Point(image.getWidth()/2,image.getHeight()/2); 
     }
     
     const double angle = last.angle;
     const int X = last.pos.x;
     const int Y = last.pos.y;
     const int lutSize = (int)data->lut.size();
     const int angleIndex = angle / (2*M_PI) * (lutSize-1);
     const int ROI = getPropertyValue("tracking.position range");
     const float rotationRange = getPropertyValue("tracking.rotation range");
     const int step1 = getPropertyValue("tracking.coarse steps");
     //const int step2 = getPropertyValue("tracking.fine steps");
     //const float angleStepSize = 360./lutSize;
 
     const Rect roi(X - ROI/2, Y-ROI/2, ROI, ROI);
     
     SmartPtr<const Img8u> roiImageTmp = image.shallowCopy(roi);
     SmartPtr<Img8u> roiImage = roiImageTmp->deepCopyROI();
 
     const int stepRadius = lutSize * rotationRange/720;
 
     Result bestResult = last;
     for(int i = -stepRadius; i <= stepRadius; i+= step1){
       int curIndex = angleIndex + i;
       while(curIndex >= lutSize) curIndex -= lutSize;
       while(curIndex < 0) curIndex += lutSize;
       
       data->prox->apply(roiImage.get(),data->lut.at(curIndex).get(),&data->buf);
       
       Point maxPos;
       float maxValue = data->buf->getMax(0,&maxPos);
     
       Result curr(maxPos+last.pos,
                   (float(curIndex)/lutSize) * 2 * M_PI, 
                   maxValue,
                   data->lut.at(curIndex).get());
       if(curr.proximityValue > bestResult.proximityValue){
         bestResult = curr;
       }
       if(allResults) allResults->push_back(curr);
     }
     data->lastResult = bestResult;
     return bestResult;
   }

	bool poseTracker::newPose(tf::StampedTransform transform){
		
		Eigen::Vector3f curr(transform.getOrigin().x(), transform.getOrigin().y(), transform.getOrigin().z());
		pose.push(curr);
		if(pose.size() < 50){
			return true;
		}

		float squaredNorm = (pose.front() - curr).squaredNorm();
		pose.pop();
		bool tmp = squaredNorm > 0.2;
		std::cout << tmp << "  Max: " << squaredNorm << std::endl;
		return squaredNorm > 0.2;

	}