zeroc-ice 3.6.5 → 3.7.4

data/ext/ice/cpp/src/Ice/ACM.cpp

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #include <Ice/ACM.h>
 #include <Ice/ConnectionI.h>
@@ -18,13 +13,15 @@ using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
+#ifndef ICE_CPP11_MAPPING
 IceUtil::Shared* IceInternal::upCast(ACMMonitor* p) { return p; }
 IceUtil::Shared* IceInternal::upCast(FactoryACMMonitor* p) { return p; }
+#endif
 
 IceInternal::ACMConfig::ACMConfig(bool server) :
     timeout(IceUtil::Time::seconds(60)),
-    heartbeat(Ice::HeartbeatOnInvocation),
-    close(server ? Ice::CloseOnInvocation : Ice::CloseOnInvocationAndIdle)
+    heartbeat(ICE_ENUM(ACMHeartbeat, HeartbeatOnDispatch)),
+    close(server ? ICE_ENUM(ACMClose, CloseOnInvocation) : ICE_ENUM(ACMClose, CloseOnInvocationAndIdle))
 {
 }
 
@@ -41,30 +38,41 @@ IceInternal::ACMConfig::ACMConfig(const Ice::PropertiesPtr& p,
     else
     {
         timeoutProperty = prefix + ".Timeout";
-    };
+    }
+
+    int timeoutVal = p->getPropertyAsIntWithDefault(timeoutProperty, static_cast<int>(dflt.timeout.toSeconds()));
+    if(timeoutVal >= 0)
+    {
+        timeout = IceUtil::Time::seconds(timeoutVal);
+    }
+    else
+    {
+        l->warning("invalid value for property `" + timeoutProperty + "', default value will be used instead");
+        timeout = dflt.timeout;
+    }
 
-    this->timeout = IceUtil::Time::seconds(p->getPropertyAsIntWithDefault(timeoutProperty,
-                                                                          static_cast<int>(dflt.timeout.toSeconds())));
-    int hb = p->getPropertyAsIntWithDefault(prefix + ".Heartbeat", dflt.heartbeat);
-    if(hb >= Ice::HeartbeatOff && hb <= Ice::HeartbeatAlways)
+    int hb = p->getPropertyAsIntWithDefault(prefix + ".Heartbeat", static_cast<int>(dflt.heartbeat));
+    if(hb >= static_cast<int>(ICE_ENUM(ACMHeartbeat, HeartbeatOff)) &&
+       hb <= static_cast<int>(ICE_ENUM(ACMHeartbeat, HeartbeatAlways)))
     {
-        this->heartbeat = static_cast<Ice::ACMHeartbeat>(hb);
+        heartbeat = static_cast<Ice::ACMHeartbeat>(hb);
     }
     else
     {
         l->warning("invalid value for property `" + prefix + ".Heartbeat" + "', default value will be used instead");
-        this->heartbeat = dflt.heartbeat;
+        heartbeat = dflt.heartbeat;
     }
 
-    int cl = p->getPropertyAsIntWithDefault(prefix + ".Close", dflt.close);
-    if(cl >= Ice::CloseOff && cl <= Ice::CloseOnIdleForceful)
+    int cl = p->getPropertyAsIntWithDefault(prefix + ".Close", static_cast<int>(dflt.close));
+    if(cl >= static_cast<int>(ICE_ENUM(ACMClose, CloseOff)) &&
+       cl <= static_cast<int>(ICE_ENUM(ACMClose, CloseOnIdleForceful)))
     {
-        this->close = static_cast<Ice::ACMClose>(cl);
+        close = static_cast<Ice::ACMClose>(cl);
     }
     else
     {
         l->warning("invalid value for property `" + prefix + ".Close" + "', default value will be used instead");
-        this->close = dflt.close;
+        close = dflt.close;
     }
 }
 
@@ -104,8 +112,8 @@ IceInternal::FactoryACMMonitor::destroy()
     //
     if(!_connections.empty())
     {
-        _instance->timer()->cancel(this);
-        _instance->timer()->schedule(this, IceUtil::Time());
+        _instance->timer()->cancel(ICE_SHARED_FROM_THIS);
+        _instance->timer()->schedule(ICE_SHARED_FROM_THIS, IceUtil::Time());
     }
 
     _instance = 0;
@@ -132,7 +140,7 @@ IceInternal::FactoryACMMonitor::add(const ConnectionIPtr& connection)
     if(_connections.empty())
     {
         _connections.insert(connection);
-        _instance->timer()->scheduleRepeated(this, _config.timeout / 2);
+        _instance->timer()->scheduleRepeated(ICE_SHARED_FROM_THIS, _config.timeout / 2);
     }
     else
     {
@@ -181,7 +189,7 @@ IceInternal::FactoryACMMonitor::acm(const IceUtil::Optional& timeout,
     {
         config.heartbeat = *heartbeat;
     }
-    return new ConnectionACMMonitor(this, _instance->timer(), config);
+    return ICE_MAKE_SHARED(ConnectionACMMonitor, ICE_SHARED_FROM_THIS, _instance->timer(), config);
 }
 
 Ice::ACM
@@ -228,7 +236,7 @@ IceInternal::FactoryACMMonitor::runTimerTask()
 
         if(_connections.empty())
         {
-            _instance->timer()->cancel(this);
+            _instance->timer()->cancel(ICE_SHARED_FROM_THIS);
             return;
         }
     }
@@ -301,18 +309,21 @@ IceInternal::ConnectionACMMonitor::add(const ConnectionIPtr& connection)
     _connection = connection;
     if(_config.timeout != IceUtil::Time())
     {
-        _timer->scheduleRepeated(this, _config.timeout / 2);
+        _timer->scheduleRepeated(ICE_SHARED_FROM_THIS, _config.timeout / 2);
     }
 }
 
 void
-IceInternal::ConnectionACMMonitor::remove(const ConnectionIPtr& connection)
+IceInternal::ConnectionACMMonitor::remove(ICE_MAYBE_UNUSED const ConnectionIPtr& connection)
 {
+#ifdef _MSC_VER
+    UNREFERENCED_PARAMETER(connection);
+#endif
     Lock sync(*this);
     assert(_connection == connection);
     if(_config.timeout != IceUtil::Time())
     {
-        _timer->cancel(this);
+        _timer->cancel(ICE_SHARED_FROM_THIS);
     }
     _connection = 0;
 }

data/ext/ice/cpp/src/Ice/ACM.h

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #ifndef ICE_ACM_H
 #define ICE_ACM_H
@@ -51,6 +46,9 @@ public:
 };
 
 class FactoryACMMonitor : public ACMMonitor, public IceUtil::Monitor<IceUtil::Mutex>
+#ifdef ICE_CPP11_MAPPING
+                        , public std::enable_shared_from_this<FactoryACMMonitor>
+#endif
 {
 public:
 
@@ -85,7 +83,11 @@ private:
     std::vector<Ice::ConnectionIPtr> _reapedConnections;
 };
 
-class ConnectionACMMonitor : public ACMMonitor, public ::IceUtil::Mutex
+class ConnectionACMMonitor : public ACMMonitor,
+                             public IceUtil::Mutex
+#ifdef ICE_CPP11_MAPPING
+                           , public std::enable_shared_from_this<ConnectionACMMonitor>
+#endif
 {
 public:
 

data/ext/ice/cpp/src/Ice/ACMF.h

@@ -0,0 +1,30 @@
+//
+// Copyright (c) ZeroC, Inc. All rights reserved.
+//
+
+#ifndef ICE_ACM_F_H
+#define ICE_ACM_F_H
+
+#include <IceUtil/Shared.h>
+#include <Ice/Handle.h>
+
+namespace IceInternal
+{
+
+class ACMMonitor;
+class FactoryACMMonitor;
+
+#ifdef ICE_CPP11_MAPPING
+using ACMMonitorPtr = ::std::shared_ptr<ACMMonitor>;
+using FactoryACMMonitorPtr = ::std::shared_ptr<FactoryACMMonitor>;
+#else
+IceUtil::Shared* upCast(ACMMonitor*);
+typedef IceInternal::Handle<ACMMonitor> ACMMonitorPtr;
+
+IceUtil::Shared* upCast(FactoryACMMonitor*);
+typedef IceInternal::Handle<FactoryACMMonitor> FactoryACMMonitorPtr;
+#endif
+
+}
+
+#endif

data/ext/ice/cpp/src/Ice/Acceptor.cpp

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #include <Ice/Acceptor.h>
 
@@ -13,4 +8,9 @@ using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
+Acceptor::~Acceptor()
+{
+    // Out of line to avoid weak vtable
+}
+
 IceUtil::Shared* IceInternal::upCast(Acceptor* p) { return p; }

data/ext/ice/cpp/src/Ice/Acceptor.h

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #ifndef ICE_ACCEPTOR_H
 #define ICE_ACCEPTOR_H
@@ -19,14 +14,15 @@
 namespace IceInternal
 {
 
-class ICE_API Acceptor : virtual public ::IceUtil::Shared
+class ICE_API Acceptor : public virtual ::IceUtil::Shared
 {
 public:
+    virtual ~Acceptor();
 
     virtual NativeInfoPtr getNativeInfo() = 0;
     virtual void close() = 0;
     virtual EndpointIPtr listen() = 0;
-#if defined(ICE_USE_IOCP) || defined(ICE_OS_WINRT)
+#if defined(ICE_USE_IOCP) || defined(ICE_OS_UWP)
     virtual void startAccept() = 0;
     virtual void finishAccept() = 0;
 #endif

data/ext/ice/cpp/src/Ice/AcceptorF.h

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #ifndef ICE_ACCEPTOR_F_H
 #define ICE_ACCEPTOR_F_H

data/ext/ice/cpp/src/Ice/ArgVector.cpp

@@ -0,0 +1,59 @@
+//
+// Copyright (c) ZeroC, Inc. All rights reserved.
+//
+
+#include <Ice/ArgVector.h>
+#include <cstring>
+
+IceInternal::ArgVector::ArgVector(int argcP, const char* const argvP[])
+{
+    assert(argcP >= 0);
+    _args.resize(static_cast<size_t>(argcP));
+    for(size_t i = 0; i < static_cast<size_t>(argcP); ++i)
+    {
+        _args[i] = argvP[i];
+    }
+    setupArgcArgv();
+}
+
+IceInternal::ArgVector::ArgVector(const ::std::vector< ::std::string>& vec)
+{
+    _args = vec;
+    setupArgcArgv();
+}
+
+IceInternal::ArgVector::ArgVector(const ArgVector& rhs)
+{
+    _args = rhs._args;
+    setupArgcArgv();
+}
+
+IceInternal::ArgVector&
+IceInternal::ArgVector::operator=(const ArgVector& rhs)
+{
+    delete[] argv;
+    argv = 0;
+    _args = rhs._args;
+    setupArgcArgv();
+    return *this;
+}
+
+IceInternal::ArgVector::~ArgVector()
+{
+    delete[] argv;
+}
+
+void
+IceInternal::ArgVector::setupArgcArgv()
+{
+    argc = static_cast<int>(_args.size());
+    if((argv = new char*[static_cast<size_t>(argc + 1)]) == 0)
+    {
+        throw ::std::bad_alloc();
+    }
+    for(size_t i = 0; i < static_cast<size_t>(argc); i++)
+    {
+        argv[i] = const_cast<char*>(_args[i].c_str());
+    }
+    argv[argc] = 0;
+}

data/ext/ice/cpp/src/Ice/ArgVector.h

@@ -0,0 +1,36 @@
+//
+// Copyright (c) ZeroC, Inc. All rights reserved.
+//
+
+#ifndef ICE_ARGVECTOR_H
+#define ICE_ARGVECTOR_H
+
+#include <Ice/Config.h>
+#include <vector>
+#include <string>
+
+namespace IceInternal
+{
+
+class ICE_API ArgVector
+{
+public:
+
+    ArgVector(int argc, const char* const argv[]);
+    ArgVector(const ::std::vector< ::std::string>&);
+    ArgVector(const ArgVector&);
+    ArgVector& operator=(const ArgVector&);
+    ~ArgVector();
+
+    int argc;
+    char** argv;
+
+private:
+
+    ::std::vector< ::std::string> _args;
+    void setupArgcArgv();
+};
+
+}
+
+#endif

data/ext/ice/cpp/src/Ice/AsyncResult.cpp

@@ -1,163 +1,26 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
-#include <IceUtil/DisableWarnings.h>
+#ifndef ICE_CPP11_MAPPING
+
 #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;
 
 IceUtil::Shared* Ice::upCast(AsyncResult* p) { return p; }
 
-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 0;
-}
-
-ObjectPrx 
-AsyncResult::getProxy() const
-{
-    return 0;
-}
-
-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) && !_exception.get())
-    {
-        _monitor.wait();
-    }
-}
-
-void
-AsyncResult::throwLocalException() const
-{
-    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor);
-    if(_exception.get())
-    {
-        _exception.get()->ice_throw();
-    }
-}
-
-bool 
-AsyncResult::sentSynchronously() const
-{
-    return _sentSynchronously;
-}
-
-LocalObjectPtr 
-AsyncResult::getCookie() const
-{
-    return _cookie;
-}
-
-const std::string& 
-AsyncResult::getOperation() const
-{
-    return _operation;
-}
-
-void
-AsyncResult::__throwUserException()
-{
-    try
-    {
-        _is.startReadEncaps();
-        _is.throwException();
-    }
-    catch(const Ice::UserException&)
-    {
-        _is.endReadEncaps();
-        throw;
-    }
-}
-
-bool
-AsyncResult::__wait()
+AsyncResult::~AsyncResult()
 {
-    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(_exception.get())
-    {
-        _exception.get()->ice_throw();
-    }
-    return _state & OK;
+    // Out of line to avoid weak vtable
 }
 
 void
-AsyncResult::__check(const AsyncResultPtr& r, const IceProxy::Ice::Object* prx, const string& operation)
+AsyncResult::_check(const AsyncResultPtr& r, const IceProxy::Ice::Object* prx, const string& operation)
 {
-    __check(r, operation);
+    check(r, operation);
     if(r->getProxy().get() != prx)
     {
         throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, "Proxy for call to end_" + operation +
@@ -167,9 +30,9 @@ AsyncResult::__check(const AsyncResultPtr& r, const IceProxy::Ice::Object* prx,
 }
 
 void
-AsyncResult::__check(const AsyncResultPtr& r, const Ice::Communicator* com, const string& operation)
+AsyncResult::_check(const AsyncResultPtr& r, const Ice::Communicator* com, const string& operation)
 {
-    __check(r, operation);
+    check(r, operation);
     if(r->getCommunicator().get() != com)
     {
         throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, "Communicator for call to end_" + operation +
@@ -179,9 +42,9 @@ AsyncResult::__check(const AsyncResultPtr& r, const Ice::Communicator* com, cons
 }
 
 void
-AsyncResult::__check(const AsyncResultPtr& r, const Ice::Connection* con, const string& operation)
+AsyncResult::_check(const AsyncResultPtr& r, const Ice::Connection* con, const string& operation)
 {
-    __check(r, operation);
+    check(r, operation);
     if(r->getConnection().get() != con)
     {
         throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, "Connection for call to end_" + operation +
@@ -191,409 +54,17 @@ AsyncResult::__check(const AsyncResultPtr& r, const Ice::Connection* con, const
 }
 
 void
-AsyncResult::__check(const AsyncResultPtr& r, const string& operation)
+AsyncResult::check(const AsyncResultPtr& r, const string& operation)
 {
     if(!r)
     {
         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);
-    }
-}
-
-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);
-}
-
-AsyncResult::~AsyncResult()
-{
-}
-
-bool
-AsyncResult::sent(bool done)
-{
-    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor);
-    assert(!_exception.get());
-
-    bool alreadySent = _state & Sent;
-    _state |= Sent;
-    if(done)
-    {
-        _state |= Done | OK;
-        _cancellationHandler = 0;
-        if(!_callback || !_callback->hasSentCallback())
-        {
-            _observer.detach();
-        }
+                                                " method: " + r->getOperation());
     }
-
-    _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;
 }
 
-bool
-AsyncResult::finished(const Ice::Exception& ex)
-{
-    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor);
-    _state |= Done;
-    _exception.reset(ex.ice_clone());
-    _cancellationHandler = 0;
-    _observer.failed(ex.ice_name());
-    if(!_callback)
-    {
-        _observer.detach();
-    }
-    _monitor.notifyAll();
-    return _callback;
-}
-
-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, 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, this));
-}
-
-void
-AsyncResult::invokeSent()
-{
-    assert(_callback);
-
-    try
-    {
-        AsyncResultPtr self(this);
-        _callback->sent(self);
-    }
-    catch(const std::exception& ex)
-    {
-        warning(ex);
-    }
-    catch(...)
-    {
-        warning();
-    }
-
-    if(_observer)
-    {
-        ObjectPrx proxy = getProxy();
-        if(!proxy || !proxy->ice_isTwoway())
-        {
-            _observer.detach();
-        }            
-    }
-}
-
-void
-AsyncResult::invokeCompleted()
-{
-    assert(_callback);
-
-    try
-    {
-        AsyncResultPtr self(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);
-        _cancellationException.reset(ex.ice_clone());
-        if(!_cancellationHandler)
-        {
-            return;
-        }
-        handler = _cancellationHandler;
-    }
-    handler->asyncRequestCanceled(OutgoingAsyncBasePtr::dynamicCast(this), ex);
-}
-
-void
-AsyncResult::cancelable(const CancellationHandlerPtr& handler)
-{
-    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor);
-    if(_cancellationException.get())
-    {
-        try
-        {
-            _cancellationException->ice_throw();
-        }
-        catch(const Ice::Exception&)
-        {
-            _cancellationException.reset(0);
-            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 = new DummyCallback;
-
-#ifdef ICE_CPP11
-
-Ice::CallbackPtr
-Ice::newCallback(const ::IceInternal::Function<void (const AsyncResultPtr&)>& completed,
-                 const ::IceInternal::Function<void (const AsyncResultPtr&)>& sent)
-{
-    class Cpp11CB : public GenericCallbackBase
-    {
-    public:
-
-        Cpp11CB(const ::std::function<void (const AsyncResultPtr&)>& completed,
-                const ::std::function<void (const AsyncResultPtr&)>& sent) :
-            _completed(completed),
-            _sent(sent)
-        {
-            checkCallback(true, completed != nullptr);
-        }
-
-        virtual void
-        completed(const AsyncResultPtr& result) const
-        {
-            _completed(result);
-        }
-
-        virtual CallbackBasePtr
-        verify(const LocalObjectPtr&)
-        {
-            return this; // Nothing to do, the cookie is not type-safe.
-        }
-
-        virtual void
-        sent(const AsyncResultPtr& result) const
-        {
-            if(_sent != nullptr)
-            {
-                _sent(result);
-             }
-        }
-
-        virtual bool
-        hasSentCallback() const
-        {
-            return _sent != nullptr;
-        }
-
-    private:
-
-        ::std::function< void (const AsyncResultPtr&)> _completed;
-        ::std::function< void (const AsyncResultPtr&)> _sent;
-    };
-
-    return new Cpp11CB(completed, sent);
-}
 #endif
-
-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");
-    }
-}
-
-