Refactored invocation code to better suite new C++11 mapping

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