void
ConnectRequestHandler::asyncRequestCanceled(const OutgoingAsyncBasePtr& outAsync, const Ice::LocalException& ex)
{
{
Lock sync(*this);
if(ICE_EXCEPTION_GET(_exception))
{
return; // The request has been notified of a failure already.
}
if(!initialized())
{
for(deque<Request>::iterator p = _requests.begin(); p != _requests.end(); ++p)
{
if(p->outAsync.get() == outAsync.get())
{
_requests.erase(p);
if(outAsync->completed(ex))
{
outAsync->invokeCompletedAsync();
}
return;
}
}
}
}
_connection->asyncRequestCanceled(outAsync, ex);
}
void
CollocatedRequestHandler::sendResponse(Int requestId, BasicStream* os, Byte, bool amd)
{
OutgoingAsyncBasePtr outAsync;
{
Lock sync(*this);
assert(_response);
os->i = os->b.begin() + sizeof(replyHdr) + 4;
if(_traceLevels->protocol >= 1)
{
fillInValue(os, 10, static_cast<Int>(os->b.size()));
traceRecv(*os, _logger, _traceLevels);
}
map<int, OutgoingBase*>::iterator p = _requests.find(requestId);
if(p != _requests.end())
{
p->second->completed(*os);
_requests.erase(p);
}
else
{
map<int, OutgoingAsyncBasePtr>::iterator q = _asyncRequests.find(requestId);
if(q != _asyncRequests.end())
{
os->swap(*q->second->getIs());
if(q->second->completed())
{
outAsync = q->second;
}
_asyncRequests.erase(q);
}
}
}
if(outAsync)
{
//
// If called from an AMD dispatch, invoke asynchronously
// the completion callback since this might be called from
// the user code.
//
if(amd)
{
outAsync->invokeCompletedAsync();
}
else
{
outAsync->invokeCompleted();
}
}
_adapter->decDirectCount();
}
void
CollocatedRequestHandler::asyncRequestCanceled(const OutgoingAsyncBasePtr& outAsync, const LocalException& ex)
{
Lock sync(*this);
map<OutgoingAsyncBasePtr, Int>::iterator p = _sendAsyncRequests.find(outAsync);
if(p != _sendAsyncRequests.end())
{
if(p->second > 0)
{
_asyncRequests.erase(p->second);
}
_sendAsyncRequests.erase(p);
if(outAsync->completed(ex))
{
outAsync->invokeCompletedAsync();
}
return;
}
OutgoingAsyncPtr o = OutgoingAsyncPtr::dynamicCast(outAsync);
if(o)
{
for(map<Int, OutgoingAsyncBasePtr>::iterator q = _asyncRequests.begin(); q != _asyncRequests.end(); ++q)
{
if(q->second.get() == o.get())
{
_asyncRequests.erase(q);
if(outAsync->completed(ex))
{
outAsync->invokeCompletedAsync();
}
return;
}
}
}
}
void
CollocatedRequestHandler::handleException(int requestId, const Exception& ex, bool amd)
{
if(requestId == 0)
{
return; // Ignore exception for oneway messages.
}
OutgoingAsyncBasePtr outAsync;
{
Lock sync(*this);
map<int, OutgoingBase*>::iterator p = _requests.find(requestId);
if(p != _requests.end())
{
p->second->completed(ex);
_requests.erase(p);
}
else
{
map<int, OutgoingAsyncBasePtr>::iterator q = _asyncRequests.find(requestId);
if(q != _asyncRequests.end())
{
if(q->second->completed(ex))
{
outAsync = q->second;
}
_asyncRequests.erase(q);
}
}
}
if(outAsync)
{
//
// If called from an AMD dispatch, invoke asynchronously
// the completion callback since this might be called from
// the user code.
//
if(amd)
{
outAsync->invokeCompletedAsync();
}
else
{
outAsync->invokeCompleted();
}
}
}