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

int Scene::Tick(int* currFunction, int* currTask) {  if(IsDone())    return (int)SUCCES;  if(stack.empty())      return (int)FAILURE;  // Go to stack and execute last entry if not null-pointer. If null-pointer, remove and take next. If stack is empty, return false.  while(functions[stack.back().x][stack.back().y] == UNDEFINED) { // Find entry which is not undefined    stack.pop_back();    if(stack.empty())      return FAILURE; // No more commmands. We already checked if we solved the task, so we return FAILURE  }    *currFunction = stack.back().x;  *currTask = stack.back().y;  // Execute function  int returnValue = CallFunc(functions[stack.back().x][stack.back().y]);  // (x, y+1) into stack.  stack.back().y++;  // If return is not -1, put (return, 0) into stack;  if(returnValue != -1)    stack.push_back((Pos){returnValue, 0});  return (int)NOT_DONE;}

CVariant CKadOperation::AddLoadRes(const CVariant& LoadRes, CKadNode* pNode){	SOpProgress* pProgress = GetProgress(pNode);	CVariant FilteredRes = LoadRes.Clone(false); // Make a Shellow Copy	const CVariant& LoadedList = LoadRes["RES"];	CVariant FilteredList;	for(uint32 i=0; i < LoadedList.Count(); i++)	{		CVariant Loaded = LoadedList.At(i).Clone(false); // Make a Shellow Copy		const CVariant& XID = Loaded["XID"];		// Counting		if(pProgress) // might be NULL if we filter our own index response right now		{			SOpStatus &Status = pProgress->Loads[XID];			Status.Results++;			if(!Loaded.Get("MORE"))				Status.Done = true; // this marks that no more results are to be expected form this node		}		SOpStatus* pStatus = &m_LoadMap[XID].Status;		pStatus->Results++;		if(!pStatus->Done)			pStatus->Done = IsDone(SOpProgress::GetLoads, XID);				if(!pStatus->Done)			Loaded.Insert("MORE", true);		else			Loaded.Remove("MORE");		//		if(Loaded.Has("ERR"))		{			FilteredList.Append(Loaded);			continue;		}		// Filtering		CVariant UniquePayloads;		const CVariant& Payloads = Loaded["PLD"];		for(uint32 j=0; j < Payloads.Count(); j++)		{			const CVariant& Payload = Payloads.At(j);			if(m_LoadFilter[XID].insert(Payload["DATA"].GetFP()).second)				UniquePayloads.Append(Payload);		}		// Note: we must add this even if UniquePayloads is empty or else we will misscount replys		CVariant NewLoaded;		NewLoaded["XID"] = XID;		NewLoaded["PLD"] = UniquePayloads;		FilteredList.Append(NewLoaded);		//	}	FilteredRes.Insert("RES", FilteredList);	return FilteredRes;}

void CLoadLTADlg::OnTimer(UINT nIDEvent) {	CEdit* pEdit = ((CEdit*)GetDlgItem(IDC_LOADLOG));	pEdit->SetSel(-1, 0, TRUE);	if(nIDEvent == TIMER_ID)	{		BOOL bDone = IsDone();		//see if we need to update the load log		//(the check is done so that when it is running, we don't refresh it		//continually)		if(m_bPrevLoaderDone == FALSE)		{			UpdateLoadLog();		}		//see if the finishing state has finished at all		if(bDone != m_bPrevLoaderDone)		{			((CButton*)GetDlgItem(IDC_SAVELOADLOG))->EnableWindow(bDone);			((CButton*)GetDlgItem(IDOK))->EnableWindow(bDone);			m_bPrevLoaderDone = bDone;		}		// automatically close the dialog on load completion		if( m_bAutoConfirm && bDone && m_bPrevLoaderDone )		{			OnOK();		}	}		CDialog::OnTimer(nIDEvent);}

//------------------------------------------------------------voidnsFilteredContentIterator::Last(){  if (!mCurrentIterator) {    NS_ERROR("Missing iterator!");    return;  }  // If we are switching directions then  // we need to switch how we process the nodes  if (mDirection != eBackward) {    mCurrentIterator = mIterator;    mDirection       = eBackward;    mIsOutOfRange    = false;  }  mCurrentIterator->Last();  if (mCurrentIterator->IsDone()) {    return;  }  nsINode *currentNode = mCurrentIterator->GetCurrentNode();  nsCOMPtr<nsIDOMNode> node(do_QueryInterface(currentNode));  bool didCross;  CheckAdvNode(node, didCross, eBackward);}

voidnsFilteredContentIterator::Prev(){  if (mIsOutOfRange || !mCurrentIterator) {    NS_ASSERTION(mCurrentIterator, "Missing iterator!");    return;  }  // If we are switching directions then  // we need to switch how we process the nodes  if (mDirection != eBackward) {    nsresult rv = SwitchDirections(false);    if (NS_FAILED(rv)) {      return;    }  }  mCurrentIterator->Prev();  if (mCurrentIterator->IsDone()) {    return;  }  // If we can't get the current node then   // don't check to see if we can skip it  nsINode *currentNode = mCurrentIterator->GetCurrentNode();  nsCOMPtr<nsIDOMNode> node(do_QueryInterface(currentNode));  CheckAdvNode(node, mDidSkip, eBackward);}

PyObject *pyllbc_PackLemma_Top::Read(pyllbc_Stream *stream){    if (UNLIKELY(!IsDone()))    {        pyllbc_SetError("top-lemma not done, could not unpack data");        return NULL;    }    size_t idx = 0;    PyObject *values = PyTuple_New(_lemmas.size());    for (; idx < _lemmas.size(); idx++)    {        PyObject *value;        Base *lemma = _lemmas[idx];        if (!(value = lemma->Read(stream)))            break;        PyTuple_SET_ITEM(values, idx, value);    }    if (idx != _lemmas.size())    {        Py_DECREF(values);        values = NULL;    }    return values;}

HRESULTSoundD3D::Play(){	if (IsPlaying())  return S_OK;	if (!buffer)      return E_FAIL;	HRESULT hr = E_FAIL;	if (IsDone())	hr = Rewind();	if (IsReady()) {		if (moved)		Localize();		if (flags & LOOP || flags & STREAMED)		hr = buffer->Play(0, 0, DSBPLAY_LOOPING);		else		hr = buffer->Play(0, 0, 0);		if (SUCCEEDED(hr))		status = PLAYING;	}	return hr;}

bool CLIENTFX_INSTANCE::IsFinished(){	if (IsDone()) 		return true;	CLinkListNode<FX_LINK>	*pActiveNode = m_collActiveFX.GetHead();	CBaseFX	*pFX = LTNULL;	while (pActiveNode)	{		pFX = pActiveNode->m_Data.m_pFX;		// Check for expiration		if( pFX ) 		{							//determine if this effect has expired			bool bExpired = ((pFX->GetElapsed() >= pFX->GetEndTime()) || pFX->IsShuttingDown()) && 							 (pFX->IsFinishedShuttingDown() || !pActiveNode->m_Data.m_pRef->m_bSmoothShutdown);						if (!bExpired) 				return false;		}		pActiveNode = pActiveNode->m_pNext;	}	return true;}

void BattleAnimation::DrawAt(int x, int y) {	if (!sprite) return; // Initialization failed	if (IsDone()) return;	const RPG::AnimationFrame& anim_frame = animation.frames[frame];	std::vector<RPG::AnimationCellData>::const_iterator it;	for (it = anim_frame.cells.begin(); it != anim_frame.cells.end(); ++it) {		const RPG::AnimationCellData& cell = *it;		if (!cell.valid) {			// Skip unused cells (they are created by deleting cells in the			// animation editor, resulting in gaps)			continue;		}		sprite->SetX(cell.x + x);		sprite->SetY(cell.y + y);		int sx = cell.cell_id % 5;		int sy = cell.cell_id / 5;		int size = large ? 128 : 96;		sprite->SetSrcRect(Rect(sx * size, sy * size, size, size));		sprite->SetOx(size / 2);		sprite->SetOy(size / 2);		sprite->SetTone(Tone(cell.tone_red * 128 / 100,			cell.tone_green * 128 / 100,			cell.tone_blue * 128 / 100,			cell.tone_gray * 128 / 100));		sprite->SetOpacity(255 * (100 - cell.transparency) / 100);		sprite->SetZoomX(cell.zoom / 100.0);		sprite->SetZoomY(cell.zoom / 100.0);		sprite->Draw();	}}

const LLBC_String &pyllbc_PackLemma::ToString() const{    if (!IsDone())        return _emptyStr;    return _str;}

    void Environment::Run(const int n_steps)    {      int t;      unsigned int i;      for(i = 0; i < agents.size(); i++)	{	  agents[i]->SetPerformance(0);	}      UpdateDisplays();      if(delay)	{	  sleep(delay);	}      for(t = 0; t < n_steps; t++)	{	  if(IsDone())	    {	      return;	    }	  Step();	  if(delay)	    {	      sleep(delay);	    }	}    }

void T_SimpleListIterator<Item>::Next() {	NAssert(!IsDone()) ;	if (_reverse) {		_current=_current->prev ;	} else {		_current=_current->next ;	}}

		const char& String::StringIterator::CurrentItem() const		{			if (IsDone()) {				throw IteratorOutOfBoundException();			}			return (_string->operator[](_current));		}

void CLoadLTADlg::OnCancel() {	//don't let them quit while the thread is running	if(IsDone() == FALSE)		return;		CDialog::OnCancel();}

Item MyListIterator<Item>::CurrentItem() const{    if(IsDone())    {        throw IteratorOutOfBounds;    }    return _list->Get(_current);}

	virtual ~FXmppMessageReceiveTask()	{		// task shouldn't really be deleted until done but just in case		if (!IsDone())		{			Stop();		}	}

boolnsFilteredContentIterator::IsDone(){  if (mIsOutOfRange || !mCurrentIterator) {    return true;  }  return mCurrentIterator->IsDone();}

Job*CryptTask::CreateNextJob(){	if (IsDone())		return NULL;	CryptJob* job = CreateJob();	_PrepareJob(job);	return job;}

bool CItem::MustShowReadJobs() const{	if (GetParent() != NULL)	{		return !GetParent()->IsDone();	}	else	{		return !IsDone();	}}

void Window::Render(const boost::shared_ptr<Surface>& target){    if (IsDone())    {        return;    }    target->PushState();    target->SetViewportRelative(GetBounds());    OnRender(target);    target->PopState();}

bool S3FileRequest::WaitUntilDone() const{    unsigned timeoutCount = 0;    float totalProgress = GetProgress();    while (timeoutCount++ < DOWNLOAD_WAIT_TIMEOUT)    {        if (IsDone())        {            break;        }        // Let's reset our timeout        if (GetProgress() != totalProgress)        {            timeoutCount = 0;            totalProgress = GetProgress();        }        std::this_thread::sleep_for(std::chrono::seconds(1));    }    return IsDone();}

unsigned VChatClient::GetAllChannelsEx(){	Reset();	VChatAPI::GetAllChannels(NULL);	while(!IsDone() && !HasFailed())	{		Process();		soe::Sleep(10);	}	return m_result;}

int pyllbc_PackLemma_Top::Write(pyllbc_Stream *stream, PyObject *values){    if (UNLIKELY(!IsDone()))    {        pyllbc_SetError("top-lemma not done, could not pack data");        return LLBC_FAILED;    }    const bool valuesIsNone = pyllbc_TypeDetector::IsNone(values);    if (valuesIsNone)    {        if (!_lemmas.empty())        {            pyllbc_SetError("not found any values to pack, but has been specified format character symbol");            return LLBC_FAILED;        }        return LLBC_OK;    }    else if (!pyllbc_TypeDetector::IsSequence(values))    {        pyllbc_SetError("will pack data not iterable");        return LLBC_FAILED;    }        const Py_ssize_t seqSize = PySequence_Size(values);    if (seqSize != static_cast<Py_ssize_t>(_lemmas.size()))    {        LLBC_String errStr;        pyllbc_SetError(errStr.format(            "will pack data sequence size[%ld] not equal format character size[%d]",             seqSize, _lemmas.size()));        return LLBC_FAILED;    }    for (Py_ssize_t i = 0; i < seqSize; i++)    {        Base *lemma = _lemmas.at(i);        PyObject *obj = PySequence_GetItem(values, i);        if (lemma->Write(stream, obj) != LLBC_OK)        {            Py_DECREF(obj);            return LLBC_FAILED;        }        Py_DECREF(obj);    }    return LLBC_OK;}