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;
}
