diff options
Diffstat (limited to 'cpp/src/Ice/AsyncResult.cpp')
| -rw-r--r-- | cpp/src/Ice/AsyncResult.cpp | 508 |
1 files changed, 5 insertions, 503 deletions
diff --git a/cpp/src/Ice/AsyncResult.cpp b/cpp/src/Ice/AsyncResult.cpp index 37a5581f11a..b8c33b60089 100644 --- a/cpp/src/Ice/AsyncResult.cpp +++ b/cpp/src/Ice/AsyncResult.cpp @@ -7,158 +7,16 @@ // // ********************************************************************** +#ifndef ICE_CPP11_MAPPING + #include <IceUtil/DisableWarnings.h> #include <Ice/AsyncResult.h> -#include <Ice/ThreadPool.h> -#include <Ice/Instance.h> -#include <Ice/LoggerUtil.h> -#include <Ice/Properties.h> -#include <Ice/RequestHandler.h> -#include <Ice/OutgoingAsync.h> +#include <Ice/Proxy.h> using namespace std; using namespace Ice; -using namespace IceInternal; -#ifndef ICE_CPP11_MAPPING IceUtil::Shared* Ice::upCast(AsyncResult* p) { return p; } -#endif - -const unsigned char Ice::AsyncResult::OK = 0x1; -const unsigned char Ice::AsyncResult::Done = 0x2; -const unsigned char Ice::AsyncResult::Sent = 0x4; -const unsigned char Ice::AsyncResult::EndCalled = 0x8; - -void -AsyncResult::cancel() -{ - cancel(InvocationCanceledException(__FILE__, __LINE__)); -} - -Int -AsyncResult::getHash() const -{ - return static_cast<Int>(reinterpret_cast<Long>(this) >> 4); -} - -CommunicatorPtr -AsyncResult::getCommunicator() const -{ - return _communicator; -} - -ConnectionPtr -AsyncResult::getConnection() const -{ - return ICE_NULLPTR; -} - -ObjectPrxPtr -AsyncResult::getProxy() const -{ - return ICE_NULLPTR; -} - -bool -AsyncResult::isCompleted() const -{ - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor); - return _state & Done; -} - -void -AsyncResult::waitForCompleted() -{ - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor); - while(!(_state & Done)) - { - _monitor.wait(); - } -} - -bool -AsyncResult::isSent() const -{ - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor); - return _state & Sent; -} - -void -AsyncResult::waitForSent() -{ - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor); - while(!(_state & Sent) && !ICE_EXCEPTION_GET(_exception)) - { - _monitor.wait(); - } -} - -void -AsyncResult::throwLocalException() const -{ - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor); - if(ICE_EXCEPTION_GET(_exception)) - { - ICE_RETHROW_EXCEPTION(_exception); - } -} - -bool -AsyncResult::sentSynchronously() const -{ - return _sentSynchronously; -} - -#ifndef ICE_CPP11_MAPPING -LocalObjectPtr -AsyncResult::getCookie() const -{ - return _cookie; -} -#endif - -const std::string& -AsyncResult::getOperation() const -{ - return _operation; -} - -void -AsyncResult::__throwUserException() -{ - try - { - _is.startEncapsulation(); - _is.throwException(); - } - catch(const Ice::UserException&) - { - _is.endEncapsulation(); - throw; - } -} - -bool -AsyncResult::__wait() -{ - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor); - if(_state & EndCalled) - { - throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, "end_ method called more than once"); - } - _state |= EndCalled; - while(!(_state & Done)) - { - _monitor.wait(); - } - - if(ICE_EXCEPTION_GET(_exception)) - { - ICE_RETHROW_EXCEPTION(_exception); - } - - return _state & OK; -} void AsyncResult::__check(const AsyncResultPtr& r, const IceProxy::Ice::Object* prx, const string& operation) @@ -203,368 +61,12 @@ AsyncResult::__check(const AsyncResultPtr& r, const string& operation) { throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, "AsyncResult == null"); } - else if(&r->_operation != &operation) + else if(r->getOperation() != operation) { throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, "Incorrect operation for end_" + operation + - " method: " + r->_operation); + " method: " + r->getOperation()); } } -#ifdef ICE_CPP11_MAPPING -AsyncResult::AsyncResult(const CommunicatorPtr& communicator, - const IceInternal::InstancePtr& instance, - const string& op, - const CallbackBasePtr& callback) : - _instance(instance), - _sentSynchronously(false), - _is(instance.get(), Ice::currentProtocolEncoding), - _communicator(communicator), - _operation(op), - _callback(callback), - _state(0) -{ - if(!_callback) - { - throw IceUtil::IllegalArgumentException(__FILE__, __LINE__); - } -} -#else -AsyncResult::AsyncResult(const CommunicatorPtr& communicator, - const IceInternal::InstancePtr& instance, - const string& op, - const CallbackBasePtr& del, - const LocalObjectPtr& cookie) : - _instance(instance), - _sentSynchronously(false), - _is(instance.get(), Ice::currentProtocolEncoding), - _communicator(communicator), - _operation(op), - _callback(del), - _cookie(cookie), - _state(0) -{ - if(!_callback) - { - throw IceUtil::IllegalArgumentException(__FILE__, __LINE__); - } - const_cast<CallbackBasePtr&>(_callback) = _callback->verify(_cookie); -} #endif -AsyncResult::~AsyncResult() -{ -} - -bool -AsyncResult::sent(bool done) -{ - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor); - assert(!ICE_EXCEPTION_GET(_exception)); - bool alreadySent = _state & Sent; - _state |= Sent; - if(done) - { - _state |= Done | OK; - _cancellationHandler = 0; - if(!_callback || !_callback->hasSentCallback()) - { - _observer.detach(); - } - } - - _monitor.notifyAll(); - return !alreadySent && _callback && _callback->hasSentCallback(); -} - -bool -AsyncResult::finished(bool ok) -{ - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor); - _state |= Done; - if(ok) - { - _state |= OK; - } - _cancellationHandler = 0; - if(!_callback) - { - _observer.detach(); - } - _monitor.notifyAll(); - return _callback != ICE_NULLPTR; -} - -bool -AsyncResult::finished(const Ice::Exception& ex) -{ - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor); - _state |= Done; - ICE_RESET_EXCEPTION(_exception, ex.ice_clone()); - _cancellationHandler = 0; - _observer.failed(ex.ice_id()); - if(!_callback) - { - _observer.detach(); - } - _monitor.notifyAll(); - return _callback != ICE_NULLPTR; -} - -void -AsyncResult::invokeSentAsync() -{ - class AsynchronousSent : public DispatchWorkItem - { - public: - - AsynchronousSent(const ConnectionPtr& connection, const AsyncResultPtr& result) : - DispatchWorkItem(connection), _result(result) - { - } - - virtual void - run() - { - _result->invokeSent(); - } - - private: - - const AsyncResultPtr _result; - }; - - // - // This is called when it's not safe to call the sent callback - // synchronously from this thread. Instead the exception callback - // is called asynchronously from the client thread pool. - // - try - { - _instance->clientThreadPool()->dispatch(new AsynchronousSent(_cachedConnection, ICE_SHARED_FROM_THIS)); - } - catch(const Ice::CommunicatorDestroyedException&) - { - } -} - -void -AsyncResult::invokeCompletedAsync() -{ - class AsynchronousCompleted : public DispatchWorkItem - { - public: - - AsynchronousCompleted(const ConnectionPtr& connection, const AsyncResultPtr& result) : - DispatchWorkItem(connection), _result(result) - { - } - - virtual void - run() - { - _result->invokeCompleted(); - } - - private: - - const AsyncResultPtr _result; - }; - - // - // CommunicatorDestroyedCompleted is the only exception that can propagate directly - // from this method. - // - _instance->clientThreadPool()->dispatch(new AsynchronousCompleted(_cachedConnection, ICE_SHARED_FROM_THIS)); -} - -void -AsyncResult::invokeSent() -{ - assert(_callback); - - try - { - AsyncResultPtr self(ICE_SHARED_FROM_THIS); - _callback->sent(self); - } - catch(const std::exception& ex) - { - warning(ex); - } - catch(...) - { - warning(); - } - - if(_observer) - { - ObjectPrxPtr proxy = getProxy(); - if(!proxy || !proxy->ice_isTwoway()) - { - _observer.detach(); - } - } -} - -void -AsyncResult::invokeCompleted() -{ - assert(_callback); - - try - { - AsyncResultPtr self(ICE_SHARED_FROM_THIS); - _callback->completed(self); - } - catch(const std::exception& ex) - { - warning(ex); - } - catch(...) - { - warning(); - } - - _observer.detach(); -} - -void -AsyncResult::cancel(const Ice::LocalException& ex) -{ - CancellationHandlerPtr handler; - { - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor); - ICE_RESET_EXCEPTION(_cancellationException, ex.ice_clone()); - if(!_cancellationHandler) - { - return; - } - handler = _cancellationHandler; - } - handler->asyncRequestCanceled(ICE_DYNAMIC_CAST(OutgoingAsyncBase, ICE_SHARED_FROM_THIS), ex); -} - -void -AsyncResult::cancelable(const CancellationHandlerPtr& handler) -{ - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor); - - - if(ICE_EXCEPTION_GET(_cancellationException)) - { - try - { - ICE_RETHROW_EXCEPTION(_cancellationException); - } - catch(const Ice::LocalException&) - { - ICE_RESET_EXCEPTION(_cancellationException, ICE_NULLPTR); - throw; - } - } - _cancellationHandler = handler; -} - -void -AsyncResult::warning(const std::exception& exc) const -{ - if(_instance->initializationData().properties->getPropertyAsIntWithDefault("Ice.Warn.AMICallback", 1) > 0) - { - Warning out(_instance->initializationData().logger); - const Exception* ex = dynamic_cast<const Exception*>(&exc); - if(ex) - { - out << "Ice::Exception raised by AMI callback:\n" << *ex; - } - else - { - out << "std::exception raised by AMI callback:\n" << exc.what(); - } - } -} - -void -AsyncResult::warning() const -{ - if(_instance->initializationData().properties->getPropertyAsIntWithDefault("Ice.Warn.AMICallback", 1) > 0) - { - Warning out(_instance->initializationData().logger); - out << "unknown exception raised by AMI callback"; - } -} - - -namespace -{ - -// -// Dummy class derived from CallbackBase -// We use this class for the __dummyCallback extern pointer in OutgoingAsync. In turn, -// this allows us to test whether the user supplied a null delegate instance to the -// generated begin_ method without having to generate a separate test to throw IllegalArgumentException -// in the inlined versions of the begin_ method. In other words, this reduces the amount of generated -// object code. -// -class DummyCallback : public CallbackBase -{ -public: - - DummyCallback() - { - } - - virtual void - completed(const Ice::AsyncResultPtr&) const - { - assert(false); - } - - virtual CallbackBasePtr - verify(const Ice::LocalObjectPtr&) - { - // - // Called by the AsyncResult constructor to verify the delegate. The dummy - // delegate is passed when the user used a begin_ method without delegate. - // By returning 0 here, we tell the AsyncResult that no delegates was - // provided. - // - return 0; - } - - virtual void - sent(const AsyncResultPtr&) const - { - assert(false); - } - - virtual bool - hasSentCallback() const - { - assert(false); - return false; - } -}; - -} - -// -// This gives a pointer value to compare against in the generated -// begin_ method to decide whether the caller passed a null pointer -// versus the generated inline version of the begin_ method having -// passed a pointer to the dummy delegate. -// -CallbackBasePtr IceInternal::__dummyCallback = ICE_MAKE_SHARED(DummyCallback); - -void -IceInternal::CallbackBase::checkCallback(bool obj, bool cb) -{ - if(!obj) - { - throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, "callback object cannot be null"); - } - if(!cb) - { - throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, "callback cannot be null"); - } -} - |