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

void DownloadPartCommand::RunImpl(){	try {		if (!m_client.GetAccount().get()) {			MojString err;			err.format("Account is not loaded for '%s'", AsJsonString(m_client.GetAccountId()).c_str());			throw MailException(err.data(), __FILE__, __LINE__);		}		m_client.GetSession()->FetchEmail(m_emailId, m_partId, m_listener);		Complete();	} catch (const std::exception& ex) {		Failure(ex);	} catch (...) {		Failure(MailException("Unknown exception in downloading email", __FILE__, __LINE__));	}}

MojErr AuthPlainCommand::HandleResponse(const std::string& line){	MojLogInfo(m_log, "AUTH PLAIN command response");	if (m_status == Status_Ok) {		MojLogInfo(m_log, "AUTH PLAIN OK");		m_session.AuthPlainSuccess();	} else {		SmtpSession::SmtpError error = GetStandardError();		error.internalError = "AUTH PLAIN failed";		m_session.AuthPlainFailure(error);	}	Complete();	return MojErrNone;}

void CCBSettingHandler::SetCBForServiceGroup()    {    TRACE_FUNC_ENTRY        Trace(KDebugPrintD, "iClassArray.Count(): ", iClassArray.Count());    if (iClassArray.Count() != 0)        {        iCBInfo->iServiceGroup = iClassArray[0];        iPhone.SetCallBarringStatus(iStatus, iCondition, *iCBInfo);        iClassArray.Remove(0);        SetActive();        }    else        {        Complete(KErrNone);        }    TRACE_FUNC_EXIT    }

bool CMobSkillState::Update(time_point tick){    if (tick > GetEntryTime() + m_castTime && !IsCompleted())    {        action_t action;        m_PEntity->OnMobSkillFinished(*this, action);        m_PEntity->loc.zone->PushPacket(m_PEntity, CHAR_INRANGE_SELF, new CActionPacket(action));        auto delay = std::chrono::milliseconds(m_PSkill->getAnimationTime());        m_finishTime = tick + delay;        Complete();    }    if (IsCompleted() && tick > m_finishTime)    {        m_PEntity->PAI->EventHandler.triggerListener("WEAPONSKILL_STATE_EXIT", m_PEntity, m_PSkill->getID());        return true;    }    return false;}

// -----------------------------------------------------------------------------// CSTSCredentialManager::CreateCSRL// Creates a CSR// -----------------------------------------------------------------------------void CSTSCredentialManager::CreateCSRL(){    if ((!iKeyInfo) || (!iDistinguishedName))    {        Complete(KErrGeneral);        return;    }    iRequest = CPKCS10Request::NewL(*iDistinguishedName, *iKeyInfo);    delete iRequestEncoded;    iRequestEncoded = NULL;    iState = ECreatingCSR;    iRequest->CreateEncoding(iRequestEncoded, iStatus);    SetActive();}

bool CMagicState::Update(time_point tick){    if (tick > GetEntryTime() + m_castTime && !IsCompleted())    {        m_interrupted = false;        auto PTarget = m_PEntity->IsValidTarget(m_targid, m_PSpell->getValidTarget(), m_errorMsg);        MSGBASIC_ID msg = MSGBASIC_IS_INTERRUPTED;        action_t action;        if (HasMoved() || !CanCastSpell(PTarget))        {            m_interrupted = true;        }        else if (battleutils::IsParalyzed(m_PEntity))        {            msg = MSGBASIC_IS_PARALYZED;            m_interrupted = true;        }        else if (battleutils::IsIntimidated(m_PEntity, static_cast<CBattleEntity*>(PTarget)))        {            msg = MSGBASIC_IS_INTIMIDATED;            m_interrupted = true;        }        if (m_interrupted)        {            m_PEntity->OnCastInterrupted(*this, action, msg);        }        else        {            m_PEntity->OnCastFinished(*this,action);        }        m_PEntity->PAI->EventHandler.triggerListener("MAGIC_USE", m_PEntity, PTarget, m_PSpell.get(), &action);        m_PEntity->loc.zone->PushPacket(m_PEntity, CHAR_INRANGE_SELF, new CActionPacket(action));        Complete();    }    else if (IsCompleted() && tick > GetEntryTime() + m_castTime + std::chrono::milliseconds(m_PSpell->getAnimationTime()))    {        m_PEntity->PAI->EventHandler.triggerListener("MAGIC_STATE_EXIT", m_PEntity, m_PSpell.get());        return true;    }    return false;}

bool CWeaponSkillState::Update(time_point tick){    if (!IsCompleted())    {        SpendCost();        action_t action;        m_PEntity->OnWeaponSkillFinished(*this, action);        m_PEntity->loc.zone->PushPacket(m_PEntity, CHAR_INRANGE_SELF, new CActionPacket(action));        auto delay = m_PSkill->getAnimationTime();        m_finishTime = tick + delay;        Complete();    }    else if (tick > m_finishTime)    {        m_PEntity->PAI->EventHandler.triggerListener("WEAPONSKILL_STATE_EXIT", m_PEntity, m_PSkill->getID());        return true;    }    return false;}

// ---------------------------------------------------------------------------// CThumbnailMDSQueryTask::ReturnPath()// ---------------------------------------------------------------------------//void CThumbnailMDSQueryTask::ReturnPath(const TDesC& aUri)    {    if ( ClientThreadAlive() )        {        // add path to message        TInt ret = iMessage.Read( 0, iRequestParams );              if(ret == KErrNone)            {            TThumbnailRequestParams& params = iRequestParams();            params.iFileName = aUri;            ret = iMessage.Write( 0, iRequestParams );            }                    // complete the message with a code from which client side        // knows to make a new request using the path        Complete( KThumbnailErrThumbnailNotFound );        ResetMessageData();        }    }

// ---------------------------------------------------------------------------// CThumbnailMDSQueryTask::StartL()// ---------------------------------------------------------------------------//void CThumbnailMDSQueryTask::StartL()    {    TN_DEBUG2( "CThumbnailMDSQueryTask(0x%08x)::StartL()", this );    OstTrace1( TRACE_NORMAL, CTHUMBNAILMDSQUERYTASK_STARTL, "CThumbnailMDSQueryTask::StartL;this=%o", this );    CThumbnailTask::StartL();        if (iMessage.Handle())        {        // start query        iQuery->FindL();        }    else        {        // no point to continue        Complete( KErrCancel );        ResetMessageData();        }    }

/**Handles leaves during RunL@param aError Error code*/TInt CMsgImOutboxSend::RunError(TInt aError)	{	switch (iState)		{		case EStateConnectingSession:			{			if (iMobilityOperation != EMobilityOperationMigrating)				{				iProgress.iSendFileProgress.iSessionState = EConnectingToSmtp;				iProgress.iSendFileProgress.iBytesSent = 0;				iProgress.iSendFileProgress.iBytesToSend = 0;				iProgress.SetMsgNo(KErrNotFound);				iProgress.SetConnectionIAP(KErrNotFound);				}			break;			}		case EStateSendingFiles:			{			if (iSession)				{				iProgress.iSendFileProgress = iSession->FileProgress();				}			iProgress.iSendFileProgress.iSessionState = ESendingImail;			break;			}		case EStateUserPrompting:		case EStateClosingSession:		case EStateWaitingNewCarrier:		case EStateMobilityError:		default:			{			__ASSERT_DEBUG(EFalse, gPanic(EImsmUnexpectedState6));			break;			}		}	Complete(aError);	return KErrNone;	}

// ----------------------------------------------------------------------------// ----------------------------------------------------------------------------void CIpsPlgImap4PopulateOp::DoRunL()    {    FUNC_LOG;    TInt err = iStatus.Int();    delete iSubOperation;    iSubOperation = NULL;        switch( iState )        {        case EStateConnecting:            {            TMsvEntry tentry;            TMsvId service;            iMsvSession.GetEntry(iService, service, tentry );            if( !tentry.Connected() )                {                CompleteObserver( KErrCouldNotConnect );                return;                }            DoPopulateL();            break;            }        case EStateFetching:                     {            if( err != KErrNone && iSubOperation )                {                iFetchErrorProgress = iSubOperation->ProgressL().AllocL();                iState = EStateIdle;                Complete();                }            break;            }        case EStateInfoEntryChange:            {            DoPopulateL();            break;            }        case EStateIdle:        default:            break;        }    }

MojErr PopAccountDeleteCommand::SmtpAccountDeletedResponse(MojObject& response, MojErr err){	try {		ErrorToException(err);		MojLogInfo(m_log, "PopAccountDeleteCommand::SmtpAccountDeletedResponse");		m_client.AccountDeleted();		m_msg->replySuccess();		Complete();	} catch (const std::exception& e) {		m_msg->replyError(err);		Failure(e);	} catch (...) {		m_msg->replyError(MojErrInternal);		Failure(MailException("unknown exception", __FILE__, __LINE__));	}	return MojErrNone;}

void DMediaDriverTest::DoRead(TInt64 &aPos,TInt aLength,TMediaDrvDescData &aTrg)//// Read from specified area of media.//	{	TInt ret=KErrNone;	if (!aTrg.IsCurrentThread())		ret=KErrGeneral;	else		{		if ((ret=aTrg.CurrentThreadDescCheck(aLength))==KErrNone)            {			TDes8 &t=*((TDes8*)aTrg.iPtr);			Mem::Copy((TAny*)(t.Ptr()+aTrg.iOffset),&iBuf[aPos.Low()],aLength);			t.SetLength(aLength+aTrg.iOffset);			}		}    Complete(KMediaDrvReadReq,ret);	}

void DChannelComm::InitiateRead(TAny *aRxDes, TInt aLength)	{	// Complete zero-length read immediately.  maybe not//	if (aLength == 0)//		{//		Complete(ERx, KErrNone);//		return;//		}	TInt max=Kern::ThreadGetDesMaxLength(iClient,aRxDes);	if (max < Abs(aLength) || max < 0)		Complete(ERx, KErrGeneral);		// do not start the Turnaround timer (invalid Descriptor this read never starts)	else		{		iClientDestPtr = aRxDes;		Read(iClient, aRxDes, aLength);		}	}

// ---------------------------------------------------------------------------// CAtSmsNack::EventSignal// other items were commented in a header// ---------------------------------------------------------------------------void CAtSmsNack::EventSignal(TAtEventSource aEventSource, TInt aStatus)/** * Handle the events from the comm port *ValidateExpectString * @param aSource denotes if event is due to read, write or timeout */	{	LOGTEXT3(_L8("CAtSmsNack::EventSignal iStatus=%D iSource=%D"),aStatus,aEventSource);	if(aStatus == KErrNone)		{		if((aEventSource == EWriteCompletion))			{			LOGTEXT(_L8("CAtSmsNack::EventSignal,EWriteCompletion!"));			return;			}		aStatus = iError;		}	Complete();	iPhoneGlobals.iEventSignalActive = EFalse;	iCtsyDispatcherCallback.CallbackSmsAckSmsStoredComp(aStatus);	}

void CWin32Socket::Receive(TWin32Message& aMessage)	{	__ASSERT_DEBUG(iReceiveMessage == NULL, Panic(EWinSockPrtCWin32SocketMultipleReceiveRequests));	iReceiveMessage = &aMessage;	WSP_LOG(WspLog::Printf(_L("CWin32Socket::Receive: this: 0x%x, bytes to get: %d"), this, iReceiveMessage->WriteBuffer().MaxLength()));	iReceiveBuffer.buf = reinterpret_cast<char*>(const_cast<TUint8*>(iReceiveMessage->WriteBuffer().Ptr()));	iReceiveBuffer.len = iReceiveMessage->WriteBuffer().MaxLength();	iFlags = 0;	iReceiveOverlapped.hEvent = (void*) this;	DWORD numberOfBytesReceived;	TInt ret = WSARecv(iSocket, &iReceiveBuffer, 1, &numberOfBytesReceived, &iFlags, &iReceiveOverlapped, &ReceiveCompletion);	if (ret == SOCKET_ERROR)		{		TInt err = WSAGetLastError();		if (err != WSA_IO_PENDING)			{			WSP_LOG(WspLog::Printf(_L("/tsocket error: %d"), err));			Complete(iReceiveMessage, MapWinSockError(err));			}		}	}

/** *	Step through the various representative states for handling a message  *  Four States: *	 EParsing - Parses SL push message (retrieving the href and action attributes) *	 ESearching - Searching in the msg Store for any duplicate Sl Msg Entry *	 EProcessing - Save or update SL msg in the Msg store *	 EDone - Clean up */void CSLContentHandler::RunL()	{	 __LOG_PTR_DEBUG("CSLContentHandler:: RunL Called");	 switch(iState)		{		case EParsing:			ParsePushMsgL();			break;		case ESearching:			SearchingForDuplicatesMsgEntryL(); 			break;		case EProcessing:			ProcessingPushMsgEntryL();			break;		case EDone:			Complete(KErrNone);			break;		default:			 break;		}	}

bool CRangeState::Update(time_point tick){    if (tick > GetEntryTime() + m_aimTime && !IsCompleted())    {        auto PTarget = m_PEntity->IsValidTarget(m_targid, TARGET_ENEMY, m_errorMsg);        CanUseRangedAttack(PTarget);        if (m_startPos.x != m_PEntity->loc.p.x || m_startPos.y != m_PEntity->loc.p.y)        {            m_errorMsg = std::make_unique<CMessageBasicPacket>(m_PEntity, m_PEntity, 0, 0, MSGBASIC_MOVE_AND_INTERRUPT);        }        action_t action;        if (m_errorMsg && m_errorMsg->getMessageID() != MSGBASIC_CANNOT_SEE)        {            action.id = m_PEntity->id;            action.actiontype = ACTION_RANGED_INTERRUPT;            actionList_t& actionList = action.getNewActionList();            actionList.ActionTargetID = PTarget ? PTarget->id : m_PEntity->id;            actionTarget_t& actionTarget = actionList.getNewActionTarget();            actionTarget.animation = ANIMATION_RANGED;            m_PEntity->pushPacket(m_errorMsg.release());            m_PEntity->loc.zone->PushPacket(m_PEntity, CHAR_INRANGE_SELF, new CActionPacket(action));        }        else        {            m_errorMsg.reset();            m_PEntity->OnRangedAttack(*this, action);            m_PEntity->loc.zone->PushPacket(m_PEntity, CHAR_INRANGE_SELF, new CActionPacket(action));        }        Complete();    }    if (IsCompleted() && tick > GetEntryTime() + m_aimTime + 1.5s)    {        return true;    }    return false;}

void CATSmsMessagingWrite::StartPduWrite()/** * Kicks off the writing of the actual pdu. Begins by converting the pdu * into ascii form, and writing the pdu length and message status to the phone. */	{	iMsgDataAscii.Zero();	// Convert PDU from binary to ASCII	CATSmsUtils::AppendDataToAscii(iMsgDataAscii,iSmsEntry->iMsgData);	if(iMsgDataAscii.Length()==0)		{		LOGTEXT(_L8("CATSmsMessagingWrite:/tStartPduWrite - Failed to convert binary PDU to ASCII"));		Complete(KErrCorrupt);		return;		}	// Send PDU length to the phone	const TInt pduLengthSemiOctets(iMsgDataAscii.Length());	const TInt pduLengthOctets(pduLengthSemiOctets/2+pduLengthSemiOctets%2);	if (iNextAttempt==CPhoneGlobals::EPhoneTestNewStandard) 		{		// Prepend a zero length SCA to PDU - this forces phone to use default SCA		// See GSM 07.05 for details		_LIT8(zeroLengthSca, "00");		iMsgDataAscii.Insert(0,zeroLengthSca);		}		iTxBuffer.Zero();	TInt stat=SetMsgStatus();	if (stat==KErrNotSupported)		iTxBuffer.Format(KSmsWriteLengthCommand,pduLengthOctets);	else		iTxBuffer.Format(KSmsWriteCommand,pduLengthOctets,stat);	iIo->Write(this,iTxBuffer);	iIo->SetTimeOut(this,5000);	iState=EATWaitForSendingPduLengthComplete;	}

void Joiner::HandleSecureCoapClientConnect(bool aConnected){    switch (mState)    {    case OT_JOINER_STATE_CONNECT:        if (aConnected)        {            mState = OT_JOINER_STATE_CONNECTED;            SendJoinerFinalize();            mTimer.Start(kTimeout);        }        else        {            Complete(OT_ERROR_SECURITY);        }        break;    default:        break;    }}

bool CAbilityState::Update(time_point tick){    if (!IsCompleted() && tick > GetEntryTime() + m_castTime)    {        if (CanUseAbility())        {            action_t action;            m_PEntity->OnAbility(*this, action);            m_PEntity->PAI->EventHandler.triggerListener("ABILITY_USE", m_PEntity, GetTarget(), m_PAbility.get(), &action);            m_PEntity->loc.zone->PushPacket(m_PEntity, CHAR_INRANGE_SELF, new CActionPacket(action));        }        Complete();    }    if (IsCompleted() && tick > GetEntryTime() + m_castTime + m_PAbility->getAnimationTime())    {        m_PEntity->PAI->EventHandler.triggerListener("ABILITY_STATE_EXIT", m_PEntity, m_PAbility.get());        return true;    }    return false;}

// Deletevoid CImImap4Compound::DeleteL(TRequestStatus& aStatus, const TMsvId aSource)	{	LOG_COMMANDS((iSession->LogText(_L8("COMPOUND Delete(%x)"),aSource)));	Queue(aStatus);	// Save parameters	iSource=aSource;	iMessageSelection=iSelectionStillToDelete=1;	// Find the offending source folder	if ((iSourceFolder=FindFolderL(iSource))==NULL)		{		Complete(KErrNotFound);		return;		}	// Select it	iStep=0;	iSequence=SeqDelete;	DoRunL();	}

boolDirectParser::TryRead (int howmany){  DirectMessage msg;  bool haveOne (true);  bool atLeastOne (false);  for (int i=0; i<howmany && haveOne; i++) {    haveOne = Read (msg);    atLeastOne |= haveOne;    if (haveOne) {      emit Message (msg);      qDebug () << " Good Direct Read, emit message with "                 << msg.Op() <<"/" << msg.Subop();    } else {      qDebug () << " Bad Direct Read, no emit";      if (Good () && !Complete()) {        Reset ();      }    }  }  return atLeastOne ;}

void CCmdCifTest::TestCompleted(TInt aError)	{	// Delete interim data	delete iEnvForScript;	iEnvForScript = NULL;	delete iParser;	iParser = NULL;	delete iCurrentCif;	iCurrentCif = NULL;	if (aError == KErrNone || iKeepGoing)		{		// Async call NextCif()		TRequestStatus* stat = &iStatus;		User::RequestComplete(stat, KErrNone);		SetActive();		}	else		{		Complete(aError);		}	}

/**	 * Step through the various representative states for handling a message  * 1. Initial State - Parsing SIA Push Msg * 2. Make a CO connection * 3. Delete Content Handler Plugin Owner (i.e self) */void CSIAContentHandler::RunL()	{	__LOG_PTR_DEBUG("CSIAContentHandler:: RunL Called");	// use active state machine routine to manage activites:	switch(iState) 		{	case EParsing:		ParsePushMsgL();		break;	case ERequestingConn:		RequestConnectionL();		break;	case EOpeningCOconn:		OpenConnectionL();		break;	case EDone: 		Complete(KErrNone);		break;	default:		break;		}	}

int ShowMenu(int Offset){  int Msgs[]={MComplete,MComplete,MMenuCfg,MAutoCfg};  TCHAR Bottom[30];  FSF.sprintf(Bottom,_T("[%d]"),windows->count());  FarMenuItem Items[sizeof(Msgs)/sizeof(Msgs[0])];  TCHAR ItemText[sizeof(Msgs)/sizeof(Msgs[0])][128];  for(unsigned int i=0;i<(sizeof(Msgs)/sizeof(Msgs[0]));i++)  {    Items[i].Flags=0;    _tcscpy(ItemText[i],GetMsg(Msgs[i]));    Items[i].Text=ItemText[i];  }  ItemText[1][0]=0;  Items[1].Flags|=MIF_SEPARATOR;  int MenuCode=0,SelectedItem=0;  do  {    Items[SelectedItem].Flags|=MIF_SELECTED;    MenuCode=Info.Menu(&MainGuid,&MainMenuGuid,-1,-1,0,FMENU_AUTOHIGHLIGHT|FMENU_WRAPMODE,GetMsg(MEditCmpl),Bottom,_T("Contents"),NULL,NULL,&Items[Offset],sizeof(Msgs)/sizeof(Msgs[0])-Offset);    Items[SelectedItem].Flags&=~MIF_SELECTED;    SelectedItem=MenuCode;    if(MenuCode>=0) MenuCode+=Offset;    switch(MenuCode)    {      case 0: // "OK"        Complete();        break;      case 2: // Menu        MCmpl->ShowDialog();        break;      case 3: // Auto        ACmpl->ShowDialog();        break;    }  } while(MenuCode>0);  return TRUE;}

bool CDeathState::Update(time_point tick){    if (IsCompleted() || m_PEntity->animation != ANIMATION_DEATH)    {        return true;    }    else if (tick > GetEntryTime() + m_deathTime && !IsCompleted())    {        Complete();        m_PEntity->OnDeathTimer();    }    else if (m_PEntity->objtype == TYPE_PC && tick > GetEntryTime() + 8s && !IsCompleted() &&             !m_raiseSent && m_PEntity->isDead())    {        auto PChar = static_cast<CCharEntity*>(m_PEntity);        if (PChar->m_hasRaise)        {            PChar->pushPacket(new CRaiseTractorMenuPacket(PChar, TYPE_RAISE));            m_raiseSent = true;        }    }    return false;}