bool Node<TBv>::collided(const Node<TBv>* query, TCollidedNodes& output) const { bool result = false; if (overlapped(query)) { /// Stores any pairs that overlapped. output.push_back(std::make_pair(this, query)); result = true; auto leftQuery = query->getLeft(); auto rightQuery = query->getRight(); auto left = getLeft(); auto right = getRight(); if (left != 0 && left->overlapped(query)) { output.push_back(std::make_pair(left, query)); left->collided(leftQuery, output); left->collided(rightQuery, output); } if (right != 0 && right->overlapped(query)) { output.push_back(std::make_pair(right, query)); right->collided(leftQuery, output); right->collided(rightQuery, output); } } return result; }
bool SdbLegacyIOCompletion::GetOvelappedIoResult(LPOVERLAPPED ovl_data, ULONG* bytes_transferred, bool wait) { if (NULL != bytes_transferred) { *bytes_transferred = 0; } if (!IsOpened()) { SetLastError(ERROR_INVALID_HANDLE); return false; } ULONG transfer; bool ret = GetOverlappedResult(parent_legacy_io_object()->usb_handle(), overlapped(), &transfer, wait) ? true : false; // TODO: This is bizzare but I've seen it happening // that GetOverlappedResult with wait set to true returns "prematurely", // with wrong transferred bytes value and GetLastError reporting // ERROR_IO_PENDING. So, lets give it an up to a 20 ms loop! ULONG error = GetLastError(); if (wait && ret && (0 == transfer) && (0 != expected_transfer_size_) && ((ERROR_IO_INCOMPLETE == error) || (ERROR_IO_PENDING == error))) { for (int trying = 0; trying < 10; trying++) { Sleep(2); ret = GetOverlappedResult(parent_legacy_io_object()->usb_handle(), overlapped(), &transfer, wait) ? true : false; error = GetLastError(); if (!ret || (0 != transfer) || ((ERROR_IO_INCOMPLETE != error) && (ERROR_IO_PENDING != error))) { break; } } } if (NULL != ovl_data) { CopyMemory(ovl_data, overlapped(), sizeof(OVERLAPPED)); } if (NULL != bytes_transferred) { *bytes_transferred = is_write_ioctl() ? transferred_bytes_ : transfer; } return ret; }
virtual bool no_overlap(particle_shape_type const& s, particle_id_type const& ignore1, particle_id_type const& ignore2) const { boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped( check_overlap(s, ignore1, ignore2)); return (!overlapped || ::size(*overlapped) == 0); }
virtual bool no_overlap(particle_shape_type const& s) const { boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped( check_overlap(s)); // boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped( // check_overlap<particle_shape_type>(s)); return (!overlapped || ::size(*overlapped) == 0); }
bool AdbIOCompletion::IsCompleted() { SetLastError(NO_ERROR); if (!IsOpened()) { SetLastError(ERROR_INVALID_HANDLE); return true; } return HasOverlappedIoCompleted(overlapped()) ? true : false; }
void Win32NamedPipeNetworkSession::implWrite(const std::vector<ByteBuffer> & buffers) { if ( !mSocketPtr ) { RCF_LOG_4() << "Win32NamedPipeNetworkSession - connection has been closed."; return; } RCF_LOG_4()(RCF::lengthByteBuffers(buffers)) << "Win32NamedPipeNetworkSession - calling WriteFile()."; ASIO_NS::windows::overlapped_ptr overlapped( mSocketPtr->get_io_service(), WriteHandler(sharedFromThis())); const ByteBuffer & byteBuffer = buffers.front(); DWORD dwBytesWritten = 0; bool writeOk = false; HANDLE hPipe = mSocketPtr->native(); BOOL ok = WriteFile( hPipe, byteBuffer.getPtr(), static_cast<DWORD>(byteBuffer.getLength()), &dwBytesWritten, overlapped.get()); DWORD dwErr = GetLastError();; if (!ok && ( dwErr == ERROR_IO_PENDING || dwErr == ERROR_MORE_DATA)) { writeOk = true; } else if (dwBytesWritten) { writeOk = true; } if (writeOk) { overlapped.release(); } else { AsioErrorCode ec( dwErr, ASIO_NS::error::get_system_category()); overlapped.complete(ec, 0); } }
bool clear_volume(particle_shape_type const& shape, particle_id_type const& ignore0, particle_id_type const& ignore1) const { LOG_DEBUG(("clear_volume was called here.")); main_.clear_volume(shape, base_type::id_); boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped( main_.world()->check_overlap(shape, ignore0, ignore1)); if (overlapped && ::size(*overlapped)) { return false; } return true; }
// Function responsible of accepting a connection on the socket. inline Socket* TCPSocket::accept() { Socket* return_value = NULL; lock_ref().enter(); if ( socket_ref() != NULL && listen() ) { sockaddr_storage target; SOCKET new_socket; int target_size = sizeof(target); memset(&target,'\0',target_size); new_socket = WSAAccept(socket_ref(),reinterpret_cast<sockaddr*>(&target),&target_size,NULL,NULL); if ( new_socket != INVALID_SOCKET ) { TCPSocket* accepted_socket = new (std::nothrow) TCPSocket( ( protocol() == SOCKET_TCP_V4 ? false : true ) , new_socket,target); if ( accepted_socket != NULL ) { accepted_socket->queue_size(queue_size()); accepted_socket->blocking(blocking()); accepted_socket->send_timeout(send_timeout()); accepted_socket->receive_timeout(receive_timeout()); accepted_socket->keep_alive(keep_alive()); accepted_socket->keep_alive_timeout(keep_alive_timeout()); accepted_socket->keep_alive_interval(keep_alive_interval()); accepted_socket->overlapped(overlapped()); accepted_socket->send_overlapped_function(send_overlapped_function()); accepted_socket->receive_overlapped_function(receive_overlapped_function()); _accepted_sockets.push_back(accepted_socket); return_value = accepted_socket; } else closesocket(new_socket); } } lock_ref().leave(); return return_value; };
void Win32NamedPipeNetworkSession::implWrite(AsioNetworkSession &toBeNotified, const char * buffer, std::size_t bufferLen) { ASIO_NS::windows::overlapped_ptr overlapped( mSocketPtr->get_io_service(), boost::bind( &AsioNetworkSession::onNetworkWriteCompleted, toBeNotified.sharedFromThis(), ASIO_NS::placeholders::error, ASIO_NS::placeholders::bytes_transferred)); DWORD dwBytesWritten = 0; bool writeOk = false; HANDLE hPipe = mSocketPtr->native(); BOOL ok = WriteFile( hPipe, buffer, static_cast<DWORD>(bufferLen), &dwBytesWritten, overlapped.get()); DWORD dwErr = GetLastError(); if (!ok && ( dwErr == ERROR_IO_PENDING || dwErr == ERROR_MORE_DATA)) { writeOk = true; } else if (dwBytesWritten) { writeOk = true; } if (writeOk) { overlapped.release(); } else { AsioErrorCode ec( dwErr, ASIO_NS::error::get_system_category()); overlapped.complete(ec, 0); } }
vector<Interval> intervalIntersection(vector<Interval>& A, vector<Interval>& B) { int lenA = A.size(); int lenB = B.size(); vector<Interval> result; if (lenA <=0 || lenB<=0) return result; //edge case int i=0, j=0; while ( i < lenA && j < lenB ) { if( overlapped(A[i], B[j]) ) { result.push_back(mergeTwoInterval(A[i], B[j])); // if the current interval is not overlapped with next one, // then we move the next interval. int nexti = i; if ( j==lenB-1 || !overlapped(A[i], B[j+1]) ) nexti=i+1; if ( i==lenA-1 || !overlapped(A[i+1], B[j]) ) j++; i = nexti; }else{ //if not overlapped, we just move the next one compareInterval(A[i], B[j]) ? i++ : j++; } } return result; }
void PipeNode::doListen(const std::wstring & name) { HANDLE handle = CreateNamedPipeW((L"\\\\.\\pipe\\" + name).c_str(), PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED, PIPE_WAIT, PIPE_UNLIMITED_INSTANCES, 0x1000, 0x1000, 0, NULL); pipe_.reset(new boost::asio::windows::stream_handle(ioService_, handle)); boost::asio::windows::overlapped_ptr overlapped(ioService_, boost::bind(&PipeNode::handleConnected, this, _1, name)); bool ok = ConnectNamedPipe(pipe_->native(), overlapped.get()) != FALSE; DWORD error = GetLastError(); if(!ok && error != ERROR_IO_PENDING) { boost::system::error_code ec(error, boost::asio::error::get_system_category()); overlapped.complete(ec, 0); } else { overlapped.release(); } }
//overlap, compute the overlap area between r1 and r2. the rect is for root bool overlap(const rectangle& r1, const rectangle& r2, rectangle& r) { if(overlapped(r1, r2)) { auto l1 = static_cast<long long>(r1.x) + r1.width; auto l2 = static_cast<long long>(r2.x) + r2.width; auto b1 = static_cast<long long>(r1.y) + r1.height; auto b2 = static_cast<long long>(r2.y) + r2.height; r.x = r1.x < r2.x ? r2.x : r1.x; r.y = r1.y < r2.y ? r2.y : r1.y; r.width = static_cast<unsigned>(l1 < l2 ? l1 - r.x: l2 - r.x); r.height = static_cast<unsigned>(b1 < b2 ? b1 - r.y: b2 - r.y); return true; } return false; }
void Win32NamedPipeNetworkSession::implAccept() { RCF_LOG_4()<< "Win32NamedPipeNetworkSession - calling ConnectNamedPipe()."; ASIO_NS::windows::overlapped_ptr overlapped( mSocketPtr->get_io_service(), boost::bind( &AsioNetworkSession::onAcceptCompleted, sharedFromThis(), ASIO_NS::placeholders::error)); HANDLE hPipe = mSocketPtr->native(); BOOL ok = ConnectNamedPipe(hPipe, overlapped.get()); DWORD dwErr = GetLastError(); // ConnectNamedPipe() can complete either synchronously or // asynchronously. We need to cater for both possibilities. if ( !ok && dwErr == ERROR_IO_PENDING ) { // Asynchronous accept. overlapped.release(); } else if (!ok && dwErr == ERROR_PIPE_CONNECTED) { // Synchronous connect. AsioErrorCode ec; overlapped.complete(ec, 0); } else { // ConnectNamedPipe() may return a synchronous error. In particular we sometimes // get ERROR_NO_DATA ("The pipe is being closed"). So, here we need another // accept call. // MSDN says ConectNamedPipe will always return 0, in overlapped mode. RCF_ASSERT(!ok); mTransport.createNetworkSession()->beginAccept(); } }
void Matrix::next() { Ruleset::Piece piece = _next.dequeue(); _rules->populateSequence(_next); Pair position = _rules->getStartPosition(piece); if (_tetromino) _tetromino->deleteLater(); _tetromino = new Tetromino(piece, this); _tetromino->setPosition(position); QObject::connect(_tetromino, SIGNAL(evMove(int)), this, SLOT(onMove(int))); QObject::connect(_tetromino, SIGNAL(evMoveFail()), this, SLOT(onMoveFail())); QObject::connect(_tetromino, SIGNAL(evTurn(int)), this, SLOT(onTurn(int))); QObject::connect(_tetromino, SIGNAL(evTurnFail()), this, SLOT(onTurnFail())); QObject::connect(_tetromino, SIGNAL(evFall(int)), this, SLOT(onFall(int))); QObject::connect(_tetromino, SIGNAL(evDrop(int)), this, SLOT(onDrop(int))); QObject::connect(_tetromino, SIGNAL(evLand()), this, SLOT(onLand())); QObject::connect(_tetromino, SIGNAL(evLock()), this, SLOT(onLock())); if (_ghost) _ghost->deleteLater(); _ghost = new Tetromino(piece, this); _ghost->setPosition(position); _ghost->drop(); _ghost->setLocked(false); emit evTetromino(_tetromino); emit evGhost(_ghost); if (overlapped()) { emit evTopOut(); setState(STATE_OVER, true); } }
bool Node<TBv>::overlapped(const Node<TBv>* other) const { return other != 0 ? overlapped(*other) : false; }
void Win32NamedPipeNetworkSession::implRead(char * buffer, std::size_t bufferLen) { if ( !mSocketPtr ) { RCF_LOG_4() << "Win32NamedPipeNetworkSession - connection has been closed."; return; } RCF_LOG_4()(bufferLen) << "Win32NamedPipeNetworkSession - calling ReadFile()."; ASIO_NS::windows::overlapped_ptr overlapped( mSocketPtr->get_io_service(), ReadHandler(sharedFromThis())); DWORD dwBytesRead = 0; bool readOk = false; HANDLE hPipe = mSocketPtr->native(); BOOL ok = ReadFile( hPipe, buffer, static_cast<DWORD>(bufferLen), &dwBytesRead, overlapped.get()); DWORD realError = 0; DWORD dwErr = 0; if (!ok) { dwErr = GetLastError(); if ( dwErr != ERROR_IO_PENDING && dwErr != ERROR_MORE_DATA) { realError = dwErr; } } if ( dwBytesRead || (ok && dwBytesRead == 0 && bufferLen == 0) || (!ok && realError == 0)) { readOk = true; } if (readOk) { overlapped.release(); } else { AsioErrorCode ec( dwErr, ASIO_NS::error::get_system_category()); overlapped.complete(ec, 0); } }
std::size_t Win32NamedPipeClientTransport::implWriteAsync( const std::vector<ByteBuffer> &byteBuffers) { mAsyncMode = true; RecursiveLock lock(mOverlappedPtr->mMutex); mOverlappedPtr->mOpType = OverlappedAmi::Write; // Construct an OVERLAPPED-derived object to contain the handler. ASIO_NS::windows::overlapped_ptr overlapped( mSocketPtr->get_io_service(), AmiIoHandler(mOverlappedPtr)); const ByteBuffer & byteBuffer = byteBuffers.front(); DWORD dwBytesWritten = 0; bool writeOk = false; BOOL ok = WriteFile( mhPipe, byteBuffer.getPtr(), static_cast<DWORD>(byteBuffer.getLength()), &dwBytesWritten, overlapped.get()); DWORD dwErr = GetLastError();; if (!ok && ( dwErr == ERROR_IO_PENDING || dwErr == WSA_IO_PENDING || dwErr == ERROR_MORE_DATA)) { writeOk = true; } else if (dwBytesWritten) { writeOk = true; } if (writeOk) { // The operation was successfully initiated, so ownership of the // OVERLAPPED-derived object has passed to the io_service. overlapped.release(); // Set timer. boost::uint32_t nowMs = getCurrentTimeMs(); boost::uint32_t timeoutMs = mEndTimeMs - nowMs; mAsioTimerPtr->expires_from_now( boost::posix_time::milliseconds(timeoutMs) ); mAsioTimerPtr->async_wait( AmiTimerHandler(mOverlappedPtr) ); } else { // The operation completed immediately, so a completion notification needs // to be posted. When complete() is called, ownership of the OVERLAPPED- // derived object passes to the io_service. AsioErrorCode ec( dwErr, ASIO_NS::error::get_system_category()); overlapped.complete(ec, 0); } return 0; }
size_t read_some_at(implementation_type& impl, boost::uint64_t offset, const MutableBufferSequence& buffers, boost::system::error_code& ec) { if (!is_open(impl)) { ec = boost::asio::error::bad_descriptor; return 0; } // Find first buffer of non-zero length. boost::asio::mutable_buffer buffer; typename MutableBufferSequence::const_iterator iter = buffers.begin(); typename MutableBufferSequence::const_iterator end = buffers.end(); for (DWORD i = 0; iter != end; ++iter, ++i) { buffer = boost::asio::mutable_buffer(*iter); if (boost::asio::buffer_size(buffer) != 0) break; } // A request to read 0 bytes on a stream handle is a no-op. if (boost::asio::buffer_size(buffer) == 0) { ec = boost::system::error_code(); return 0; } overlapped_wrapper overlapped(ec); if (ec) { return 0; } // Read some data. overlapped.Offset = offset & 0xFFFFFFFF; overlapped.OffsetHigh = (offset >> 32) & 0xFFFFFFFF; BOOL ok = ::ReadFile(impl.handle_, boost::asio::buffer_cast<LPVOID>(buffer), static_cast<DWORD>(boost::asio::buffer_size(buffer)), 0, &overlapped); if (!ok) { DWORD last_error = ::GetLastError(); if (last_error != ERROR_IO_PENDING && last_error != ERROR_MORE_DATA) { if (last_error == ERROR_HANDLE_EOF) { ec = boost::asio::error::eof; } else { ec = boost::system::error_code(last_error, boost::asio::error::get_system_category()); } return 0; } } // Wait for the operation to complete. DWORD bytes_transferred = 0; ok = ::GetOverlappedResult(impl.handle_, &overlapped, &bytes_transferred, TRUE); if (!ok) { DWORD last_error = ::GetLastError(); if (last_error == ERROR_HANDLE_EOF) { ec = boost::asio::error::eof; } else { ec = boost::system::error_code(last_error, boost::asio::error::get_system_category()); } } ec = boost::system::error_code(); return bytes_transferred; }