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

void AseLoader::Process_MESH_FACE_LIST(IN std::vector<D3DXVECTOR3>& pos, OUT std::vector<FVF_PositionNormalTexture>& vertex){	int level = 0;	do 	{		char* aseToken = GetToken();		if (IsEqual(aseToken, "{"))		{			level++;		}		else if (IsEqual(aseToken, "}"))		{			level--;		}		else if (IsEqual(aseToken, ID_MESH_FACE))		{					//			//*MESH_FACE    0:    A : 0 B : 1 C : 2 AB : 1 BC : 1 CA : 1			int index = GetInteger();			GetToken();			int a = GetInteger();			GetToken();			int b = GetInteger();			GetToken();			int c = GetInteger();			vertex[index * 3 + 0].pos = pos[a];			vertex[index * 3 + 1].pos = pos[c];			vertex[index * 3 + 2].pos = pos[b];		}	} while (level > 0);}

bool CGlobalVars::info_single_limper(){	/*	*  return true if there is a single limper	* Example:	*  -true: I'm Bigblind, SB fold and other player limped	*  -true: I'm Bigblind, SB limped and the rest fold	*/	if (br==1)	{		if(SB)		{			//SB posted (2*bblind+1*sblind)			if(IsEqual(get_potplayer(), (get_sblind() + get_bblind() + get_bblind())))				return true;			if(set_preflop_position() == 2 && IsEqual(get_potplayer(), (get_bblind() + get_bblind())))				return true;		}		else		{			//no SB (2*bblind)			if(IsEqual(get_potplayer(), get_bblind() + get_bblind()))				return true;		}	}	return false;}

bool IsEqual(const pvdb::ConceptMap& lhs, const pvdb::ConceptMap& rhs){  //Compare nodes  {    const std::vector<boost::shared_ptr<const pvdb::Node> > lhs_nodes = lhs.GetNodes();    const std::vector<boost::shared_ptr<const pvdb::Node> > rhs_nodes = rhs.GetNodes();    if (lhs_nodes.size() != rhs_nodes.size()) return false;    const int n_nodes = static_cast<int>(lhs_nodes.size());    for (int i=0; i!=n_nodes; ++i)    {      if (!IsEqual(*lhs_nodes[i],*rhs_nodes[i])) return false;    }  }  //Compare edges  {    const std::vector<boost::shared_ptr<const pvdb::Edge> > lhs_edges = lhs.GetEdges();    const std::vector<boost::shared_ptr<const pvdb::Edge> > rhs_edges = rhs.GetEdges();    if (lhs_edges.size() != rhs_edges.size()) return false;    const int n_edges = static_cast<int>(lhs_edges.size());    for (int i=0; i!=n_edges; ++i)    {      if (!IsEqual(*lhs_edges[i],*rhs_edges[i])) return false;    }  }  return true;}

void PCFPipesMgr::CombinationPipe(AcGePoint3d &Pt1,AcGePoint3d &Pt2){	PCFPipe *pPipe = NULL;	PCFPipe *pPipe1 = NULL;	PCFPipe *pPipe2 = NULL;	IteratorPtr<PCFPipe> PipeitPtr(CreateIt());	for(PipeitPtr->Fist();!PipeitPtr->IsDone();PipeitPtr->Next())	{		pPipe = &PipeitPtr->CurrentItem();		ASSERT(pPipe != NULL);		if(IsEqual(pPipe->EndPt(),Pt1))		{			pPipe1 = pPipe;		}		if(IsEqual(pPipe->StartPt(),Pt2))		{			pPipe2 = pPipe;		}	}	if(pPipe1!=NULL&&pPipe2!=NULL)	{		pPipe1->EndPt(pPipe2->EndPt());		Del(pPipe2->GetKey());	}}

void cAseLoader::ProcessMESH_TFACELIST( IN std::vector<D3DXVECTOR2>& vecVT, 	OUT std::vector<ST_PNT_VERTEX>& vecVertex ){	int nLevel = 0;	do 	{		char* szToken = GetToken();		if(IsEqual(szToken, "{"))		{			++nLevel;		}		else if(IsEqual(szToken, "}"))		{			--nLevel;		}		else if(IsEqual(szToken, ID_MESH_TFACE))		{			int nFaceIndex = GetInteger();			int nA = GetInteger();			int nB = GetInteger();			int nC = GetInteger();			vecVertex[nFaceIndex * 3 + 0].t = vecVT[nA];			vecVertex[nFaceIndex * 3 + 1].t = vecVT[nC];			vecVertex[nFaceIndex * 3 + 2].t = vecVT[nB];		}	} while (nLevel > 0);}

BOOL IsEqual(CERTIFICATENAMES& n1, CERTIFICATENAMES&n2)	{	if (n1.flags != n2.flags)		return FALSE;	if (n1.flags & CERTIFICATENAME_DIGEST)		{		if (memcmp(&n1.digest, &n2.digest, sizeof(n1.digest)) != 0)			return FALSE;		}	if (n1.flags & CERTIFICATENAME_ISSUERSERIAL)		{		if (!IsEqual(n1.issuerSerial.issuerName, n2.issuerSerial.issuerName))			return FALSE;		if (!IsEqual(n1.issuerSerial.serialNumber, n2.issuerSerial.serialNumber))			return FALSE;		}	if (n1.flags & CERTIFICATENAME_SUBJECT)		{		if (!IsEqual(n1.subject, n2.subject))			return FALSE;		}	if (n1.flags & CERTIFICATENAME_ISSUER)		{		if (!IsEqual(n1.issuer, n2.issuer))			return FALSE;		}	return TRUE;	}

double CTableLimits::GuessSmallBlindFromBigBlind(){	write_log(3, "CTableLimits::GuessSmallBlindFromBigBlind()/n");	// Special case: 0.02/0.05/0.10	if (IsEqual(tablelimit_unreliable_input.bblind, 0.05))	{		return 0.02;	}	// Special case: 0.05/0.15/0.30	if (IsEqual(tablelimit_unreliable_input.bblind, 0.15))	{		return 0.05;	}	// Special case: 0.10/0.25/0.50	if (IsEqual(tablelimit_unreliable_input.bblind, 0.25))	{		return 0.10;	}	// Special case: 0.02/0.05	if (IsEqual(tablelimit_unreliable_input.bblind, 0.05))	{		return 0.02;	}	return (tablelimit_unreliable_input.bblind / 2);}

list search_and_destroy(element e, list l){	list r = l;	if (l == NULL)		return NULL;	if (detect(e, l) == false)		return l;	list tmp = l;	if (IsEqual(head(l), e) == true)	{		l = DelFirst(l);		return l;	}	while (llenght(l) != 1)	{		if (IsEqual(head(tail(l)), e) == true)		{			DeleteElement(l->next->value);			tmp = l->next;			l->next = l->next->next;			free(tmp);			return r;		}		l = tail(l);	}	return NULL;}

void Room::reorderWalls(){	int index;	std::vector<MazeWall>::iterator it;	MazeWall tempMaze;	double tmpX =  walls[0].To_X;	double tmpY = walls[0].To_Y;	for(unsigned int i = 0; i < walls.size();i++)	{		index = getWallIndex(i + 1, tmpX ,tmpY);		if(IsEqual(tmpX, walls[index].To_X) &&  IsEqual(tmpY,walls[index].To_Y))		{			tmpX =  walls[index].From_X;			tmpY = walls[index].From_Y;		}		else		{			tmpX =  walls[index].To_X;			tmpY = walls[index].To_Y;		}		it = walls.begin();		if(index > -1)		{			tempMaze = walls[index];			walls.erase(it + index);			walls.insert(it + i + 1,tempMaze);		}	}}

int CGlobalVars::first_limper(){	/*	*  	*/	//Check UTG...BT	for(int i=3; i < k_MaxChairs; i++)	{		for(int j=0; j < k_MaxChairs; j++)		{			if(IsEqual(currentbets[j], get_bblind()) && (get_ac_dealpos(j) == i))				return j;		}	}	//Check SB	for(int i=0; i < k_MaxChairs; i++)	{		if(IsEqual(currentbets[i], get_bblind()) && (get_ac_dealpos(i) == 1))			return i;	}	return -1;}

cFrame* cAseLoader::Load( char* szFullPath ){	fopen_s(&m_fp, szFullPath, "r");	while(char* szToken = GetToken())	{		if(IsEqual(szToken, ID_SCENE))		{			SkipBlock();		}		else if(IsEqual(szToken, ID_MATERIAL_LIST))		{			ProcessMATERIAL_LIST();		}		else if(IsEqual(szToken, ID_GEOMETRY))		{			cFrame* pFrame = ProcessGEOMOBJECT();			m_mapFrame[pFrame->GetFrameName()] = pFrame;			if(m_pRoot == NULL)				m_pRoot = pFrame;		}	}			fclose(m_fp);	if(m_pRoot)		m_pRoot->SetOriginLocalTM(NULL);	return m_pRoot;}

bool CMesh::IntersectSegments(CVector<2> const &vA0, CVector<2> const &vA1, CVector<2> const &vB0, CVector<2> const &vB1, float &fTA, float &fTB){  CVector<2> vA, vB, vBP, vAP, vD;  float fD;  vA = vA1 - vA0;  vB = vB1 - vB0;  vAP = vA.Perpendicular2D();  vBP = vB.Perpendicular2D();  fD = vA % vBP;  if (IsEqual(fD, 0)) // Colinear or one of the vectors is 0, so we return no intersection    return false;  vD = vB0 - vA0;  fTA = (vD % vBP) / fD;  if (fTA < 0 || fTA > 1)    return false;  fTB = (vD % vAP) / fD;  if (fTB < 0 || fTB > 1)    return false;  ASSERT(IsEqual(((vB0 + fTB * vB) - (vA0 + fTA * vA)).Length(), 0));  return true;}

	ERMsg COGRBaseOption::ProcessOption(int& i, int argc, char* argv[])	{		ERMsg msg;		string error;		if (IsUsed(BASE_OPTIONS) && IsEqual(argv[i], "--utility_version"))		{			m_bVersion = true;		}		else if (IsUsed(BASE_OPTIONS) && IsEqual(argv[i], "-co") && i < argc - 1)		{			m_createOptions.push_back(argv[++i]);		}		else if (IsUsed(BASE_OPTIONS) && IsEqual(argv[i], "-of") && i < argc - 1)		{			m_format = argv[++i];		}		else if (IsUsed(BASE_OPTIONS) && IsEqual(argv[i], "-wo") && i < argc - 1)//working option		{			//UNIFIED_SRC_NODATA			m_workOptions.push_back(argv[++i]);		}		else if (IsUsed(BASE_OPTIONS) && IsEqual(argv[i], "-multi"))		{			m_bMulti = true;		}		else if (IsUsed(BASE_OPTIONS) && IsEqual(argv[i], "-f") && i < argc - 1)		{			m_format = argv[i + 1];		}		else if (IsUsed(BASE_OPTIONS) && IsEqual(argv[i], "-overwrite"))		{			m_bOverwrite = true;		}		else if (IsUsed(BASE_OPTIONS) && IsEqual(argv[i], "-q"))		{			m_bQuiet = true;		}		else if (IsEqual(argv[i], "-?") || IsEqual(argv[i], "-help"))		{			m_bNeedHelp = true;		}		else if (argv[i][0] == '-')		{			error = string("ERROR: Invalid option: ") + argv[i] + ", use - ? for more help./n";			msg.ajoute(error);			//return false;		}		else		{			m_filesPath.push_back(argv[i]);		}		return msg;	}

void PlayerHpBar::SetOffset(const std::string &target, Vector2f offset){	if (IsEqual(target.c_str(), "avatar"))	{		m_avatarOffset = offset;	}	else if (IsEqual(target.c_str(), "bar"))	{		m_barOffset = offset;	}}

int TranslateSeriesStatusFrom(const std::wstring& value) {  if (IsEqual(value, L"Currently Airing")) {    return anime::kAiring;  } else if (IsEqual(value, L"Finished Airing")) {    return anime::kFinishedAiring;  } else if (IsEqual(value, L"Not Yet Aired")) {    return anime::kNotYetAired;  }  LOG(LevelWarning, L"Unknown value: " + value);  return anime::kUnknownStatus;}

LRESULT AnimeDialog::OnNotify(int idCtrl, LPNMHDR pnmh) {  switch (idCtrl) {    case IDC_LINK_NOWPLAYING: {      switch (pnmh->code) {        // Link click        case NM_CLICK: {          PNMLINK pNMLink = reinterpret_cast<PNMLINK>(pnmh);          wstring action = pNMLink->item.szUrl;          if (IsEqual(pNMLink->item.szID, L"menu")) {            action = UI.Menus.Show(m_hWindow, 0, 0, pNMLink->item.szUrl);          } else if (IsEqual(pNMLink->item.szID, L"search")) {            action = L"SearchAnime(" + CurrentEpisode.title + L")";          } else if (IsEqual(pNMLink->item.szUrl, L"score")) {            action = L"";            CurrentEpisode.anime_id = ToInt(pNMLink->item.szID);            auto anime_item = AnimeDatabase.FindItem(CurrentEpisode.anime_id);            if (anime_item) {              anime_item->AddtoUserList();              auto synonyms = anime_item->GetUserSynonyms();              synonyms.push_back(CurrentEpisode.title);              anime_item->SetUserSynonyms(synonyms);              Meow.UpdateCleanTitles(anime_item->GetId());              Settings.Save();              anime_item->StartWatching(CurrentEpisode);              MainDialog.ChangeStatus();            }          }          ExecuteAction(action, 0, GetCurrentId());          return TRUE;        }        // Custom draw        case NM_CUSTOMDRAW: {          return CDRF_DODEFAULT;        }      }      break;    }    case IDC_TAB_ANIME: {      switch (pnmh->code) {        // Tab select        case TCN_SELCHANGE: {          SetCurrentPage(tab_.GetCurrentlySelected() + 1);          break;        }      }      break;    }  }    return 0;}

	ERMsg COGRBaseOption::ParseOption(int argc, char* argv[])	{		ERMsg msg;		// Must process GDAL_SKIP before GDALAllRegister(), but we can't call 		// GDALGeneralCmdLineProcessor before it needs the drivers to be registered 		// for the --format or --formats options 		for (int i = 1; i < argc; i++)		{			if (IsEqual(argv[i], "--config") && i + 2 < argc && IsEqual(argv[i + 1], "GDAL_SKIP"))			{				CPLSetConfigOption(argv[i + 1], argv[i + 2]);				i += 2;			}		}		// -------------------------------------------------------------------- 		//      Register standard GDAL drivers, and process generic GDAL        		//      command options.                                                		// -------------------------------------------------------------------- 		OGRRegisterAll();		argc = OGRGeneralCmdLineProcessor(argc, &argv, 0);		if (argc < 1)			exit(-argc);		// -------------------------------------------------------------------- 		//      Parse arguments.                                                		// -------------------------------------------------------------------- 		for (int i = 1; i < argc; i++)		{			msg += ProcessOption(i, argc, argv);		}		if (m_bVersion)		{			string error = Format("%s was compiled against GDAL %s and is running against GDAL %s/n",				argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));			msg.ajoute(error);			//return msg;		}		if (m_bNeedHelp)		{			msg.ajoute(GetUsage());			msg.ajoute(GetHelp());			//return msg;		}		return msg;	}

/** * Virtual function to calculate a point for this fucntion. * @param x (input) x input value for this function. * @return Y value corresponding to the x input. */TMathResultTrigFunction::CalculateY(	double x,	double *y){	TMathResult status = MATH_SUCCESS;	double result = 0;	double angle = x;	if(GetAngleMode() == MATH_ANGLES_IN_DEGREES)	{		angle = DegreesToRadians(x);	}	switch(GetOperatorType())	{	case MATH_SIN:		result = sin(angle);		break;	case MATH_COS:		result = cos(angle);		break;	case MATH_TAN:		result = tan(angle);		break;	case MATH_COT:		result = tan(angle);		if(!IsEqual(result, 0))			result = 1/result;		else			status = MATH_UNDEFINED;		break;	case MATH_SEC:		result = cos(angle);		if(!IsEqual(result, 0))			result = 1/result;		else			status = MATH_UNDEFINED;		break;	case MATH_CSC:		result = sin(angle);		if(!IsEqual(result, 0))			result = 1/result;		else			status = MATH_UNDEFINED;		break;	}	if(status == MATH_SUCCESS)		*y = result;	return status;}

uint ButtonComponent::GetStyleIndex(const std::string& style){	if (IsEqual(style.c_str(), "deep_on_click"))	{		return DEEP_ON_CLICK;	}	else if (IsEqual(style.c_str(), "deep_on_focus"))	{		return DEEP_ON_FOCUS;	}	assert(nullptr);	return 100;}