bool CWeaponMagazinedWGrenade::Action(s32 cmd, u32 flags) { if(m_bGrenadeMode && cmd==kWPN_FIRE) { if(IsPending()) return false; if(flags&CMD_START) { if(iAmmoElapsed) LaunchGrenade (); else Reload (); if(GetState() == eIdle) OnEmptyClick (); } return true; } if(inherited::Action(cmd, flags)) return true; switch(cmd) { case kWPN_FUNC: { if(flags&CMD_START && !IsPending()) SwitchState(eSwitch); return true; } } return false; }
BOOL CHttpRequest::Execute(BOOL bBackground) { if ( IsPending() ) return FALSE; Cancel(); ASSERT( m_sURL.GetLength() > 0 ); ASSERT( m_pPost == NULL ); m_bCancel = FALSE; m_nStatusCode = 0; m_pResponseHeaders.RemoveAll(); if ( m_pResponse != NULL ) delete m_pResponse; m_pResponse = NULL; if ( bBackground ) { m_hThread = AfxBeginThread( (AFX_THREADPROC)ThreadStart, this, THREAD_PRIORITY_NORMAL, 0, 0, NULL )->m_hThread; return TRUE; } else { Run(); ASSERT( ! IsPending() ); return ( m_nStatusCode >= 200 && m_nStatusCode < 300 ); } }
// 非同期通信を開始する // すでに開始しているときは失敗するが、name==NULLのときは開いているソケットに送信データを追加する bool CAsyncSocket::Send(HWND hwnd, UINT msg, const char *name, unsigned short port, const char *buf, int len, bool bKeepSession) { if (len < 0) { len = lstrlenA(buf); } if (len > 0) { // 前のデータを送信済みのときだけ送信データを追加できる if (IsPending() && !name && bKeepSession_ && sendBuf_.empty()) { sendBuf_.assign(&buf[0], &buf[len]); bKeepSession_ = bKeepSession; PostMessage(hwnd_, msg_, (WPARAM)soc_, WSAMAKESELECTREPLY(FD_WRITE, 0)); return true; } else if (!IsPending() && name) { sendBuf_.assign(&buf[0], &buf[len]); hwnd_ = hwnd; msg_ = msg; delete [] name_; name_ = new char[lstrlenA(name) + 1]; lstrcpyA(name_, name); port_ = port; bKeepSession_ = bKeepSession; // キューにたまっているかもしれないメッセージを流すため待機 bReady_ = true; PostMessage(hwnd, msg, 0, 0); return true; } } return false; }
NS_IMETHODIMP nsNDNChannel::IsPending(bool *result) { // NS_NOTREACHED("nsNDNChannel::IsPending"); // return NS_ERROR_NOT_IMPLEMENTED; *result = IsPending(); return NS_OK; }
HRESULT CLR_RT_HeapBlock_I2CXAction::PrepareXAction( I2C_USER_CONFIGURATION& config, size_t numXActions ) { NATIVE_PROFILE_CLR_I2C(); TINYCLR_HEADER(); _ASSERTE(numXActions > 0); if(IsPending()) { TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_OPERATION); } if(m_HalXAction == NULL || m_HalXActionUnits == NULL) { TINYCLR_SET_AND_LEAVE(CLR_E_NULL_REFERENCE); } I2C_InitializeTransaction( m_HalXAction, config, m_HalXActionUnits, numXActions ); TINYCLR_NOCLEANUP(); }
void EventHandler::Get(Event &ev) { // Sleep until there are events available while(!m_pending) { Timer tmp; IsPending(); if (!m_pending) tmp.WaitMs(1); } // Return first queued event if applicable Event *ep = (Event *)m_events.first(); if(ep) { ev = *ep; m_events.unlink(ep); delete ep; m_pending = m_events.first() != NULL; return; } // Return an event from the platform-specific system SysEvent(ev); }
HRESULT CLR_RT_HeapBlock_I2CXAction::PrepareXActionUnit( CLR_UINT8* src, size_t length, size_t unit, bool fRead ) { NATIVE_PROFILE_CLR_I2C(); TINYCLR_HEADER(); _ASSERTE(src != NULL); _ASSERTE(length > 0); if(IsPending()) { TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_OPERATION); } if(m_HalXActionUnits == NULL || m_dataBuffers == NULL) { TINYCLR_SET_AND_LEAVE(CLR_E_NULL_REFERENCE); } if(unit > m_xActionUnits-1) { TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_PARAMETER); } m_dataBuffers[ unit ] = (I2C_WORD*)CLR_RT_Memory::Allocate_And_Erase( length * sizeof(I2C_WORD) ); CHECK_ALLOCATION(m_dataBuffers[ unit ]); I2C_InitializeTransactionUnit( m_HalXActionUnits[ unit ], src, m_dataBuffers[ unit ], length, fRead ? TRUE : FALSE ); TINYCLR_NOCLEANUP(); }
bool CWeapon::SwitchAmmoType( u32 flags ) { if ( IsPending() || OnClient() ) return false; if ( !(flags & CMD_START) ) return false; u8 l_newType = m_ammoType; bool b1, b2; do { l_newType = u8( (u32(l_newType+1)) % m_ammoTypes.size() ); b1 = (l_newType != m_ammoType); b2 = unlimited_ammo() ? false : ( !m_pInventory->GetAny( m_ammoTypes[l_newType].c_str() ) ); } while( b1 && b2 ); if ( l_newType != m_ammoType ) { m_set_next_ammoType_on_reload = l_newType; if ( OnServer() ) { Reload(); } } return true; }
bool CWeaponMagazined::Action(s32 cmd, u32 flags) { if(inherited::Action(cmd, flags)) return true; //если оружие чем-то занято, то ничего не делать if(IsPending()) return false; switch(cmd) { case kWPN_RELOAD: { if(flags&CMD_START) if(iAmmoElapsed < iMagazineSize || IsMisfire()) Reload(); } return true; case kWPN_FIREMODE_PREV: { if(flags&CMD_START) { OnPrevFireMode(); return true; }; }break; case kWPN_FIREMODE_NEXT: { if(flags&CMD_START) { OnNextFireMode(); return true; }; }break; } return false; }
// ------------------------------------------------ // SetupForCallback // ------------------------------------------------ // void CMdSNotifier::TEntry::SetupForCallback( RMessage2 aMessage, TInt aRemoteSizeMsgSlot ) { __ASSERT_DEBUG( !IsPending(), MMdCCommon::Panic( KErrCorrupt ) ); iMessage = aMessage; iRemoteSizeMsgSlot = aRemoteSizeMsgSlot; }
void CMailBox::WaitForCall() { std::unique_lock<std::mutex> callLock(m_callMutex); while(!IsPending()) { m_waitCondition.wait(callLock); } }
BOOL CHttpRequest::SetURL(LPCTSTR pszURL) { CSingleLock pLock( &m_pSection ); if ( IsPending() ) return FALSE; if ( pszURL == NULL || _tcsncmp( pszURL, _T("http"), 4 ) ) return FALSE; m_sURL = pszURL; return TRUE; }
IDBRequestReadyState IDBRequest::ReadyState() const { AssertIsOnOwningThread(); return IsPending() ? IDBRequestReadyState::Pending : IDBRequestReadyState::Done; }
NS_IMETHODIMP nsFtpChannel::ResumeAt(PRUint64 aStartPos, const nsACString& aEntityID) { NS_ENSURE_TRUE(!IsPending(), NS_ERROR_IN_PROGRESS); mEntityID = aEntityID; mStartPos = aStartPos; mResumeRequested = (mStartPos || !mEntityID.IsEmpty()); return NS_OK; }
void CHttpRequest::AddHeader(LPCTSTR pszKey, LPCTSTR pszValue) { CSingleLock pLock( &m_pSection ); if ( IsPending() ) return; m_sRequestHeaders += pszKey; m_sRequestHeaders += _T(": "); m_sRequestHeaders += pszValue; m_sRequestHeaders += _T("\r\n"); }
// 送受信停止を要求する // 呼び出し後ProcessRecv()が負値を返すと完了(ソケットも閉じられる) bool CAsyncSocket::Shutdown() { if (IsPending() && !bShutdown_) { if (soc_ != INVALID_SOCKET) { shutdown(soc_, SD_BOTH); } bShutdown_ = true; } return bShutdown_; }
void CWeaponKnife::switch2_Attacking (u32 state) { if(IsPending()) return; if(state==eFire) PlayHUDMotion("anm_attack", FALSE, this, state); else //eFire2 PlayHUDMotion("anm_attack2", FALSE, this, state); SetPending (TRUE); }
CString CHttpRequest::GetResponseString(UINT nCodePage) { CSingleLock pLock( &m_pSection ); CString str; if ( ! IsPending() && m_pResponse != NULL ) { str = m_pResponse->ReadString( m_pResponse->m_nLength, nCodePage ); } return str; }
void AbortablePromise::Abort() { if (IsPending()) { return; } MaybeReject(NS_ERROR_ABORT); nsCOMPtr<nsIRunnable> runnable = NS_NewRunnableMethod(this, &AbortablePromise::DoAbort); Promise::DispatchToMicroTask(runnable); }
NS_IMETHODIMP nsFtpChannel::SetUploadStream(nsIInputStream *stream, const nsACString &contentType, PRInt32 contentLength) { NS_ENSURE_TRUE(!IsPending(), NS_ERROR_IN_PROGRESS); mUploadStream = stream; // NOTE: contentLength is intentionally ignored here. return NS_OK; }
//переключение режимов стрельбы одиночными и очередями bool CWeaponMagazined::SwitchMode() { if (eIdle != GetState() || IsPending()) return false; if (SingleShotMode()) m_iQueueSize = WEAPON_ININITE_QUEUE; else m_iQueueSize = 1; PlaySound(sndEmptyClick, get_LastFP()); return true; }
NS_IMETHODIMP IDBRequest::GetReadyState(nsAString& aReadyState) { NS_ASSERTION(NS_IsMainThread(), "Wrong thread!"); if (IsPending()) { aReadyState.AssignLiteral("pending"); } else { aReadyState.AssignLiteral("done"); } return NS_OK; }
void CHttpRequest::SetPostData(LPCVOID pBody, DWORD nBody) { CSingleLock pLock( &m_pSection ); if ( IsPending() ) return; if ( m_pPost != NULL ) delete m_pPost; m_pPost = NULL; if ( pBody != NULL && nBody > 0 ) { m_pPost = new CBuffer(); m_pPost->Add( pBody, nBody ); } }
CString CHttpRequest::GetHeader(LPCTSTR pszName) { CSingleLock pLock( &m_pSection ); CString strIn, strOut; if ( IsPending() ) return strOut; strIn = pszName; CharLower( strIn.GetBuffer() ); strIn.ReleaseBuffer(); m_pResponseHeaders.Lookup( strIn, strOut ); return strOut; }
HRESULT CLR_RT_HeapBlock_I2CXAction::Enqueue() { NATIVE_PROFILE_CLR_I2C(); TINYCLR_HEADER(); if(!m_HalXAction || IsPending()) { TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_OPERATION); } if(!::I2C_Enqueue( m_HalXAction )) { TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_OPERATION); } TINYCLR_NOCLEANUP(); }
void CMailBox::ReceiveCall() { MESSAGE message; { std::lock_guard<std::mutex> waitLock(m_callMutex); if(!IsPending()) return; message = std::move(m_calls.front()); m_calls.pop_front(); } message.function(); if(message.sync) { std::lock_guard<std::mutex> waitLock(m_callMutex); m_callDone = true; m_callFinished.notify_all(); } }
BOOL CHttpRequest::InflateResponse() { CSingleLock pLock( &m_pSection, TRUE ); if ( IsPending() || m_pResponse == NULL ) return FALSE; CString strEncoding = GetHeader( _T("Content-Encoding") ); if ( strEncoding.CompareNoCase( _T("deflate") ) == 0 ) { return m_pResponse->Inflate(); } if ( strEncoding.CompareNoCase( _T("gzip") ) == 0 ) { return m_pResponse->Ungzip(); } return TRUE; }
HRESULT CLR_RT_HeapBlock_I2CXAction::AllocateXAction( CLR_UINT32 numXActionUnits ) { NATIVE_PROFILE_CLR_I2C(); TINYCLR_HEADER(); CLR_UINT32 index; if(IsPending()) { TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_OPERATION); } m_xActionUnits = numXActionUnits; // allocate memory for the transaction m_HalXAction = (I2C_HAL_XACTION*)CLR_RT_Memory::Allocate_And_Erase( sizeof(I2C_HAL_XACTION) ); CHECK_ALLOCATION(m_HalXAction); ((HAL_CONTINUATION*)m_HalXAction)->Initialize(); ::I2C_XAction_SetState( m_HalXAction, I2C_HAL_XACTION::c_Status_Idle ); // initialize pointers to data buffers m_dataBuffers = (I2C_WORD**)CLR_RT_Memory::Allocate_And_Erase( sizeof(I2C_WORD*) * numXActionUnits ); CHECK_ALLOCATION(m_dataBuffers); // allocate memory for the transaction units m_HalXActionUnits = (I2C_HAL_XACTION_UNIT**)CLR_RT_Memory::Allocate_And_Erase( sizeof(I2C_HAL_XACTION_UNIT*) * numXActionUnits ); CHECK_ALLOCATION(m_HalXActionUnits); for(index = 0; index < numXActionUnits; ++index) { m_HalXActionUnits[ index ] = (I2C_HAL_XACTION_UNIT*)CLR_RT_Memory::Allocate_And_Erase( sizeof(I2C_HAL_XACTION_UNIT) ); CHECK_ALLOCATION(m_HalXActionUnits[ index ]); } TINYCLR_CLEANUP(); if(FAILED(hr)) { ReleaseBuffers(); } TINYCLR_CLEANUP_END(); }
nsresult ProcessUpdates(nsIFile *greDir, nsIFile *appDir, nsIFile *updRootDir, int argc, char **argv, const char *&appVersion) { nsresult rv; nsCOMPtr<nsIFile> updatesDir; rv = updRootDir->Clone(getter_AddRefs(updatesDir)); if (NS_FAILED(rv)) return rv; rv = updatesDir->AppendNative(NS_LITERAL_CSTRING("updates")); if (NS_FAILED(rv)) return rv; rv = updatesDir->AppendNative(NS_LITERAL_CSTRING("0")); if (NS_FAILED(rv)) return rv; PRBool exists; rv = updatesDir->Exists(&exists); if (NS_FAILED(rv) || !exists) return rv; nsCOMPtr<nsILocalFile> statusFile; if (GetStatusFile(updatesDir, statusFile) && IsPending(statusFile)) { nsCOMPtr<nsILocalFile> versionFile; // Remove the update if the update application version file doesn't exist // or if the update's application version is less than the current // application version. if (!GetVersionFile(updatesDir, versionFile) || IsOlderVersion(versionFile, appVersion)) { updatesDir->Remove(PR_TRUE); } else { ApplyUpdate(greDir, updatesDir, statusFile, appDir, argc, argv); } } return NS_OK; }
NS_IMETHODIMP nsFileChannel::SetUploadStream(nsIInputStream *stream, const nsACString &contentType, PRInt32 contentLength) { NS_ENSURE_TRUE(!IsPending(), NS_ERROR_IN_PROGRESS); if ((mUploadStream = stream)) { mUploadLength = contentLength; if (mUploadLength < 0) { // Make sure we know how much data we are uploading. PRUint32 avail; nsresult rv = mUploadStream->Available(&avail); if (NS_FAILED(rv)) return rv; mUploadLength = avail; } } else { mUploadLength = -1; } return NS_OK; }