Completed fix for ICE-5567: move various C++11 classes/functions out of line

13 files changed, 552 insertions, 462 deletions

diff --git a/cpp/include/Ice/CommunicatorAsync.h b/cpp/include/Ice/CommunicatorAsync.h
index a47ff1282d7..5258a2e1a55 100644
--- a/cpp/include/Ice/CommunicatorAsync.h
+++ b/cpp/include/Ice/CommunicatorAsync.h
@@ -40,43 +40,13 @@ public:
             __com->end_flushBatchRequests(__result);
             assert(false);
         }
-        catch(::Ice::Exception& ex)
+        catch(const ::Ice::Exception& ex)
         {
             ::IceInternal::CallbackNC<T>::__exception(__result, ex);
         }
     }
 };
 
-#ifdef ICE_CPP11
-class Cpp11FnCallbackNC_Communicator_flushBatchRequests : virtual public ::IceInternal::Cpp11FnCallbackNC
-{
-public:
-    
-    Cpp11FnCallbackNC_Communicator_flushBatchRequests(
-                                            const ::IceInternal::Function<void (const ::Ice::Exception&)>& excb,
-                                            const ::IceInternal::Function<void (bool)>& sentcb) :
-        ::IceInternal::Cpp11FnCallbackNC(excb, sentcb)
-    {
-        CallbackBase::checkCallback(true, excb != nullptr);
-    }
-    
-    virtual void
-    __completed(const ::Ice::AsyncResultPtr& __result) const
-    {
-        ::Ice::CommunicatorPtr __com = __result->getCommunicator();
-        assert(__com);
-        try
-        {
-            __com->end_flushBatchRequests(__result);
-            assert(false);
-        }
-        catch(::Ice::Exception& ex)
-        {
-            ::IceInternal::Cpp11FnCallbackNC::__exception(__result, ex);
-        }
-    }
-};
-#endif
 
 template<class T> Callback_Communicator_flushBatchRequestsPtr
 newCallback_Communicator_flushBatchRequests(const IceUtil::Handle<T>& instance,
@@ -118,7 +88,7 @@ public:
             __com->end_flushBatchRequests(__result);
             assert(false);
         }
-        catch(::Ice::Exception& ex)
+        catch(const ::Ice::Exception& ex)
         {
             ::IceInternal::Callback<T, CT>::__exception(__result, ex);
         }
diff --git a/cpp/include/Ice/ConnectionAsync.h b/cpp/include/Ice/ConnectionAsync.h
index 7d049d4755b..4275bdf9aa8 100644
--- a/cpp/include/Ice/ConnectionAsync.h
+++ b/cpp/include/Ice/ConnectionAsync.h
@@ -41,43 +41,13 @@ public:
             __con->end_flushBatchRequests(__result);
             assert(false);
         }
-        catch(::Ice::Exception& ex)
+        catch(const ::Ice::Exception& ex)
         {
             ::IceInternal::CallbackNC<T>::__exception(__result, ex);
         }
     }
 };
 
-#ifdef ICE_CPP11
-class Cpp11FnCallbackNC_Connection_flushBatchRequests : virtual public ::IceInternal::Cpp11FnCallbackNC
-{
-public:
-    
-    Cpp11FnCallbackNC_Connection_flushBatchRequests(const ::IceInternal::Function<void (const ::Ice::Exception&)>& excb,
-                            const ::IceInternal::Function<void (bool)>& sentcb) :
-        ::IceInternal::Cpp11FnCallbackNC(excb, sentcb)
-    {
-        CallbackBase::checkCallback(true, excb != nullptr);
-    }
-    
-    virtual void
-    __completed(const ::Ice::AsyncResultPtr& __result) const
-    {
-        ::Ice::ConnectionPtr __con = __result->getConnection();
-        assert(__con);
-        try
-        {
-            __con->end_flushBatchRequests(__result);
-            assert(false);
-        }
-        catch(::Ice::Exception& ex)
-        {
-            ::IceInternal::Cpp11FnCallbackNC::__exception(__result, ex);
-        }
-    }
-};
-#endif
-
 template<class T> Callback_Connection_flushBatchRequestsPtr
 newCallback_Connection_flushBatchRequests(const IceUtil::Handle<T>& instance,
                                           void (T::*excb)(const ::Ice::Exception&),
@@ -118,7 +88,7 @@ public:
             __con->end_flushBatchRequests(__result);
             assert(false);
         }
-        catch(::Ice::Exception& ex)
+        catch(const ::Ice::Exception& ex)
         {
             ::IceInternal::Callback<T, CT>::__exception(__result, ex);
         }
diff --git a/cpp/include/Ice/Dispatcher.h b/cpp/include/Ice/Dispatcher.h
index 348ba87bb9d..d8283e0d720 100644
--- a/cpp/include/Ice/Dispatcher.h
+++ b/cpp/include/Ice/Dispatcher.h
@@ -41,39 +41,11 @@ public:
 
 typedef IceUtil::Handle<Dispatcher> DispatcherPtr;
 
-}
-
 #ifdef ICE_CPP11
-namespace IceInternal
-{
-class ICE_API Cpp11Dispatcher : public ::Ice::Dispatcher
-{
-public:
-    
-    Cpp11Dispatcher(const ::std::function<void (const ::Ice::DispatcherCallPtr&, const ::Ice::ConnectionPtr)>& cb) :
-        _cb(cb)
-    {
-    }
-    
-    virtual void dispatch(const ::Ice::DispatcherCallPtr& call, const ::Ice::ConnectionPtr& conn);
-    
-private:
-    
-    const ::std::function<void (const ::Ice::DispatcherCallPtr&, const ::Ice::ConnectionPtr)> _cb;
-};
-
-}
-
-namespace Ice
-{
-
-inline DispatcherPtr
-newDispatcher(const ::std::function<void (const ::Ice::DispatcherCallPtr&, const ::Ice::ConnectionPtr)>& cb)
-{
-    return new ::IceInternal::Cpp11Dispatcher(cb);
-}
+ICE_API DispatcherPtr
+newDispatcher(const ::std::function<void (const DispatcherCallPtr&, const ConnectionPtr)>&);
+#endif
 
 }
 
 #endif
-#endif
diff --git a/cpp/include/Ice/OutgoingAsync.h b/cpp/include/Ice/OutgoingAsync.h
index 848cb6b69ba..c432663c966 100644
--- a/cpp/include/Ice/OutgoingAsync.h
+++ b/cpp/include/Ice/OutgoingAsync.h
@@ -536,44 +536,6 @@ public:
     }
 };
 
-class Cpp11AsyncCallback : public GenericCallbackBase
-{
-public:
-
-    Cpp11AsyncCallback(const ::std::function<void (const ::Ice::AsyncResultPtr&)>& completed,
-                       const ::std::function<void (const ::Ice::AsyncResultPtr&)>& sent) :
-        _completed(completed), 
-        _sent(sent)
-    {
-        checkCallback(true, completed != nullptr);
-    }
-
-    virtual void __completed(const ::Ice::AsyncResultPtr& result) const
-    {
-        _completed(result);
-    }
-
-    virtual CallbackBasePtr __verify(::Ice::LocalObjectPtr&)
-    {
-        return this; // Nothing to do, the cookie is not type-safe.
-    }
-
-    virtual void __sent(const ::Ice::AsyncResultPtr& result) const
-    {
-        if(_sent != nullptr)
-        {
-            _sent(result);
-        }
-    }
-    
-    virtual bool __hasSentCallback() const
-    {
-        return _sent != nullptr;
-    }
-    
-    ::std::function< void (const ::Ice::AsyncResultPtr&)> _completed;
-    ::std::function< void (const ::Ice::AsyncResultPtr&)> _sent;
-};
 #endif
 
 }
@@ -585,28 +547,26 @@ typedef IceUtil::Handle< ::IceInternal::GenericCallbackBase> CallbackPtr;
 
 template<class T> CallbackPtr
 newCallback(const IceUtil::Handle<T>& instance,
-            void (T::*cb)(const ::Ice::AsyncResultPtr&),
-            void (T::*sentcb)(const ::Ice::AsyncResultPtr&) = 0)
+            void (T::*cb)(const AsyncResultPtr&),
+            void (T::*sentcb)(const AsyncResultPtr&) = 0)
 {
     return new ::IceInternal::AsyncCallback<T>(instance, cb, sentcb);
 }
 
 template<class T> CallbackPtr
 newCallback(T* instance,
-            void (T::*cb)(const ::Ice::AsyncResultPtr&),
-            void (T::*sentcb)(const ::Ice::AsyncResultPtr&) = 0)
+            void (T::*cb)(const AsyncResultPtr&),
+            void (T::*sentcb)(const AsyncResultPtr&) = 0)
 {
     return new ::IceInternal::AsyncCallback<T>(instance, cb, sentcb);
 }
 
 #ifdef ICE_CPP11
-inline CallbackPtr
-newCallback(const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& completed,
-            const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& sent = 
-                  ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
-{
-    return new ::IceInternal::Cpp11AsyncCallback(completed, sent);
-}
+
+ICE_API CallbackPtr
+newCallback(const ::IceInternal::Function<void (const AsyncResultPtr&)>&,
+            const ::IceInternal::Function<void (const AsyncResultPtr&)>& = 
+               ::IceInternal::Function<void (const AsyncResultPtr&)>());
 #endif
 
 //
diff --git a/cpp/include/Ice/Proxy.h b/cpp/include/Ice/Proxy.h
index 212fe0a1ef3..0155efadbf0 100644
--- a/cpp/include/Ice/Proxy.h
+++ b/cpp/include/Ice/Proxy.h
@@ -154,62 +154,35 @@ typedef IceUtil::Handle<AMI_Object_ice_flushBatchRequests> AMI_Object_ice_flushB
 namespace IceInternal
 {
 
-class ICE_API Cpp11FnCallbackNC : virtual public CallbackBase
+class ICE_API Cpp11FnCallbackNC : public CallbackBase
 {
 public:
 
-    Cpp11FnCallbackNC(const ::std::function<void (const ::Ice::Exception&)>& excb,
-                      const ::std::function<void (bool)>& sentcb) :
-        _exception(excb),
-        _sent(sentcb)
-    {
-    }
+    Cpp11FnCallbackNC(const ::std::function<void (const ::Ice::Exception&)>&,
+                      const ::std::function<void (bool)>&);
 
-    virtual CallbackBasePtr __verify(::Ice::LocalObjectPtr&)
-    {
-        return this;
-    }
+    virtual CallbackBasePtr __verify(::Ice::LocalObjectPtr&);
 
-    virtual void __sent(const ::Ice::AsyncResultPtr& result) const
-    {
-        if(_sent != nullptr)
-        {
-            _sent(result->sentSynchronously());
-        }
-    }
-
-    virtual bool __hasSentCallback() const
-    {
-        return _sent != nullptr;
-    }
+    virtual void __sent(const ::Ice::AsyncResultPtr&) const;
+ 
+    virtual bool __hasSentCallback() const;
 
 protected:
 
-    void __exception(const ::Ice::AsyncResultPtr&, const ::Ice::Exception& ex) const
-    {
-        if(_exception != nullptr)
-        {
-            _exception(ex);
-        }
-    }
+    void __exception(const ::Ice::AsyncResultPtr&, const ::Ice::Exception& ex) const;
 
     ::std::function<void (const ::Ice::Exception&)> _exception;
     ::std::function<void (bool)> _sent;
 };
 
-class ICE_API Cpp11FnOnewayCallbackNC : virtual public ::IceInternal::Cpp11FnCallbackNC
+class ICE_API Cpp11FnOnewayCallbackNC : public Cpp11FnCallbackNC
 {
 public:
     
-    Cpp11FnOnewayCallbackNC(const ::std::function<void ()>& cb,
-                            const ::std::function<void (const ::Ice::Exception&)>& excb,
-                            const ::std::function<void (bool)>& sentcb) :
-        Cpp11FnCallbackNC(excb, sentcb),
-        _cb(cb)
-    {
-        CallbackBase::checkCallback(true, cb || excb != nullptr);
-    }
-    
+    Cpp11FnOnewayCallbackNC(const ::std::function<void ()>&,
+                            const ::std::function<void (const ::Ice::Exception&)>&,
+                            const ::std::function<void (bool)>&);
+
     virtual void
     __completed(const ::Ice::AsyncResultPtr&) const;
     
@@ -245,7 +218,7 @@ public:
         return ice_isA(typeId, &context);
     }
     
-#ifdef  ICE_CPP11
+#ifdef ICE_CPP11
     ::Ice::AsyncResultPtr
     begin_ice_isA(const ::std::string& typeId, 
                   const ::Ice::Context& ctx, 
@@ -620,7 +593,7 @@ public:
         const ::std::vector< ::Ice::Byte>& inParams,
         const ::IceInternal::Function<void (bool, const ::std::vector< ::Ice::Byte>&)>& response, 
         const ::IceInternal::Function<void (const ::Ice::Exception&)>& exception = 
-        ::IceInternal::Function<void (const ::Ice::Exception&)>(),
+           ::IceInternal::Function<void (const ::Ice::Exception&)>(),
         const ::IceInternal::Function<void (bool)>& sent = ::IceInternal::Function<void (bool)>())
     {
         return __begin_ice_invoke(operation, mode, inParams, 0, response, exception, sent);
@@ -633,7 +606,7 @@ public:
         const ::Ice::Context& ctx,
         const ::IceInternal::Function<void (bool, const ::std::vector< ::Ice::Byte>&)>& response,
         const ::IceInternal::Function<void (const ::Ice::Exception&)>& exception = 
-        ::IceInternal::Function<void (const ::Ice::Exception&)>(),
+           ::IceInternal::Function<void (const ::Ice::Exception&)>(),
         const ::IceInternal::Function<void (bool)>& sent = ::IceInternal::Function<void (bool)>())
     {
         return __begin_ice_invoke(operation, mode, inParams, &ctx, response, exception, sent);
@@ -921,55 +894,30 @@ protected:
 private:
 
     ::IceInternal::RequestHandlerPtr createRequestHandler(bool);
-    
+
+    bool ice_isA(const ::std::string&, const ::Ice::Context*);
+    ::Ice::AsyncResultPtr begin_ice_isA(const ::std::string&,
+                                        const ::Ice::Context*,
+                                        const ::IceInternal::CallbackBasePtr&,
+                                        const ::Ice::LocalObjectPtr&);
+
 #ifdef ICE_CPP11
     ::Ice::AsyncResultPtr __begin_ice_isA(
-        const ::std::string& typeId, 
-        const ::Ice::Context* ctx,
-        const ::IceInternal::Function<void (bool)>& response, 
-        const ::IceInternal::Function<void (const ::Ice::Exception&)>& exception = 
-        ::IceInternal::Function<void (const ::Ice::Exception&)>(),
-        const ::IceInternal::Function<void (bool)>& sent = ::IceInternal::Function<void (bool)>())
-    {
-        class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
-        {
-        public:
+        const ::std::string&, 
+        const ::Ice::Context*,
+        const ::IceInternal::Function<void (bool)>&, 
+        const ::IceInternal::Function<void (const ::Ice::Exception&)>& = 
+           ::IceInternal::Function<void (const ::Ice::Exception&)>(),
+        const ::IceInternal::Function<void (bool)>& = ::IceInternal::Function<void (bool)>());
+#endif
 
-            Cpp11CB(const ::std::function<void (bool)>& responseFunc, 
-                    const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, 
-                    const ::std::function<void (bool)>& sentFunc) :
-                ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
-                _response(responseFunc)
-            {
-                CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
-            }
 
-            virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
-            {
-                ::Ice::ObjectPrx __proxy = ::Ice::ObjectPrx::uncheckedCast(__result->getProxy());
-                bool __ret;
-                try
-                {
-                    __ret = __proxy->end_ice_isA(__result);
-                }
-                catch(::Ice::Exception& ex)
-                {
-                    Cpp11FnCallbackNC::__exception(__result, ex);
-                    return;
-                }
-                if(_response != nullptr)
-                {
-                    _response(__ret);
-                }
-            }
-        
-        private:
-            
-            ::std::function<void (bool)> _response;
-        };
-        return begin_ice_isA(typeId, ctx, new Cpp11CB(response, exception, sent), 0);
-    }
-    
+    void ice_ping(const ::Ice::Context*);
+    ::Ice::AsyncResultPtr begin_ice_ping(const ::Ice::Context*,
+                                         const ::IceInternal::CallbackBasePtr&,
+                                         const ::Ice::LocalObjectPtr&);
+
+#ifdef ICE_CPP11
     ::Ice::AsyncResultPtr __begin_ice_ping(
         const ::Ice::Context* ctx,
         const ::IceInternal::Function<void ()>& response, 
@@ -979,224 +927,35 @@ private:
     {
         return begin_ice_ping(ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(response, exception, sent), 0);
     }
-    
-    ::Ice::AsyncResultPtr __begin_ice_id(
-        const ::Ice::Context* ctx,
-        const ::IceInternal::Function<void (const ::std::string&)>& response, 
-        const ::IceInternal::Function<void (const ::Ice::Exception&)>& exception = 
-        ::IceInternal::Function<void (const ::Ice::Exception&)>(),
-        const ::IceInternal::Function<void (bool)>& sent = 
-        ::IceInternal::Function<void (bool)>())
-    {
-        class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
-        {
-        public:
-
-            Cpp11CB(const ::std::function<void (const ::std::string&)>& responseFunc, 
-                    const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, 
-                    const ::std::function<void (bool)>& sentFunc) :
-                ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
-                _response(responseFunc)
-            {
-                CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
-            }
-
-            virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
-            {
-                ::Ice::ObjectPrx __proxy = ::Ice::ObjectPrx::uncheckedCast(__result->getProxy());
-                ::std::string __ret;
-                try
-                {
-                    __ret = __proxy->end_ice_id(__result);
-                }
-                catch(::Ice::Exception& ex)
-                {
-                    Cpp11FnCallbackNC::__exception(__result, ex);
-                    return;
-                }
-                if(_response != nullptr)
-                {
-                    _response(__ret);
-                }
-            }
-        
-        private:
-            
-            ::std::function<void (const ::std::string&)> _response;
-        };
-        return begin_ice_id(ctx, new Cpp11CB(response, exception, sent), 0);
-    }
-    
-    ::Ice::AsyncResultPtr __begin_ice_ids(
-        const ::Ice::Context* ctx,
-        const ::IceInternal::Function<void (const ::std::vector< ::std::string>&)>& response,
-        const ::IceInternal::Function<void (const ::Ice::Exception&)>& exception = 
-        ::IceInternal::Function<void (const ::Ice::Exception&)>(),
-        const ::IceInternal::Function<void (bool)>& sent =
-        ::IceInternal::Function<void (bool)>())
-    {
-        class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
-        {
-        public:
-
-            Cpp11CB(const ::std::function<void (const ::std::vector< ::std::string>&)>& responseFunc, 
-                    const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, 
-                    const ::std::function<void (bool)>& sentFunc) :
-                ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
-                _response(responseFunc)
-            {
-                CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
-            }
-
-            virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
-            {
-                ::Ice::ObjectPrx __proxy = ::Ice::ObjectPrx::uncheckedCast(__result->getProxy());
-                ::std::vector< ::std::string> __ret;
-                try
-                {
-                    __ret = __proxy->end_ice_ids(__result);
-                }
-                catch(::Ice::Exception& ex)
-                {
-                    Cpp11FnCallbackNC::__exception(__result, ex);
-                    return;
-                }
-                if(_response != nullptr)
-                {
-                    _response(__ret);
-                }
-            }
-        
-        private:
-            
-            ::std::function<void (const ::std::vector< ::std::string>&)> _response;
-        };
-        return begin_ice_ids(ctx, new Cpp11CB(response, exception, sent), 0);
-    }
 #endif
 
-    bool ice_isA(const ::std::string&, const ::Ice::Context*);
-    ::Ice::AsyncResultPtr begin_ice_isA(const ::std::string&,
-                                        const ::Ice::Context*,
-                                        const ::IceInternal::CallbackBasePtr&,
-                                        const ::Ice::LocalObjectPtr&);
-
-    void ice_ping(const ::Ice::Context*);
-    ::Ice::AsyncResultPtr begin_ice_ping(const ::Ice::Context*,
-                                         const ::IceInternal::CallbackBasePtr&,
-                                         const ::Ice::LocalObjectPtr&);
-
     ::std::vector< ::std::string> ice_ids(const ::Ice::Context*);
     ::Ice::AsyncResultPtr begin_ice_ids(const ::Ice::Context*,
                                         const ::IceInternal::CallbackBasePtr&,
                                         const ::Ice::LocalObjectPtr&);
 
+#ifdef ICE_CPP11
+    ::Ice::AsyncResultPtr __begin_ice_ids(
+        const ::Ice::Context*,
+        const ::IceInternal::Function<void (const ::std::vector< ::std::string>&)>&,
+        const ::IceInternal::Function<void (const ::Ice::Exception&)>& = 
+           ::IceInternal::Function<void (const ::Ice::Exception&)>(),
+        const ::IceInternal::Function<void (bool)>& =
+           ::IceInternal::Function<void (bool)>());
+#endif
+
     ::std::string ice_id(const ::Ice::Context*);
     ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::Context*,
                                        const ::IceInternal::CallbackBasePtr&,
                                        const ::Ice::LocalObjectPtr&);
-    
 #ifdef ICE_CPP11
-    ::Ice::AsyncResultPtr __begin_ice_invoke(
-        const ::std::string& operation, 
-        ::Ice::OperationMode mode, 
-        const ::std::vector< ::Ice::Byte>& inParams,
-        const ::Ice::Context* ctx,
-        const ::IceInternal::Function<void (bool, const ::std::vector< ::Ice::Byte>&)>& response,
-        const ::IceInternal::Function<void (const ::Ice::Exception&)>& exception = 
-        ::IceInternal::Function<void (const ::Ice::Exception&)>(),
-        const ::IceInternal::Function<void (bool)>& sent = ::IceInternal::Function<void (bool)>())
-    {
-        class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
-        {
-        public:
-
-            Cpp11CB(const ::std::function<void (bool, const ::std::vector< ::Ice::Byte>&)>& responseFunc, 
-                    const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, 
-                    const ::std::function<void (bool)>& sentFunc) :
-                ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
-                _response(responseFunc)
-            {
-                CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
-            }
-
-            virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
-            {
-                ::Ice::ObjectPrx __proxy = ::Ice::ObjectPrx::uncheckedCast(__result->getProxy());
-                bool __ret;
-                ::std::vector< ::Ice::Byte> p1;
-                try
-                {
-                    __ret = __proxy->end_ice_invoke(p1, __result);
-                }
-                catch(::Ice::Exception& ex)
-                {
-                    Cpp11FnCallbackNC::__exception(__result, ex);
-                    return;
-                }
-                if(_response != nullptr)
-                {
-                    _response(__ret, p1);
-                }
-            }
-        
-        private:
-            
-            ::std::function<void (bool, const ::std::vector< ::Ice::Byte>&)> _response;
-        };
-        return begin_ice_invoke(operation, mode, inParams, ctx, new Cpp11CB(response, exception, sent), 0);
-    }
-    
-    ::Ice::AsyncResultPtr __begin_ice_invoke(
-        const ::std::string& operation,
-        ::Ice::OperationMode mode, 
-        const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams,
-        const ::Ice::Context* ctx,
-        const ::IceInternal::Function<void (bool, const ::std::pair<const ::Ice::Byte*, 
-                                                                    const ::Ice::Byte*>&)>& response,
-        const ::IceInternal::Function<void (const ::Ice::Exception&)>& exception = 
-        ::IceInternal::Function<void (const ::Ice::Exception&)>(),
-        const ::IceInternal::Function<void (bool)>& sent = ::IceInternal::Function<void (bool)>())
-    {
-        class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
-        {
-        public:
-
-            Cpp11CB(const ::std::function<void (bool, const ::std::pair<const ::Ice::Byte*, 
-                                                                        const ::Ice::Byte*>&)>& responseFunc,
-                    const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, 
-                    const ::std::function<void (bool)>& sentFunc) :
-                ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
-                _response(responseFunc)
-            {
-                CallbackBase::checkCallback(true, _response || _exception != nullptr);
-            }
-
-            virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
-            {
-                bool __ret;
-                ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*> p1;
-                try
-                {
-                    __ret = __result->getProxy()->___end_ice_invoke(p1, __result);
-                }
-                catch(::Ice::Exception& ex)
-                {
-                    Cpp11FnCallbackNC::__exception(__result, ex);
-                    return;
-                }
-                if(_response != nullptr)
-                {
-                    _response(__ret, p1);
-                }
-            }
-        
-        private:
-            
-            ::std::function<void (bool, const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&)> _response;
-        };
-        return begin_ice_invoke(operation, mode, inParams, ctx, new Cpp11CB(response, exception, sent), 0);
-    }
+    ::Ice::AsyncResultPtr __begin_ice_id(
+        const ::Ice::Context*,
+        const ::IceInternal::Function<void (const ::std::string&)>&, 
+        const ::IceInternal::Function<void (const ::Ice::Exception&)>& = 
+           ::IceInternal::Function<void (const ::Ice::Exception&)>(),
+        const ::IceInternal::Function<void (bool)>& sent = 
+           ::IceInternal::Function<void (bool)>());
 #endif
 
     bool ice_invoke(const ::std::string&, 
@@ -1204,6 +963,7 @@ private:
                     const ::std::vector< ::Ice::Byte>&,
                     ::std::vector< ::Ice::Byte>&,
                     const ::Ice::Context*);
+
     ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string&, 
                                            ::Ice::OperationMode, 
                                            const ::std::vector< ::Ice::Byte>&,
@@ -1211,11 +971,25 @@ private:
                                            const ::IceInternal::CallbackBasePtr&,
                                            const ::Ice::LocalObjectPtr&);
 
+#ifdef ICE_CPP11
+    ::Ice::AsyncResultPtr __begin_ice_invoke(
+        const ::std::string&, 
+        ::Ice::OperationMode, 
+        const ::std::vector< ::Ice::Byte>&,
+        const ::Ice::Context*,
+        const ::IceInternal::Function<void (bool, const ::std::vector< ::Ice::Byte>&)>&,
+        const ::IceInternal::Function<void (const ::Ice::Exception&)>& = 
+           ::IceInternal::Function<void (const ::Ice::Exception&)>(),
+        const ::IceInternal::Function<void (bool)>& = ::IceInternal::Function<void (bool)>());
+    
+#endif
+
     bool ice_invoke(const ::std::string&, 
                     ::Ice::OperationMode,
                     const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&,
                     ::std::vector< ::Ice::Byte>&,
                     const ::Ice::Context*);
+
     ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string&, 
                                            ::Ice::OperationMode, 
                                            const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&,
@@ -1223,6 +997,18 @@ private:
                                            const ::IceInternal::CallbackBasePtr&,
                                            const ::Ice::LocalObjectPtr&);
   
+#ifdef ICE_CPP11
+    ::Ice::AsyncResultPtr __begin_ice_invoke(
+        const ::std::string&,
+        ::Ice::OperationMode, 
+        const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&,
+        const ::Ice::Context*,
+        const ::IceInternal::Function<void (bool, const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&)>&,
+        const ::IceInternal::Function<void (const ::Ice::Exception&)>& = 
+           ::IceInternal::Function<void (const ::Ice::Exception&)>(),
+        const ::IceInternal::Function<void (bool)>& = ::IceInternal::Function<void (bool)>());
+#endif
+
     ::Ice::AsyncResultPtr begin_ice_flushBatchRequestsInternal(const ::IceInternal::CallbackBasePtr&,
                                                                const ::Ice::LocalObjectPtr&);
 
diff --git a/cpp/src/Ice/CommunicatorI.cpp b/cpp/src/Ice/CommunicatorI.cpp
index 2af374c1fb5..8bc80d47363 100644
--- a/cpp/src/Ice/CommunicatorI.cpp
+++ b/cpp/src/Ice/CommunicatorI.cpp
@@ -222,6 +222,45 @@ Ice::CommunicatorI::begin_flushBatchRequests(const Callback_Communicator_flushBa
     return __begin_flushBatchRequests(cb, cookie);
 }
 
+#ifdef ICE_CPP11
+AsyncResultPtr 
+Ice::CommunicatorI::begin_flushBatchRequests(
+    const IceInternal::Function<void (const Exception&)>& exception,
+    const IceInternal::Function<void (bool)>& sent)
+{
+    class Cpp11CB : public IceInternal::Cpp11FnCallbackNC
+    {
+
+    public:
+    
+        Cpp11CB(const IceInternal::Function<void (const Exception&)>& excb,
+                const IceInternal::Function<void (bool)>& sentcb) :
+            IceInternal::Cpp11FnCallbackNC(excb, sentcb)
+        {
+            CallbackBase::checkCallback(true, excb != nullptr);
+        }
+        
+        virtual void
+        __completed(const AsyncResultPtr& __result) const
+        {
+            CommunicatorPtr __com = __result->getCommunicator();
+            assert(__com);
+            try
+            {
+                __com->end_flushBatchRequests(__result);
+                assert(false);
+            }
+            catch(const Exception& ex)
+            {
+                IceInternal::Cpp11FnCallbackNC::__exception(__result, ex);
+            }
+        }
+    };
+
+    return __begin_flushBatchRequests(new Cpp11CB(exception, sent), 0);
+}
+#endif
+
 namespace
 {
 
diff --git a/cpp/src/Ice/CommunicatorI.h b/cpp/src/Ice/CommunicatorI.h
index 8aef1ed13fa..3aa27681465 100644
--- a/cpp/src/Ice/CommunicatorI.h
+++ b/cpp/src/Ice/CommunicatorI.h
@@ -61,19 +61,16 @@ public:
 
     virtual void flushBatchRequests();
 
-#ifdef ICE_CPP11
-    virtual ::Ice::AsyncResultPtr begin_flushBatchRequests(
-                            const ::IceInternal::Function<void (const ::Ice::Exception&)>& exception,
-                            const ::IceInternal::Function<void (bool)>& sent = ::IceInternal::Function<void (bool)>())
-    {
-        return __begin_flushBatchRequests(new Cpp11FnCallbackNC_Communicator_flushBatchRequests(exception, sent), 0);
-    }
-#endif
-
     virtual AsyncResultPtr begin_flushBatchRequests();
     virtual AsyncResultPtr begin_flushBatchRequests(const CallbackPtr&, const LocalObjectPtr& = 0);
     virtual AsyncResultPtr begin_flushBatchRequests(const Callback_Communicator_flushBatchRequestsPtr&,
                                                     const LocalObjectPtr& = 0);
+#ifdef ICE_CPP11
+    virtual AsyncResultPtr begin_flushBatchRequests(
+        const IceInternal::Function<void (const Exception&)>&,
+        const IceInternal::Function<void (bool)>& = IceInternal::Function<void (bool)>());
+#endif
+
     virtual void end_flushBatchRequests(const AsyncResultPtr&);
 
     virtual ObjectPrx getAdmin() const;
diff --git a/cpp/src/Ice/ConnectionI.cpp b/cpp/src/Ice/ConnectionI.cpp
index d9588b62e89..01f18e6e91f 100644
--- a/cpp/src/Ice/ConnectionI.cpp
+++ b/cpp/src/Ice/ConnectionI.cpp
@@ -983,6 +983,45 @@ Ice::ConnectionI::begin_flushBatchRequests(const Callback_Connection_flushBatchR
     return __begin_flushBatchRequests(cb, cookie);
 }
 
+#ifdef ICE_CPP11
+AsyncResultPtr 
+Ice::ConnectionI::begin_flushBatchRequests(
+    const IceInternal::Function<void (const Exception&)>& exception, 
+    const IceInternal::Function<void (bool)>& sent)
+{
+
+    class Cpp11CB : public IceInternal::Cpp11FnCallbackNC
+    {
+    public:
+    
+        Cpp11CB(const IceInternal::Function<void (const Exception&)>& excb,
+                const IceInternal::Function<void (bool)>& sentcb) :
+            IceInternal::Cpp11FnCallbackNC(excb, sentcb)
+        {
+            CallbackBase::checkCallback(true, excb != nullptr);
+        }
+        
+        virtual void
+        __completed(const AsyncResultPtr& __result) const
+        {
+            ConnectionPtr __con = __result->getConnection();
+            assert(__con);
+            try
+            {
+                __con->end_flushBatchRequests(__result);
+                assert(false);
+            }
+            catch(const Exception& ex)
+            {
+                IceInternal::Cpp11FnCallbackNC::__exception(__result, ex);
+            }
+        }
+    };
+    
+    return __begin_flushBatchRequests(new Cpp11CB(exception, sent), 0);
+}
+#endif
+
 AsyncResultPtr
 Ice::ConnectionI::__begin_flushBatchRequests(const CallbackBasePtr& cb, const LocalObjectPtr& cookie)
 {
diff --git a/cpp/src/Ice/ConnectionI.h b/cpp/src/Ice/ConnectionI.h
index 36200d0aa4d..b7254df51ba 100644
--- a/cpp/src/Ice/ConnectionI.h
+++ b/cpp/src/Ice/ConnectionI.h
@@ -166,19 +166,16 @@ public:
 
     virtual void flushBatchRequests(); // From Connection.
     
-#ifdef ICE_CPP11
-    virtual ::Ice::AsyncResultPtr begin_flushBatchRequests(
-                            const ::IceInternal::Function<void (const ::Ice::Exception&)>& exception, 
-                            const ::IceInternal::Function<void (bool)>& sent = ::IceInternal::Function<void (bool)>())
-    {
-        return __begin_flushBatchRequests(new Cpp11FnCallbackNC_Connection_flushBatchRequests(exception, sent), 0);
-    }
-#endif
-
     virtual AsyncResultPtr begin_flushBatchRequests();
     virtual AsyncResultPtr begin_flushBatchRequests(const CallbackPtr&, const LocalObjectPtr& = 0);
     virtual AsyncResultPtr begin_flushBatchRequests(const Callback_Connection_flushBatchRequestsPtr&,
-                                                    const LocalObjectPtr& = 0);
+                                                    const LocalObjectPtr& = 0);    
+#ifdef ICE_CPP11
+    virtual AsyncResultPtr begin_flushBatchRequests(
+        const ::IceInternal::Function<void (const ::Ice::Exception&)>&, 
+        const ::IceInternal::Function<void (bool)>& = ::IceInternal::Function<void (bool)>());
+#endif
+
     virtual void end_flushBatchRequests(const AsyncResultPtr&);
 
     bool flushBatchRequests(IceInternal::BatchOutgoing*);
diff --git a/cpp/src/Ice/Initialize.cpp b/cpp/src/Ice/Initialize.cpp
index f4279f7812d..ad0591e4366 100644
--- a/cpp/src/Ice/Initialize.cpp
+++ b/cpp/src/Ice/Initialize.cpp
@@ -368,9 +368,27 @@ IceInternal::getInstanceTimer(const CommunicatorPtr& communicator)
 }
 
 #ifdef ICE_CPP11
-void
-IceInternal::Cpp11Dispatcher::dispatch(const ::Ice::DispatcherCallPtr& call, const ::Ice::ConnectionPtr& conn)
+Ice::DispatcherPtr
+Ice::newDispatcher(const ::std::function<void (const DispatcherCallPtr&, const ConnectionPtr)>& cb)
 {
-    _cb(call, conn);
+    class Cpp11Dispatcher : public Dispatcher
+    {
+    public:
+        
+        Cpp11Dispatcher(const ::std::function<void (const DispatcherCallPtr&, const ConnectionPtr)>& cb) :
+            _cb(cb)
+        {
+        }
+        
+        virtual void dispatch(const DispatcherCallPtr& call, const ConnectionPtr& conn)
+        {
+            _cb(call, conn);
+        }
+        
+    private:
+        const ::std::function<void (const DispatcherCallPtr&, const ConnectionPtr)> _cb;
+    };
+
+    return new Cpp11Dispatcher(cb);
 }
 #endif
diff --git a/cpp/src/Ice/OutgoingAsync.cpp b/cpp/src/Ice/OutgoingAsync.cpp
index e8aadb6fb38..17095659df5 100644
--- a/cpp/src/Ice/OutgoingAsync.cpp
+++ b/cpp/src/Ice/OutgoingAsync.cpp
@@ -1183,6 +1183,54 @@ public:
 //
 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(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;
+        }
+        
+        ::std::function< void (const AsyncResultPtr&)> _completed;
+        ::std::function< void (const AsyncResultPtr&)> _sent;
+    };
+    
+    return new Cpp11CB(completed, sent);
+}
+#endif
+
 void
 Ice::AMICallbackBase::__exception(const ::Ice::Exception& ex)
 {
@@ -1198,3 +1246,4 @@ Ice::AMICallbackBase::__sent(bool sentSynchronously)
     }
 }
 
+
diff --git a/cpp/src/Ice/Proxy.cpp b/cpp/src/Ice/Proxy.cpp
index d4468b6cb2c..3e9dd5ae420 100644
--- a/cpp/src/Ice/Proxy.cpp
+++ b/cpp/src/Ice/Proxy.cpp
@@ -71,6 +71,53 @@ IceInternal::checkedCastImpl(const ObjectPrx& b, const string& f, const string&
 }
 
 #ifdef ICE_CPP11
+
+IceInternal::Cpp11FnCallbackNC::Cpp11FnCallbackNC(const ::std::function<void (const ::Ice::Exception&)>& excb,
+                                                  const ::std::function<void (bool)>& sentcb) :
+    _exception(excb),
+    _sent(sentcb)
+{
+}
+
+IceInternal::CallbackBasePtr 
+IceInternal::Cpp11FnCallbackNC::__verify(::Ice::LocalObjectPtr&)
+{
+    return this;
+}
+
+void 
+IceInternal::Cpp11FnCallbackNC::__sent(const ::Ice::AsyncResultPtr& result) const
+{
+    if(_sent != nullptr)
+    {
+        _sent(result->sentSynchronously());
+    }
+}
+
+bool 
+IceInternal::Cpp11FnCallbackNC::__hasSentCallback() const
+{
+    return _sent != nullptr;
+}
+
+void 
+IceInternal::Cpp11FnCallbackNC::__exception(const ::Ice::AsyncResultPtr&, const ::Ice::Exception& ex) const
+{
+    if(_exception != nullptr)
+    {
+        _exception(ex);
+    }
+}
+
+IceInternal::Cpp11FnOnewayCallbackNC::Cpp11FnOnewayCallbackNC(const ::std::function<void ()>& cb,
+                                                              const ::std::function<void (const ::Ice::Exception&)>& excb,
+                                                              const ::std::function<void (bool)>& sentcb) :
+    Cpp11FnCallbackNC(excb, sentcb),
+    _cb(cb)
+{
+    CallbackBase::checkCallback(true, cb || excb != nullptr);
+}
+    
 void
 IceInternal::Cpp11FnOnewayCallbackNC::__completed(const ::Ice::AsyncResultPtr& result) const
 {
@@ -182,6 +229,252 @@ IceProxy::Ice::Object::begin_ice_isA(const string& typeId,
     return __result;
 }
 
+#ifdef ICE_CPP11
+
+Ice::AsyncResultPtr 
+IceProxy::Ice::Object::__begin_ice_isA(
+    const ::std::string& typeId, 
+    const ::Ice::Context* ctx,
+    const ::IceInternal::Function<void (bool)>& response, 
+    const ::IceInternal::Function<void (const ::Ice::Exception&)>& exception,
+    const ::IceInternal::Function<void (bool)>& sent)
+{
+    class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
+    {
+    public:
+        
+        Cpp11CB(const ::std::function<void (bool)>& responseFunc, 
+                const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, 
+                const ::std::function<void (bool)>& sentFunc) :
+            ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
+            _response(responseFunc)
+        {
+            CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
+        }
+        
+        virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
+        {
+            ::Ice::ObjectPrx __proxy = ::Ice::ObjectPrx::uncheckedCast(__result->getProxy());
+            bool __ret;
+            try
+            {
+                __ret = __proxy->end_ice_isA(__result);
+            }
+            catch(const ::Ice::Exception& ex)
+            {
+                Cpp11FnCallbackNC::__exception(__result, ex);
+                return;
+            }
+            if(_response != nullptr)
+            {
+                _response(__ret);
+            }
+        }
+        
+    private:
+        
+        ::std::function<void (bool)> _response;
+    };
+
+    return begin_ice_isA(typeId, ctx, new Cpp11CB(response, exception, sent), 0);
+}
+
+Ice::AsyncResultPtr 
+IceProxy::Ice::Object::__begin_ice_id(
+    const ::Ice::Context* ctx,
+    const ::IceInternal::Function<void (const ::std::string&)>& response, 
+    const ::IceInternal::Function<void (const ::Ice::Exception&)>& exception,
+    const ::IceInternal::Function<void (bool)>& sent)
+{
+    class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
+    {
+    public:
+        
+        Cpp11CB(const ::std::function<void (const ::std::string&)>& responseFunc, 
+                const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, 
+                const ::std::function<void (bool)>& sentFunc) :
+            ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
+            _response(responseFunc)
+        {
+            CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
+        }
+        
+        virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
+        {
+            ::Ice::ObjectPrx __proxy = ::Ice::ObjectPrx::uncheckedCast(__result->getProxy());
+            ::std::string __ret;
+            try
+            {
+                __ret = __proxy->end_ice_id(__result);
+            }
+            catch(const ::Ice::Exception& ex)
+            {
+                Cpp11FnCallbackNC::__exception(__result, ex);
+                return;
+            }
+            if(_response != nullptr)
+            {
+                _response(__ret);
+            }
+        }
+        
+    private:
+        
+        ::std::function<void (const ::std::string&)> _response;
+    };
+    return begin_ice_id(ctx, new Cpp11CB(response, exception, sent), 0);
+}
+   
+Ice::AsyncResultPtr 
+IceProxy::Ice::Object::__begin_ice_ids(
+    const ::Ice::Context* ctx,
+    const ::IceInternal::Function<void (const ::std::vector< ::std::string>&)>& response,
+    const ::IceInternal::Function<void (const ::Ice::Exception&)>& exception,
+    const ::IceInternal::Function<void (bool)>& sent)
+{
+    class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
+    {
+    public:
+        
+        Cpp11CB(const ::std::function<void (const ::std::vector< ::std::string>&)>& responseFunc, 
+                const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, 
+                const ::std::function<void (bool)>& sentFunc) :
+            ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
+            _response(responseFunc)
+        {
+            CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
+        }
+        
+        virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
+        {
+            ::Ice::ObjectPrx __proxy = ::Ice::ObjectPrx::uncheckedCast(__result->getProxy());
+            ::std::vector< ::std::string> __ret;
+            try
+            {
+                __ret = __proxy->end_ice_ids(__result);
+            }
+            catch(const ::Ice::Exception& ex)
+            {
+                Cpp11FnCallbackNC::__exception(__result, ex);
+                return;
+            }
+            if(_response != nullptr)
+            {
+                _response(__ret);
+            }
+        }
+        
+    private:
+        
+        ::std::function<void (const ::std::vector< ::std::string>&)> _response;
+    };
+    return begin_ice_ids(ctx, new Cpp11CB(response, exception, sent), 0);
+}
+
+Ice::AsyncResultPtr 
+IceProxy::Ice::Object::__begin_ice_invoke(
+    const ::std::string& operation, 
+    ::Ice::OperationMode mode, 
+    const ::std::vector< ::Ice::Byte>& inParams,
+    const ::Ice::Context* ctx,
+    const ::IceInternal::Function<void (bool, const ::std::vector< ::Ice::Byte>&)>& response,
+    const ::IceInternal::Function<void (const ::Ice::Exception&)>& exception,
+    const ::IceInternal::Function<void (bool)>& sent)
+{
+    class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
+    {
+    public:
+        
+        Cpp11CB(const ::std::function<void (bool, const ::std::vector< ::Ice::Byte>&)>& responseFunc, 
+                const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, 
+                const ::std::function<void (bool)>& sentFunc) :
+            ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
+            _response(responseFunc)
+        {
+            CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
+        }
+        
+        virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
+        {
+            ::Ice::ObjectPrx __proxy = ::Ice::ObjectPrx::uncheckedCast(__result->getProxy());
+            bool __ret;
+            ::std::vector< ::Ice::Byte> p1;
+            try
+            {
+                __ret = __proxy->end_ice_invoke(p1, __result);
+            }
+            catch(const ::Ice::Exception& ex)
+            {
+                Cpp11FnCallbackNC::__exception(__result, ex);
+                return;
+            }
+            if(_response != nullptr)
+            {
+                _response(__ret, p1);
+            }
+        }
+        
+    private:
+        
+        ::std::function<void (bool, const ::std::vector< ::Ice::Byte>&)> _response;
+    };
+    
+    return begin_ice_invoke(operation, mode, inParams, ctx, new Cpp11CB(response, exception, sent), 0);
+}
+    
+Ice::AsyncResultPtr 
+IceProxy::Ice::Object::__begin_ice_invoke(
+    const ::std::string& operation,
+    ::Ice::OperationMode mode, 
+    const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams,
+    const ::Ice::Context* ctx,
+    const ::IceInternal::Function<void (bool, const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&)>& response,
+    const ::IceInternal::Function<void (const ::Ice::Exception&)>& exception,
+    const ::IceInternal::Function<void (bool)>& sent)
+{
+    class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
+    {
+    public:
+        
+        Cpp11CB(const ::std::function<void (bool, const ::std::pair<const ::Ice::Byte*, 
+                                            const ::Ice::Byte*>&)>& responseFunc,
+                const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, 
+                const ::std::function<void (bool)>& sentFunc) :
+            ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
+            _response(responseFunc)
+        {
+            CallbackBase::checkCallback(true, _response || _exception != nullptr);
+        }
+        
+        virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
+        {
+            bool __ret;
+            ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*> p1;
+            try
+            {
+                __ret = __result->getProxy()->___end_ice_invoke(p1, __result);
+            }
+            catch(const ::Ice::Exception& ex)
+            {
+                Cpp11FnCallbackNC::__exception(__result, ex);
+                return;
+            }
+            if(_response != nullptr)
+            {
+                _response(__ret, p1);
+            }
+        }
+        
+    private:
+        
+        ::std::function<void (bool, const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&)> _response;
+    };
+    return begin_ice_invoke(operation, mode, inParams, ctx, new Cpp11CB(response, exception, sent), 0);
+}
+
+#endif
+
+
 bool
 IceProxy::Ice::Object::end_ice_isA(const AsyncResultPtr& __result)
 {
diff --git a/cpp/src/slice2cpp/Gen.cpp b/cpp/src/slice2cpp/Gen.cpp
index 91397221f03..4c1dcbed7da 100644
--- a/cpp/src/slice2cpp/Gen.cpp
+++ b/cpp/src/slice2cpp/Gen.cpp
@@ -2294,7 +2294,7 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p)
         }
         writeEndCode(C, outParams, p);
         C << eb;
-        C << nl << "catch(::Ice::Exception& ex)";
+        C << nl << "catch(const ::Ice::Exception& ex)";
         C << sb;
         C << nl << "Cpp11FnCallbackNC::__exception(__result, ex);";
         C << nl << "return;";
@@ -4325,7 +4325,7 @@ Slice::Gen::AsyncCallbackTemplateVisitor::generateOperation(const OperationPtr&
         }
         writeEndCode(H, outParams, p);
         H << eb;
-        H << nl << "catch(::Ice::Exception& ex)";
+        H << nl << "catch(const ::Ice::Exception& ex)";
         H << sb;
 
         H << nl << "" << baseD << "::__exception(__result, ex);";