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

bool CTrackedNodeMgr::LinkNodes( HTRACKEDNODE ChildID, HTRACKEDNODE ParentID ){	//make sure the nodes are valid	if(!CheckValidity(ChildID) || !CheckValidity(ParentID))		return false;	ParentID->m_pChild = ChildID;	return true;}

int CWavFile::IsCanCombine(CString strPathL, CString strPathR){	BOOL b = FALSE;	DWORD m_dwDataSizeL = 0;	DWORD m_dwDataSizeR = 0;	memset(&m_formatL, 0, sizeof(WAVEFORMATEX));	memset(&m_formatR, 0, sizeof(WAVEFORMATEX));	ZeroMemory(&m_mmckinfoParent, sizeof(MMCKINFO));	ZeroMemory(&m_mmckinfoSubChunk, sizeof(MMCKINFO));		// Check Validity of the first(left channel) file	m_dwDataSizeL = CheckValidity(m_hWaveFileL, strPathL, m_formatL);	if(m_dwDataSizeL == -1)	{		MyMessageBox(_T("Invalid wave file: ") + strPathL, eERR_ERROR);		return -1;	}	// Check Validity of the second(right channel) file	m_dwDataSizeR = CheckValidity(m_hWaveFileR, strPathR, m_formatR);	if(m_dwDataSizeR == -1)	{		MyMessageBox(_T("Invalid wave file: ") + strPathR, eERR_ERROR);		return -1;	}	// All of them must be mono wave file	if(!(m_formatL.nChannels == 1))	{		MyMessageBox(_T("Not a mono wave file: ") + strPathL, eERR_ERROR);		return -1;	}	if(!(m_formatR.nChannels == 1))	{		MyMessageBox(_T("Not a mono wave file: ") + strPathR, eERR_ERROR);		return -1;	}	// They must have the same bps	if(!(m_formatL.wBitsPerSample == m_formatR.wBitsPerSample))	{		MyMessageBox(_T("They must have the same bps"), eERR_ERROR);		return -1;	}	// They must have the same sps	if(m_formatL.nSamplesPerSec != m_formatR.nSamplesPerSec)	{		MyMessageBox(_T("They must have the same sps"), eERR_ERROR);		return -1;	}	return max(m_dwDataSizeL, m_dwDataSizeR);}

bool CTrackedNodeMgr::LinkNodeOrientation(	HTRACKEDNODE ID,											HTRACKEDNODE CopyFrom ){	//check the params and parent object	if(!CheckValidity(ID) || !CheckValidity(CopyFrom))		return false;	//ok, setup the link pointer	ID->m_pMimicNode = CopyFrom;	//success	return true;}

GridDefinition::GridDefinition(const float xRange[2], const float yRange[2], float pRadius, float pSpacing)	: xMin(xRange[0]), xMax(xRange[1]), yMin(yRange[0]), yMax(yRange[1]), radius(pRadius), spacing(pSpacing), recipSpacing(1.0/spacing){	numX = (xMax - xMin >= MinRange && spacing >= MinSpacing) ? (uint32_t)((xMax - xMin) * recipSpacing) + 1 : 0;	numY = (yMax - yMin >= MinRange && spacing >= MinSpacing) ? (uint32_t)((yMax - yMin) * recipSpacing) + 1 : 0;	CheckValidity();}

/********************************************************************  Savcor IT Oy/JLM  Borland TURBO C++ 3.0  Declaration: Parse received message  Call: ret=ParseMessage(ReceiveBuffer)  Input:  char *ReceiveBuffer  Returns:  char *ret  01.12.2000 Initial coding  JLM*********************************************************************/ void ParseMessage(char *OutMes)  {  int i;  int j=0;  char token[BUFFER_SIZE];  strcpy(OutMes,"");  strcpy(tempbuf,"");  for (i=1;i<(int)strlen(Message);i++)    {		    if (IsAlpha(Message[i]) && ( i < ((int)strlen(Message)-1)))      token[j++]=Message[i];    else      {       if (j>0)        {          token[j]=0;  // end of string          strcpy(tempbuf,"");				          CheckValidity(token);           if ( (!DispWithoutLabels) && (strlen(tempbuf)>0))          {           strcat(OutMes,token);           strcat(OutMes,"=");          }          strcat(OutMes,tempbuf);					//printf ("OutMes=%s/n",OutMes);        }       j=0;			} // else    }  }

bool CTrackedNodeMgr::IsLookingAtTarget( HTRACKEDNODE ID){	if(!CheckValidity(ID))		return false;	return ID->m_bLookingAtTarget;}

bool CSettingString::SetValue(const std::string &value){  CSingleLock lock(m_critical);  if (value == m_value)    return true;      if (!CheckValidity(value))    return false;  std::string oldValue = m_value;  m_value = value;  if (!OnSettingChanging(this))  {    m_value = oldValue;    // the setting couldn't be changed because one of the    // callback handlers failed the OnSettingChanging()    // callback so we need to let all the callback handlers    // know that the setting hasn't changed    OnSettingChanging(this);    return false;  }  m_changed = m_value != m_default;  OnSettingChanged(this);  return true;}

bool CTrackedNodeMgr::SetTarget( HTRACKEDNODE ID, HOBJECT hModel, HMODELNODE hNode, const LTVector& vOffset ){	if(!CheckValidity(ID))		return false;	//make sure that the model pointed to is not ourself, this can cause infinite	//recursion	assert(hModel != ID->m_hModel);	//make sure that that is actually a valid model	uint32 nType;	if(m_pILTBase->Common()->GetObjectType(hModel, &nType) != LT_OK)		return false;	if(nType != OT_MODEL)		return false;	//make sure we have a valid node	if(hNode == INVALID_MODEL_NODE)		return false;	//setup this target	ID->m_eTrackMode	= CTrackedNode::TRACK_NODE;	ID->m_hTrackObject	= hModel;	ID->m_hTrackNode	= hNode;	ID->m_vTrackOffset	= vOffset;	//success	return true;}

bool CSettingNumber::SetValue(double value){  CExclusiveLock lock(m_critical);  if (value == m_value)    return true;  if (!CheckValidity(value))    return false;  double oldValue = m_value;  m_value = value;  if (!OnSettingChanging(this))  {    m_value = oldValue;    // the setting couldn't be changed because one of the    // callback handlers failed the OnSettingChanging()    // callback so we need to let all the callback handlers    // know that the setting hasn't changed    OnSettingChanging(this);    return false;  }  m_changed = m_value != m_default;  OnSettingChanged(this);  return true;}

bool CTrackedNodeMgr::IsAtDiscomfort( HTRACKEDNODE ID){	if(!CheckValidity(ID))		return false;	return ID->m_bInDiscomfort;}

bool CTrackedNodeMgr::IsTracking( HTRACKEDNODE ID ){	if(!CheckValidity(ID))		return false;	return ID->m_bEnabled;}

bool CTrackedNodeMgr::IsAtLimit( HTRACKEDNODE ID ){	if(!CheckValidity(ID))		return false;	return ID->m_bAtMaxThreshold;}

//m_month setter w/ error checkingvoid cDate::SetMonth(uint8_t month){	if (month <= 12 && month != 0)	{		m_month = month;		CheckValidity();	}}

bool CSettingInt::CheckValidity(const std::string &value) const{  int iValue;  if (!fromString(value, iValue))    return false;  return CheckValidity(iValue);}

bool CTrackedNodeMgr::SetOrientOnAnim( HTRACKEDNODE ID, bool bTrackOnAnim ){	if(!CheckValidity(ID))		return false;	//just set the flag on the node	ID->m_bOrientFromAnim = bTrackOnAnim;	return true;}

bool CTrackedNodeMgr::SetIgnoreParentAnimation( HTRACKEDNODE ID, bool bIgnoreParentAnimation ){	if(!CheckValidity(ID))		return false;	//just set the flag on the node	ID->m_bIgnoreParentAnimation = bIgnoreParentAnimation;	return true;}

nsresultnsIConstraintValidation::CheckValidity(bool* aValidity){  NS_ENSURE_ARG_POINTER(aValidity);  *aValidity = CheckValidity();  return NS_OK;}

bool CTrackedNodeMgr::SetAutoDisable( HTRACKEDNODE ID, bool bAutoDisable ){	if(!CheckValidity(ID))		return false;	//just set the flag on the node	ID->m_bAutoDisable = bAutoDisable;	return true;}

bool CTrackedNodeMgr::SetTargetObject( HTRACKEDNODE ID, const LTVector& vPosition ){	if(!CheckValidity(ID))		return false;	//setup this target	ID->m_eTrackMode	= CTrackedNode::TRACK_OBJSPACEPOS;	ID->m_vTrackOffset	= vPosition;	return true;}

Trajectory PlanningProblem::RRT_APF_Solve(const ObstacleSet &ob_set,                                           Trajectory &prior_plan,                                           bool stop_when_collid){    Trajectory *temp_trajec = new Trajectory();    temp_trajec->appendState(initialState);    for(int step = 1; step <= MAX_APF_STEP_TRY; step++) {        // check reaching the goal state        Station current_station = temp_trajec->getLastStation();        if( (goal.minDistTo(current_station) < agent->radius() * 1) )        {            temp_trajec->appendState(goal.goal_point);            planningResult = true;            break;        }        Vector2D total_force;        if( !pathHasCollision(current_station, goal.goal_point, ob_set) ) {//            temp_trajec->appendState(goal.goal_point);//            planningResult = true;//            break;            total_force += GoalAttractiveForce(current_station);        }//        else        {            Station next_goal = getNextStation(current_station, prior_plan);            total_force += PathDirectedForce(current_station, prior_plan);            vector<Vector2D> ob_forces = ObstacleForces(current_station, ob_set);            Vector2D ob_total_force;            for(uint i=0; i<ob_forces.size(); i++)  {                ob_total_force += ob_forces[i];            }            if(!pathHasCollision(current_station, next_goal, ob_set)) {                ob_total_force *= 0.2;            }            total_force += ob_total_force;        }        Station new_station;        new_station = agent->step(current_station,                                  (total_force.normalized()).to3D(),                                  0.080 /*sec*/);        temp_trajec->appendState(new_station);        if(stop_when_collid) {            if( !CheckValidity(new_station) ) {                planningResult = false;                break;            }        }    }    return *temp_trajec;}

Station PlanningProblem::SampleStateUniform(){    Station sampled_station;    for(int i=0; i < MAX_SAMPLING_TRY; ++i)    {        Vector3D rand_pos = actualBound->getUniformSample();        sampled_station.setPosition(rand_pos);        if(CheckValidity(sampled_station))            return sampled_station;    }    return Station();}

bool CTrackedNodeMgr::TargetAnimation( HTRACKEDNODE ID, const LTVector& vOffset ){	if(!CheckValidity(ID))		return false;	//setup the target	ID->m_eTrackMode	= CTrackedNode::TRACK_ANIMATION;	ID->m_vTrackOffset	= vOffset;	//success	return true;}

// Read the grid parameters from a string returning true if successbool GridDefinition::ReadParameters(const StringRef& s){	bool ok = (sscanf(s.Pointer(), "%f,%f,%f,%f,%f,%f,%lu,%lu", &xMin, &xMax, &yMin, &yMax, &radius, &spacing, &numX, &numY) == 8);	if (ok)	{		CheckValidity();		recipSpacing = 1.0 / spacing;	}	else	{		isValid = false;	}	return ok;}

/* Function definition */int * GenerateInitPopulation(unsigned int** dMat){  int i, city;  int *initialPopulation = (int *)malloc(sizeof(int) * NUM_CITIES * NUM_CITIES) ;  for(city ; city < NUM_CITIES; city++)  {     GenerateTour(city + 1, &initialPopulation[city  * NUM_CITIES], dMat);     CheckValidity(&initialPopulation[city  * NUM_CITIES] , "init");  }  return initialPopulation;}

bool CTrackedNodeMgr::GetOrientationSpace( HTRACKEDNODE ID,	LTVector& vRight, 											LTVector& vUp, 											LTVector& vForward){	if(!CheckValidity(ID))		return false;	//read in the vectors	LTMatrix mTargetTransform = ID->m_mInvTargetTransform;	mTargetTransform.Transpose();	mTargetTransform.GetBasisVectors(&vRight, &vUp, &vForward);	return true;}

bool CTrackedNodeMgr::GetBasisSpace( HTRACKEDNODE ID,	LTVector& vRight, 														LTVector& vUp, 														LTVector& vForward,														LTVector& vPos){	if(!CheckValidity(ID))		return false;	vRight		= ID->m_vActualRight;	vUp			= ID->m_vActualUp;	vForward	= ID->m_vActualForward;	vPos		= ID->m_vActualPos;	return true;}