C++11 ami lambda support

7 files changed, 842 insertions, 31 deletions

diff --git a/cpp/include/Ice/CommunicatorAsync.h b/cpp/include/Ice/CommunicatorAsync.h
index 26915051f8d..cb7dfeb288c 100644
--- a/cpp/include/Ice/CommunicatorAsync.h
+++ b/cpp/include/Ice/CommunicatorAsync.h
@@ -42,11 +42,41 @@ public:
         catch(::Ice::Exception& ex)
         {
             ::IceInternal::CallbackNC<T>::__exception(__result, ex);
-            return;
         }
     }
 };
 
+#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,
                                             void (T::*excb)(const ::Ice::Exception&),
@@ -90,7 +120,6 @@ public:
         catch(::Ice::Exception& ex)
         {
             ::IceInternal::Callback<T, CT>::__exception(__result, ex);
-            return;
         }
     }
 };
diff --git a/cpp/include/Ice/ConnectionAsync.h b/cpp/include/Ice/ConnectionAsync.h
index 5d850e577f4..4a27138aa53 100644
--- a/cpp/include/Ice/ConnectionAsync.h
+++ b/cpp/include/Ice/ConnectionAsync.h
@@ -42,11 +42,40 @@ public:
         catch(::Ice::Exception& ex)
         {
             ::IceInternal::CallbackNC<T>::__exception(__result, ex);
-            return;
         }
     }
 };
 
+#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&),
@@ -90,7 +119,6 @@ public:
         catch(::Ice::Exception& ex)
         {
             ::IceInternal::Callback<T, CT>::__exception(__result, ex);
-            return;
         }
     }
 };
diff --git a/cpp/include/Ice/Dispatcher.h b/cpp/include/Ice/Dispatcher.h
index 323ca7afa68..5ad42625215 100644
--- a/cpp/include/Ice/Dispatcher.h
+++ b/cpp/include/Ice/Dispatcher.h
@@ -9,9 +9,13 @@
 
 #pragma once
 
+#include <IceUtil/Config.h>
 #include <IceUtil/Shared.h>
 #include <IceUtil/Handle.h>
 #include <Ice/ConnectionF.h>
+#ifdef ICE_CPP11
+#   include <functional>
+#endif
 
 namespace Ice
 {
@@ -37,3 +41,36 @@ 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);
+}
+
+}
+#endif
diff --git a/cpp/include/Ice/OutgoingAsync.h b/cpp/include/Ice/OutgoingAsync.h
index ff9c4e1a4fc..2b482e4bae5 100644
--- a/cpp/include/Ice/OutgoingAsync.h
+++ b/cpp/include/Ice/OutgoingAsync.h
@@ -22,6 +22,9 @@
 #include <Ice/BasicStream.h>
 
 #include <memory>
+#ifdef ICE_CPP11
+#   include <functional> // for std::function
+#endif
 
 namespace IceInternal
 {
@@ -411,6 +414,125 @@ public:
     Callback sent;
 };
 
+#ifdef ICE_CPP11
+
+template<typename T> struct callback_type
+{
+    static const int value = 1;
+};
+
+template<> struct callback_type<void(const ::Ice::AsyncResultPtr&)>
+{
+    static const int value = 2;
+};
+
+template<> struct callback_type<void(const ::Ice::Exception&)>
+{
+    static const int value = 3;
+};
+
+template<typename Callable, typename = void> struct callable_type
+{
+    static const int value = 1;
+};
+
+template<class Callable> struct callable_type<Callable, typename ::std::enable_if< ::std::is_class<Callable>::value && 
+                                                                                   !::std::is_bind_expression<Callable>::value>::type>
+{
+    template<typename T, T> struct TypeCheck;
+    template<typename T> struct AsyncResultCallback
+    {
+        typedef void (T::*ok)(const ::Ice::AsyncResultPtr&) const;
+    };
+    template<typename T> struct ExceptionCallback
+    {
+        typedef void (T::*ok)(const ::Ice::Exception&) const;
+    };
+
+    typedef char (&other)[1];
+    typedef char (&asyncResult)[2];
+    typedef char (&exception)[3];
+
+    template<typename T> static other check(...);
+    template<typename T> static asyncResult check(TypeCheck<typename AsyncResultCallback<T>::ok, &T::operator()>*);
+    template<typename T> static exception check(TypeCheck<typename ExceptionCallback<T>::ok, &T::operator()>*);
+
+    enum { value = sizeof(check<Callable>(0)) };
+};
+
+template<> struct callable_type<void(*)(const ::Ice::AsyncResultPtr&)> 
+{
+    static const int value = 2;
+};
+
+template<> struct callable_type<void(*)(const ::Ice::Exception&)>
+{
+    static const int value = 3;
+};
+
+template<typename Callable, typename Callback> struct is_callable
+{
+    static const bool value = callable_type<Callable>::value == callback_type<Callback>::value;
+};
+
+template<class S> class Function : public std::function<S>
+{
+
+public:
+
+    template<typename T> Function(T f, typename ::std::enable_if<is_callable<T, S>::value>::type* = 0) : std::function<S>(f)
+    {
+    }
+    
+    Function()
+    {
+    }
+    
+    Function(::std::nullptr_t) : ::std::function<S>(nullptr)
+    {
+    }
+};
+
+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
+
 }
 
 namespace Ice
@@ -434,6 +556,16 @@ newCallback(T* instance,
     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);
+}
+#endif
+
 //
 // Operation callbacks are specified in Proxy.h
 //
diff --git a/cpp/include/Ice/Proxy.h b/cpp/include/Ice/Proxy.h
index 8db60bcf9ed..c182ee79a9e 100644
--- a/cpp/include/Ice/Proxy.h
+++ b/cpp/include/Ice/Proxy.h
@@ -149,13 +149,84 @@ typedef IceUtil::Handle<AMI_Object_ice_flushBatchRequests> AMI_Object_ice_flushB
 
 }
 
+#ifdef ICE_CPP11
+namespace IceInternal
+{
+
+class ICE_API Cpp11FnCallbackNC : virtual public CallbackBase
+{
+public:
+
+    Cpp11FnCallbackNC(const ::std::function<void (const ::Ice::Exception&)>& excb,
+                      const ::std::function<void (bool)>& sentcb) :
+        _exception(excb),
+        _sent(sentcb)
+    {
+    }
+
+    virtual CallbackBasePtr __verify(::Ice::LocalObjectPtr& cookie)
+    {
+        return this;
+    }
+
+    virtual void __sent(const ::Ice::AsyncResultPtr& result) const
+    {
+        if(_sent != nullptr)
+        {
+            _sent(result->sentSynchronously());
+        }
+    }
+
+    virtual bool __hasSentCallback() const
+    {
+        return _sent != nullptr;
+    }
+
+protected:
+
+    void __exception(const ::Ice::AsyncResultPtr&, const ::Ice::Exception& ex) const
+    {
+        if(_exception != nullptr)
+        {
+            _exception(ex);
+        }
+    }
+
+    ::std::function<void (const ::Ice::Exception&)> _exception;
+    ::std::function<void (bool)> _sent;
+};
+
+class ICE_API Cpp11FnOnewayCallbackNC : virtual public ::IceInternal::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);
+    }
+    
+    virtual void
+    __completed(const ::Ice::AsyncResultPtr&) const;
+    
+private:
+    
+    ::std::function<void ()> _cb;
+};
+
+}
+#endif
+
 namespace IceProxy { namespace Ice
 {
 
 class ICE_API Object : public ::IceUtil::Shared, private ::IceUtil::Mutex
 {
 public:
-
+    
     bool operator==(const Object&) const;
     bool operator!=(const Object&) const;
     bool operator<(const Object&) const;
@@ -174,6 +245,48 @@ public:
     {
         return ice_isA(typeId, &context);
     }
+    
+#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)>())
+    {
+        return __begin_ice_isA(typeId, &ctx, response, exception, sent);
+    }
+    
+    ::Ice::AsyncResultPtr
+    begin_ice_isA(const ::std::string& typeId, 
+                  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)>())
+    {
+        return __begin_ice_isA(typeId, 0, response, exception, sent);
+    }
+    
+    ::Ice::AsyncResultPtr
+    begin_ice_isA(const ::std::string& typeId, 
+                  const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& completed,
+                  const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& sent =
+                                                                ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
+    {
+        return begin_ice_isA(typeId, 0, ::Ice::newCallback(completed, sent), 0);
+    }
+    
+    ::Ice::AsyncResultPtr
+    begin_ice_isA(const ::std::string& typeId, 
+                  const ::Ice::Context& ctx, 
+                  const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& completed, 
+                  const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& sent =
+                                                                ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
+    {
+        return begin_ice_isA(typeId, &ctx, ::Ice::newCallback(completed, sent), 0);
+    }
+#endif
 
     ::Ice::AsyncResultPtr begin_ice_isA(const ::std::string& typeId)
     {
@@ -226,6 +339,44 @@ public:
         ice_ping(&context);
     }
     
+#ifdef ICE_CPP11
+    ::Ice::AsyncResultPtr
+    begin_ice_ping(const ::IceInternal::Function<void ()>& 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)>())
+    {
+        return __begin_ice_ping(0, response, exception, sent);
+    }
+    
+    ::Ice::AsyncResultPtr
+    begin_ice_ping(const ::Ice::Context& ctx,
+                   const ::IceInternal::Function<void ()>& 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)>())
+    {
+        return __begin_ice_ping(&ctx, response, exception, sent);
+    }
+    
+    ::Ice::AsyncResultPtr
+    begin_ice_ping(const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& completed, 
+                   const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& sent =
+                                                                ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
+    {
+        return begin_ice_ping(0, ::Ice::newCallback(completed, sent), 0);
+    }
+    
+    ::Ice::AsyncResultPtr
+    begin_ice_ping(const ::Ice::Context& ctx, 
+                   const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& completed, 
+                   const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& sent =
+                                                                ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
+    {
+        return begin_ice_ping(&ctx, ::Ice::newCallback(completed, sent), 0);
+    }
+#endif
+
     ::Ice::AsyncResultPtr begin_ice_ping()
     {
         return begin_ice_ping(0, ::IceInternal::__dummyCallback, 0);
@@ -271,6 +422,44 @@ public:
     {
         return ice_ids(&context);
     }
+    
+#ifdef ICE_CPP11
+    ::Ice::AsyncResultPtr
+    begin_ice_ids(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)>())
+    {
+        return __begin_ice_ids(0, response, exception, sent);
+    }
+    
+    ::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)>())
+    {
+        return __begin_ice_ids(&ctx, response, exception, sent);
+    }
+    
+    ::Ice::AsyncResultPtr
+    begin_ice_ids(const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& completed, 
+                  const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& sent = 
+                                                                ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
+    {
+        return begin_ice_ids(0, ::Ice::newCallback(completed, sent), 0);
+    }
+    
+    ::Ice::AsyncResultPtr
+    begin_ice_ids(const ::Ice::Context& ctx, 
+                  const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& completed,
+                  const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& sent = 
+                                                                ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
+    {
+        return begin_ice_ids(&ctx, ::Ice::newCallback(completed, sent), 0);
+    }
+#endif
 
     ::Ice::AsyncResultPtr begin_ice_ids()
     {
@@ -303,7 +492,7 @@ public:
 
     ::Ice::AsyncResultPtr begin_ice_ids(const ::Ice::Context& __ctx,
                                         const ::Ice::Callback_Object_ice_idsPtr& __del,
-					const ::Ice::LocalObjectPtr& __cookie = 0)
+                                        const ::Ice::LocalObjectPtr& __cookie = 0)
     {
         return begin_ice_ids(&__ctx, __del, __cookie);
     }
@@ -318,6 +507,44 @@ public:
     {
         return ice_id(&context);
     }
+    
+#ifdef ICE_CPP11
+    ::Ice::AsyncResultPtr
+    begin_ice_id(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)>())
+    {
+        return __begin_ice_id(0, response, exception, sent);
+    }
+    
+    ::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)>())
+    {
+        return __begin_ice_id(&ctx, response, exception, sent);
+    }
+    
+    ::Ice::AsyncResultPtr
+    begin_ice_id(const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& completed,
+                 const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& sent =
+                                                                ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
+    {
+        return begin_ice_id(0, ::Ice::newCallback(completed, sent), 0);
+    }
+    
+    ::Ice::AsyncResultPtr
+    begin_ice_id(const ::Ice::Context& ctx,
+                 const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& completed,
+                 const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& sent =
+                                                                ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
+    {
+        return begin_ice_id(&ctx, ::Ice::newCallback(completed, sent), 0);
+    }
+#endif
 
     ::Ice::AsyncResultPtr begin_ice_id()
     {
@@ -337,7 +564,7 @@ public:
 
     ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::Context& __ctx,
                                        const ::Ice::CallbackPtr& __del,
-				       const ::Ice::LocalObjectPtr& __cookie = 0)
+                                       const ::Ice::LocalObjectPtr& __cookie = 0)
     {
         return begin_ice_id(&__ctx, __del, __cookie);
     }
@@ -350,7 +577,7 @@ public:
 
     ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::Context& __ctx,
                                        const ::Ice::Callback_Object_ice_idPtr& __del,
-				       const ::Ice::LocalObjectPtr& __cookie = 0)
+                                       const ::Ice::LocalObjectPtr& __cookie = 0)
     {
         return begin_ice_id(&__ctx, __del, __cookie);
     }
@@ -380,6 +607,58 @@ public:
     bool ice_invoke_async(const ::Ice::AMI_Object_ice_invokePtr&, const ::std::string&, ::Ice::OperationMode,
                           const ::std::vector< ::Ice::Byte>&, const ::Ice::Context&);
 
+#ifdef ICE_CPP11
+    ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& operation, 
+                                           ::Ice::OperationMode mode, 
+                                           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&)>(),
+                                           const ::IceInternal::Function<void (bool)>& sent =
+                                                            ::IceInternal::Function<void (bool)>())
+    {
+        return __begin_ice_invoke(operation, mode, inParams, 0, response, exception, sent);
+    }
+    
+    ::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)>())
+    {
+        return __begin_ice_invoke(operation, mode, inParams, &ctx, response, exception, sent);
+    }
+    
+    ::Ice::AsyncResultPtr begin_ice_invoke(
+            const ::std::string& operation,
+            ::Ice::OperationMode mode, 
+            const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams,
+            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)>())
+    {
+        return __begin_ice_invoke(operation, mode, inParams, 0, response, exception, sent);
+    }
+    
+    ::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)>())
+    {
+        return __begin_ice_invoke(operation, mode, inParams, &ctx, response, exception, sent);
+    }
+#endif
+
     ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& operation, 
                                            ::Ice::OperationMode mode, 
                                            const ::std::vector< ::Ice::Byte>& inParams)
@@ -577,6 +856,16 @@ public:
 
     void ice_flushBatchRequests();
     bool ice_flushBatchRequests_async(const ::Ice::AMI_Object_ice_flushBatchRequestsPtr&);
+    
+#ifdef ICE_CPP11
+    ::Ice::AsyncResultPtr begin_ice_flushBatchRequests(
+                                    const ::IceInternal::Function<void (const ::Ice::Exception&)>& exception, 
+                                    const ::IceInternal::Function<void (bool)>& sent = ::IceInternal::Function<void (bool)>())
+    {
+        return begin_ice_flushBatchRequestsInternal(new ::IceInternal::Cpp11FnOnewayCallbackNC(nullptr, exception, sent), 0);
+    }
+#endif
+
     ::Ice::AsyncResultPtr begin_ice_flushBatchRequests()
     {
         return begin_ice_flushBatchRequestsInternal(::IceInternal::__dummyCallback, 0);
@@ -621,28 +910,283 @@ protected:
     virtual Object* __newInstance() const;
 
 private:
+    
+#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:
+
+            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);
+    }
+    
+    ::Ice::AsyncResultPtr __begin_ice_ping(
+                                        const ::Ice::Context* ctx,
+                                        const ::IceInternal::Function<void ()>& 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)>())
+    {
+        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&);
+                                        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&);
+                                         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&);
+                                        const ::Ice::LocalObjectPtr&);
 
     ::std::string ice_id(const ::Ice::Context*);
     ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::Context*,
                                        const ::IceInternal::CallbackBasePtr&,
-				       const ::Ice::LocalObjectPtr&);
-   
+                                       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);
+    }
+#endif
+
     bool ice_invoke(const ::std::string&, 
                     ::Ice::OperationMode, 
                     const ::std::vector< ::Ice::Byte>&,
@@ -1053,19 +1597,19 @@ public:
 
     virtual CallbackBasePtr __verify(::Ice::LocalObjectPtr& cookie)
     {
-	if(cookie != 0) // Makes sure begin_ was called without a cookie
-	{
-	    throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, "cookie specified for callback without cookie");
-	}
+        if(cookie != 0) // Makes sure begin_ was called without a cookie
+        {
+            throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, "cookie specified for callback without cookie");
+        }
         return this;
     }
 
     virtual void __sent(const ::Ice::AsyncResultPtr& result) const
     {
-	if(sent)
-	{
-	    (callback.get()->*sent)(result->sentSynchronously());
-	}
+        if(sent)
+        {
+            (callback.get()->*sent)(result->sentSynchronously());
+        }
     }
 
     virtual bool __hasSentCallback() const
@@ -1107,19 +1651,19 @@ public:
 
     virtual CallbackBasePtr __verify(::Ice::LocalObjectPtr& cookie)
     {
-	if(cookie && !CT::dynamicCast(cookie))
-	{
-	    throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, "unexpected cookie type");
-	}
+        if(cookie && !CT::dynamicCast(cookie))
+        {
+            throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, "unexpected cookie type");
+        }
         return this;
     }
 
     virtual void __sent(const ::Ice::AsyncResultPtr& result) const
     {
-	if(sent)
-	{
-	    (callback.get()->*sent)(result->sentSynchronously(), CT::dynamicCast(result->getCookie()));
-	}
+        if(sent)
+        {
+            (callback.get()->*sent)(result->sentSynchronously(), CT::dynamicCast(result->getCookie()));
+        }
     }
 
     virtual bool __hasSentCallback() const
@@ -1161,6 +1705,8 @@ public:
     }
 };
 
+
+
 template<class T, typename CT>
 class TwowayCallback : public Callback<T, CT>
 {
diff --git a/cpp/include/Ice/Stream.h b/cpp/include/Ice/Stream.h
index 6ec33c5e2e1..3257def6c6a 100644
--- a/cpp/include/Ice/Stream.h
+++ b/cpp/include/Ice/Stream.h
@@ -331,7 +331,24 @@ public:
     virtual void write(const Float*, const Float*) = 0;
     virtual void write(const Double*, const Double*) = 0;
 
-    virtual void writeOptional(Int, OptionalType) = 0; 
+    virtual void writeOptional(Int, OptionalType) = 0;
+
+//
+// COMPILER FIX: clang using libc++ cannot use the StreamHelper to write
+// vector<bool>, as vector<bool> get optimized to
+// __bit_const_reference that has not size member function.
+//
+#if defined(__clang__) && defined(_LIBCPP_VERSION)
+    virtual void write(const ::std::vector<bool>& v)
+    {
+        writeSize(static_cast<Int>(v.size()));
+        for(::std::vector<bool>::const_iterator p = v.begin(); p != v.end(); ++p)
+        {
+            bool v = (*p);
+            write(v);
+        }
+    }
+#endif
 
     template<typename T> inline void write(const T& v)
     {
diff --git a/cpp/include/Ice/StreamTraits.h b/cpp/include/Ice/StreamTraits.h
index 9f37834d8cf..97638d5152b 100644
--- a/cpp/include/Ice/StreamTraits.h
+++ b/cpp/include/Ice/StreamTraits.h
@@ -402,6 +402,28 @@ struct StreamHelper<std::pair<T, T>, StreamTraitTypeSequence>
     }
 };
 
+template<>
+struct StreamHelper<std::pair< ::std::vector<bool>::const_iterator,
+                               ::std::vector<bool>::const_iterator>, StreamTraitTypeSequence>
+{
+    template<class S> static inline void 
+    write(S* stream, const std::pair< ::std::vector<bool>::const_iterator,
+                                      ::std::vector<bool>::const_iterator>& v)
+    {
+        stream->writeSize(static_cast< ::Ice::Int>(IceUtilInternal::distance(v.first, v.second)));
+        for(::std::vector<bool>::const_iterator p = v.first; p != v.second; ++p)
+        {
+            stream->write(static_cast<bool>(*p));
+        }
+    }
+
+    template<class S> static inline void 
+    read(S* stream, std::pair< ::std::vector<bool>::const_iterator, ::std::vector<bool>::const_iterator>&)
+    {
+         assert(false); // Only used for marshaling.
+    }
+};
+
 // Helper for zero-copy array sequence parameters
 template<typename T>
 struct StreamHelper<std::pair<IceUtil::ScopedArray<T>, std::pair<const T*, const T*> >, StreamTraitTypeSequence>