ICE-7179 - Update std::function code style

67 files changed, 1084 insertions, 1084 deletions

diff --git a/cpp/include/Ice/Initialize.h b/cpp/include/Ice/Initialize.h
index 3aeaf7e87b7..f64a62db13b 100644
--- a/cpp/include/Ice/Initialize.h
+++ b/cpp/include/Ice/Initialize.h
@@ -89,8 +89,8 @@ struct InitializationData
 #ifdef ICE_CPP11_MAPPING
     std::function<void()> threadStart;
     std::function<void()> threadStop;
-    std::function<void (std::function<void ()>, const std::shared_ptr<Ice::Connection>&)> dispatcher;
-    std::function<std::string (int)> compactIdResolver;
+    std::function<void(std::function<void()>, const std::shared_ptr<Ice::Connection>&)> dispatcher;
+    std::function<std::string(int)> compactIdResolver;
     std::function<void(const Ice::BatchRequest&, int, int)> batchRequestInterceptor;
 #else
     ThreadNotificationPtr threadHook;
diff --git a/cpp/include/Ice/InputStream.h b/cpp/include/Ice/InputStream.h
index 4cb23d71ef2..b9525b385e4 100644
--- a/cpp/include/Ice/InputStream.h
+++ b/cpp/include/Ice/InputStream.h
@@ -120,7 +120,7 @@ public:
     void setLogger(const LoggerPtr&);
 
 #ifdef ICE_CPP11_MAPPING
-    void setCompactIdResolver(std::function<std::string (int)>);
+    void setCompactIdResolver(std::function<std::string(int)>);
 #else
     void setCompactIdResolver(const CompactIdResolverPtr&);
 #endif
@@ -687,7 +687,7 @@ private:
     LoggerPtr logger() const;
 
 #ifdef ICE_CPP11_MAPPING
-    std::function<std::string (int)> compactIdResolver() const;
+    std::function<std::string(int)> compactIdResolver() const;
 #else
     CompactIdResolverPtr compactIdResolver() const;
 #endif
@@ -949,7 +949,7 @@ private:
     ValueFactoryManagerPtr _valueFactoryManager;
     LoggerPtr _logger;
 #ifdef ICE_CPP11_MAPPING
-    std::function<std::string (int)> _compactIdResolver;
+    std::function<std::string(int)> _compactIdResolver;
 #else
     CompactIdResolverPtr _compactIdResolver;
 #endif
diff --git a/cpp/include/Ice/Object.h b/cpp/include/Ice/Object.h
index a3b11f6ebce..b97dd0b6107 100644
--- a/cpp/include/Ice/Object.h
+++ b/cpp/include/Ice/Object.h
@@ -184,8 +184,8 @@ public:
 
 #ifdef ICE_CPP11_MAPPING
     virtual void ice_invokeAsync(std::vector<Byte>,
-                                 std::function<void (bool, std::vector<Byte>)>,
-                                 std::function<void (std::exception_ptr)>,
+                                 std::function<void(bool, std::vector<Byte>)>,
+                                 std::function<void(std::exception_ptr)>,
                                  const Current&) = 0;
 #else
     virtual void ice_invoke_async(const AMD_Object_ice_invokePtr&, const std::vector<Byte>&, const Current&) = 0;
@@ -199,8 +199,8 @@ public:
 
 #ifdef ICE_CPP11_MAPPING
     virtual void ice_invokeAsync(std::pair<const Byte*, const Byte*>,
-                                 std::function<void (bool, std::pair<const Byte*, const Byte*>)>,
-                                 std::function<void (std::exception_ptr)>,
+                                 std::function<void(bool, std::pair<const Byte*, const Byte*>)>,
+                                 std::function<void(std::exception_ptr)>,
                                  const Current&) = 0;
 #else
     virtual void ice_invoke_async(const AMD_Object_ice_invokePtr&, const std::pair<const Byte*, const Byte*>&,
diff --git a/cpp/include/Ice/OutgoingAsync.h b/cpp/include/Ice/OutgoingAsync.h
index 90d7c3582e9..aac2b242698 100644
--- a/cpp/include/Ice/OutgoingAsync.h
+++ b/cpp/include/Ice/OutgoingAsync.h
@@ -258,7 +258,7 @@ public:
     void invoke(const std::string&);
 #ifdef ICE_CPP11_MAPPING
     void invoke(const std::string&, Ice::OperationMode, Ice::FormatType, const Ice::Context&,
-                const std::function<void (Ice::OutputStream*)>&);
+                const std::function<void(Ice::OutputStream*)>&);
     void throwUserException();
 #endif
 
@@ -292,7 +292,7 @@ protected:
     const Ice::EncodingVersion _encoding;
 
 #ifdef ICE_CPP11_MAPPING
-    std::function<void (const ::Ice::UserException&)> _userException;
+    std::function<void(const ::Ice::UserException&)> _userException;
 #endif
 
     bool _synchronous;
@@ -387,7 +387,7 @@ class ICE_API LambdaInvoke : virtual public OutgoingAsyncCompletionCallback
 {
 public:
 
-    LambdaInvoke(std::function<void (::std::exception_ptr)>&& exception, std::function<void (bool)>&& sent) :
+    LambdaInvoke(std::function<void(::std::exception_ptr)>&& exception, std::function<void(bool)>&& sent) :
         _exception(std::move(exception)), _sent(std::move(sent))
     {
     }
@@ -402,9 +402,9 @@ protected:
     virtual void handleInvokeException(const Ice::Exception&, OutgoingAsyncBase*) const override;
     virtual void handleInvokeResponse(bool, OutgoingAsyncBase*) const override;
 
-    std::function<void (::std::exception_ptr)> _exception;
-    std::function<void (bool)> _sent;
-    std::function<void (bool)> _response;
+    std::function<void(::std::exception_ptr)> _exception;
+    std::function<void(bool)> _sent;
+    std::function<void(bool)> _response;
 };
 
 template<typename Promise>
@@ -421,7 +421,7 @@ public:
 protected:
 
     Promise _promise;
-    std::function<void (bool)> _response;
+    std::function<void(bool)> _response;
 
 private:
 
@@ -477,8 +477,8 @@ public:
            Ice::OperationMode mode,
            Ice::FormatType format,
            const Ice::Context& ctx,
-           std::function<void (Ice::OutputStream*)>&& write,
-           std::function<void (const Ice::UserException&)>&& userException)
+           std::function<void(Ice::OutputStream*)>&& write,
+           std::function<void(const Ice::UserException&)>&& userException)
     {
         _read = [](Ice::InputStream* stream)
         {
@@ -495,9 +495,9 @@ public:
            Ice::OperationMode mode,
            Ice::FormatType format,
            const Ice::Context& ctx,
-           std::function<void (Ice::OutputStream*)>&& write,
-           std::function<void (const Ice::UserException&)>&& userException,
-           std::function<T (Ice::InputStream*)>&& read)
+           std::function<void(Ice::OutputStream*)>&& write,
+           std::function<void(const Ice::UserException&)>&& userException,
+           std::function<T(Ice::InputStream*)>&& read)
     {
         _read = std::move(read);
         _userException = std::move(userException);
@@ -506,7 +506,7 @@ public:
 
 protected:
 
-    std::function<T (Ice::InputStream*)> _read;
+    std::function<T(Ice::InputStream*)> _read;
 };
 
 template<>
@@ -521,8 +521,8 @@ public:
            Ice::OperationMode mode,
            Ice::FormatType format,
            const Ice::Context& ctx,
-           std::function<void (Ice::OutputStream*)>&& write,
-           std::function<void (const Ice::UserException&)>&& userException)
+           std::function<void(Ice::OutputStream*)>&& write,
+           std::function<void(const Ice::UserException&)>&& userException)
     {
         _userException = std::move(userException);
         OutgoingAsync::invoke(operation, mode, format, ctx, write);
@@ -535,9 +535,9 @@ class LambdaOutgoing : public OutgoingAsyncT<R>, public LambdaInvoke
 public:
 
     LambdaOutgoing(const std::shared_ptr<Ice::ObjectPrx>& proxy,
-                   std::function<void (R)> response,
-                   std::function<void (::std::exception_ptr)>& ex,
-                   std::function<void (bool)>& sent) :
+                   std::function<void(R)> response,
+                   std::function<void(::std::exception_ptr)>& ex,
+                   std::function<void(bool)>& sent) :
         OutgoingAsyncT<R>(proxy), LambdaInvoke(std::move(ex), std::move(sent))
     {
         _response = [this, response](bool ok)
@@ -575,8 +575,8 @@ public:
 
     LambdaOutgoing(const std::shared_ptr<Ice::ObjectPrx>& proxy,
                    std::function<void()> response,
-                   std::function<void (::std::exception_ptr)>& ex,
-                   std::function<void (bool)>& sent) :
+                   std::function<void(::std::exception_ptr)>& ex,
+                   std::function<void(bool)>& sent) :
         OutgoingAsyncT<void>(proxy), LambdaInvoke(std::move(ex), std::move(sent))
     {
         _response = [this, response](bool ok)
diff --git a/cpp/include/Ice/Proxy.h b/cpp/include/Ice/Proxy.h
index ab369eb6e37..7b29ef98781 100644
--- a/cpp/include/Ice/Proxy.h
+++ b/cpp/include/Ice/Proxy.h
@@ -109,7 +109,7 @@ public:
 
 protected:
 
-    std::function<R (bool, Ice::InputStream*)> _read;
+    std::function<R(bool, Ice::InputStream*)> _read;
 };
 
 template<typename R>
@@ -118,9 +118,9 @@ class InvokeLambdaOutgoing : public InvokeOutgoingAsyncT<R>, public LambdaInvoke
 public:
 
     InvokeLambdaOutgoing(const ::std::shared_ptr<::Ice::ObjectPrx>& proxy,
-                         ::std::function<void (R)> response,
-                         ::std::function<void (::std::exception_ptr)>& ex,
-                         ::std::function<void (bool)>& sent) :
+                         ::std::function<void(R)> response,
+                         ::std::function<void(::std::exception_ptr)>& ex,
+                         ::std::function<void(bool)>& sent) :
         InvokeOutgoingAsyncT<R>(proxy), LambdaInvoke(::std::move(ex), ::std::move(sent))
     {
         if(response)
@@ -178,9 +178,9 @@ public:
 
     ProxyGetConnectionLambda(const ::std::shared_ptr<::Ice::ObjectPrx>& proxy,
                              ::std::function<::std::shared_ptr<Ice::Connection>()> getConnection,
-                             ::std::function<void (::std::shared_ptr<Ice::Connection>)> response,
-                             ::std::function<void (::std::exception_ptr)>& ex,
-                             ::std::function<void (bool)>& sent) :
+                             ::std::function<void(::std::shared_ptr<Ice::Connection>)> response,
+                             ::std::function<void(::std::exception_ptr)>& ex,
+                             ::std::function<void(bool)>& sent) :
         ProxyGetConnection(proxy), LambdaInvoke(::std::move(ex), ::std::move(sent))
     {
         _response = [response, getConnection](bool)
@@ -211,8 +211,8 @@ class ProxyFlushBatchLambda : public ProxyFlushBatchAsync, public LambdaInvoke
 public:
 
     ProxyFlushBatchLambda(const ::std::shared_ptr<::Ice::ObjectPrx>& proxy,
-                          ::std::function<void (::std::exception_ptr)>& ex,
-                          ::std::function<void (bool)>& sent) :
+                          ::std::function<void(::std::exception_ptr)>& ex,
+                          ::std::function<void(bool)>& sent) :
         ProxyFlushBatchAsync(proxy), LambdaInvoke(::std::move(ex), ::std::move(sent))
     {
     }
@@ -268,9 +268,9 @@ public:
 
     ::std::function<void()>
     ice_isAAsync(const ::std::string& typeId,
-                 ::std::function<void (bool)> response,
-                 ::std::function<void (::std::exception_ptr)> ex = nullptr,
-                 ::std::function<void (bool)> sent = nullptr,
+                 ::std::function<void(bool)> response,
+                 ::std::function<void(::std::exception_ptr)> ex = nullptr,
+                 ::std::function<void(bool)> sent = nullptr,
                  const ::Ice::Context& ctx = ::Ice::noExplicitContext)
     {
         return makeLambdaOutgoing<bool>(response, ex, sent, this, &ObjectPrx::__ice_isA, typeId, ctx);
@@ -293,9 +293,9 @@ public:
     }
 
     ::std::function<void()>
-    ice_pingAsync(::std::function<void ()> response,
-                  ::std::function<void (::std::exception_ptr)> ex = nullptr,
-                  ::std::function<void (bool)> sent = nullptr,
+    ice_pingAsync(::std::function<void()> response,
+                  ::std::function<void(::std::exception_ptr)> ex = nullptr,
+                  ::std::function<void(bool)> sent = nullptr,
                   const ::Ice::Context& ctx = ::Ice::noExplicitContext)
     {
         return makeLambdaOutgoing(response, ex, sent, this, &ObjectPrx::__ice_ping, ctx);
@@ -318,9 +318,9 @@ public:
     }
 
     ::std::function<void()>
-    ice_idsAsync(::std::function<void (::std::vector<::std::string>)> response,
-                 ::std::function<void (::std::exception_ptr)> ex = nullptr,
-                 ::std::function<void (bool)> sent = nullptr,
+    ice_idsAsync(::std::function<void(::std::vector<::std::string>)> response,
+                 ::std::function<void(::std::exception_ptr)> ex = nullptr,
+                 ::std::function<void(bool)> sent = nullptr,
                  const ::Ice::Context& ctx = ::Ice::noExplicitContext)
     {
         return makeLambdaOutgoing<::std::vector<::std::string>>(response, ex, sent, this, &ObjectPrx::__ice_ids, ctx);
@@ -342,10 +342,10 @@ public:
         return makePromiseOutgoing<::std::string>(true, this, &ObjectPrx::__ice_id, ctx).get();
     }
 
-    ::std::function<void ()>
-    ice_idAsync(::std::function<void (::std::string)> response,
-                ::std::function<void (::std::exception_ptr)> ex = nullptr,
-                ::std::function<void (bool)> sent = nullptr,
+    ::std::function<void()>
+    ice_idAsync(::std::function<void(::std::string)> response,
+                ::std::function<void(::std::exception_ptr)> ex = nullptr,
+                ::std::function<void(bool)> sent = nullptr,
                 const ::Ice::Context& ctx = ::Ice::noExplicitContext)
     {
         return makeLambdaOutgoing<::std::string>(response, ex, sent, this, &ObjectPrx::__ice_id, ctx);
@@ -398,13 +398,13 @@ public:
         return result.ok;
     }
 
-    ::std::function<void ()>
+    ::std::function<void()>
     ice_invokeAsync(const ::std::string& operation,
                     ::Ice::OperationMode mode,
                     const ::std::vector<::Ice::Byte>& inP,
-                    ::std::function<void (bool, ::std::vector<::Ice::Byte>)> response,
-                    ::std::function<void (::std::exception_ptr)> ex = nullptr,
-                    ::std::function<void (bool)> sent = nullptr,
+                    ::std::function<void(bool, ::std::vector<::Ice::Byte>)> response,
+                    ::std::function<void(::std::exception_ptr)> ex = nullptr,
+                    ::std::function<void(bool)> sent = nullptr,
                     const ::Ice::Context& ctx = ::Ice::noExplicitContext)
     {
         using Outgoing = ::IceInternal::InvokeLambdaOutgoing<Result_ice_invoke>;
@@ -450,13 +450,13 @@ public:
         std::pair<const ::Ice::Byte*, const ::Ice::Byte*> outParams;
     };
 
-    ::std::function<void ()>
+    ::std::function<void()>
     ice_invokeAsync(const ::std::string& operation,
                     ::Ice::OperationMode mode,
                     const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inP,
-                    ::std::function<void (bool, ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>)> response,
-                    ::std::function<void (::std::exception_ptr)> ex = nullptr,
-                    ::std::function<void (bool)> sent = nullptr,
+                    ::std::function<void(bool, ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>)> response,
+                    ::std::function<void(::std::exception_ptr)> ex = nullptr,
+                    ::std::function<void(bool)> sent = nullptr,
                     const ::Ice::Context& ctx = ::Ice::noExplicitContext)
     {
         using Outgoing = ::IceInternal::InvokeLambdaOutgoing<Result_ice_invoke_zerocopy>;
@@ -541,10 +541,10 @@ public:
         return ice_getConnectionAsync().get();
     }
 
-    ::std::function<void ()>
-    ice_getConnectionAsync(::std::function<void (::std::shared_ptr<::Ice::Connection>)> response,
-                           ::std::function<void (::std::exception_ptr)> ex = nullptr,
-                           ::std::function<void (bool)> sent = nullptr)
+    ::std::function<void()>
+    ice_getConnectionAsync(::std::function<void(::std::shared_ptr<::Ice::Connection>)> response,
+                           ::std::function<void(::std::exception_ptr)> ex = nullptr,
+                           ::std::function<void(bool)> sent = nullptr)
     {
         using LambdaOutgoing = ::IceInternal::ProxyGetConnectionLambda;
         auto outAsync = ::std::make_shared<LambdaOutgoing>(shared_from_this(),
@@ -579,9 +579,9 @@ public:
         return ice_flushBatchRequestsAsync().get();
     }
 
-    std::function<void ()>
-    ice_flushBatchRequestsAsync(::std::function<void (::std::exception_ptr)> ex,
-                                ::std::function<void (bool)> sent = nullptr)
+    std::function<void()>
+    ice_flushBatchRequestsAsync(::std::function<void(::std::exception_ptr)> ex,
+                                ::std::function<void(bool)> sent = nullptr)
     {
         using LambdaOutgoing = ::IceInternal::ProxyFlushBatchLambda;
         auto outAsync = ::std::make_shared<LambdaOutgoing>(shared_from_this(), ex, sent);
diff --git a/cpp/include/IceBT/Plugin.h b/cpp/include/IceBT/Plugin.h
index d9db59694c4..82a90aad893 100644
--- a/cpp/include/IceBT/Plugin.h
+++ b/cpp/include/IceBT/Plugin.h
@@ -59,7 +59,7 @@ public:
     //
 #ifdef ICE_CPP11_MAPPING
     virtual void startDiscovery(const std::string& address,
-                                std::function<void (const std::string& addr, const PropertyMap& props)>) = 0;
+                                std::function<void(const std::string& addr, const PropertyMap& props)>) = 0;
 #else
     virtual void startDiscovery(const std::string& address, const DiscoveryCallbackPtr& cb) = 0;
 #endif
diff --git a/cpp/include/IceUtil/Config.h b/cpp/include/IceUtil/Config.h
index 8c09e4cab31..3c4df410371 100644
--- a/cpp/include/IceUtil/Config.h
+++ b/cpp/include/IceUtil/Config.h
@@ -315,9 +315,9 @@ typedef long long Int64;
 #   define ICE_SHARED_FROM_THIS shared_from_this()
 #   define ICE_CHECKED_CAST(T, ...) Ice::checkedCast<T>(__VA_ARGS__)
 #   define ICE_UNCHECKED_CAST(T, ...) Ice::uncheckedCast<T>(__VA_ARGS__)
-#   define ICE_VALUE_FACTORY ::std::function<::std::shared_ptr<::Ice::Value> (const std::string&)>
-#   define ICE_CLOSE_CALLBACK ::std::function<void (const ::std::shared_ptr<::Ice::Connection>&)>
-#   define ICE_HEARTBEAT_CALLBACK ::std::function<void (const ::std::shared_ptr<::Ice::Connection>&)>
+#   define ICE_VALUE_FACTORY ::std::function<::std::shared_ptr<::Ice::Value>(const std::string&)>
+#   define ICE_CLOSE_CALLBACK ::std::function<void(const ::std::shared_ptr<::Ice::Connection>&)>
+#   define ICE_HEARTBEAT_CALLBACK ::std::function<void(const ::std::shared_ptr<::Ice::Connection>&)>
 #   define ICE_IN(...) __VA_ARGS__
 #   define ICE_EXCEPTION_ISSET(T) T
 #   define ICE_RETHROW_EXCEPTION(T) ::std::rethrow_exception(T)
diff --git a/cpp/src/Ice/CommunicatorI.cpp b/cpp/src/Ice/CommunicatorI.cpp
index c2d07f217ed..3311768e765 100644
--- a/cpp/src/Ice/CommunicatorI.cpp
+++ b/cpp/src/Ice/CommunicatorI.cpp
@@ -215,16 +215,16 @@ Ice::CommunicatorI::flushBatchRequests()
     Communicator::flushBatchRequestsAsync().get();
 }
 
-::std::function<void ()>
-Ice::CommunicatorI::flushBatchRequestsAsync(function<void (exception_ptr)> ex, function<void (bool)> sent)
+::std::function<void()>
+Ice::CommunicatorI::flushBatchRequestsAsync(function<void(exception_ptr)> ex, function<void(bool)> sent)
 {
     class CommunicatorFlushBatchLambda : public CommunicatorFlushBatchAsync, public LambdaInvoke
     {
     public:
 
         CommunicatorFlushBatchLambda(const InstancePtr& instance,
-                                     std::function<void (std::exception_ptr)> ex,
-                                     std::function<void (bool)> sent) :
+                                     std::function<void(std::exception_ptr)> ex,
+                                     std::function<void(bool)> sent) :
             CommunicatorFlushBatchAsync(instance), LambdaInvoke(std::move(ex), std::move(sent))
         {
         }
diff --git a/cpp/src/Ice/CommunicatorI.h b/cpp/src/Ice/CommunicatorI.h
index cc5a536cbfb..83c4661c316 100644
--- a/cpp/src/Ice/CommunicatorI.h
+++ b/cpp/src/Ice/CommunicatorI.h
@@ -68,9 +68,9 @@ public:
     virtual void flushBatchRequests();
 
 #ifdef ICE_CPP11_MAPPING
-    virtual ::std::function<void ()>
-    flushBatchRequestsAsync(::std::function<void (::std::exception_ptr)>,
-                            ::std::function<void (bool)> = nullptr);
+    virtual ::std::function<void()>
+    flushBatchRequestsAsync(::std::function<void(::std::exception_ptr)>,
+                            ::std::function<void(bool)> = nullptr);
 #else
     virtual AsyncResultPtr begin_flushBatchRequests();
     virtual AsyncResultPtr begin_flushBatchRequests(const CallbackPtr&, const LocalObjectPtr& = 0);
diff --git a/cpp/src/Ice/ConnectionI.cpp b/cpp/src/Ice/ConnectionI.cpp
index 3322d30421e..4f038bea61f 100644
--- a/cpp/src/Ice/ConnectionI.cpp
+++ b/cpp/src/Ice/ConnectionI.cpp
@@ -808,9 +808,9 @@ Ice::ConnectionI::flushBatchRequests()
     Connection::flushBatchRequestsAsync().get();
 }
 
-std::function<void ()>
-Ice::ConnectionI::flushBatchRequestsAsync(::std::function<void (::std::exception_ptr)> ex,
-                                           ::std::function<void (bool)> sent)
+std::function<void()>
+Ice::ConnectionI::flushBatchRequestsAsync(::std::function<void(::std::exception_ptr)> ex,
+                                           ::std::function<void(bool)> sent)
 {
     class ConnectionFlushBatchLambda : public ConnectionFlushBatchAsync, public LambdaInvoke
     {
@@ -818,8 +818,8 @@ Ice::ConnectionI::flushBatchRequestsAsync(::std::function<void (::std::exception
 
         ConnectionFlushBatchLambda(std::shared_ptr<Ice::ConnectionI>&& connection,
                                    const InstancePtr& instance,
-                                   std::function<void (std::exception_ptr)> ex,
-                                   std::function<void (bool)> sent) :
+                                   std::function<void(std::exception_ptr)> ex,
+                                   std::function<void(bool)> sent) :
             ConnectionFlushBatchAsync(connection, instance), LambdaInvoke(std::move(ex), std::move(sent))
         {
         }
diff --git a/cpp/src/Ice/ConnectionI.h b/cpp/src/Ice/ConnectionI.h
index d4a0ea2101e..d10213fa5c4 100644
--- a/cpp/src/Ice/ConnectionI.h
+++ b/cpp/src/Ice/ConnectionI.h
@@ -191,9 +191,9 @@ public:
     virtual void flushBatchRequests();
 
 #ifdef ICE_CPP11_MAPPING
-    virtual std::function<void ()>
-    flushBatchRequestsAsync(::std::function<void (::std::exception_ptr)>,
-                             ::std::function<void (bool)> = nullptr);
+    virtual std::function<void()>
+    flushBatchRequestsAsync(::std::function<void(::std::exception_ptr)>,
+                             ::std::function<void(bool)> = nullptr);
 #else
     virtual AsyncResultPtr begin_flushBatchRequests();
     virtual AsyncResultPtr begin_flushBatchRequests(const CallbackPtr&, const LocalObjectPtr& = 0);
diff --git a/cpp/src/Ice/InputStream.cpp b/cpp/src/Ice/InputStream.cpp
index 3a68ba04040..bfba4b17eec 100644
--- a/cpp/src/Ice/InputStream.cpp
+++ b/cpp/src/Ice/InputStream.cpp
@@ -216,7 +216,7 @@ Ice::InputStream::setLogger(const LoggerPtr& logger)
 
 void
 #ifdef ICE_CPP11_MAPPING
-Ice::InputStream::setCompactIdResolver(std::function<std::string (int)> r)
+Ice::InputStream::setCompactIdResolver(std::function<std::string(int)> r)
 #else
 Ice::InputStream::setCompactIdResolver(const CompactIdResolverPtr& r)
 #endif
@@ -1329,7 +1329,7 @@ Ice::InputStream::resolveCompactId(int id) const
     string type;
 
 #ifdef ICE_CPP11_MAPPING
-    function<string (int)> resolver = compactIdResolver();
+    function<string(int)> resolver = compactIdResolver();
 #else
     CompactIdResolverPtr resolver = compactIdResolver();
 #endif
@@ -1442,7 +1442,7 @@ Ice::InputStream::logger() const
 }
 
 #ifdef ICE_CPP11_MAPPING
-function<string (int)>
+function<string(int)>
 Ice::InputStream::compactIdResolver() const
 {
     if(_compactIdResolver)
@@ -1528,7 +1528,7 @@ Ice::InputStream::EncapsDecoder::newInstance(const string& typeId)
     // Try to find a factory registered for the specific type.
     //
 #ifdef ICE_CPP11_MAPPING
-    function<ValuePtr (const string&)> userFactory;
+    function<ValuePtr(const string&)> userFactory;
     if(_valueFactoryManager)
     {
         userFactory = _valueFactoryManager->find(typeId);
@@ -1571,7 +1571,7 @@ Ice::InputStream::EncapsDecoder::newInstance(const string& typeId)
     if(!v)
     {
 #ifdef ICE_CPP11_MAPPING
-        function<ValuePtr (const string&)> of = IceInternal::factoryTable->getValueFactory(typeId);
+        function<ValuePtr(const string&)> of = IceInternal::factoryTable->getValueFactory(typeId);
         if(of)
         {
             v = of(typeId);
diff --git a/cpp/src/Ice/Instance.cpp b/cpp/src/Ice/Instance.cpp
index 743ca63f0cf..a561645ea64 100644
--- a/cpp/src/Ice/Instance.cpp
+++ b/cpp/src/Ice/Instance.cpp
@@ -918,7 +918,7 @@ IceInternal::Instance::setLogger(const Ice::LoggerPtr& logger)
 
 #ifdef ICE_CPP11_MAPPING
 void
-IceInternal::Instance::setThreadHook(function<void ()> threadStart, function<void ()> threadStop)
+IceInternal::Instance::setThreadHook(function<void()> threadStart, function<void()> threadStop)
 {
     _initData.threadStart = move(threadStart);
     _initData.threadStop = move(threadStop);
diff --git a/cpp/src/Ice/Instance.h b/cpp/src/Ice/Instance.h
index 9e6e43044ab..86d465705bb 100644
--- a/cpp/src/Ice/Instance.h
+++ b/cpp/src/Ice/Instance.h
@@ -130,7 +130,7 @@ public:
 
     void setLogger(const Ice::LoggerPtr&);
 #ifdef ICE_CPP11_MAPPING
-    void setThreadHook(std::function<void ()>, std::function<void ()>);
+    void setThreadHook(std::function<void()>, std::function<void()>);
 #else
     void setThreadHook(const Ice::ThreadNotificationPtr&);
 #endif
diff --git a/cpp/src/Ice/OutgoingAsync.cpp b/cpp/src/Ice/OutgoingAsync.cpp
index 558221cef04..55d1c9b2ae2 100644
--- a/cpp/src/Ice/OutgoingAsync.cpp
+++ b/cpp/src/Ice/OutgoingAsync.cpp
@@ -1110,7 +1110,7 @@ OutgoingAsync::invoke(const string& operation,
                       Ice::OperationMode mode,
                       Ice::FormatType format,
                       const Ice::Context& context,
-                      const function<void (Ice::OutputStream*)>& write)
+                      const function<void(Ice::OutputStream*)>& write)
 {
     try
     {
diff --git a/cpp/src/Ice/PropertiesAdminI.cpp b/cpp/src/Ice/PropertiesAdminI.cpp
index 016ef526c68..ed82eaff96d 100644
--- a/cpp/src/Ice/PropertiesAdminI.cpp
+++ b/cpp/src/Ice/PropertiesAdminI.cpp
@@ -54,8 +54,8 @@ PropertiesAdminI::getPropertiesForPrefix(const string& prefix, const Current&)
 void
 #ifdef ICE_CPP11_MAPPING
 PropertiesAdminI::setPropertiesAsync(PropertyDict props,
-                                     function<void ()> response,
-                                     function<void (exception_ptr)>,
+                                     function<void()> response,
+                                     function<void(exception_ptr)>,
                                      const Current&)
 #else
 PropertiesAdminI::setProperties_async(const AMD_PropertiesAdmin_setPropertiesPtr& cb, const PropertyDict& props,
diff --git a/cpp/src/Ice/PropertiesAdminI.h b/cpp/src/Ice/PropertiesAdminI.h
index b534d39e45a..6e852c7b583 100644
--- a/cpp/src/Ice/PropertiesAdminI.h
+++ b/cpp/src/Ice/PropertiesAdminI.h
@@ -29,8 +29,8 @@ public:
     virtual std::string getProperty(std::string, const Ice::Current&);
     virtual Ice::PropertyDict getPropertiesForPrefix(std::string, const Ice::Current&);
     virtual void setPropertiesAsync(::Ice::PropertyDict,
-                                    ::std::function<void ()>,
-                                    ::std::function<void (::std::exception_ptr)>,
+                                    ::std::function<void()>,
+                                    ::std::function<void(::std::exception_ptr)>,
                                     const Ice::Current&);
 #else
     virtual std::string getProperty(const std::string&, const Ice::Current&);
diff --git a/cpp/src/Ice/RequestHandler.cpp b/cpp/src/Ice/RequestHandler.cpp
index b4de66cf070..bca8cbb84eb 100644
--- a/cpp/src/Ice/RequestHandler.cpp
+++ b/cpp/src/Ice/RequestHandler.cpp
@@ -55,4 +55,4 @@ RequestHandler::RequestHandler(const ReferencePtr& reference) :
     _reference(reference),
     _response(reference->getMode() == Reference::ModeTwoway)
 {
-}
\ No newline at end of file
+}
diff --git a/cpp/src/Ice/ResponseHandler.cpp b/cpp/src/Ice/ResponseHandler.cpp
index a8a65152ee4..b43c1ad5697 100644
--- a/cpp/src/Ice/ResponseHandler.cpp
+++ b/cpp/src/Ice/ResponseHandler.cpp
@@ -14,4 +14,4 @@ using namespace IceInternal;
 
 #ifndef ICE_CPP11_MAPPING
 IceUtil::Shared* IceInternal::upCast(ResponseHandler* obj) { return obj; }
-#endif
\ No newline at end of file
+#endif
diff --git a/cpp/src/Ice/ThreadPool.h b/cpp/src/Ice/ThreadPool.h
index 9cccedca63e..6ff21fb606d 100644
--- a/cpp/src/Ice/ThreadPool.h
+++ b/cpp/src/Ice/ThreadPool.h
@@ -133,7 +133,7 @@ private:
 
     const InstancePtr _instance;
 #ifdef ICE_CPP11_MAPPING
-    std::function<void (std::function<void ()>, const std::shared_ptr<Ice::Connection>&)> _dispatcher;
+    std::function<void(std::function<void()>, const std::shared_ptr<Ice::Connection>&)> _dispatcher;
 #else
     const Ice::DispatcherPtr _dispatcher;
 #endif
diff --git a/cpp/src/IceBT/Engine.cpp b/cpp/src/IceBT/Engine.cpp
index 7de56260cad..ff970db0f63 100644
--- a/cpp/src/IceBT/Engine.cpp
+++ b/cpp/src/IceBT/Engine.cpp
@@ -135,7 +135,7 @@ public:
             extractProperties(values[1], props);
 
 #ifdef ICE_CPP11_MAPPING
-            vector<function<void (const string&, const PropertyMap&)>> callbacks;
+            vector<function<void(const string&, const PropertyMap&)>> callbacks;
 #else
             vector<DiscoveryCallbackPtr> callbacks;
 #endif
@@ -344,7 +344,7 @@ public:
     }
 
 #ifdef ICE_CPP11_MAPPING
-    void startDiscovery(const string& addr, function<void (const string&, const PropertyMap&)> cb)
+    void startDiscovery(const string& addr, function<void(const string&, const PropertyMap&)> cb)
 #else
     void startDiscovery(const string& addr, const DiscoveryCallbackPtr& cb)
 #endif
@@ -371,7 +371,7 @@ public:
             auto p = _discoveryCallbacks.find(path);
             if(p == _discoveryCallbacks.end())
             {
-                _discoveryCallbacks[path] = vector<function<void (const string&, const PropertyMap&)>>();
+                _discoveryCallbacks[path] = vector<function<void(const string&, const PropertyMap&)>>();
             }
             _discoveryCallbacks[path].push_back(move(cb));
 #else
@@ -929,7 +929,7 @@ public:
     DBus::ConnectionPtr _dbusConnection;
     vector<IceUtil::ThreadPtr> _threads;
 #ifdef ICE_CPP11_MAPPING
-    map<string, vector<function<void (const string&, const PropertyMap&)>>> _discoveryCallbacks;
+    map<string, vector<function<void(const string&, const PropertyMap&)>>> _discoveryCallbacks;
 #else
     map<string, vector<DiscoveryCallbackPtr> > _discoveryCallbacks;
 #endif
@@ -996,7 +996,7 @@ IceBT::Engine::removeService(const string& address, unsigned int handle)
 
 void
 #ifdef ICE_CPP11_MAPPING
-IceBT::Engine::startDiscovery(const string& address, function<void (const string&, const PropertyMap&)> cb)
+IceBT::Engine::startDiscovery(const string& address, function<void(const string&, const PropertyMap&)> cb)
 #else
 IceBT::Engine::startDiscovery(const string& address, const DiscoveryCallbackPtr& cb)
 #endif
diff --git a/cpp/src/IceBT/Engine.h b/cpp/src/IceBT/Engine.h
index 9deaeac67fc..1b674e24aa6 100644
--- a/cpp/src/IceBT/Engine.h
+++ b/cpp/src/IceBT/Engine.h
@@ -62,7 +62,7 @@ public:
     void removeService(const std::string&, unsigned int);
 
 #ifdef ICE_CPP11_MAPPING
-    void startDiscovery(const std::string&, std::function<void (const std::string&, const PropertyMap&)>);
+    void startDiscovery(const std::string&, std::function<void(const std::string&, const PropertyMap&)>);
 #else
     void startDiscovery(const std::string&, const DiscoveryCallbackPtr&);
 #endif
diff --git a/cpp/src/IceBT/PluginI.cpp b/cpp/src/IceBT/PluginI.cpp
index 9506ead32ef..07a6fb67c42 100644
--- a/cpp/src/IceBT/PluginI.cpp
+++ b/cpp/src/IceBT/PluginI.cpp
@@ -82,7 +82,7 @@ IceBT::PluginI::destroy()
 
 void
 #ifdef ICE_CPP11_MAPPING
-IceBT::PluginI::startDiscovery(const string& address, function<void (const string&, const PropertyMap&)> cb)
+IceBT::PluginI::startDiscovery(const string& address, function<void(const string&, const PropertyMap&)> cb)
 #else
 IceBT::PluginI::startDiscovery(const string& address, const DiscoveryCallbackPtr& cb)
 #endif
diff --git a/cpp/src/IceBT/PluginI.h b/cpp/src/IceBT/PluginI.h
index f211299cafc..aa846e01891 100644
--- a/cpp/src/IceBT/PluginI.h
+++ b/cpp/src/IceBT/PluginI.h
@@ -33,7 +33,7 @@ public:
     // From IceBT::Plugin.
     //
 #ifdef ICE_CPP11_MAPPING
-    virtual void startDiscovery(const std::string&, std::function<void (const std::string&, const PropertyMap&)>);
+    virtual void startDiscovery(const std::string&, std::function<void(const std::string&, const PropertyMap&)>);
 #else
     virtual void startDiscovery(const std::string&, const DiscoveryCallbackPtr&);
 #endif
diff --git a/cpp/src/IceBox/ServiceManagerI.cpp b/cpp/src/IceBox/ServiceManagerI.cpp
index 9fe98f1a29e..ed4af718a91 100644
--- a/cpp/src/IceBox/ServiceManagerI.cpp
+++ b/cpp/src/IceBox/ServiceManagerI.cpp
@@ -915,7 +915,7 @@ IceBox::ServiceManagerI::stopAll()
 
 #ifdef ICE_CPP11_MAPPING
 
-function<void (exception_ptr)>
+function<void(exception_ptr)>
 IceBox::ServiceManagerI::makeObserverCompletedCallback(const shared_ptr<ServiceObserverPrx>& observer)
 {
     auto self = weak_from_this();
diff --git a/cpp/src/IceBox/ServiceManagerI.h b/cpp/src/IceBox/ServiceManagerI.h
index 4a48c14bd7e..7107056e509 100644
--- a/cpp/src/IceBox/ServiceManagerI.h
+++ b/cpp/src/IceBox/ServiceManagerI.h
@@ -76,7 +76,7 @@ private:
     void servicesStopped(const std::vector<std::string>&, const std::set<ServiceObserverPrxPtr>&);
 
 #ifdef ICE_CPP11_MAPPING
-    std::function<void (std::exception_ptr)> makeObserverCompletedCallback(const std::shared_ptr<ServiceObserverPrx>&);
+    std::function<void(std::exception_ptr)> makeObserverCompletedCallback(const std::shared_ptr<ServiceObserverPrx>&);
     void observerRemoved(const std::shared_ptr<ServiceObserverPrx>&, std::exception_ptr);
 #else
     void observerRemoved(const ServiceObserverPrx&, const std::exception&);
diff --git a/cpp/src/IceDiscovery/LocatorI.cpp b/cpp/src/IceDiscovery/LocatorI.cpp
index a3406228c9c..c3f3c87b2ed 100644
--- a/cpp/src/IceDiscovery/LocatorI.cpp
+++ b/cpp/src/IceDiscovery/LocatorI.cpp
@@ -28,8 +28,8 @@ LocatorRegistryI::LocatorRegistryI(const Ice::CommunicatorPtr& com) :
 void
 LocatorRegistryI::setAdapterDirectProxyAsync(string adapterId,
                                               shared_ptr<ObjectPrx> proxy,
-                                              function<void ()> response,
-                                              function<void (exception_ptr)>,
+                                              function<void()> response,
+                                              function<void(exception_ptr)>,
                                               const Ice::Current&)
 #else
 void
@@ -60,8 +60,8 @@ void
 LocatorRegistryI::setReplicatedAdapterDirectProxyAsync(string adapterId,
                                                         string replicaGroupId,
                                                         shared_ptr<ObjectPrx> proxy,
-                                                        function<void ()> response,
-                                                        function<void (exception_ptr)>,
+                                                        function<void()> response,
+                                                        function<void(exception_ptr)>,
                                                         const Ice::Current&)
 #else
 void
@@ -108,8 +108,8 @@ LocatorRegistryI::setReplicatedAdapterDirectProxy_async(
 void
 LocatorRegistryI::setServerProcessProxyAsync(string,
                                               shared_ptr<ProcessPrx>,
-                                              function<void ()> response,
-                                              function<void (exception_ptr)>,
+                                              function<void()> response,
+                                              function<void(exception_ptr)>,
                                               const Ice::Current&)
 {
     response();
@@ -227,8 +227,8 @@ LocatorI::LocatorI(const LookupIPtr& lookup, const LocatorRegistryPrxPtr& regist
 #ifdef ICE_CPP11_MAPPING
 void
 LocatorI::findObjectByIdAsync(Ice::Identity id,
-                               function<void (const shared_ptr<ObjectPrx>&)> response,
-                               function<void (exception_ptr)>,
+                               function<void(const shared_ptr<ObjectPrx>&)> response,
+                               function<void(exception_ptr)>,
                                const Ice::Current&) const
 {
     _lookup->findObject(response, id);
@@ -236,8 +236,8 @@ LocatorI::findObjectByIdAsync(Ice::Identity id,
 
 void
 LocatorI::findAdapterByIdAsync(string adapterId,
-                                function<void (const shared_ptr<ObjectPrx>&)> response,
-                                function<void (exception_ptr)>,
+                                function<void(const shared_ptr<ObjectPrx>&)> response,
+                                function<void(exception_ptr)>,
                                 const Ice::Current&) const
 {
     _lookup->findAdapter(response, adapterId);
diff --git a/cpp/src/IceDiscovery/LocatorI.h b/cpp/src/IceDiscovery/LocatorI.h
index 8b30b8a963b..0c71f2ef9fa 100644
--- a/cpp/src/IceDiscovery/LocatorI.h
+++ b/cpp/src/IceDiscovery/LocatorI.h
@@ -28,23 +28,23 @@ public:
     virtual void
     setAdapterDirectProxyAsync(std::string,
                                std::shared_ptr<Ice::ObjectPrx>,
-                               std::function<void ()>,
-                               std::function<void (std::exception_ptr)>,
+                               std::function<void()>,
+                               std::function<void(std::exception_ptr)>,
                                const Ice::Current&);
 
     virtual void
     setReplicatedAdapterDirectProxyAsync(std::string,
                                          std::string,
                                          std::shared_ptr<Ice::ObjectPrx>,
-                                         std::function<void ()>,
-                                         std::function<void (std::exception_ptr)>,
+                                         std::function<void()>,
+                                         std::function<void(std::exception_ptr)>,
                                          const Ice::Current&);
 
     virtual void
     setServerProcessProxyAsync(std::string,
                                std::shared_ptr<Ice::ProcessPrx>,
-                               std::function<void ()>,
-                               std::function<void (std::exception_ptr)>,
+                               std::function<void()>,
+                               std::function<void(std::exception_ptr)>,
                                const Ice::Current&);
 #else
     virtual void
@@ -83,14 +83,14 @@ public:
 #ifdef ICE_CPP11_MAPPING
     virtual void
     findObjectByIdAsync(Ice::Identity,
-                        std::function<void (const std::shared_ptr<Ice::ObjectPrx>&)>,
-                        std::function<void (std::exception_ptr)>,
+                        std::function<void(const std::shared_ptr<Ice::ObjectPrx>&)>,
+                        std::function<void(std::exception_ptr)>,
                         const Ice::Current&) const;
 
     virtual void
     findAdapterByIdAsync(std::string,
-                         std::function<void (const std::shared_ptr<Ice::ObjectPrx>&)>,
-                         std::function<void (std::exception_ptr)>,
+                         std::function<void(const std::shared_ptr<Ice::ObjectPrx>&)>,
+                         std::function<void(std::exception_ptr)>,
                          const Ice::Current&) const;
 #else
     virtual void
diff --git a/cpp/src/IceDiscovery/LookupI.cpp b/cpp/src/IceDiscovery/LookupI.cpp
index 4499e997118..5ad2350c68b 100644
--- a/cpp/src/IceDiscovery/LookupI.cpp
+++ b/cpp/src/IceDiscovery/LookupI.cpp
@@ -243,7 +243,7 @@ LookupI::findAdapterById(const string& domainId, const string& adapterId, const
 
 #ifdef ICE_CPP11_MAPPING
 void
-LookupI::findObject(function<void (const shared_ptr<Ice::ObjectPrx>&)> response, const Ice::Identity& id)
+LookupI::findObject(function<void(const shared_ptr<Ice::ObjectPrx>&)> response, const Ice::Identity& id)
 {
     Lock sync(*this);
     map<Ice::Identity, ObjectRequestPtr>::iterator p = _objectRequests.find(id);
@@ -268,7 +268,7 @@ LookupI::findObject(function<void (const shared_ptr<Ice::ObjectPrx>&)> response,
 }
 
 void
-LookupI::findAdapter(function<void (const shared_ptr<Ice::ObjectPrx>&)> response, const std::string& adapterId)
+LookupI::findAdapter(function<void(const shared_ptr<Ice::ObjectPrx>&)> response, const std::string& adapterId)
 {
     Lock sync(*this);
     map<string, AdapterRequestPtr>::iterator p = _adapterRequests.find(adapterId);
diff --git a/cpp/src/IceDiscovery/LookupI.h b/cpp/src/IceDiscovery/LookupI.h
index 49ba8db5916..1432d7f0ff7 100644
--- a/cpp/src/IceDiscovery/LookupI.h
+++ b/cpp/src/IceDiscovery/LookupI.h
@@ -45,7 +45,7 @@ public:
         return --_nRetry >= 0;
     }
 
-    bool addCallback(std::function<void (const std::shared_ptr<::Ice::ObjectPrx>&)> cb)
+    bool addCallback(std::function<void(const std::shared_ptr<::Ice::ObjectPrx>&)> cb)
     {
         _callbacks.push_back(cb);
         return _callbacks.size() == 1;
@@ -65,7 +65,7 @@ protected:
     LookupIPtr _lookup;
     const T _id;
     int _nRetry;
-    std::vector<std::function<void (const std::shared_ptr<::Ice::ObjectPrx>&)>> _callbacks;
+    std::vector<std::function<void(const std::shared_ptr<::Ice::ObjectPrx>&)>> _callbacks;
 };
 
 class ObjectRequest : public Request<Ice::Identity>, public Ice::EnableSharedFromThis<ObjectRequest>
@@ -223,8 +223,8 @@ public:
                                 const Ice::Current&);
     virtual void findAdapterById(std::string, std::string, ::std::shared_ptr<IceDiscovery::LookupReplyPrx>,
                                  const Ice::Current&);
-    void findObject(std::function<void (const std::shared_ptr<Ice::ObjectPrx>&)>, const Ice::Identity&);
-    void findAdapter(std::function<void (const std::shared_ptr<Ice::ObjectPrx>&)>, const std::string&);
+    void findObject(std::function<void(const std::shared_ptr<Ice::ObjectPrx>&)>, const Ice::Identity&);
+    void findAdapter(std::function<void(const std::shared_ptr<Ice::ObjectPrx>&)>, const std::string&);
 #else
     virtual void findObjectById(const std::string&, const Ice::Identity&, const IceDiscovery::LookupReplyPrx&,
                                 const Ice::Current&);
diff --git a/cpp/src/IceLocatorDiscovery/PluginI.cpp b/cpp/src/IceLocatorDiscovery/PluginI.cpp
index 72e05063eba..4851e98bfcc 100644
--- a/cpp/src/IceLocatorDiscovery/PluginI.cpp
+++ b/cpp/src/IceLocatorDiscovery/PluginI.cpp
@@ -64,8 +64,8 @@ public:
             Ice::OperationMode mode,
             const pair<const Ice::Byte*, const Ice::Byte*>& inParams,
             const Ice::Context& ctx,
-            function<void (bool, const pair<const Ice::Byte*, const Ice::Byte*>&)> responseCB,
-            function<void (exception_ptr)> exceptionCB) :
+            function<void(bool, const pair<const Ice::Byte*, const Ice::Byte*>&)> responseCB,
+            function<void(exception_ptr)> exceptionCB) :
         _locator(locator),
         _operation(operation),
         _mode(mode),
@@ -106,8 +106,8 @@ protected:
     const Ice::Context _context;
     const Ice::ByteSeq _inParams;
 #ifdef ICE_CPP11_MAPPING
-    function<void (bool, const pair<const Ice::Byte*, const Ice::Byte*>&)> _responseCB;
-    function<void (exception_ptr)> _exceptionCB;
+    function<void(bool, const pair<const Ice::Byte*, const Ice::Byte*>&)> _responseCB;
+    function<void(exception_ptr)> _exceptionCB;
     exception_ptr _exception;
 #else
     const Ice::AMD_Object_ice_invokePtr _amdCB;
@@ -130,8 +130,8 @@ public:
 
 #ifdef ICE_CPP11_MAPPING
     virtual void ice_invokeAsync(pair<const Ice::Byte*, const Ice::Byte*>,
-                                 function<void (bool, pair<const Ice::Byte*, const Ice::Byte*>)>,
-                                 function<void (exception_ptr)>,
+                                 function<void(bool, pair<const Ice::Byte*, const Ice::Byte*>)>,
+                                 function<void(exception_ptr)>,
                                  const Ice::Current&);
 #else
     virtual void ice_invoke_async(const Ice::AMD_Object_ice_invokePtr&, const pair<const Ice::Byte*, const Ice::Byte*>&,
@@ -195,8 +195,8 @@ public:
 #ifdef ICE_CPP11_MAPPING
     virtual void
     findObjectByIdAsync(::Ice::Identity,
-                        function<void (const shared_ptr<::Ice::ObjectPrx>&)> response,
-                        function<void (exception_ptr)>,
+                        function<void(const shared_ptr<::Ice::ObjectPrx>&)> response,
+                        function<void(exception_ptr)>,
                         const Ice::Current&) const
     {
         response(nullptr);
@@ -204,8 +204,8 @@ public:
 
     virtual void
     findAdapterByIdAsync(string,
-                         function<void (const shared_ptr<::Ice::ObjectPrx>&)> response,
-                         function<void (exception_ptr)>,
+                         function<void(const shared_ptr<::Ice::ObjectPrx>&)> response,
+                         function<void(exception_ptr)>,
                          const Ice::Current&) const
     {
         response(nullptr);
@@ -560,8 +560,8 @@ LocatorI::setLookupReply(const LookupReplyPrxPtr& lookupReply)
 #ifdef ICE_CPP11_MAPPING
 void
 LocatorI::ice_invokeAsync(pair<const Ice::Byte*, const Ice::Byte*> inParams,
-                          function<void (bool, pair<const Ice::Byte*, const Ice::Byte*>)> responseCB,
-                          function<void (exception_ptr)> exceptionCB,
+                          function<void(bool, pair<const Ice::Byte*, const Ice::Byte*>)> responseCB,
+                          function<void(exception_ptr)> exceptionCB,
                           const Ice::Current& current)
 {
     invoke(nullptr, make_shared<Request>(this, current.operation, current.mode, inParams, current.ctx,
diff --git a/cpp/src/Slice/CPlusPlusUtil.cpp b/cpp/src/Slice/CPlusPlusUtil.cpp
index 32032668243..dc0b9cdd4a5 100644
--- a/cpp/src/Slice/CPlusPlusUtil.cpp
+++ b/cpp/src/Slice/CPlusPlusUtil.cpp
@@ -1485,7 +1485,7 @@ Slice::classDefToDelegateString(const ClassDefPtr& cl, int typeCtx, bool cpp11)
     TypePtr ret = op->returnType();
     string retS = returnTypeToString(ret, op->returnIsOptional(), op->getMetaData(), typeCtx, cpp11);
 
-    string t = "::std::function<" + retS + " (";
+    string t = "::std::function<" + retS + "(";
 
     ParamDeclList paramList = cl->allOperations().front()->parameters();
     for(ParamDeclList::iterator q = paramList.begin(); q != paramList.end(); ++q)
diff --git a/cpp/src/slice2cpp/Gen.cpp b/cpp/src/slice2cpp/Gen.cpp
index 28899335797..2ca81cf9e91 100644
--- a/cpp/src/slice2cpp/Gen.cpp
+++ b/cpp/src/slice2cpp/Gen.cpp
@@ -6354,7 +6354,7 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p)
     // Lambda based asynchronous operation
     //
     H << sp;
-    H << nl << "::std::function<void ()>";
+    H << nl << "::std::function<void()>";
     H << nl << name << "Async(";
     H.useCurrentPosAsIndent();
     if(!lambdaParamsDecl.empty())
@@ -6365,9 +6365,9 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p)
         }
         H << nl;
     }
-    H << "::std::function<void " << spar << lambdaOutParams << epar << "> __response,";
-    H << nl << "::std::function<void (::std::exception_ptr)> __ex = nullptr,";
-    H << nl << "::std::function<void (bool)> __sent = nullptr,";
+    H << "::std::function<void" << spar << lambdaOutParams << epar << "> __response,";
+    H << nl << "::std::function<void(::std::exception_ptr)> __ex = nullptr,";
+    H << nl << "::std::function<void(bool)> __sent = nullptr,";
     H << nl << "const ::Ice::Context& __ctx = Ice::noExplicitContext)";
     H.restoreIndent();
     H << sb;
@@ -7033,7 +7033,7 @@ Slice::Gen::Cpp11LocalObjectVisitor::visitOperation(const OperationPtr& p)
         }
 
         H << sp;
-        H << nl << "virtual ::std::function<void ()>";
+        H << nl << "virtual ::std::function<void()>";
         H << nl << name << "Async(";
         H.useCurrentPosAsIndent();
         for(vector<string>::const_iterator i = paramsDeclAMI.begin(); i != paramsDeclAMI.end(); ++i)
@@ -7044,8 +7044,8 @@ Slice::Gen::Cpp11LocalObjectVisitor::visitOperation(const OperationPtr& p)
         {
             H << nl;
         }
-        H << "::std::function<void (::std::exception_ptr)> exception,";
-        H << nl << "::std::function<void (bool)> sent = nullptr) = 0;";
+        H << "::std::function<void(::std::exception_ptr)> exception,";
+        H << nl << "::std::function<void(bool)> sent = nullptr) = 0;";
         H.restoreIndent();
 
         H << sp;
@@ -7493,8 +7493,8 @@ Slice::Gen::Cpp11InterfaceVisitor::visitOperation(const OperationPtr& p)
         {
             H << "," << nl;
         }
-        H << "::std::function<void (" << responseParams << ")>," << nl
-          << "::std::function<void (::std::exception_ptr)>, const Ice::Current&)" << isConst << " = 0;";
+        H << "::std::function<void(" << responseParams << ")>," << nl
+          << "::std::function<void(::std::exception_ptr)>, const Ice::Current&)" << isConst << " = 0;";
         H.restoreIndent();
     }
 
@@ -8356,8 +8356,8 @@ Slice::Gen::Cpp11ImplVisitor::visitClassDefStart(const ClassDefPtr& p)
 
             string isConst = ((op->mode() == Operation::Nonmutating) || op->hasMetaData("cpp:const")) ? " const" : "";
 
-            H << "std::function<void (" << responseParams << ")>,";
-            H << nl << "std::function<void (std::exception_ptr)>,";
+            H << "std::function<void(" << responseParams << ")>,";
+            H << nl << "std::function<void(std::exception_ptr)>,";
             H << nl << "const Ice::Current&)" << isConst << ';';
             H.restoreIndent();
 
@@ -8369,8 +8369,8 @@ Slice::Gen::Cpp11ImplVisitor::visitClassDefStart(const ClassDefPtr& p)
                 C << ' ' << fixKwd((*q)->name()) << "," << nl;
             }
 
-            C << "std::function<void (" << responseParams << ")> " << opName << "_response,";
-            C << nl << "std::function<void (std::exception_ptr)>,";
+            C << "std::function<void(" << responseParams << ")> " << opName << "_response,";
+            C << nl << "std::function<void(std::exception_ptr)>,";
             C << nl << "const Ice::Current& current)" << isConst;
             C.restoreIndent();
             C << sb;
diff --git a/cpp/test/Ice/background/Server.cpp b/cpp/test/Ice/background/Server.cpp
index a15140bb1c4..201b7610d5d 100644
--- a/cpp/test/Ice/background/Server.cpp
+++ b/cpp/test/Ice/background/Server.cpp
@@ -25,8 +25,8 @@ public:
 #ifdef ICE_CPP11_MAPPING
     virtual void
     findAdapterByIdAsync(string,
-                         function<void (const shared_ptr<Ice::ObjectPrx>&)> response,
-                         function<void (exception_ptr)>,
+                         function<void(const shared_ptr<Ice::ObjectPrx>&)> response,
+                         function<void(exception_ptr)>,
                          const Ice::Current& current) const
     {
         _controller->checkCallPause(current);
@@ -36,8 +36,8 @@ public:
 
     virtual void
     findObjectByIdAsync(Ice::Identity id,
-                        function<void (const shared_ptr<Ice::ObjectPrx>&)> response,
-                        function<void (exception_ptr)>,
+                        function<void(const shared_ptr<Ice::ObjectPrx>&)> response,
+                        function<void(exception_ptr)>,
                         const Ice::Current& current) const
     {
         _controller->checkCallPause(current);
diff --git a/cpp/test/Ice/custom/TestAMDI.cpp b/cpp/test/Ice/custom/TestAMDI.cpp
index 67f4e56555c..62f26631b26 100644
--- a/cpp/test/Ice/custom/TestAMDI.cpp
+++ b/cpp/test/Ice/custom/TestAMDI.cpp
@@ -19,8 +19,8 @@ TestIntfI::TestIntfI(const Ice::CommunicatorPtr& communicator)
 
 void
 TestIntfI::opDoubleArrayAsync(std::pair<const Ice::Double*, const Ice::Double*> in,
-                              std::function<void (const Test::DoubleSeq&, const Test::DoubleSeq&)> response,
-                              std::function<void (std::exception_ptr)>, const Ice::Current&)
+                              std::function<void(const Test::DoubleSeq&, const Test::DoubleSeq&)> response,
+                              std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     Test::DoubleSeq out(in.first, in.second);
     response(out, out);
@@ -28,8 +28,8 @@ TestIntfI::opDoubleArrayAsync(std::pair<const Ice::Double*, const Ice::Double*>
 
 void
 TestIntfI::opBoolArrayAsync(std::pair<const bool*, const bool*> in,
-                            std::function<void (const Test::BoolSeq&, const Test::BoolSeq&)> response,
-                            std::function<void (std::exception_ptr)>, const Ice::Current&)
+                            std::function<void(const Test::BoolSeq&, const Test::BoolSeq&)> response,
+                            std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     Test::BoolSeq out(in.first, in.second);
     response(out, out);
@@ -37,17 +37,17 @@ TestIntfI::opBoolArrayAsync(std::pair<const bool*, const bool*> in,
 
 void
 TestIntfI::opByteArrayAsync(std::pair<const Ice::Byte*, const Ice::Byte*> in,
-                            std::function<void (const std::pair<const Ice::Byte*, const Ice::Byte*>&,
+                            std::function<void(const std::pair<const Ice::Byte*, const Ice::Byte*>&,
                                                 const std::pair<const Ice::Byte*, const Ice::Byte*>&)> response,
-                            std::function<void (std::exception_ptr)>, const Ice::Current&)
+                            std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
 
 void
 TestIntfI::opVariableArrayAsync(std::pair<const Test::Variable*, const Test::Variable*> in,
-                                std::function<void (const Test::VariableList&, const Test::VariableList&)> response,
-                                std::function<void (std::exception_ptr)>, const Ice::Current&)
+                                std::function<void(const Test::VariableList&, const Test::VariableList&)> response,
+                                std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     Test::VariableList out(in.first, in.second);
     response(out, out);
@@ -55,8 +55,8 @@ TestIntfI::opVariableArrayAsync(std::pair<const Test::Variable*, const Test::Var
 
 void
 TestIntfI::opBoolRangeAsync(std::pair<Test::BoolSeq::const_iterator, Test::BoolSeq::const_iterator> in,
-                            std::function<void (const Test::BoolSeq&, const Test::BoolSeq&)> response,
-                            std::function<void (std::exception_ptr)>, const Ice::Current&)
+                            std::function<void(const Test::BoolSeq&, const Test::BoolSeq&)> response,
+                            std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     Test::BoolSeq out(in.first, in.second);
     response(out, out);
@@ -64,11 +64,11 @@ TestIntfI::opBoolRangeAsync(std::pair<Test::BoolSeq::const_iterator, Test::BoolS
 
 void
 TestIntfI::opByteRangeAsync(std::pair<Test::ByteList::const_iterator, Test::ByteList::const_iterator> in,
-                            std::function<void (const std::pair<Test::ByteList::const_iterator,
+                            std::function<void(const std::pair<Test::ByteList::const_iterator,
                                                 Test::ByteList::const_iterator>&,
                                                 const std::pair<Test::ByteList::const_iterator,
                                                 Test::ByteList::const_iterator>&)> response,
-                            std::function<void (std::exception_ptr)>, const Ice::Current&)
+                            std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
@@ -76,8 +76,8 @@ TestIntfI::opByteRangeAsync(std::pair<Test::ByteList::const_iterator, Test::Byte
 void
 TestIntfI::opVariableRangeAsync(std::pair<Test::VariableList::const_iterator,
                                 Test::VariableList::const_iterator> in,
-                                std::function<void (const Test::VariableList&, const Test::VariableList&)> response,
-                                std::function<void (std::exception_ptr)>, const Ice::Current&)
+                                std::function<void(const Test::VariableList&, const Test::VariableList&)> response,
+                                std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     Test::VariableList out(in.first, in.second);
     response(out, out);
@@ -86,8 +86,8 @@ TestIntfI::opVariableRangeAsync(std::pair<Test::VariableList::const_iterator,
 
 void
 TestIntfI::opByteRangeTypeAsync(std::pair<Test::ByteList::const_iterator, Test::ByteList::const_iterator> in,
-                                std::function<void (const Test::ByteList&, const Test::ByteList&)> response,
-                                std::function<void (std::exception_ptr)>, const Ice::Current&)
+                                std::function<void(const Test::ByteList&, const Test::ByteList&)> response,
+                                std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     Test::ByteList out(in.first, in.second);
     response(out, out);
@@ -96,9 +96,9 @@ TestIntfI::opByteRangeTypeAsync(std::pair<Test::ByteList::const_iterator, Test::
 void
 TestIntfI::opVariableRangeTypeAsync(std::pair<std::deque<Test::Variable>::const_iterator,
                                     std::deque<Test::Variable>::const_iterator> in,
-                                    std::function<void (const Test::VariableList&,
+                                    std::function<void(const Test::VariableList&,
                                                         const Test::VariableList&)> response,
-                                    std::function<void (std::exception_ptr)>, const Ice::Current&)
+                                    std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     Test::VariableList out(in.first, in.second);
     response(out, out);
@@ -106,8 +106,8 @@ TestIntfI::opVariableRangeTypeAsync(std::pair<std::deque<Test::Variable>::const_
 
 void
 TestIntfI::opBoolSeqAsync(std::deque<bool> in,
-                          std::function<void (const std::deque<bool>&, const std::deque<bool>&)> response,
-                          std::function<void (std::exception_ptr)>, const Ice::Current&)
+                          std::function<void(const std::deque<bool>&, const std::deque<bool>&)> response,
+                          std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
@@ -115,73 +115,73 @@ TestIntfI::opBoolSeqAsync(std::deque<bool> in,
 
 void
 TestIntfI::opBoolListAsync(Test::BoolList in,
-                           std::function<void (const Test::BoolList&, const Test::BoolList&)> response,
-                           std::function<void (std::exception_ptr)>, const Ice::Current&)
+                           std::function<void(const Test::BoolList&, const Test::BoolList&)> response,
+                           std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
 
 void
 TestIntfI::opByteSeqAsync(std::deque<Ice::Byte> in,
-                          std::function<void (const std::deque<Ice::Byte>&, const std::deque<Ice::Byte>&)> response,
-                          std::function<void (std::exception_ptr)>, const Ice::Current&)
+                          std::function<void(const std::deque<Ice::Byte>&, const std::deque<Ice::Byte>&)> response,
+                          std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
 
 void
 TestIntfI::opByteListAsync(Test::ByteList in,
-                           std::function<void (const Test::ByteList&, const Test::ByteList&)> response,
-                           std::function<void (std::exception_ptr)>, const Ice::Current&)
+                           std::function<void(const Test::ByteList&, const Test::ByteList&)> response,
+                           std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
 
 void
 TestIntfI::opMyByteSeqAsync(MyByteSeq in,
-                            std::function<void (const MyByteSeq&, const MyByteSeq&)> response,
-                            std::function<void (std::exception_ptr)>, const Ice::Current&)
+                            std::function<void(const MyByteSeq&, const MyByteSeq&)> response,
+                            std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
 
 void
 TestIntfI::opStringAsync(Util::string_view in,
-                         std::function<void (const Util::string_view&, const Util::string_view&)> response,
-                         std::function<void (std::exception_ptr)>, const Ice::Current&)
+                         std::function<void(const Util::string_view&, const Util::string_view&)> response,
+                         std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
 
 void
 TestIntfI::opStringSeqAsync(std::deque<std::string> in,
-                            std::function<void (const std::deque<std::string>&, const std::deque<std::string>&)> response,
-                            std::function<void (std::exception_ptr)>, const Ice::Current&)
+                            std::function<void(const std::deque<std::string>&, const std::deque<std::string>&)> response,
+                            std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
 
 void
 TestIntfI::opStringListAsync(Test::StringList in,
-                             std::function<void (const Test::StringList&, const Test::StringList&)> response,
-                             std::function<void (std::exception_ptr)>, const Ice::Current&)
+                             std::function<void(const Test::StringList&, const Test::StringList&)> response,
+                             std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
 
 void
 TestIntfI::opFixedSeqAsync(std::deque<Test::Fixed> in,
-                           std::function<void (const std::deque<Test::Fixed>&,
+                           std::function<void(const std::deque<Test::Fixed>&,
                                                const std::deque<Test::Fixed>&)> response,
-                           std::function<void (std::exception_ptr)>, const Ice::Current&)
+                           std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
 
 void
 TestIntfI::opFixedListAsync(Test::FixedList in,
-                            std::function<void (const Test::FixedList&, const Test::FixedList&)> response,
-                            std::function<void (std::exception_ptr)>, const Ice::Current&)
+                            std::function<void(const Test::FixedList&, const Test::FixedList&)> response,
+                            std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
@@ -189,128 +189,128 @@ TestIntfI::opFixedListAsync(Test::FixedList in,
 
 void
 TestIntfI::opVariableSeqAsync(std::deque<Test::Variable> in,
-                              std::function<void (const std::deque<Test::Variable>&,
+                              std::function<void(const std::deque<Test::Variable>&,
                                                   const std::deque<Test::Variable>&)> response,
-                              std::function<void (std::exception_ptr)>, const Ice::Current&)
+                              std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
 
 void
 TestIntfI::opVariableListAsync(Test::VariableList in,
-                               std::function<void (const Test::VariableList&, const Test::VariableList&)> response,
-                               std::function<void (std::exception_ptr)>, const Ice::Current&)
+                               std::function<void(const Test::VariableList&, const Test::VariableList&)> response,
+                               std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
 
 void
 TestIntfI::opStringStringDictSeqAsync(std::deque<Test::StringStringDict> in,
-                                      std::function<void (const std::deque<Test::StringStringDict>&,
+                                      std::function<void(const std::deque<Test::StringStringDict>&,
                                                           const std::deque<Test::StringStringDict>&)> response,
-                                      std::function<void (std::exception_ptr)>, const Ice::Current&)
+                                      std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
 
 void
 TestIntfI::opStringStringDictListAsync(Test::StringStringDictList in,
-                                       std::function<void (const Test::StringStringDictList&,
+                                       std::function<void(const Test::StringStringDictList&,
                                                            const Test::StringStringDictList&)> response,
-                                       std::function<void (std::exception_ptr)>, const Ice::Current&)
+                                       std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
 
 void
 TestIntfI::opESeqAsync(std::deque<Test::E> in,
-                       std::function<void (const std::deque<Test::E>&, const std::deque<Test::E>&)> response,
-                       std::function<void (std::exception_ptr)>, const Ice::Current&)
+                       std::function<void(const std::deque<Test::E>&, const std::deque<Test::E>&)> response,
+                       std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
 
 void
 TestIntfI::opEListAsync(Test::EList in,
-                        std::function<void (const Test::EList&, const Test::EList&)> response,
-                        std::function<void (std::exception_ptr)>, const Ice::Current&)
+                        std::function<void(const Test::EList&, const Test::EList&)> response,
+                        std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
 
 void
 TestIntfI::opCPrxSeqAsync(std::deque<std::shared_ptr<Ice::ObjectPrx>> in,
-                          std::function<void (const std::deque<std::shared_ptr<Ice::ObjectPrx>>&,
+                          std::function<void(const std::deque<std::shared_ptr<Ice::ObjectPrx>>&,
                                               const std::deque<std::shared_ptr<Ice::ObjectPrx>>&)> response,
-                          std::function<void (std::exception_ptr)>, const Ice::Current&)
+                          std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
 
 void
 TestIntfI::opCPrxListAsync(Test::CPrxList in,
-                           std::function<void (const Test::CPrxList&, const Test::CPrxList&)> response,
-                           std::function<void (std::exception_ptr)>, const Ice::Current&)
+                           std::function<void(const Test::CPrxList&, const Test::CPrxList&)> response,
+                           std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
 
 void
 TestIntfI::opCSeqAsync(std::deque<std::shared_ptr<Test::C>> in,
-                       std::function<void (const std::deque<std::shared_ptr<Test::C>>&,
+                       std::function<void(const std::deque<std::shared_ptr<Test::C>>&,
                                            const std::deque<std::shared_ptr<Test::C>>&)> response,
-                       std::function<void (std::exception_ptr)>, const Ice::Current&)
+                       std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
 
 void
 TestIntfI::opCListAsync(Test::CList in,
-                        std::function<void (const Test::CList&, const Test::CList&)> response,
-                        std::function<void (std::exception_ptr)>, const Ice::Current&)
+                        std::function<void(const Test::CList&, const Test::CList&)> response,
+                        std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
 
 void
 TestIntfI::opClassStructAsync(Test::ClassStruct in1, Test::ClassStructSeq in2,
-                              std::function<void (const Test::ClassStruct&,
+                              std::function<void(const Test::ClassStruct&,
                                                   const Test::ClassStruct&, const Test::ClassStructSeq&)> response,
-                              std::function<void (std::exception_ptr)>, const Ice::Current&)
+                              std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in1, in1, in2);
 }
 
 void
 TestIntfI::opOutArrayByteSeqAsync(Test::ByteSeq in,
-                                  std::function<void (const std::pair<const Ice::Byte*, const Ice::Byte*>&)> response,
-                                  std::function<void (std::exception_ptr)>, const Ice::Current&)
+                                  std::function<void(const std::pair<const Ice::Byte*, const Ice::Byte*>&)> response,
+                                  std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(std::make_pair(in.data(), in.data() + in.size()));
 }
 
 void
 TestIntfI::opOutRangeByteSeqAsync(Test::ByteSeq in,
-                                  std::function<void (const std::pair<Test::ByteSeq::const_iterator,
+                                  std::function<void(const std::pair<Test::ByteSeq::const_iterator,
                                                       Test::ByteSeq::const_iterator>&)> response,
-                                  std::function<void (std::exception_ptr)>, const Ice::Current&)
+                                  std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(std::make_pair(in.begin(), in.end()));
 }
 
 void
 TestIntfI::opIntStringDictAsync(Test::IntStringDict in,
-                                std::function<void (const Test::IntStringDict&, const Test::IntStringDict&)> response,
-                                std::function<void (std::exception_ptr)>, const Ice::Current&)
+                                std::function<void(const Test::IntStringDict&, const Test::IntStringDict&)> response,
+                                std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
 
 void
 TestIntfI::opVarDictAsync(Test::CustomMap<std::string, Ice::Int> in,
-                          std::function<void (const Test::CustomMap<Ice::Long, Ice::Long>&,
+                          std::function<void(const Test::CustomMap<Ice::Long, Ice::Long>&,
                                               const Test::CustomMap<std::string, Ice::Int>&)> response,
-                          std::function<void (std::exception_ptr)>, const Ice::Current&)
+                          std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     Test::CustomMap<Ice::Long, Ice::Long> result;
     for(Ice::Long i = 0; i < 1000; ++i)
@@ -322,17 +322,17 @@ TestIntfI::opVarDictAsync(Test::CustomMap<std::string, Ice::Int> in,
 
 void
 TestIntfI::opCustomIntStringDictAsync(std::map<Ice::Int, ::Util::string_view> in,
-                                      std::function<void (const std::map<Ice::Int, ::Util::string_view>&,
+                                      std::function<void(const std::map<Ice::Int, ::Util::string_view>&,
                                                           const std::map<Ice::Int, ::Util::string_view>&)> response,
-                                      std::function<void (std::exception_ptr)>, const Ice::Current&)
+                                      std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
 
 void
 TestIntfI::opShortBufferAsync(Test::ShortBuffer in,
-                              std::function<void (const Test::ShortBuffer&, const Test::ShortBuffer&)> response,
-                              std::function<void (std::exception_ptr)>, const Ice::Current&)
+                              std::function<void(const Test::ShortBuffer&, const Test::ShortBuffer&)> response,
+                              std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
@@ -340,25 +340,25 @@ TestIntfI::opShortBufferAsync(Test::ShortBuffer in,
 
 void
 TestIntfI::opBoolBufferAsync(Test::CustomBuffer<bool> in,
-                             std::function<void (const Test::CustomBuffer<bool>&,
+                             std::function<void(const Test::CustomBuffer<bool>&,
                                                  const Test::CustomBuffer<bool>&)> response,
-                             std::function<void (std::exception_ptr)>, const Ice::Current&)
+                             std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
 
 void
 TestIntfI::opBufferStructAsync(Test::BufferStruct in,
-                               std::function<void (const Test::BufferStruct&)> response,
-                               std::function<void (std::exception_ptr)>, const Ice::Current&)
+                               std::function<void(const Test::BufferStruct&)> response,
+                               std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in);
 }
 
 
 void
-TestIntfI::shutdownAsync(std::function<void ()> response,
-                         std::function<void (std::exception_ptr)>, const Ice::Current&)
+TestIntfI::shutdownAsync(std::function<void()> response,
+                         std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     _communicator->shutdown();
     response();
diff --git a/cpp/test/Ice/custom/TestAMDI.h b/cpp/test/Ice/custom/TestAMDI.h
index 696d2fbdc4c..095af0a68c4 100644
--- a/cpp/test/Ice/custom/TestAMDI.h
+++ b/cpp/test/Ice/custom/TestAMDI.h
@@ -21,210 +21,210 @@ public:
 #ifdef ICE_CPP11_MAPPING
 
     void opDoubleArrayAsync(std::pair<const ::Ice::Double*, const ::Ice::Double*>,
-                            std::function<void (const ::Test::DoubleSeq&, const ::Test::DoubleSeq&)>,
-                            std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                            std::function<void(const ::Test::DoubleSeq&, const ::Test::DoubleSeq&)>,
+                            std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opBoolArrayAsync(std::pair<const bool*, const bool*>,
-                          std::function<void (const ::Test::BoolSeq&, const ::Test::BoolSeq&)>,
-                          std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                          std::function<void(const ::Test::BoolSeq&, const ::Test::BoolSeq&)>,
+                          std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opByteArrayAsync(std::pair<const ::Ice::Byte*, const ::Ice::Byte*>,
-                          std::function<void (const std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&,
+                          std::function<void(const std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&,
                                               const std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&)>,
-                          std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                          std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
     void opVariableArrayAsync(std::pair<const ::Test::Variable*, const ::Test::Variable*>,
-                              std::function<void (const ::Test::VariableList&, const ::Test::VariableList&)>,
-                              std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                              std::function<void(const ::Test::VariableList&, const ::Test::VariableList&)>,
+                              std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
     void opBoolRangeAsync(std::pair< ::Test::BoolSeq::const_iterator,	::Test::BoolSeq::const_iterator>,
-                          std::function<void (const ::Test::BoolSeq&, const ::Test::BoolSeq&)>,
-                          std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                          std::function<void(const ::Test::BoolSeq&, const ::Test::BoolSeq&)>,
+                          std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opByteRangeAsync(std::pair< ::Test::ByteList::const_iterator,	::Test::ByteList::const_iterator>,
-                          std::function<void (const std::pair< ::Test::ByteList::const_iterator,
+                          std::function<void(const std::pair< ::Test::ByteList::const_iterator,
                                               ::Test::ByteList::const_iterator>&,
                                               const std::pair< ::Test::ByteList::const_iterator,
                                               ::Test::ByteList::const_iterator>&)>,
-                          std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                          std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
     void opVariableRangeAsync(std::pair< ::Test::VariableList::const_iterator,
                               ::Test::VariableList::const_iterator>,
-                              std::function<void (const ::Test::VariableList&, const ::Test::VariableList&)>,
-                              std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                              std::function<void(const ::Test::VariableList&, const ::Test::VariableList&)>,
+                              std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opByteRangeTypeAsync(std::pair< ::Test::ByteList::const_iterator,  ::Test::ByteList::const_iterator>,
-                              std::function<void (const ::Test::ByteList&, const ::Test::ByteList&)>,
-                              std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                              std::function<void(const ::Test::ByteList&, const ::Test::ByteList&)>,
+                              std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opVariableRangeTypeAsync(std::pair<std::deque< ::Test::Variable>::const_iterator,
                                   std::deque< ::Test::Variable>::const_iterator>,
-                                  std::function<void (const ::Test::VariableList&,
+                                  std::function<void(const ::Test::VariableList&,
                                                       const ::Test::VariableList&)>,
-                                  std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                                  std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opBoolSeqAsync(std::deque<bool>,
-                        std::function<void (const std::deque<bool>&, const std::deque<bool>&)>,
-                        std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                        std::function<void(const std::deque<bool>&, const std::deque<bool>&)>,
+                        std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opBoolListAsync(::Test::BoolList,
-                         std::function<void (const ::Test::BoolList&, const ::Test::BoolList&)>,
-                         std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                         std::function<void(const ::Test::BoolList&, const ::Test::BoolList&)>,
+                         std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opByteSeqAsync(std::deque< ::Ice::Byte>,
-                        std::function<void (const std::deque< ::Ice::Byte>&, const std::deque< ::Ice::Byte>&)>,
-                        std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                        std::function<void(const std::deque< ::Ice::Byte>&, const std::deque< ::Ice::Byte>&)>,
+                        std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opByteListAsync(::Test::ByteList,
-                         std::function<void (const ::Test::ByteList&, const ::Test::ByteList&)>,
-                         std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                         std::function<void(const ::Test::ByteList&, const ::Test::ByteList&)>,
+                         std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opMyByteSeqAsync(MyByteSeq,
-                          std::function<void (const MyByteSeq&, const MyByteSeq&)>,
-                          std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                          std::function<void(const MyByteSeq&, const MyByteSeq&)>,
+                          std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opStringAsync(Util::string_view,
-                       std::function<void (const Util::string_view&, const Util::string_view&)>,
-                       std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                       std::function<void(const Util::string_view&, const Util::string_view&)>,
+                       std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opStringSeqAsync(std::deque<std::string>,
-                          std::function<void (const std::deque<std::string>&, const std::deque<std::string>&)>,
-                          std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                          std::function<void(const std::deque<std::string>&, const std::deque<std::string>&)>,
+                          std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
     void opStringListAsync(::Test::StringList,
-                           std::function<void (const ::Test::StringList&, const ::Test::StringList&)>,
-                           std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                           std::function<void(const ::Test::StringList&, const ::Test::StringList&)>,
+                           std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opFixedSeqAsync(std::deque< ::Test::Fixed>,
-                         std::function<void (const std::deque< ::Test::Fixed>&,
+                         std::function<void(const std::deque< ::Test::Fixed>&,
                                              const std::deque< ::Test::Fixed>&)>,
-                         std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                         std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opFixedListAsync(::Test::FixedList,
-                          std::function<void (const ::Test::FixedList&, const ::Test::FixedList&)>,
-                          std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                          std::function<void(const ::Test::FixedList&, const ::Test::FixedList&)>,
+                          std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opVariableSeqAsync(std::deque< ::Test::Variable>,
-                            std::function<void (const std::deque< ::Test::Variable>&,
+                            std::function<void(const std::deque< ::Test::Variable>&,
                                                 const std::deque< ::Test::Variable>&)>,
-                            std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                            std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
     void opVariableListAsync(::Test::VariableList,
-                             std::function<void (const ::Test::VariableList&, const ::Test::VariableList&)>,
-                             std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                             std::function<void(const ::Test::VariableList&, const ::Test::VariableList&)>,
+                             std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opStringStringDictSeqAsync(std::deque< ::Test::StringStringDict>,
-                                    std::function<void (const std::deque< ::Test::StringStringDict>&,
+                                    std::function<void(const std::deque< ::Test::StringStringDict>&,
                                                         const std::deque< ::Test::StringStringDict>&)>,
-                                    std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                                    std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opStringStringDictListAsync(::Test::StringStringDictList,
-                                     std::function<void (const ::Test::StringStringDictList&,
+                                     std::function<void(const ::Test::StringStringDictList&,
                                                          const ::Test::StringStringDictList&)>,
-                                     std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                                     std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opESeqAsync(std::deque< ::Test::E>,
-                     std::function<void (const std::deque< ::Test::E>&, const std::deque< ::Test::E>&)>,
-                     std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                     std::function<void(const std::deque< ::Test::E>&, const std::deque< ::Test::E>&)>,
+                     std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opEListAsync(::Test::EList,
-                      std::function<void (const ::Test::EList&, const ::Test::EList&)>,
-                      std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                      std::function<void(const ::Test::EList&, const ::Test::EList&)>,
+                      std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opCPrxSeqAsync(std::deque<std::shared_ptr<Ice::ObjectPrx>>,
-                        std::function<void (const std::deque<std::shared_ptr<Ice::ObjectPrx>>&,
+                        std::function<void(const std::deque<std::shared_ptr<Ice::ObjectPrx>>&,
                                             const std::deque<std::shared_ptr<Ice::ObjectPrx>>&)>,
-                        std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                        std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opCPrxListAsync(::Test::CPrxList,
-                         std::function<void (const ::Test::CPrxList&, const ::Test::CPrxList&)>,
-                         std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                         std::function<void(const ::Test::CPrxList&, const ::Test::CPrxList&)>,
+                         std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opCSeqAsync(std::deque<std::shared_ptr<Test::C>>,
-                     std::function<void (const std::deque<std::shared_ptr<Test::C>>&,
+                     std::function<void(const std::deque<std::shared_ptr<Test::C>>&,
                                          const std::deque<std::shared_ptr<Test::C>>&)>,
-                     std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                     std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opCListAsync(::Test::CList,
-                      std::function<void (const ::Test::CList&, const ::Test::CList&)>,
-                      std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                      std::function<void(const ::Test::CList&, const ::Test::CList&)>,
+                      std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opClassStructAsync(::Test::ClassStruct, ::Test::ClassStructSeq,
-                            std::function<void (const ::Test::ClassStruct&,
+                            std::function<void(const ::Test::ClassStruct&,
                                                 const ::Test::ClassStruct&, const ::Test::ClassStructSeq&)>,
-                            std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                            std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opOutArrayByteSeqAsync(::Test::ByteSeq,
-                                std::function<void (const std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&)>,
-                                std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                                std::function<void(const std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&)>,
+                                std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opOutRangeByteSeqAsync(::Test::ByteSeq,
-                                std::function<void (const std::pair< ::Test::ByteSeq::const_iterator,
+                                std::function<void(const std::pair< ::Test::ByteSeq::const_iterator,
                                                     ::Test::ByteSeq::const_iterator>&)>,
-                                std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                                std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opIntStringDictAsync(::Test::IntStringDict,
-                              std::function<void (const ::Test::IntStringDict&, const ::Test::IntStringDict&)>,
-                              std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                              std::function<void(const ::Test::IntStringDict&, const ::Test::IntStringDict&)>,
+                              std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opVarDictAsync(::Test::CustomMap<std::string, ::Ice::Int>,
-                        std::function<void (const ::Test::CustomMap< ::Ice::Long, ::Ice::Long>&,
+                        std::function<void(const ::Test::CustomMap< ::Ice::Long, ::Ice::Long>&,
                                             const ::Test::CustomMap<std::string, ::Ice::Int>&)>,
-                        std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                        std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opCustomIntStringDictAsync(std::map< ::Ice::Int, ::Util::string_view>,
-                                    std::function<void (const std::map< ::Ice::Int, ::Util::string_view>&,
+                                    std::function<void(const std::map< ::Ice::Int, ::Util::string_view>&,
                                                         const std::map< ::Ice::Int, ::Util::string_view>&)>,
-                                    std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                                    std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opShortBufferAsync(::Test::ShortBuffer,
-                            std::function<void (const ::Test::ShortBuffer&, const ::Test::ShortBuffer&)>,
-                            std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                            std::function<void(const ::Test::ShortBuffer&, const ::Test::ShortBuffer&)>,
+                            std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opBoolBufferAsync(::Test::CustomBuffer<bool>,
-                           std::function<void (const ::Test::CustomBuffer<bool>&,
+                           std::function<void(const ::Test::CustomBuffer<bool>&,
                                                const ::Test::CustomBuffer<bool>&)>,
-                           std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                           std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
     void opBufferStructAsync(::Test::BufferStruct,
-                             std::function<void (const ::Test::BufferStruct&)>,
-                             std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                             std::function<void(const ::Test::BufferStruct&)>,
+                             std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
-    void shutdownAsync(std::function<void ()>,
-                       std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+    void shutdownAsync(std::function<void()>,
+                       std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
 #else
diff --git a/cpp/test/Ice/custom/WstringAMDI.cpp b/cpp/test/Ice/custom/WstringAMDI.cpp
index 08becc717e8..1641cf96cb2 100644
--- a/cpp/test/Ice/custom/WstringAMDI.cpp
+++ b/cpp/test/Ice/custom/WstringAMDI.cpp
@@ -13,24 +13,24 @@
 
 void
 Test1::WstringClassI::opStringAsync(std::wstring in,
-                                    std::function<void (const std::wstring&, const std::wstring&)> response,
-                                    std::function<void (std::exception_ptr)>, const Ice::Current&)
+                                    std::function<void(const std::wstring&, const std::wstring&)> response,
+                                    std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
 
 void
 Test1::WstringClassI::opStructAsync(Test1::WstringStruct in,
-                                    std::function<void (const Test1::WstringStruct&, const Test1::WstringStruct&)> response,
-                                    std::function<void (std::exception_ptr)>, const Ice::Current&)
+                                    std::function<void(const Test1::WstringStruct&, const Test1::WstringStruct&)> response,
+                                    std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
 
 void
 Test1::WstringClassI::throwExceptAsync(std::wstring in,
-                                       std::function<void ()>,
-                                       std::function<void (std::exception_ptr)> error, const Ice::Current&)
+                                       std::function<void()>,
+                                       std::function<void(std::exception_ptr)> error, const Ice::Current&)
 {
     Test1::WstringException ex(in);
     error(std::make_exception_ptr(ex));
@@ -38,24 +38,24 @@ Test1::WstringClassI::throwExceptAsync(std::wstring in,
 
 void
 Test2::WstringClassI::opStringAsync(std::wstring in,
-                                    std::function<void (const std::wstring&, const std::wstring&)> response,
-                                    std::function<void (std::exception_ptr)>, const Ice::Current&)
+                                    std::function<void(const std::wstring&, const std::wstring&)> response,
+                                    std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
 
 void
 Test2::WstringClassI::opStructAsync(Test2::WstringStruct in,
-                                    std::function<void (const Test2::WstringStruct&, const Test2::WstringStruct&)> response,
-                                    std::function<void (std::exception_ptr)>, const Ice::Current&)
+                                    std::function<void(const Test2::WstringStruct&, const Test2::WstringStruct&)> response,
+                                    std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
 
 void
 Test2::WstringClassI::throwExceptAsync(std::wstring in,
-                                       std::function<void ()>,
-                                       std::function<void (std::exception_ptr)> error, const Ice::Current&)
+                                       std::function<void()>,
+                                       std::function<void(std::exception_ptr)> error, const Ice::Current&)
 
 {
     Test2::WstringException ex(in);
diff --git a/cpp/test/Ice/custom/WstringAMDI.h b/cpp/test/Ice/custom/WstringAMDI.h
index 2e92755c42c..a53e389fe3d 100644
--- a/cpp/test/Ice/custom/WstringAMDI.h
+++ b/cpp/test/Ice/custom/WstringAMDI.h
@@ -21,16 +21,16 @@ class WstringClassI : public virtual WstringClassDisp
 public:
 
     void opStringAsync(std::wstring,
-                       std::function<void (const std::wstring&, const std::wstring&)>,
-                       std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                       std::function<void(const std::wstring&, const std::wstring&)>,
+                       std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
     void opStructAsync(::Test1::WstringStruct,
-                       std::function<void (const ::Test1::WstringStruct&, const ::Test1::WstringStruct&)>,
-                       std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                       std::function<void(const ::Test1::WstringStruct&, const ::Test1::WstringStruct&)>,
+                       std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
     void throwExceptAsync(std::wstring,
-                          std::function<void ()>,
-                          std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                          std::function<void()>,
+                          std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 };
 #else
 class WstringClassI : public virtual WstringClass
@@ -60,16 +60,16 @@ class WstringClassI : public virtual WstringClassDisp
 public:
 
     void opStringAsync(std::wstring,
-                       std::function<void (const std::wstring&, const std::wstring&)>,
-                       std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                       std::function<void(const std::wstring&, const std::wstring&)>,
+                       std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
     void opStructAsync(::Test2::WstringStruct,
-                       std::function<void (const ::Test2::WstringStruct&, const ::Test2::WstringStruct&)>,
-                       std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                       std::function<void(const ::Test2::WstringStruct&, const ::Test2::WstringStruct&)>,
+                       std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
     void throwExceptAsync(std::wstring,
-                          std::function<void ()>,
-                          std::function<void (std::exception_ptr)>, const Ice::Current&) override;
+                          std::function<void()>,
+                          std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 };
 
 #else
diff --git a/cpp/test/Ice/dispatcher/Client.cpp b/cpp/test/Ice/dispatcher/Client.cpp
index 3c4e1735e01..b94e3199616 100644
--- a/cpp/test/Ice/dispatcher/Client.cpp
+++ b/cpp/test/Ice/dispatcher/Client.cpp
@@ -29,7 +29,7 @@ class DispatcherCall : public Ice::DispatcherCall
 {
 public:
 
-    DispatcherCall(function<void ()> call) :
+    DispatcherCall(function<void()> call) :
         _call(move(call))
     {
     }
@@ -41,7 +41,7 @@ public:
 
 private:
 
-    function<void ()> _call;
+    function<void()> _call;
 };
 #endif
 
@@ -65,7 +65,7 @@ main(int argc, char* argv[])
 
 #ifdef ICE_CPP11_MAPPING
         Ice::DispatcherPtr dispatcher = new Dispatcher();
-        initData.dispatcher = [=](function<void ()> call, const shared_ptr<Ice::Connection>& conn)
+        initData.dispatcher = [=](function<void()> call, const shared_ptr<Ice::Connection>& conn)
             {
                 dispatcher->dispatch(new DispatcherCall(call), conn);
             };
diff --git a/cpp/test/Ice/dispatcher/Collocated.cpp b/cpp/test/Ice/dispatcher/Collocated.cpp
index 59eb3490b94..a83ee20a446 100644
--- a/cpp/test/Ice/dispatcher/Collocated.cpp
+++ b/cpp/test/Ice/dispatcher/Collocated.cpp
@@ -44,7 +44,7 @@ class DispatcherCall : public Ice::DispatcherCall
 {
 public:
 
-    DispatcherCall(function<void ()> call) :
+    DispatcherCall(function<void()> call) :
         _call(move(call))
     {
     }
@@ -56,7 +56,7 @@ public:
 
 private:
 
-    function<void ()> _call;
+    function<void()> _call;
 };
 #endif
 
@@ -73,7 +73,7 @@ main(int argc, char* argv[])
         initData.properties = Ice::createProperties(argc, argv);
 #ifdef ICE_CPP11_MAPPING
         Ice::DispatcherPtr dispatcher = new Dispatcher();
-        initData.dispatcher = [=](function<void ()> call, const shared_ptr<Ice::Connection>& conn)
+        initData.dispatcher = [=](function<void()> call, const shared_ptr<Ice::Connection>& conn)
             {
                 dispatcher->dispatch(new DispatcherCall(call), conn);
             };
diff --git a/cpp/test/Ice/dispatcher/Server.cpp b/cpp/test/Ice/dispatcher/Server.cpp
index b8c51969db3..585bce0c16c 100644
--- a/cpp/test/Ice/dispatcher/Server.cpp
+++ b/cpp/test/Ice/dispatcher/Server.cpp
@@ -45,7 +45,7 @@ class DispatcherCall : public Ice::DispatcherCall
 {
 public:
 
-    DispatcherCall(function<void ()> call) :
+    DispatcherCall(function<void()> call) :
         _call(move(call))
     {
     }
@@ -57,7 +57,7 @@ public:
 
 private:
 
-    function<void ()> _call;
+    function<void()> _call;
 };
 #endif
 
@@ -81,7 +81,7 @@ main(int argc, char* argv[])
 
 #ifdef ICE_CPP11_MAPPING
         Ice::DispatcherPtr dispatcher = new Dispatcher();
-        initData.dispatcher = [=](function<void ()> call, const shared_ptr<Ice::Connection>& conn)
+        initData.dispatcher = [=](function<void()> call, const shared_ptr<Ice::Connection>& conn)
             {
                 dispatcher->dispatch(new DispatcherCall(call), conn);
             };
diff --git a/cpp/test/Ice/exceptions/TestAMDI.cpp b/cpp/test/Ice/exceptions/TestAMDI.cpp
index deb949defee..873494443cc 100644
--- a/cpp/test/Ice/exceptions/TestAMDI.cpp
+++ b/cpp/test/Ice/exceptions/TestAMDI.cpp
@@ -30,8 +30,8 @@ ThrowerI::ThrowerI()
 
 #ifdef ICE_CPP11_MAPPING
 void
-ThrowerI::shutdownAsync(function<void ()> response,
-                        function<void (exception_ptr)>,
+ThrowerI::shutdownAsync(function<void()> response,
+                        function<void(exception_ptr)>,
                         const Ice::Current& current)
 {
     current.adapter->getCommunicator()->shutdown();
@@ -39,16 +39,16 @@ ThrowerI::shutdownAsync(function<void ()> response,
 }
 
 void
-ThrowerI::supportsUndeclaredExceptionsAsync(function<void (bool)> response,
-                                            function<void (exception_ptr)>,
+ThrowerI::supportsUndeclaredExceptionsAsync(function<void(bool)> response,
+                                            function<void(exception_ptr)>,
                                             const Ice::Current&)
 {
     response(true);
 }
 
 void
-ThrowerI::supportsAssertExceptionAsync(function<void (bool)> response,
-                                       function<void (exception_ptr)>,
+ThrowerI::supportsAssertExceptionAsync(function<void(bool)> response,
+                                       function<void(exception_ptr)>,
                                        const Ice::Current&)
 {
     response(false);
@@ -56,8 +56,8 @@ ThrowerI::supportsAssertExceptionAsync(function<void (bool)> response,
 
 void
 ThrowerI::throwAasAAsync(int a,
-                         function<void ()>,
-                         function<void (exception_ptr)> exception,
+                         function<void()>,
+                         function<void(exception_ptr)> exception,
                          const Ice::Current&)
 {
     try
@@ -74,8 +74,8 @@ ThrowerI::throwAasAAsync(int a,
 
 void
 ThrowerI::throwAorDasAorDAsync(int a,
-                               function<void ()>,
-                               function<void (exception_ptr)> exception,
+                               function<void()>,
+                               function<void(exception_ptr)> exception,
                                const Ice::Current&)
 {
     try
@@ -101,8 +101,8 @@ ThrowerI::throwAorDasAorDAsync(int a,
 
 void
 ThrowerI::throwBasAAsync(int a, int b,
-                         function<void ()>,
-                         function<void (exception_ptr)> exception,
+                         function<void()>,
+                         function<void(exception_ptr)> exception,
                          const Ice::Current&)
 {
     try
@@ -120,8 +120,8 @@ ThrowerI::throwBasAAsync(int a, int b,
 
 void
 ThrowerI::throwCasAAsync(int a, int b, int c,
-                         function<void ()>,
-                         function<void (exception_ptr)> exception,
+                         function<void()>,
+                         function<void(exception_ptr)> exception,
                          const Ice::Current&)
 {
     try
@@ -140,8 +140,8 @@ ThrowerI::throwCasAAsync(int a, int b, int c,
 
 void
 ThrowerI::throwBasBAsync(int a, int b,
-                         function<void ()>,
-                         function<void (exception_ptr)> exception,
+                         function<void()>,
+                         function<void(exception_ptr)> exception,
                          const Ice::Current&)
 {
     try
@@ -159,8 +159,8 @@ ThrowerI::throwBasBAsync(int a, int b,
 
 void
 ThrowerI::throwCasBAsync(int a, int b, int c,
-                         function<void ()>,
-                         function<void (exception_ptr)> exception,
+                         function<void()>,
+                         function<void(exception_ptr)> exception,
                          const Ice::Current&)
 {
     try
@@ -179,8 +179,8 @@ ThrowerI::throwCasBAsync(int a, int b, int c,
 
 void
 ThrowerI::throwCasCAsync(int a, int b, int c,
-                         function<void ()>,
-                         function<void (exception_ptr)> exception,
+                         function<void()>,
+                         function<void(exception_ptr)> exception,
                          const Ice::Current&)
 {
     try
@@ -199,8 +199,8 @@ ThrowerI::throwCasCAsync(int a, int b, int c,
 
 void
 ThrowerI::throwModAAsync(int a, int a2,
-                         function<void ()>,
-                         function<void (exception_ptr)> exception,
+                         function<void()>,
+                         function<void(exception_ptr)> exception,
                          const Ice::Current&)
 {
     Mod::A ex;
@@ -211,8 +211,8 @@ ThrowerI::throwModAAsync(int a, int a2,
 
 void
 ThrowerI::throwUndeclaredAAsync(int a,
-                                function<void ()>,
-                                function<void (exception_ptr)> exception,
+                                function<void()>,
+                                function<void(exception_ptr)> exception,
                                 const Ice::Current&)
 {
     try
@@ -229,8 +229,8 @@ ThrowerI::throwUndeclaredAAsync(int a,
 
 void
 ThrowerI::throwUndeclaredBAsync(int a, int b,
-                                function<void ()>,
-                                function<void (exception_ptr)>,
+                                function<void()>,
+                                function<void(exception_ptr)>,
                                 const Ice::Current&)
 {
     B ex;
@@ -241,8 +241,8 @@ ThrowerI::throwUndeclaredBAsync(int a, int b,
 
 void
 ThrowerI::throwUndeclaredCAsync(int a, int b, int c,
-                                function<void ()>,
-                                function<void (exception_ptr)> exception,
+                                function<void()>,
+                                function<void(exception_ptr)> exception,
                                 const Ice::Current&)
 {
     try
@@ -260,8 +260,8 @@ ThrowerI::throwUndeclaredCAsync(int a, int b, int c,
 }
 
 void
-ThrowerI::throwLocalExceptionAsync(function<void ()>,
-                                   function<void (exception_ptr)> exception,
+ThrowerI::throwLocalExceptionAsync(function<void()>,
+                                   function<void(exception_ptr)> exception,
                                    const Ice::Current&)
 {
     try
@@ -275,8 +275,8 @@ ThrowerI::throwLocalExceptionAsync(function<void ()>,
 }
 
 void
-ThrowerI::throwNonIceExceptionAsync(function<void ()>,
-                                    function<void (exception_ptr)> exception,
+ThrowerI::throwNonIceExceptionAsync(function<void()>,
+                                    function<void(exception_ptr)> exception,
                                     const Ice::Current&)
 {
     try
@@ -290,8 +290,8 @@ ThrowerI::throwNonIceExceptionAsync(function<void ()>,
 }
 
 void
-ThrowerI::throwAssertExceptionAsync(function<void ()>,
-                                    function<void (exception_ptr)>,
+ThrowerI::throwAssertExceptionAsync(function<void()>,
+                                    function<void(exception_ptr)>,
                                     const Ice::Current&)
 {
     assert(false); // No supported in C++
@@ -299,16 +299,16 @@ ThrowerI::throwAssertExceptionAsync(function<void ()>,
 
 void
 ThrowerI::throwMemoryLimitExceptionAsync(ICE_IN(Ice::ByteSeq),
-                                         function<void (const Ice::ByteSeq&)> response,
-                                         function<void (exception_ptr)>,
+                                         function<void(const Ice::ByteSeq&)> response,
+                                         function<void(exception_ptr)>,
                                          const Ice::Current&)
 {
     response(Ice::ByteSeq(1024 * 20)); // 20 KB.
 }
 
 void
-ThrowerI::throwLocalExceptionIdempotentAsync(function<void ()>,
-                                             function<void (exception_ptr)> exception,
+ThrowerI::throwLocalExceptionIdempotentAsync(function<void()>,
+                                             function<void(exception_ptr)> exception,
                                              const Ice::Current&)
 {
     try
@@ -323,8 +323,8 @@ ThrowerI::throwLocalExceptionIdempotentAsync(function<void ()>,
 }
 
 void
-ThrowerI::throwAfterResponseAsync(function<void ()> response,
-                                  function<void (exception_ptr)>,
+ThrowerI::throwAfterResponseAsync(function<void()> response,
+                                  function<void(exception_ptr)>,
                                   const Ice::Current&)
 {
     response();
@@ -333,8 +333,8 @@ ThrowerI::throwAfterResponseAsync(function<void ()> response,
 }
 
 void
-ThrowerI::throwAfterExceptionAsync(function<void ()>,
-                                   function<void (exception_ptr)> exception,
+ThrowerI::throwAfterExceptionAsync(function<void()>,
+                                   function<void(exception_ptr)> exception,
                                    const Ice::Current&)
 {
     try
@@ -349,8 +349,8 @@ ThrowerI::throwAfterExceptionAsync(function<void ()>,
 }
 
 void
-ThrowerI::throwEAsync(function<void ()>,
-                      function<void (exception_ptr)> exception,
+ThrowerI::throwEAsync(function<void()>,
+                      function<void(exception_ptr)> exception,
                       const Ice::Current&)
 {
     try
@@ -364,8 +364,8 @@ ThrowerI::throwEAsync(function<void ()>,
 }
 
 void
-ThrowerI::throwFAsync(function<void ()>,
-                      function<void (exception_ptr)> exception,
+ThrowerI::throwFAsync(function<void()>,
+                      function<void(exception_ptr)> exception,
                       const Ice::Current&)
 {
     try
@@ -379,8 +379,8 @@ ThrowerI::throwFAsync(function<void ()>,
 }
 
 void
-ThrowerI::throwGAsync(function<void ()>,
-                      function<void (exception_ptr)> exception,
+ThrowerI::throwGAsync(function<void()>,
+                      function<void(exception_ptr)> exception,
                       const Ice::Current&)
 {
     try
@@ -398,8 +398,8 @@ ThrowerI::throwGAsync(function<void ()>,
 }
 
 void
-ThrowerI::throwHAsync(function<void ()>,
-                      function<void (exception_ptr)> exception,
+ThrowerI::throwHAsync(function<void()>,
+                      function<void(exception_ptr)> exception,
                       const Ice::Current&)
 {
     try
diff --git a/cpp/test/Ice/exceptions/TestAMDI.h b/cpp/test/Ice/exceptions/TestAMDI.h
index 182fe8f6de6..d3908090358 100644
--- a/cpp/test/Ice/exceptions/TestAMDI.h
+++ b/cpp/test/Ice/exceptions/TestAMDI.h
@@ -23,116 +23,116 @@ public:
     ThrowerI();
 
 #ifdef ICE_CPP11_MAPPING
-    virtual void shutdownAsync(std::function<void ()>,
-                               std::function<void (std::exception_ptr)>,
+    virtual void shutdownAsync(std::function<void()>,
+                               std::function<void(std::exception_ptr)>,
                                const Ice::Current&);
 
-    virtual void supportsUndeclaredExceptionsAsync(std::function<void (bool)>,
-                                                   std::function<void (std::exception_ptr)>,
+    virtual void supportsUndeclaredExceptionsAsync(std::function<void(bool)>,
+                                                   std::function<void(std::exception_ptr)>,
                                                    const Ice::Current&);
 
-    virtual void supportsAssertExceptionAsync(std::function<void (bool)>,
-                                              std::function<void (std::exception_ptr)>,
+    virtual void supportsAssertExceptionAsync(std::function<void(bool)>,
+                                              std::function<void(std::exception_ptr)>,
                                               const Ice::Current&);
 
     virtual void throwAasAAsync(int,
-                                std::function<void ()>,
-                                std::function<void (std::exception_ptr)>,
+                                std::function<void()>,
+                                std::function<void(std::exception_ptr)>,
                                 const Ice::Current&);
 
     virtual void throwAorDasAorDAsync(int,
-                                      std::function<void ()>,
-                                      std::function<void (std::exception_ptr)>,
+                                      std::function<void()>,
+                                      std::function<void(std::exception_ptr)>,
                                       const Ice::Current&);
 
     virtual void throwBasAAsync(int, int,
-                                std::function<void ()>,
-                                std::function<void (std::exception_ptr)>,
+                                std::function<void()>,
+                                std::function<void(std::exception_ptr)>,
                                 const Ice::Current&);
 
     virtual void throwCasAAsync(int, int, int,
-                                std::function<void ()>,
-                                std::function<void (std::exception_ptr)>,
+                                std::function<void()>,
+                                std::function<void(std::exception_ptr)>,
                                 const Ice::Current&);
 
     virtual void throwBasBAsync(int, int,
-                                std::function<void ()>,
-                                std::function<void (std::exception_ptr)>,
+                                std::function<void()>,
+                                std::function<void(std::exception_ptr)>,
                                 const Ice::Current&);
 
     virtual void throwCasBAsync(int, int, int,
-                                std::function<void ()>,
-                                std::function<void (std::exception_ptr)>,
+                                std::function<void()>,
+                                std::function<void(std::exception_ptr)>,
                                 const Ice::Current&);
 
     virtual void throwCasCAsync(int, int, int,
-                                std::function<void ()>,
-                                std::function<void (std::exception_ptr)>,
+                                std::function<void()>,
+                                std::function<void(std::exception_ptr)>,
                                 const Ice::Current&);
 
     virtual void throwModAAsync(int, int,
-                                std::function<void ()>,
-                                std::function<void (std::exception_ptr)>,
+                                std::function<void()>,
+                                std::function<void(std::exception_ptr)>,
                                 const Ice::Current&);
 
     virtual void throwUndeclaredAAsync(int,
-                                       std::function<void ()>,
-                                       std::function<void (std::exception_ptr)>,
+                                       std::function<void()>,
+                                       std::function<void(std::exception_ptr)>,
                                        const Ice::Current&);
 
     virtual void throwUndeclaredBAsync(int, int,
-                                       std::function<void ()>,
-                                       std::function<void (std::exception_ptr)>,
+                                       std::function<void()>,
+                                       std::function<void(std::exception_ptr)>,
                                        const Ice::Current&);
 
     virtual void throwUndeclaredCAsync(int, int, int,
-                                       std::function<void ()>,
-                                       std::function<void (std::exception_ptr)>,
+                                       std::function<void()>,
+                                       std::function<void(std::exception_ptr)>,
                                        const Ice::Current&);
 
-    virtual void throwLocalExceptionAsync(std::function<void ()>,
-                                          std::function<void (std::exception_ptr)>,
+    virtual void throwLocalExceptionAsync(std::function<void()>,
+                                          std::function<void(std::exception_ptr)>,
                                           const Ice::Current&);
 
-    virtual void throwNonIceExceptionAsync(std::function<void ()>,
-                                           std::function<void (std::exception_ptr)>,
+    virtual void throwNonIceExceptionAsync(std::function<void()>,
+                                           std::function<void(std::exception_ptr)>,
                                            const Ice::Current&);
 
-    virtual void throwAssertExceptionAsync(std::function<void ()>,
-                                           std::function<void (std::exception_ptr)>,
+    virtual void throwAssertExceptionAsync(std::function<void()>,
+                                           std::function<void(std::exception_ptr)>,
                                            const Ice::Current&);
 
     virtual void throwMemoryLimitExceptionAsync(ICE_IN(Ice::ByteSeq),
-                                                std::function<void (const Ice::ByteSeq&)>,
-                                                std::function<void (std::exception_ptr)>,
+                                                std::function<void(const Ice::ByteSeq&)>,
+                                                std::function<void(std::exception_ptr)>,
                                                 const Ice::Current&);
 
-    virtual void throwLocalExceptionIdempotentAsync(std::function<void ()>,
-                                                    std::function<void (std::exception_ptr)>,
+    virtual void throwLocalExceptionIdempotentAsync(std::function<void()>,
+                                                    std::function<void(std::exception_ptr)>,
                                                     const Ice::Current&);
 
-    virtual void throwAfterResponseAsync(std::function<void ()>,
-                                         std::function<void (std::exception_ptr)>,
+    virtual void throwAfterResponseAsync(std::function<void()>,
+                                         std::function<void(std::exception_ptr)>,
                                          const Ice::Current&);
 
-    virtual void throwAfterExceptionAsync(std::function<void ()>,
-                                          std::function<void (std::exception_ptr)>,
+    virtual void throwAfterExceptionAsync(std::function<void()>,
+                                          std::function<void(std::exception_ptr)>,
                                           const Ice::Current&);
     
-    virtual void throwEAsync(std::function<void ()>,
-                             std::function<void (std::exception_ptr)>,
+    virtual void throwEAsync(std::function<void()>,
+                             std::function<void(std::exception_ptr)>,
                              const Ice::Current&);
 
-    virtual void throwFAsync(std::function<void ()>,
-                             std::function<void (std::exception_ptr)>,
+    virtual void throwFAsync(std::function<void()>,
+                             std::function<void(std::exception_ptr)>,
                              const Ice::Current&);
 
-    virtual void throwGAsync(std::function<void ()>,
-                             std::function<void (std::exception_ptr)>,
+    virtual void throwGAsync(std::function<void()>,
+                             std::function<void(std::exception_ptr)>,
                              const Ice::Current&);
 
-    virtual void throwHAsync(std::function<void ()>,
-                             std::function<void (std::exception_ptr)>,
+    virtual void throwHAsync(std::function<void()>,
+                             std::function<void(std::exception_ptr)>,
                              const Ice::Current&);
 #else
     virtual void shutdown_async(const Test::AMD_Thrower_shutdownPtr&,
diff --git a/cpp/test/Ice/interceptor/MyObjectI.cpp b/cpp/test/Ice/interceptor/MyObjectI.cpp
index dc20205f3f2..c59fb3c150d 100644
--- a/cpp/test/Ice/interceptor/MyObjectI.cpp
+++ b/cpp/test/Ice/interceptor/MyObjectI.cpp
@@ -86,8 +86,8 @@ MyObjectI::badSystemAdd(int, int, const Ice::Current&)
 void
 MyObjectI::amdAddAsync(int x,
                        int y,
-                       function<void (int)> response,
-                       function<void (exception_ptr)>,
+                       function<void(int)> response,
+                       function<void(exception_ptr)>,
                        const Ice::Current&)
 {
     thread t(
@@ -102,8 +102,8 @@ MyObjectI::amdAddAsync(int x,
 void
 MyObjectI::amdAddWithRetryAsync(int x,
                                 int y,
-                                function<void (int)> response,
-                                function<void (exception_ptr)>,
+                                function<void(int)> response,
+                                function<void(exception_ptr)>,
                                 const Ice::Current& current)
 {
     thread t(
@@ -125,8 +125,8 @@ MyObjectI::amdAddWithRetryAsync(int x,
 void
 MyObjectI::amdBadAddAsync(int x,
                           int y,
-                          function<void (int)>,
-                          function<void (exception_ptr)> error,
+                          function<void(int)>,
+                          function<void(exception_ptr)> error,
                           const Ice::Current&)
 {
     thread t(
@@ -148,8 +148,8 @@ MyObjectI::amdBadAddAsync(int x,
 void
 MyObjectI::amdNotExistAddAsync(int x,
                                int y,
-                               function<void (int)>,
-                               function<void (exception_ptr)> error,
+                               function<void(int)>,
+                               function<void(exception_ptr)> error,
                                const Ice::Current&)
 {
     thread t(
@@ -171,8 +171,8 @@ MyObjectI::amdNotExistAddAsync(int x,
 void
 MyObjectI::amdBadSystemAddAsync(int x,
                                 int y,
-                                function<void (int)>,
-                                function<void (exception_ptr)> error,
+                                function<void(int)>,
+                                function<void(exception_ptr)> error,
                                 const Ice::Current&)
 {
     thread t(
diff --git a/cpp/test/Ice/interceptor/MyObjectI.h b/cpp/test/Ice/interceptor/MyObjectI.h
index 7629d61ca0f..dadd3cddebf 100644
--- a/cpp/test/Ice/interceptor/MyObjectI.h
+++ b/cpp/test/Ice/interceptor/MyObjectI.h
@@ -40,11 +40,11 @@ public:
     virtual int badSystemAdd(int, int, const Ice::Current&);
 
 #ifdef ICE_CPP11_MAPPING
-    virtual void amdAddAsync(int, int, std::function<void (int)>, std::function<void (std::exception_ptr)>, const Ice::Current&);
-    virtual void amdAddWithRetryAsync(int, int, std::function<void (int)>, std::function<void (std::exception_ptr)>, const Ice::Current&);
-    virtual void amdBadAddAsync(int, int, std::function<void (int)>, std::function<void (std::exception_ptr)>, const Ice::Current&);
-    virtual void amdNotExistAddAsync(int, int, std::function<void (int)>, std::function<void (std::exception_ptr)>, const Ice::Current&);
-    virtual void amdBadSystemAddAsync(int, int, std::function<void (int)>, std::function<void (std::exception_ptr)>, const Ice::Current&);
+    virtual void amdAddAsync(int, int, std::function<void(int)>, std::function<void(std::exception_ptr)>, const Ice::Current&);
+    virtual void amdAddWithRetryAsync(int, int, std::function<void(int)>, std::function<void(std::exception_ptr)>, const Ice::Current&);
+    virtual void amdBadAddAsync(int, int, std::function<void(int)>, std::function<void(std::exception_ptr)>, const Ice::Current&);
+    virtual void amdNotExistAddAsync(int, int, std::function<void(int)>, std::function<void(std::exception_ptr)>, const Ice::Current&);
+    virtual void amdBadSystemAddAsync(int, int, std::function<void(int)>, std::function<void(std::exception_ptr)>, const Ice::Current&);
 #else
     virtual void amdAdd_async(const Test::AMD_MyObject_amdAddPtr&, int, int, const Ice::Current&);
     virtual void amdAddWithRetry_async(const Test::AMD_MyObject_amdAddWithRetryPtr&, int, int, const Ice::Current&);
diff --git a/cpp/test/Ice/invoke/BlobjectI.cpp b/cpp/test/Ice/invoke/BlobjectI.cpp
index 421c8505061..b23d44dbc5c 100644
--- a/cpp/test/Ice/invoke/BlobjectI.cpp
+++ b/cpp/test/Ice/invoke/BlobjectI.cpp
@@ -97,8 +97,8 @@ BlobjectArrayI::ice_invoke(const pair<const Ice::Byte*, const Ice::Byte*>& inEnc
 #ifdef ICE_CPP11_MAPPING
 void
 BlobjectAsyncI::ice_invokeAsync(vector<Ice::Byte> inEncaps,
-                                function<void (bool, vector<Ice::Byte>)> response,
-                                function<void (exception_ptr)>,
+                                function<void(bool, vector<Ice::Byte>)> response,
+                                function<void(exception_ptr)>,
                                 const Ice::Current& current)
 {
     Ice::InputStream in(current.adapter->getCommunicator(), inEncaps);
@@ -109,8 +109,8 @@ BlobjectAsyncI::ice_invokeAsync(vector<Ice::Byte> inEncaps,
 
 void
 BlobjectArrayAsyncI::ice_invokeAsync(pair<const Ice::Byte*, const Ice::Byte*> inEncaps,
-                                     function<void (bool, pair<const Ice::Byte*, const Ice::Byte*>)> response,
-                                     function<void (exception_ptr)>,
+                                     function<void(bool, pair<const Ice::Byte*, const Ice::Byte*>)> response,
+                                     function<void(exception_ptr)>,
                                      const Ice::Current& current)
 {
     Ice::InputStream in(current.adapter->getCommunicator(), inEncaps);
diff --git a/cpp/test/Ice/invoke/BlobjectI.h b/cpp/test/Ice/invoke/BlobjectI.h
index 6506758b838..aeed860e009 100644
--- a/cpp/test/Ice/invoke/BlobjectI.h
+++ b/cpp/test/Ice/invoke/BlobjectI.h
@@ -33,8 +33,8 @@ class BlobjectAsyncI : public Ice::BlobjectAsync
 public:
 
     virtual void ice_invokeAsync(std::vector<Ice::Byte>,
-                                 std::function<void (bool, std::vector<Ice::Byte>)>,
-                                 std::function<void (std::exception_ptr)>,
+                                 std::function<void(bool, std::vector<Ice::Byte>)>,
+                                 std::function<void(std::exception_ptr)>,
                                  const Ice::Current&);
 };
 
@@ -43,8 +43,8 @@ class BlobjectArrayAsyncI : public Ice::BlobjectArrayAsync
 public:
 
     virtual void ice_invokeAsync(std::pair<const Ice::Byte*, const Ice::Byte*>,
-                                 std::function<void (bool, std::pair<const Ice::Byte*, const Ice::Byte*>)>,
-                                 std::function<void (std::exception_ptr)>,
+                                 std::function<void(bool, std::pair<const Ice::Byte*, const Ice::Byte*>)>,
+                                 std::function<void(std::exception_ptr)>,
                                  const Ice::Current&);
 };
 #else
diff --git a/cpp/test/Ice/location/ServerLocator.cpp b/cpp/test/Ice/location/ServerLocator.cpp
index 0305124cbc9..99958c2326f 100644
--- a/cpp/test/Ice/location/ServerLocator.cpp
+++ b/cpp/test/Ice/location/ServerLocator.cpp
@@ -21,8 +21,8 @@ ServerLocatorRegistry::ServerLocatorRegistry()
 #ifdef ICE_CPP11_MAPPING
 void
 ServerLocatorRegistry::setAdapterDirectProxyAsync(string adapter, ::shared_ptr<::Ice::ObjectPrx> object,
-                                                  function<void ()> response,
-                                                  function<void (exception_ptr)>,
+                                                  function<void()> response,
+                                                  function<void(exception_ptr)>,
                                                   const ::Ice::Current&)
 #else
 void
@@ -49,8 +49,8 @@ ServerLocatorRegistry::setAdapterDirectProxy_async(const Ice::AMD_LocatorRegistr
 #ifdef ICE_CPP11_MAPPING
 void
 ServerLocatorRegistry::setReplicatedAdapterDirectProxyAsync(string adapter, string replicaGroup, shared_ptr<Ice::ObjectPrx> object,
-                                                            function<void ()> response,
-                                                            function<void (exception_ptr)>,
+                                                            function<void()> response,
+                                                            function<void(exception_ptr)>,
                                                             const ::Ice::Current&)
 #else
 void
@@ -81,8 +81,8 @@ ServerLocatorRegistry::setReplicatedAdapterDirectProxy_async(
 void
 ServerLocatorRegistry::setServerProcessProxyAsync(string,
                                                   shared_ptr<Ice::ProcessPrx>,
-                                                  function<void ()> response,
-                                                  function<void (exception_ptr)>,
+                                                  function<void()> response,
+                                                  function<void(exception_ptr)>,
                                                   const ::Ice::Current&)
 {
     response();
@@ -147,8 +147,8 @@ ServerLocator::ServerLocator(const ServerLocatorRegistryPtr& registry, const ::I
 #ifdef ICE_CPP11_MAPPING
 void
 ServerLocator::findObjectByIdAsync(::Ice::Identity id,
-                                   function<void (const shared_ptr<Ice::ObjectPrx>&)> response,
-                                   function<void (exception_ptr)>,
+                                   function<void(const shared_ptr<Ice::ObjectPrx>&)> response,
+                                   function<void(exception_ptr)>,
                                    const ::Ice::Current&) const
 #else
 void
@@ -170,8 +170,8 @@ ServerLocator::findObjectById_async(const Ice::AMD_Locator_findObjectByIdPtr& re
 #ifdef ICE_CPP11_MAPPING
 void
 ServerLocator::findAdapterByIdAsync(string id,
-                                    function<void (const shared_ptr<Ice::ObjectPrx>&)> response,
-                                    function<void (exception_ptr)>,
+                                    function<void(const shared_ptr<Ice::ObjectPrx>&)> response,
+                                    function<void(exception_ptr)>,
                                     const ::Ice::Current& current) const
 {
     ++const_cast<int&>(_requestCount);
diff --git a/cpp/test/Ice/location/ServerLocator.h b/cpp/test/Ice/location/ServerLocator.h
index 15ed39a4897..85d0c545367 100644
--- a/cpp/test/Ice/location/ServerLocator.h
+++ b/cpp/test/Ice/location/ServerLocator.h
@@ -23,17 +23,17 @@ public:
 
 #ifdef ICE_CPP11_MAPPING
     virtual void setAdapterDirectProxyAsync(std::string, std::shared_ptr<::Ice::ObjectPrx>,
-                                            std::function<void ()>,
-                                            std::function<void (std::exception_ptr)>,
+                                            std::function<void()>,
+                                            std::function<void(std::exception_ptr)>,
                                             const ::Ice::Current&);
     virtual void setReplicatedAdapterDirectProxyAsync(std::string, std::string, std::shared_ptr<Ice::ObjectPrx>,
-                                                      std::function<void ()>,
-                                                      std::function<void (std::exception_ptr)>,
+                                                      std::function<void()>,
+                                                      std::function<void(std::exception_ptr)>,
                                                       const ::Ice::Current&);
 
     virtual void setServerProcessProxyAsync(std::string, std::shared_ptr<Ice::ProcessPrx>,
-                                            std::function<void ()>,
-                                            std::function<void (std::exception_ptr)>,
+                                            std::function<void()>,
+                                            std::function<void(std::exception_ptr)>,
                                             const ::Ice::Current&);
     void addObject(std::shared_ptr<::Ice::ObjectPrx>, const ::Ice::Current&);
 #else
@@ -69,13 +69,13 @@ public:
 
 #ifdef ICE_CPP11_MAPPING
     virtual void findObjectByIdAsync(::Ice::Identity,
-                                      std::function<void (const std::shared_ptr<Ice::ObjectPrx>&)>,
-                                      std::function<void (std::exception_ptr)>,
+                                      std::function<void(const std::shared_ptr<Ice::ObjectPrx>&)>,
+                                      std::function<void(std::exception_ptr)>,
                                       const ::Ice::Current&) const;
 
     virtual void findAdapterByIdAsync(::std::string,
-                                       std::function<void (const std::shared_ptr<Ice::ObjectPrx>&)>,
-                                       std::function<void (std::exception_ptr)>,
+                                       std::function<void(const std::shared_ptr<Ice::ObjectPrx>&)>,
+                                       std::function<void(std::exception_ptr)>,
                                        const ::Ice::Current&) const;
 #else
     virtual void findObjectById_async(const ::Ice::AMD_Locator_findObjectByIdPtr&, const ::Ice::Identity&,
diff --git a/cpp/test/Ice/metrics/TestAMDI.cpp b/cpp/test/Ice/metrics/TestAMDI.cpp
index df9890f3e6f..621bc976c1d 100644
--- a/cpp/test/Ice/metrics/TestAMDI.cpp
+++ b/cpp/test/Ice/metrics/TestAMDI.cpp
@@ -14,20 +14,20 @@ using namespace std;
 
 #ifdef ICE_CPP11_MAPPING
 void
-MetricsI::opAsync(function<void ()> response, function<void (exception_ptr)>, const Ice::Current&)
+MetricsI::opAsync(function<void()> response, function<void(exception_ptr)>, const Ice::Current&)
 {
     response();
 }
 
 void
-MetricsI::failAsync(function<void ()> response, function<void (exception_ptr)>, const Ice::Current& current)
+MetricsI::failAsync(function<void()> response, function<void(exception_ptr)>, const Ice::Current& current)
 {
     current.con->close(true);
     response();
 }
 
 void
-MetricsI::opWithUserExceptionAsync(function<void ()>, function<void (exception_ptr)> error, const Ice::Current&)
+MetricsI::opWithUserExceptionAsync(function<void()>, function<void(exception_ptr)> error, const Ice::Current&)
 {
     try
     {
@@ -40,7 +40,7 @@ MetricsI::opWithUserExceptionAsync(function<void ()>, function<void (exception_p
 }
 
 void
-MetricsI::opWithRequestFailedExceptionAsync(function<void ()>, function<void (exception_ptr)> error,
+MetricsI::opWithRequestFailedExceptionAsync(function<void()>, function<void(exception_ptr)> error,
                                              const Ice::Current&)
 {
     try
@@ -54,7 +54,7 @@ MetricsI::opWithRequestFailedExceptionAsync(function<void ()>, function<void (ex
 }
 
 void
-MetricsI::opWithLocalExceptionAsync(function<void ()>, function<void (exception_ptr)> error, const Ice::Current&)
+MetricsI::opWithLocalExceptionAsync(function<void()>, function<void(exception_ptr)> error, const Ice::Current&)
 {
     try
     {
@@ -67,13 +67,13 @@ MetricsI::opWithLocalExceptionAsync(function<void ()>, function<void (exception_
 }
 
 void
-MetricsI::opWithUnknownExceptionAsync(function<void ()>, function<void (exception_ptr)>, const Ice::Current&)
+MetricsI::opWithUnknownExceptionAsync(function<void()>, function<void(exception_ptr)>, const Ice::Current&)
 {
     throw "Test";
 }
 
 void
-MetricsI::opByteSAsync(Test::ByteSeq, function<void ()> response, function<void (exception_ptr)>, const Ice::Current&)
+MetricsI::opByteSAsync(Test::ByteSeq, function<void()> response, function<void(exception_ptr)>, const Ice::Current&)
 {
     response();
 }
diff --git a/cpp/test/Ice/metrics/TestAMDI.h b/cpp/test/Ice/metrics/TestAMDI.h
index 5d3dc11ecb8..e0e9abcbbf4 100644
--- a/cpp/test/Ice/metrics/TestAMDI.h
+++ b/cpp/test/Ice/metrics/TestAMDI.h
@@ -17,23 +17,23 @@ class MetricsI : public Test::Metrics
 public:
 
 #ifdef ICE_CPP11_MAPPING
-    virtual void opAsync(std::function<void ()>, std::function<void (std::exception_ptr)>, const Ice::Current&);
+    virtual void opAsync(std::function<void()>, std::function<void(std::exception_ptr)>, const Ice::Current&);
 
-    virtual void failAsync(std::function<void ()>, std::function<void (std::exception_ptr)>, const Ice::Current&);
+    virtual void failAsync(std::function<void()>, std::function<void(std::exception_ptr)>, const Ice::Current&);
 
-    virtual void opWithUserExceptionAsync(std::function<void ()>, std::function<void (std::exception_ptr)>,
+    virtual void opWithUserExceptionAsync(std::function<void()>, std::function<void(std::exception_ptr)>,
                                            const Ice::Current&);
 
-    virtual void opWithRequestFailedExceptionAsync(std::function<void ()>, std::function<void (std::exception_ptr)>,
+    virtual void opWithRequestFailedExceptionAsync(std::function<void()>, std::function<void(std::exception_ptr)>,
                                                     const Ice::Current&);
 
-    virtual void opWithLocalExceptionAsync(std::function<void ()>, std::function<void (std::exception_ptr)>,
+    virtual void opWithLocalExceptionAsync(std::function<void()>, std::function<void(std::exception_ptr)>,
                                             const Ice::Current&);
 
-    virtual void opWithUnknownExceptionAsync(std::function<void ()>, std::function<void (std::exception_ptr)>,
+    virtual void opWithUnknownExceptionAsync(std::function<void()>, std::function<void(std::exception_ptr)>,
                                               const Ice::Current&);
 
-    virtual void opByteSAsync(Test::ByteSeq, std::function<void ()>, std::function<void (std::exception_ptr)>,
+    virtual void opByteSAsync(Test::ByteSeq, std::function<void()>, std::function<void(std::exception_ptr)>,
                                const Ice::Current&);
 #else
     virtual void op_async(const Test::AMD_Metrics_opPtr&, const Ice::Current&);
diff --git a/cpp/test/Ice/operations/TestAMDI.cpp b/cpp/test/Ice/operations/TestAMDI.cpp
index 5c45abfd016..d7c5ceff2c0 100644
--- a/cpp/test/Ice/operations/TestAMDI.cpp
+++ b/cpp/test/Ice/operations/TestAMDI.cpp
@@ -76,7 +76,7 @@ class Thread_opVoid : public IceUtil::Thread
 {
 public:
 
-    Thread_opVoid(function<void ()> response) :
+    Thread_opVoid(function<void()> response) :
         _response(move(response))
     {
     }
@@ -88,12 +88,12 @@ public:
 
 private:
 
-    function<void ()> _response;
+    function<void()> _response;
 };
 
 void
-MyDerivedClassI::shutdownAsync(function<void ()> response,
-                               function<void (exception_ptr)>,
+MyDerivedClassI::shutdownAsync(function<void()> response,
+                               function<void(exception_ptr)>,
                                const Ice::Current& current)
 {
     {
@@ -110,8 +110,8 @@ MyDerivedClassI::shutdownAsync(function<void ()> response,
 }
 
 void
-MyDerivedClassI::delayAsync(Ice::Int ms, function<void ()> response,
-                            function<void (exception_ptr)>,
+MyDerivedClassI::delayAsync(Ice::Int ms, function<void()> response,
+                            function<void(exception_ptr)>,
                             const Ice::Current&)
 {
     IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(ms));
@@ -119,8 +119,8 @@ MyDerivedClassI::delayAsync(Ice::Int ms, function<void ()> response,
 }
 
 void
-MyDerivedClassI::opVoidAsync(function<void ()> response,
-                             function<void (exception_ptr)>,
+MyDerivedClassI::opVoidAsync(function<void()> response,
+                             function<void(exception_ptr)>,
                              const Ice::Current& current)
 {
     test(current.mode == OperationMode::Normal);
@@ -140,8 +140,8 @@ MyDerivedClassI::opVoidAsync(function<void ()> response,
 void
 MyDerivedClassI::opByteAsync(Ice::Byte p1,
                              Ice::Byte p2,
-                             function<void (Ice::Byte, Ice::Byte)> response,
-                             function<void (exception_ptr)>,
+                             function<void(Ice::Byte, Ice::Byte)> response,
+                             function<void(exception_ptr)>,
                              const Ice::Current&)
 {
     response(p1, p1 ^ p2);
@@ -150,8 +150,8 @@ MyDerivedClassI::opByteAsync(Ice::Byte p1,
 void
 MyDerivedClassI::opBoolAsync(bool p1,
                              bool p2,
-                             function<void (bool, bool)> response,
-                             function<void (exception_ptr)>,
+                             function<void(bool, bool)> response,
+                             function<void(exception_ptr)>,
                              const Ice::Current&)
 {
     response(p2, p1);
@@ -162,8 +162,8 @@ void
 MyDerivedClassI::opShortIntLongAsync(short p1,
                                      int p2,
                                      long long int p3,
-                                     function<void (long long int, short, int, long long int)> response,
-                                     function<void (exception_ptr)>,
+                                     function<void(long long int, short, int, long long int)> response,
+                                     function<void(exception_ptr)>,
                                      const Ice::Current&)
 {
     response(p3, p1, p2, p3);
@@ -173,8 +173,8 @@ MyDerivedClassI::opShortIntLongAsync(short p1,
 void
 MyDerivedClassI::opFloatDoubleAsync(float p1,
                                     double p2,
-                                    function<void (double, float, double)> response,
-                                    function<void (exception_ptr)>,
+                                    function<void(double, float, double)> response,
+                                    function<void(exception_ptr)>,
                                     const Ice::Current&)
 {
     response(p2, p1, p2);
@@ -183,8 +183,8 @@ MyDerivedClassI::opFloatDoubleAsync(float p1,
 void
 MyDerivedClassI::opStringAsync(string p1,
                                string p2,
-                               function<void (const string&, const string&)> response,
-                               function<void (exception_ptr)>,
+                               function<void(const string&, const string&)> response,
+                               function<void(exception_ptr)>,
                                const Ice::Current&)
 {
     response(p1 + " " + p2, p2 + " " + p1);
@@ -193,8 +193,8 @@ MyDerivedClassI::opStringAsync(string p1,
 
 void
 MyDerivedClassI::opMyEnumAsync(Test::MyEnum p1,
-                               function<void (Test::MyEnum, Test::MyEnum)> response,
-                               function<void (exception_ptr)>,
+                               function<void(Test::MyEnum, Test::MyEnum)> response,
+                               function<void(exception_ptr)>,
                                const Ice::Current&)
 {
     response(MyEnum::enum3, p1);
@@ -202,10 +202,10 @@ MyDerivedClassI::opMyEnumAsync(Test::MyEnum p1,
 
 void
 MyDerivedClassI::opMyClassAsync(shared_ptr<Test::MyClassPrx> p1,
-                                function<void (const shared_ptr<Test::MyClassPrx>&,
+                                function<void(const shared_ptr<Test::MyClassPrx>&,
                                                const shared_ptr<Test::MyClassPrx>&,
                                                const shared_ptr<Test::MyClassPrx>&)> response,
-                                function<void (exception_ptr)>,
+                                function<void(exception_ptr)>,
                                 const Ice::Current& current)
 {
     auto p2 = p1;
@@ -217,8 +217,8 @@ MyDerivedClassI::opMyClassAsync(shared_ptr<Test::MyClassPrx> p1,
 void
 MyDerivedClassI::opStructAsync(Test::Structure p1,
                                Test::Structure p2,
-                               function<void (const Test::Structure&, const Test::Structure&)> response,
-                               function<void (exception_ptr)>,
+                               function<void(const Test::Structure&, const Test::Structure&)> response,
+                               function<void(exception_ptr)>,
                                const Ice::Current&)
 {
     Test::Structure p3 = p1;
@@ -229,8 +229,8 @@ MyDerivedClassI::opStructAsync(Test::Structure p1,
 void
 MyDerivedClassI::opByteSAsync(Test::ByteS p1,
                               Test::ByteS p2,
-                              function<void (const Test::ByteS&, const Test::ByteS&)> response,
-                              function<void (exception_ptr)>,
+                              function<void(const Test::ByteS&, const Test::ByteS&)> response,
+                              function<void(exception_ptr)>,
                               const Ice::Current&)
 {
     Test::ByteS p3;
@@ -244,8 +244,8 @@ MyDerivedClassI::opByteSAsync(Test::ByteS p1,
 void
 MyDerivedClassI::opBoolSAsync(Test::BoolS p1,
                               Test::BoolS p2,
-                              function<void (const Test::BoolS&, const Test::BoolS&)> response,
-                              function<void (exception_ptr)>,
+                              function<void(const Test::BoolS&, const Test::BoolS&)> response,
+                              function<void(exception_ptr)>,
                               const Ice::Current&)
 {
     Test::BoolS p3 = p1;
@@ -260,11 +260,11 @@ void
 MyDerivedClassI::opShortIntLongSAsync(Test::ShortS p1,
                                       Test::IntS p2,
                                       Test::LongS p3,
-                                      function<void (const Test::LongS&,
+                                      function<void(const Test::LongS&,
                                                      const Test::ShortS&,
                                                      const Test::IntS&,
                                                      const Test::LongS&)> response,
-                                      function<void (exception_ptr)>,
+                                      function<void(exception_ptr)>,
                                       const Ice::Current&)
 {
     Test::ShortS p4 = p1;
@@ -279,10 +279,10 @@ MyDerivedClassI::opShortIntLongSAsync(Test::ShortS p1,
 void
 MyDerivedClassI::opFloatDoubleSAsync(Test::FloatS p1,
                                      Test::DoubleS p2,
-                                     function<void (const Test::DoubleS&,
+                                     function<void(const Test::DoubleS&,
                                                     const Test::FloatS&,
                                                     const Test::DoubleS&)> response,
-                                     function<void (exception_ptr)>,
+                                     function<void(exception_ptr)>,
                                      const Ice::Current&)
 {
     Test::FloatS p3 = p1;
@@ -297,8 +297,8 @@ MyDerivedClassI::opFloatDoubleSAsync(Test::FloatS p1,
 void
 MyDerivedClassI::opStringSAsync(Test::StringS p1,
                                 Test::StringS p2,
-                                function<void (const Test::StringS&, const Test::StringS&)> response,
-                                function<void (exception_ptr)>,
+                                function<void(const Test::StringS&, const Test::StringS&)> response,
+                                function<void(exception_ptr)>,
                                 const Ice::Current&)
 {
     Test::StringS p3 = p1;
@@ -312,8 +312,8 @@ MyDerivedClassI::opStringSAsync(Test::StringS p1,
 void
 MyDerivedClassI::opByteSSAsync(Test::ByteSS p1,
                                Test::ByteSS p2,
-                               function<void (const Test::ByteSS&, const Test::ByteSS&)> response,
-                               function<void (exception_ptr)>,
+                               function<void(const Test::ByteSS&, const Test::ByteSS&)> response,
+                               function<void(exception_ptr)>,
                                const Ice::Current&)
 {
     Test::ByteSS p3;
@@ -327,8 +327,8 @@ MyDerivedClassI::opByteSSAsync(Test::ByteSS p1,
 void
 MyDerivedClassI::opBoolSSAsync(Test::BoolSS p1,
                                Test::BoolSS p2,
-                               function<void (const Test::BoolSS&, const Test::BoolSS&)> response,
-                               function<void (exception_ptr)>,
+                               function<void(const Test::BoolSS&, const Test::BoolSS&)> response,
+                               function<void(exception_ptr)>,
                                const Ice::Current&)
 {
     auto p3 = p1;
@@ -343,11 +343,11 @@ void
 MyDerivedClassI::opShortIntLongSSAsync(Test::ShortSS p1,
                                        Test::IntSS p2,
                                        Test::LongSS p3,
-                                       function<void (const Test::LongSS&,
+                                       function<void(const Test::LongSS&,
                                                       const Test::ShortSS&,
                                                       const Test::IntSS&,
                                                       const Test::LongSS&)> response,
-                                       function<void (exception_ptr)>,
+                                       function<void(exception_ptr)>,
                                        const Ice::Current&)
 {
     auto p4 = p1;
@@ -362,10 +362,10 @@ MyDerivedClassI::opShortIntLongSSAsync(Test::ShortSS p1,
 void
 MyDerivedClassI::opFloatDoubleSSAsync(Test::FloatSS p1,
                                       Test::DoubleSS p2,
-                                      function<void (const Test::DoubleSS&,
+                                      function<void(const Test::DoubleSS&,
                                                      const Test::FloatSS&,
                                                      const Test::DoubleSS&)> response,
-                                      function<void (exception_ptr)>,
+                                      function<void(exception_ptr)>,
                                       const Ice::Current&)
 {
     Test::FloatSS p3 = p1;
@@ -380,8 +380,8 @@ MyDerivedClassI::opFloatDoubleSSAsync(Test::FloatSS p1,
 void
 MyDerivedClassI::opStringSSAsync(Test::StringSS p1,
                                  Test::StringSS p2,
-                                 function<void (const Test::StringSS&, const Test::StringSS&)> response,
-                                 function<void (exception_ptr)>,
+                                 function<void(const Test::StringSS&, const Test::StringSS&)> response,
+                                 function<void(exception_ptr)>,
                                  const Ice::Current&)
 {
     Test::StringSS p3 = p1;
@@ -394,8 +394,8 @@ MyDerivedClassI::opStringSSAsync(Test::StringSS p1,
 
 void
 MyDerivedClassI::opStringSSSAsync(Test::StringSSS p1, Test::StringSSS p2,
-                                  function<void (const Test::StringSSS&, const Test::StringSSS&)> response,
-                                  function<void (exception_ptr)>,
+                                  function<void(const Test::StringSSS&, const Test::StringSSS&)> response,
+                                  function<void(exception_ptr)>,
                                   const Ice::Current&)
 {
     Test::StringSSS p3 = p1;
@@ -408,8 +408,8 @@ MyDerivedClassI::opStringSSSAsync(Test::StringSSS p1, Test::StringSSS p2,
 
 void
 MyDerivedClassI::opByteBoolDAsync(Test::ByteBoolD p1, Test::ByteBoolD p2,
-                                  function<void (const Test::ByteBoolD&, const Test::ByteBoolD&)> response,
-                                  function<void (exception_ptr)>,
+                                  function<void(const Test::ByteBoolD&, const Test::ByteBoolD&)> response,
+                                  function<void(exception_ptr)>,
                                   const Ice::Current&)
 {
     Test::ByteBoolD p3 = p1;
@@ -420,8 +420,8 @@ MyDerivedClassI::opByteBoolDAsync(Test::ByteBoolD p1, Test::ByteBoolD p2,
 
 void
 MyDerivedClassI::opShortIntDAsync(Test::ShortIntD p1, Test::ShortIntD p2,
-                                  function<void (const Test::ShortIntD&, const Test::ShortIntD&)> response,
-                                  function<void (exception_ptr)>,
+                                  function<void(const Test::ShortIntD&, const Test::ShortIntD&)> response,
+                                  function<void(exception_ptr)>,
                                   const Ice::Current&)
 {
     Test::ShortIntD p3 = p1;
@@ -432,8 +432,8 @@ MyDerivedClassI::opShortIntDAsync(Test::ShortIntD p1, Test::ShortIntD p2,
 
 void
 MyDerivedClassI::opLongFloatDAsync(Test::LongFloatD p1, Test::LongFloatD p2,
-                                   function<void (const Test::LongFloatD&, const Test::LongFloatD&)> response,
-                                   function<void (exception_ptr)>,
+                                   function<void(const Test::LongFloatD&, const Test::LongFloatD&)> response,
+                                   function<void(exception_ptr)>,
                                    const Ice::Current&)
 {
     Test::LongFloatD p3 = p1;
@@ -444,8 +444,8 @@ MyDerivedClassI::opLongFloatDAsync(Test::LongFloatD p1, Test::LongFloatD p2,
 
 void
 MyDerivedClassI::opStringStringDAsync(Test::StringStringD p1, Test::StringStringD p2,
-                                      function<void (const Test::StringStringD&, const Test::StringStringD&)> response,
-                                      function<void (exception_ptr)>,
+                                      function<void(const Test::StringStringD&, const Test::StringStringD&)> response,
+                                      function<void(exception_ptr)>,
                                       const Ice::Current&)
 {
     Test::StringStringD p3 = p1;
@@ -456,8 +456,8 @@ MyDerivedClassI::opStringStringDAsync(Test::StringStringD p1, Test::StringString
 
 void
 MyDerivedClassI::opStringMyEnumDAsync(Test::StringMyEnumD p1, Test::StringMyEnumD p2,
-                                      function<void (const Test::StringMyEnumD&, const Test::StringMyEnumD&)> response,
-                                      function<void (exception_ptr)>,
+                                      function<void(const Test::StringMyEnumD&, const Test::StringMyEnumD&)> response,
+                                      function<void(exception_ptr)>,
                                       const Ice::Current&)
 {
     Test::StringMyEnumD p3 = p1;
@@ -468,8 +468,8 @@ MyDerivedClassI::opStringMyEnumDAsync(Test::StringMyEnumD p1, Test::StringMyEnum
 
 void
 MyDerivedClassI::opMyEnumStringDAsync(Test::MyEnumStringD p1, Test::MyEnumStringD p2,
-                                      function<void (const Test::MyEnumStringD&, const Test::MyEnumStringD&)> response,
-                                      function<void (exception_ptr)>,
+                                      function<void(const Test::MyEnumStringD&, const Test::MyEnumStringD&)> response,
+                                      function<void(exception_ptr)>,
                                       const Ice::Current&)
 {
     Test::MyEnumStringD p3 = p1;
@@ -480,9 +480,9 @@ MyDerivedClassI::opMyEnumStringDAsync(Test::MyEnumStringD p1, Test::MyEnumString
 
 void
 MyDerivedClassI::opMyStructMyEnumDAsync(Test::MyStructMyEnumD p1, Test::MyStructMyEnumD p2,
-                                        function<void (const Test::MyStructMyEnumD&,
+                                        function<void(const Test::MyStructMyEnumD&,
                                                        const Test::MyStructMyEnumD&)> response,
-                                        function<void (exception_ptr)>,
+                                        function<void(exception_ptr)>,
                                         const Ice::Current&)
 {
     Test::MyStructMyEnumD p3 = p1;
@@ -494,8 +494,8 @@ MyDerivedClassI::opMyStructMyEnumDAsync(Test::MyStructMyEnumD p1, Test::MyStruct
 void
 MyDerivedClassI::opByteBoolDSAsync(Test::ByteBoolDS p1,
                                    Test::ByteBoolDS p2,
-                                   function<void (const Test::ByteBoolDS&, const Test::ByteBoolDS&)> response,
-                                   function<void (exception_ptr)>,
+                                   function<void(const Test::ByteBoolDS&, const Test::ByteBoolDS&)> response,
+                                   function<void(exception_ptr)>,
                                    const Ice::Current&)
 {
     Test::ByteBoolDS p3 = p2;
@@ -509,8 +509,8 @@ MyDerivedClassI::opByteBoolDSAsync(Test::ByteBoolDS p1,
 void
 MyDerivedClassI::opShortIntDSAsync(Test::ShortIntDS p1,
                                    Test::ShortIntDS p2,
-                                   function<void (const Test::ShortIntDS&, const Test::ShortIntDS&)> response,
-                                   function<void (exception_ptr)>,
+                                   function<void(const Test::ShortIntDS&, const Test::ShortIntDS&)> response,
+                                   function<void(exception_ptr)>,
                                    const Ice::Current&)
 {
     Test::ShortIntDS p3 = p2;
@@ -524,8 +524,8 @@ MyDerivedClassI::opShortIntDSAsync(Test::ShortIntDS p1,
 void
 MyDerivedClassI::opLongFloatDSAsync(Test::LongFloatDS p1,
                                     Test::LongFloatDS p2,
-                                    function<void (const Test::LongFloatDS&, const Test::LongFloatDS&)> response,
-                                    function<void (exception_ptr)>,
+                                    function<void(const Test::LongFloatDS&, const Test::LongFloatDS&)> response,
+                                    function<void(exception_ptr)>,
                                     const Ice::Current&)
 {
     Test::LongFloatDS p3 = p2;
@@ -539,8 +539,8 @@ MyDerivedClassI::opLongFloatDSAsync(Test::LongFloatDS p1,
 void
 MyDerivedClassI::opStringStringDSAsync(Test::StringStringDS p1,
                                        Test::StringStringDS p2,
-                                       function<void (const Test::StringStringDS&, const Test::StringStringDS&)> response,
-                                       function<void (exception_ptr)>,
+                                       function<void(const Test::StringStringDS&, const Test::StringStringDS&)> response,
+                                       function<void(exception_ptr)>,
                                        const Ice::Current&)
 {
     Test::StringStringDS p3 = p2;
@@ -554,8 +554,8 @@ MyDerivedClassI::opStringStringDSAsync(Test::StringStringDS p1,
 void
 MyDerivedClassI::opStringMyEnumDSAsync(Test::StringMyEnumDS p1,
                                        Test::StringMyEnumDS p2,
-                                       function<void (const Test::StringMyEnumDS&, const Test::StringMyEnumDS&)> response,
-                                       function<void (exception_ptr)>,
+                                       function<void(const Test::StringMyEnumDS&, const Test::StringMyEnumDS&)> response,
+                                       function<void(exception_ptr)>,
                                        const Ice::Current&)
 {
     Test::StringMyEnumDS p3 = p2;
@@ -569,8 +569,8 @@ MyDerivedClassI::opStringMyEnumDSAsync(Test::StringMyEnumDS p1,
 void
 MyDerivedClassI::opMyEnumStringDSAsync(Test::MyEnumStringDS p1,
                                        Test::MyEnumStringDS p2,
-                                       function<void (const Test::MyEnumStringDS&, const Test::MyEnumStringDS&)> response,
-                                       function<void (exception_ptr)>,
+                                       function<void(const Test::MyEnumStringDS&, const Test::MyEnumStringDS&)> response,
+                                       function<void(exception_ptr)>,
                                        const Ice::Current&)
 {
     Test::MyEnumStringDS p3 = p2;
@@ -584,9 +584,9 @@ MyDerivedClassI::opMyEnumStringDSAsync(Test::MyEnumStringDS p1,
 void
 MyDerivedClassI::opMyStructMyEnumDSAsync(Test::MyStructMyEnumDS p1,
                                          Test::MyStructMyEnumDS p2,
-                                         function<void (const Test::MyStructMyEnumDS&,
+                                         function<void(const Test::MyStructMyEnumDS&,
                                                         const Test::MyStructMyEnumDS&)> response,
-                                         function<void (exception_ptr)>,
+                                         function<void(exception_ptr)>,
                                          const Ice::Current&)
 {
     Test::MyStructMyEnumDS p3 = p2;
@@ -600,8 +600,8 @@ MyDerivedClassI::opMyStructMyEnumDSAsync(Test::MyStructMyEnumDS p1,
 void
 MyDerivedClassI::opByteByteSDAsync(Test::ByteByteSD p1,
                                    Test::ByteByteSD p2,
-                                   function<void (const Test::ByteByteSD&, const Test::ByteByteSD&)> response,
-                                   function<void (exception_ptr)>,
+                                   function<void(const Test::ByteByteSD&, const Test::ByteByteSD&)> response,
+                                   function<void(exception_ptr)>,
                                    const Ice::Current&)
 {
     Test::ByteByteSD p3 = p2;
@@ -613,8 +613,8 @@ MyDerivedClassI::opByteByteSDAsync(Test::ByteByteSD p1,
 void
 MyDerivedClassI::opBoolBoolSDAsync(Test::BoolBoolSD p1,
                                    Test::BoolBoolSD p2,
-                                   function<void (const Test::BoolBoolSD&, const Test::BoolBoolSD&)> response,
-                                   function<void (exception_ptr)>,
+                                   function<void(const Test::BoolBoolSD&, const Test::BoolBoolSD&)> response,
+                                   function<void(exception_ptr)>,
                                    const Ice::Current&)
 {
     Test::BoolBoolSD p3 = p2;
@@ -626,8 +626,8 @@ MyDerivedClassI::opBoolBoolSDAsync(Test::BoolBoolSD p1,
 void
 MyDerivedClassI::opShortShortSDAsync(Test::ShortShortSD p1,
                                      Test::ShortShortSD p2,
-                                     function<void (const Test::ShortShortSD&, const Test::ShortShortSD&)> response,
-                                     function<void (exception_ptr)>,
+                                     function<void(const Test::ShortShortSD&, const Test::ShortShortSD&)> response,
+                                     function<void(exception_ptr)>,
                                      const Ice::Current&)
 {
     Test::ShortShortSD p3 = p2;
@@ -639,8 +639,8 @@ MyDerivedClassI::opShortShortSDAsync(Test::ShortShortSD p1,
 void
 MyDerivedClassI::opIntIntSDAsync(Test::IntIntSD p1,
                                  Test::IntIntSD p2,
-                                 function<void (const Test::IntIntSD&, const Test::IntIntSD&)> response,
-                                 function<void (exception_ptr)>,
+                                 function<void(const Test::IntIntSD&, const Test::IntIntSD&)> response,
+                                 function<void(exception_ptr)>,
                                  const Ice::Current&)
 {
     Test::IntIntSD p3 = p2;
@@ -652,8 +652,8 @@ MyDerivedClassI::opIntIntSDAsync(Test::IntIntSD p1,
 void
 MyDerivedClassI::opLongLongSDAsync(Test::LongLongSD p1,
                                    Test::LongLongSD p2,
-                                   function<void (const Test::LongLongSD&, const Test::LongLongSD&)> response,
-                                   function<void (exception_ptr)>,
+                                   function<void(const Test::LongLongSD&, const Test::LongLongSD&)> response,
+                                   function<void(exception_ptr)>,
                                    const Ice::Current&)
 {
     Test::LongLongSD p3 = p2;
@@ -665,8 +665,8 @@ MyDerivedClassI::opLongLongSDAsync(Test::LongLongSD p1,
 void
 MyDerivedClassI::opStringFloatSDAsync(Test::StringFloatSD p1,
                                       Test::StringFloatSD p2,
-                                      function<void (const Test::StringFloatSD&, const Test::StringFloatSD&)> response,
-                                      function<void (exception_ptr)>,
+                                      function<void(const Test::StringFloatSD&, const Test::StringFloatSD&)> response,
+                                      function<void(exception_ptr)>,
                                       const Ice::Current&)
 {
     Test::StringFloatSD p3 = p2;
@@ -678,9 +678,9 @@ MyDerivedClassI::opStringFloatSDAsync(Test::StringFloatSD p1,
 void
 MyDerivedClassI::opStringDoubleSDAsync(Test::StringDoubleSD p1,
                                        Test::StringDoubleSD p2,
-                                       function<void (const Test::StringDoubleSD&,
+                                       function<void(const Test::StringDoubleSD&,
                                                       const Test::StringDoubleSD&)> response,
-                                       function<void (exception_ptr)>,
+                                       function<void(exception_ptr)>,
                                        const Ice::Current&)
 {
     Test::StringDoubleSD p3 = p2;
@@ -692,9 +692,9 @@ MyDerivedClassI::opStringDoubleSDAsync(Test::StringDoubleSD p1,
 void
 MyDerivedClassI::opStringStringSDAsync(Test::StringStringSD p1,
                                        Test::StringStringSD p2,
-                                       function<void (const Test::StringStringSD&,
+                                       function<void(const Test::StringStringSD&,
                                                       const Test::StringStringSD&)> response,
-                                       function<void (exception_ptr)>,
+                                       function<void(exception_ptr)>,
                                        const Ice::Current&)
 {
     Test::StringStringSD p3 = p2;
@@ -706,9 +706,9 @@ MyDerivedClassI::opStringStringSDAsync(Test::StringStringSD p1,
 void
 MyDerivedClassI::opMyEnumMyEnumSDAsync(Test::MyEnumMyEnumSD p1,
                                        Test::MyEnumMyEnumSD p2,
-                                       function<void (const Test::MyEnumMyEnumSD&,
+                                       function<void(const Test::MyEnumMyEnumSD&,
                                                       const Test::MyEnumMyEnumSD&)> response,
-                                       function<void (exception_ptr)>,
+                                       function<void(exception_ptr)>,
                                        const Ice::Current&)
 {
     Test::MyEnumMyEnumSD p3 = p2;
@@ -719,8 +719,8 @@ MyDerivedClassI::opMyEnumMyEnumSDAsync(Test::MyEnumMyEnumSD p1,
 
 void
 MyDerivedClassI::opIntSAsync(Test::IntS s,
-                             function<void (const Test::IntS&)> response,
-                             function<void (exception_ptr)>,
+                             function<void(const Test::IntS&)> response,
+                             function<void(exception_ptr)>,
                              const Ice::Current&)
 {
     Test::IntS r;
@@ -730,8 +730,8 @@ MyDerivedClassI::opIntSAsync(Test::IntS s,
 
 void
 MyDerivedClassI::opByteSOnewayAsync(Test::ByteS,
-                                    function<void ()> response,
-                                    function<void (exception_ptr)>,
+                                    function<void()> response,
+                                    function<void(exception_ptr)>,
                                     const Ice::Current&)
 {
     IceUtil::Mutex::Lock sync(_mutex);
@@ -740,8 +740,8 @@ MyDerivedClassI::opByteSOnewayAsync(Test::ByteS,
 }
 
 void
-MyDerivedClassI::opByteSOnewayCallCountAsync(function<void (int)> response,
-                                             function<void (exception_ptr)>,
+MyDerivedClassI::opByteSOnewayCallCountAsync(function<void(int)> response,
+                                             function<void(exception_ptr)>,
                                              const Ice::Current&)
 {
     IceUtil::Mutex::Lock sync(_mutex);
@@ -750,8 +750,8 @@ MyDerivedClassI::opByteSOnewayCallCountAsync(function<void (int)> response,
 }
 
 void
-MyDerivedClassI::opContextAsync(function<void (const Ice::Context&)> response,
-                                function<void (exception_ptr)>,
+MyDerivedClassI::opContextAsync(function<void(const Ice::Context&)> response,
+                                function<void(exception_ptr)>,
                                 const Ice::Current& current)
 {
     Test::StringStringD r = current.ctx;
@@ -761,8 +761,8 @@ MyDerivedClassI::opContextAsync(function<void (const Ice::Context&)> response,
 void
 MyDerivedClassI::opDoubleMarshalingAsync(Ice::Double p1,
                                          Test::DoubleS p2,
-                                         function<void ()> response,
-                                         function<void (exception_ptr)>,
+                                         function<void()> response,
+                                         function<void(exception_ptr)>,
                                          const Ice::Current&)
 {
     Ice::Double d = 1278312346.0 / 13.0;
@@ -775,8 +775,8 @@ MyDerivedClassI::opDoubleMarshalingAsync(Ice::Double p1,
 }
 
 void
-MyDerivedClassI::opIdempotentAsync(function<void ()> response,
-                                   function<void (exception_ptr)>,
+MyDerivedClassI::opIdempotentAsync(function<void()> response,
+                                   function<void(exception_ptr)>,
                                    const Ice::Current& current)
 {
     test(current.mode == OperationMode::Idempotent);
@@ -784,8 +784,8 @@ MyDerivedClassI::opIdempotentAsync(function<void ()> response,
 }
 
 void
-MyDerivedClassI::opNonmutatingAsync(function<void ()> response,
-                                    function<void (exception_ptr)>,
+MyDerivedClassI::opNonmutatingAsync(function<void()> response,
+                                    function<void(exception_ptr)>,
                                     const Ice::Current& current)
 {
     test(current.mode == OperationMode::Nonmutating);
@@ -793,8 +793,8 @@ MyDerivedClassI::opNonmutatingAsync(function<void ()> response,
 }
 
 void
-MyDerivedClassI::opDerivedAsync(function<void ()> response,
-                                function<void (exception_ptr)>,
+MyDerivedClassI::opDerivedAsync(function<void()> response,
+                                function<void(exception_ptr)>,
                                 const Ice::Current&)
 {
     response();
@@ -802,8 +802,8 @@ MyDerivedClassI::opDerivedAsync(function<void ()> response,
 
 void
 MyDerivedClassI::opByte1Async(Ice::Byte b,
-                              function<void (Ice::Byte)> response,
-                              function<void (exception_ptr)>,
+                              function<void(Ice::Byte)> response,
+                              function<void(exception_ptr)>,
                               const Ice::Current&)
 {
     response(b);
@@ -811,8 +811,8 @@ MyDerivedClassI::opByte1Async(Ice::Byte b,
 
 void
 MyDerivedClassI::opShort1Async(Ice::Short s,
-                               function<void (Ice::Short)> response,
-                               function<void (exception_ptr)>,
+                               function<void(Ice::Short)> response,
+                               function<void(exception_ptr)>,
                                const Ice::Current&)
 {
     response(s);
@@ -820,8 +820,8 @@ MyDerivedClassI::opShort1Async(Ice::Short s,
 
 void
 MyDerivedClassI::opInt1Async(Ice::Int i,
-                             function<void (Ice::Int)> response,
-                             function<void (exception_ptr)>,
+                             function<void(Ice::Int)> response,
+                             function<void(exception_ptr)>,
                              const Ice::Current&)
 {
     response(i);
@@ -829,8 +829,8 @@ MyDerivedClassI::opInt1Async(Ice::Int i,
 
 void
 MyDerivedClassI::opLong1Async(Ice::Long l,
-                              function<void (Ice::Long)> response,
-                              function<void (exception_ptr)>,
+                              function<void(Ice::Long)> response,
+                              function<void(exception_ptr)>,
                               const Ice::Current&)
 {
     response(l);
@@ -838,8 +838,8 @@ MyDerivedClassI::opLong1Async(Ice::Long l,
 
 void
 MyDerivedClassI::opFloat1Async(Ice::Float f,
-                               function<void (Ice::Float)> response,
-                               function<void (exception_ptr)>,
+                               function<void(Ice::Float)> response,
+                               function<void(exception_ptr)>,
                                const Ice::Current&)
 {
     response(f);
@@ -847,8 +847,8 @@ MyDerivedClassI::opFloat1Async(Ice::Float f,
 
 void
 MyDerivedClassI::opDouble1Async(Ice::Double d,
-                                function<void (Ice::Double)> response,
-                                function<void (exception_ptr)>,
+                                function<void(Ice::Double)> response,
+                                function<void(exception_ptr)>,
                                 const Ice::Current&)
 {
     response(d);
@@ -856,8 +856,8 @@ MyDerivedClassI::opDouble1Async(Ice::Double d,
 
 void
 MyDerivedClassI::opString1Async(string s,
-                                function<void (const string&)> response,
-                                function<void (exception_ptr)>,
+                                function<void(const string&)> response,
+                                function<void(exception_ptr)>,
                                 const Ice::Current&)
 {
     response(s);
@@ -865,8 +865,8 @@ MyDerivedClassI::opString1Async(string s,
 
 void
 MyDerivedClassI::opStringS1Async(Test::StringS seq,
-                                 function<void (const Test::StringS&)> response,
-                                 function<void (exception_ptr)>,
+                                 function<void(const Test::StringS&)> response,
+                                 function<void(exception_ptr)>,
                                  const Ice::Current&)
 {
     response(seq);
@@ -874,8 +874,8 @@ MyDerivedClassI::opStringS1Async(Test::StringS seq,
 
 void
 MyDerivedClassI::opByteBoolD1Async(Test::ByteBoolD dict,
-                                   function<void (const Test::ByteBoolD&)> response,
-                                   function<void (exception_ptr)>,
+                                   function<void(const Test::ByteBoolD&)> response,
+                                   function<void(exception_ptr)>,
                                    const Ice::Current&)
 {
     response(dict);
@@ -883,8 +883,8 @@ MyDerivedClassI::opByteBoolD1Async(Test::ByteBoolD dict,
 
 void
 MyDerivedClassI::opStringS2Async(Test::StringS seq,
-                                 function<void (const Test::StringS&)> response,
-                                 function<void (exception_ptr)>,
+                                 function<void(const Test::StringS&)> response,
+                                 function<void(exception_ptr)>,
                                  const Ice::Current&)
 {
     response(seq);
@@ -892,8 +892,8 @@ MyDerivedClassI::opStringS2Async(Test::StringS seq,
 
 void
 MyDerivedClassI::opByteBoolD2Async(Test::ByteBoolD dict,
-                                   function<void (const Test::ByteBoolD&)> response,
-                                   function<void (exception_ptr)>,
+                                   function<void(const Test::ByteBoolD&)> response,
+                                   function<void(exception_ptr)>,
                                    const Ice::Current&)
 {
     response(dict);
@@ -901,8 +901,8 @@ MyDerivedClassI::opByteBoolD2Async(Test::ByteBoolD dict,
 
 void
 MyDerivedClassI::opMyStruct1Async(Test::MyStruct1 s,
-                                  function<void (const Test::MyStruct1&)> response,
-                                  function<void (exception_ptr)>,
+                                  function<void(const Test::MyStruct1&)> response,
+                                  function<void(exception_ptr)>,
                                   const Ice::Current&)
 {
     response(s);
@@ -910,16 +910,16 @@ MyDerivedClassI::opMyStruct1Async(Test::MyStruct1 s,
 
 void
 MyDerivedClassI::opMyClass1Async(shared_ptr<Test::MyClass1> c,
-                                 function<void (const shared_ptr<Test::MyClass1>&)> response,
-                                 function<void (exception_ptr)>,
+                                 function<void(const shared_ptr<Test::MyClass1>&)> response,
+                                 function<void(exception_ptr)>,
                                  const Ice::Current&)
 {
     response(c);
 }
 
 void
-MyDerivedClassI::opStringLiteralsAsync(function<void (const Test::StringS&)> response,
-                                       function<void (exception_ptr)>,
+MyDerivedClassI::opStringLiteralsAsync(function<void(const Test::StringS&)> response,
+                                       function<void(exception_ptr)>,
                                        const Ice::Current&)
 {
     Test::StringS data;
@@ -962,8 +962,8 @@ MyDerivedClassI::opStringLiteralsAsync(function<void (const Test::StringS&)> res
 }
 
 void
-MyDerivedClassI::opWStringLiteralsAsync(function<void (const Test::WStringS&)> response,
-                                        function<void (exception_ptr)>,
+MyDerivedClassI::opWStringLiteralsAsync(function<void(const Test::WStringS&)> response,
+                                        function<void(exception_ptr)>,
                                         const Ice::Current&)
 {
     Test::WStringS data;
diff --git a/cpp/test/Ice/operations/TestAMDI.h b/cpp/test/Ice/operations/TestAMDI.h
index 313ba44dcb7..ba87f68cb9d 100644
--- a/cpp/test/Ice/operations/TestAMDI.h
+++ b/cpp/test/Ice/operations/TestAMDI.h
@@ -38,354 +38,354 @@ public:
 #endif
 
 #ifdef ICE_CPP11_MAPPING
-    virtual void shutdownAsync(::std::function<void ()>,
-                               ::std::function<void (std::exception_ptr)>,
+    virtual void shutdownAsync(::std::function<void()>,
+                               ::std::function<void(std::exception_ptr)>,
                                const Ice::Current&);
 
     virtual void delayAsync(Ice::Int,
-                            ::std::function<void ()>,
-                            ::std::function<void (std::exception_ptr)>,
+                            ::std::function<void()>,
+                            ::std::function<void(std::exception_ptr)>,
                             const Ice::Current&);
 
-    virtual void opVoidAsync(::std::function<void ()>,
-                             ::std::function<void (std::exception_ptr)>,
+    virtual void opVoidAsync(::std::function<void()>,
+                             ::std::function<void(std::exception_ptr)>,
                              const Ice::Current&);
 
     virtual void opByteAsync(Ice::Byte, Ice::Byte,
-                             ::std::function<void (Ice::Byte, Ice::Byte)>,
-                             ::std::function<void (std::exception_ptr)>,
+                             ::std::function<void(Ice::Byte, Ice::Byte)>,
+                             ::std::function<void(std::exception_ptr)>,
                              const Ice::Current&);
 
     virtual void opBoolAsync(bool, bool,
-                             ::std::function<void (bool, bool)>,
-                             ::std::function<void (std::exception_ptr)>,
+                             ::std::function<void(bool, bool)>,
+                             ::std::function<void(std::exception_ptr)>,
                              const Ice::Current&);
 
     virtual void opShortIntLongAsync(short, int, long long int,
-                                     ::std::function<void (long long int, short, int, long long int)>,
-                                     ::std::function<void (std::exception_ptr)>,
+                                     ::std::function<void(long long int, short, int, long long int)>,
+                                     ::std::function<void(std::exception_ptr)>,
                                      const Ice::Current&);
 
     virtual void opFloatDoubleAsync(float, double,
-                                    ::std::function<void (double, float, double)>,
-                                    ::std::function<void (std::exception_ptr)>,
+                                    ::std::function<void(double, float, double)>,
+                                    ::std::function<void(std::exception_ptr)>,
                                     const Ice::Current&);
 
     virtual void opStringAsync(std::string, std::string,
-                               ::std::function<void (const ::std::string&, const ::std::string&)>,
-                               ::std::function<void (std::exception_ptr)>,
+                               ::std::function<void(const ::std::string&, const ::std::string&)>,
+                               ::std::function<void(std::exception_ptr)>,
                                const Ice::Current&);
 
     virtual void opMyEnumAsync(Test::MyEnum,
-                               std::function<void (Test::MyEnum, Test::MyEnum)>,
-                               std::function<void (std::exception_ptr)>,
+                               std::function<void(Test::MyEnum, Test::MyEnum)>,
+                               std::function<void(std::exception_ptr)>,
                                const Ice::Current&);
 
     virtual void opMyClassAsync(std::shared_ptr<Test::MyClassPrx>,
-                                std::function<void (const std::shared_ptr<Test::MyClassPrx>&,
+                                std::function<void(const std::shared_ptr<Test::MyClassPrx>&,
                                                     const std::shared_ptr<Test::MyClassPrx>&,
                                                     const std::shared_ptr<Test::MyClassPrx>&)>,
-                                ::std::function<void (std::exception_ptr)>,
+                                ::std::function<void(std::exception_ptr)>,
                                 const Ice::Current&);
 
     virtual void opStructAsync(Test::Structure, Test::Structure,
-                               ::std::function<void (const Test::Structure&, const Test::Structure&)>,
-                               ::std::function<void (std::exception_ptr)>,
+                               ::std::function<void(const Test::Structure&, const Test::Structure&)>,
+                               ::std::function<void(std::exception_ptr)>,
                                const Ice::Current&);
 
     virtual void opByteSAsync(Test::ByteS, Test::ByteS,
-                              ::std::function<void (const Test::ByteS&, const Test::ByteS&)>,
-                              ::std::function<void (std::exception_ptr)>,
+                              ::std::function<void(const Test::ByteS&, const Test::ByteS&)>,
+                              ::std::function<void(std::exception_ptr)>,
                               const Ice::Current&);
 
     virtual void opBoolSAsync(Test::BoolS, Test::BoolS,
-                              ::std::function<void (const Test::BoolS&, const Test::BoolS&)>,
-                              ::std::function<void (std::exception_ptr)>,
+                              ::std::function<void(const Test::BoolS&, const Test::BoolS&)>,
+                              ::std::function<void(std::exception_ptr)>,
                               const Ice::Current&);
 
     virtual void opShortIntLongSAsync(Test::ShortS, Test::IntS, Test::LongS,
-                                      ::std::function<void (const Test::LongS&,
+                                      ::std::function<void(const Test::LongS&,
                                                             const Test::ShortS&,
                                                             const Test::IntS&,
                                                             const Test::LongS&)>,
-                                      ::std::function<void (std::exception_ptr)>,
+                                      ::std::function<void(std::exception_ptr)>,
                                       const Ice::Current&);
 
     virtual void opFloatDoubleSAsync(Test::FloatS, Test::DoubleS,
-                                     ::std::function<void (const Test::DoubleS&,
+                                     ::std::function<void(const Test::DoubleS&,
                                                            const Test::FloatS&,
                                                            const Test::DoubleS&)>,
-                                     ::std::function<void (std::exception_ptr)>,
+                                     ::std::function<void(std::exception_ptr)>,
                                      const Ice::Current&);
 
     virtual void opStringSAsync(Test::StringS, Test::StringS,
-                                ::std::function<void (const Test::StringS&, const Test::StringS&)>,
-                                ::std::function<void (std::exception_ptr)>,
+                                ::std::function<void(const Test::StringS&, const Test::StringS&)>,
+                                ::std::function<void(std::exception_ptr)>,
                                 const Ice::Current&);
 
     virtual void opByteSSAsync(Test::ByteSS, Test::ByteSS,
-                               ::std::function<void (const Test::ByteSS&, const Test::ByteSS&)>,
-                               ::std::function<void (std::exception_ptr)>,
+                               ::std::function<void(const Test::ByteSS&, const Test::ByteSS&)>,
+                               ::std::function<void(std::exception_ptr)>,
                                const Ice::Current&);
 
     virtual void opBoolSSAsync(Test::BoolSS, Test::BoolSS,
-                               ::std::function<void (const Test::BoolSS&, const Test::BoolSS&)>,
-                               ::std::function<void (std::exception_ptr)>,
+                               ::std::function<void(const Test::BoolSS&, const Test::BoolSS&)>,
+                               ::std::function<void(std::exception_ptr)>,
                                const Ice::Current&);
 
     virtual void opShortIntLongSSAsync(Test::ShortSS, Test::IntSS, Test::LongSS,
-                                       ::std::function<void (const Test::LongSS&,
+                                       ::std::function<void(const Test::LongSS&,
                                                              const Test::ShortSS&,
                                                              const Test::IntSS&,
                                                              const Test::LongSS&)>,
-                                       ::std::function<void (std::exception_ptr)>,
+                                       ::std::function<void(std::exception_ptr)>,
                                        const Ice::Current&);
 
     virtual void opFloatDoubleSSAsync(Test::FloatSS, Test::DoubleSS,
-                                      ::std::function<void (const Test::DoubleSS&,
+                                      ::std::function<void(const Test::DoubleSS&,
                                                             const Test::FloatSS&,
                                                             const Test::DoubleSS&)>,
-                                      ::std::function<void (std::exception_ptr)>,
+                                      ::std::function<void(std::exception_ptr)>,
                                       const Ice::Current&);
 
     virtual void opStringSSAsync(Test::StringSS, Test::StringSS,
-                                 ::std::function<void (const Test::StringSS&, const Test::StringSS&)>,
-                                 ::std::function<void (std::exception_ptr)>,
+                                 ::std::function<void(const Test::StringSS&, const Test::StringSS&)>,
+                                 ::std::function<void(std::exception_ptr)>,
                                  const Ice::Current&);
 
     virtual void opStringSSSAsync(Test::StringSSS, Test::StringSSS,
-                                  ::std::function<void (const Test::StringSSS&, const Test::StringSSS&)>,
-                                  ::std::function<void (std::exception_ptr)>,
+                                  ::std::function<void(const Test::StringSSS&, const Test::StringSSS&)>,
+                                  ::std::function<void(std::exception_ptr)>,
                                   const Ice::Current&);
 
     virtual void opByteBoolDAsync(Test::ByteBoolD, Test::ByteBoolD,
-                                  ::std::function<void (const Test::ByteBoolD&, const Test::ByteBoolD&)>,
-                                  ::std::function<void (std::exception_ptr)>,
+                                  ::std::function<void(const Test::ByteBoolD&, const Test::ByteBoolD&)>,
+                                  ::std::function<void(std::exception_ptr)>,
                                   const Ice::Current&);
 
     virtual void opShortIntDAsync(Test::ShortIntD, Test::ShortIntD,
-                                  ::std::function<void (const Test::ShortIntD&, const Test::ShortIntD&)>,
-                                  ::std::function<void (std::exception_ptr)>,
+                                  ::std::function<void(const Test::ShortIntD&, const Test::ShortIntD&)>,
+                                  ::std::function<void(std::exception_ptr)>,
                                   const Ice::Current&);
 
     virtual void opLongFloatDAsync(Test::LongFloatD, Test::LongFloatD,
-                                   ::std::function<void (const Test::LongFloatD&, const Test::LongFloatD&)>,
-                                   ::std::function<void (std::exception_ptr)>,
+                                   ::std::function<void(const Test::LongFloatD&, const Test::LongFloatD&)>,
+                                   ::std::function<void(std::exception_ptr)>,
                                    const Ice::Current&);
 
     virtual void opStringStringDAsync(Test::StringStringD, Test::StringStringD,
-                                      ::std::function<void (const Test::StringStringD&, const Test::StringStringD&)>,
-                                      ::std::function<void (std::exception_ptr)>,
+                                      ::std::function<void(const Test::StringStringD&, const Test::StringStringD&)>,
+                                      ::std::function<void(std::exception_ptr)>,
                                       const Ice::Current&);
 
     virtual void opStringMyEnumDAsync(Test::StringMyEnumD, Test::StringMyEnumD,
-                                      ::std::function<void (const Test::StringMyEnumD&, const Test::StringMyEnumD&)>,
-                                      ::std::function<void (std::exception_ptr)>,
+                                      ::std::function<void(const Test::StringMyEnumD&, const Test::StringMyEnumD&)>,
+                                      ::std::function<void(std::exception_ptr)>,
                                       const Ice::Current&);
 
     virtual void opMyEnumStringDAsync(Test::MyEnumStringD, Test::MyEnumStringD,
-                                      ::std::function<void (const Test::MyEnumStringD&, const Test::MyEnumStringD&)>,
-                                      ::std::function<void (std::exception_ptr)>,
+                                      ::std::function<void(const Test::MyEnumStringD&, const Test::MyEnumStringD&)>,
+                                      ::std::function<void(std::exception_ptr)>,
                                       const Ice::Current&);
 
     virtual void opMyStructMyEnumDAsync(Test::MyStructMyEnumD, Test::MyStructMyEnumD,
-                                        ::std::function<void (const Test::MyStructMyEnumD&,
+                                        ::std::function<void(const Test::MyStructMyEnumD&,
                                                               const Test::MyStructMyEnumD&)>,
-                                        ::std::function<void (std::exception_ptr)>,
+                                        ::std::function<void(std::exception_ptr)>,
                                         const Ice::Current&);
 
     virtual void opByteBoolDSAsync(Test::ByteBoolDS, Test::ByteBoolDS,
-                                   ::std::function<void (const Test::ByteBoolDS&, const Test::ByteBoolDS&)>,
-                                   ::std::function<void (std::exception_ptr)>,
+                                   ::std::function<void(const Test::ByteBoolDS&, const Test::ByteBoolDS&)>,
+                                   ::std::function<void(std::exception_ptr)>,
                                    const Ice::Current&);
 
     virtual void opShortIntDSAsync(Test::ShortIntDS, Test::ShortIntDS,
-                                   ::std::function<void (const Test::ShortIntDS&, const Test::ShortIntDS&)>,
-                                   ::std::function<void (std::exception_ptr)>,
+                                   ::std::function<void(const Test::ShortIntDS&, const Test::ShortIntDS&)>,
+                                   ::std::function<void(std::exception_ptr)>,
                                    const Ice::Current&);
 
     virtual void opLongFloatDSAsync(Test::LongFloatDS, Test::LongFloatDS,
-                                    ::std::function<void (const Test::LongFloatDS&, const Test::LongFloatDS&)>,
-                                    ::std::function<void (std::exception_ptr)>,
+                                    ::std::function<void(const Test::LongFloatDS&, const Test::LongFloatDS&)>,
+                                    ::std::function<void(std::exception_ptr)>,
                                     const Ice::Current&);
 
     virtual void opStringStringDSAsync(Test::StringStringDS, Test::StringStringDS,
-                                       ::std::function<void (const Test::StringStringDS&, const Test::StringStringDS&)>,
-                                       ::std::function<void (std::exception_ptr)>,
+                                       ::std::function<void(const Test::StringStringDS&, const Test::StringStringDS&)>,
+                                       ::std::function<void(std::exception_ptr)>,
                                        const Ice::Current&);
 
     virtual void opStringMyEnumDSAsync(Test::StringMyEnumDS, Test::StringMyEnumDS,
-                                       ::std::function<void (const Test::StringMyEnumDS&,
+                                       ::std::function<void(const Test::StringMyEnumDS&,
                                                              const Test::StringMyEnumDS&)>,
-                                       ::std::function<void (std::exception_ptr)>,
+                                       ::std::function<void(std::exception_ptr)>,
                                        const Ice::Current&);
 
     virtual void opMyEnumStringDSAsync(Test::MyEnumStringDS, Test::MyEnumStringDS,
-                                       ::std::function<void (const Test::MyEnumStringDS&,
+                                       ::std::function<void(const Test::MyEnumStringDS&,
                                                              const Test::MyEnumStringDS&)>,
-                                       ::std::function<void (std::exception_ptr)>,
+                                       ::std::function<void(std::exception_ptr)>,
                                        const Ice::Current&);
 
     virtual void opMyStructMyEnumDSAsync(Test::MyStructMyEnumDS, Test::MyStructMyEnumDS,
-                                         ::std::function<void (const Test::MyStructMyEnumDS&,
+                                         ::std::function<void(const Test::MyStructMyEnumDS&,
                                                                const Test::MyStructMyEnumDS&)>,
-                                         ::std::function<void (std::exception_ptr)>,
+                                         ::std::function<void(std::exception_ptr)>,
                                          const Ice::Current&);
 
     virtual void opByteByteSDAsync(Test::ByteByteSD, Test::ByteByteSD,
-                                   ::std::function<void (const Test::ByteByteSD&, const Test::ByteByteSD&)>,
-                                   ::std::function<void (std::exception_ptr)>,
+                                   ::std::function<void(const Test::ByteByteSD&, const Test::ByteByteSD&)>,
+                                   ::std::function<void(std::exception_ptr)>,
                                    const Ice::Current&);
 
     virtual void opBoolBoolSDAsync(Test::BoolBoolSD, Test::BoolBoolSD,
-                                   ::std::function<void (const Test::BoolBoolSD&, const Test::BoolBoolSD&)>,
-                                   ::std::function<void (std::exception_ptr)>,
+                                   ::std::function<void(const Test::BoolBoolSD&, const Test::BoolBoolSD&)>,
+                                   ::std::function<void(std::exception_ptr)>,
                                    const Ice::Current&);
 
     virtual void opShortShortSDAsync(Test::ShortShortSD, Test::ShortShortSD,
-                                     ::std::function<void (const Test::ShortShortSD&, const Test::ShortShortSD&)>,
-                                     ::std::function<void (std::exception_ptr)>,
+                                     ::std::function<void(const Test::ShortShortSD&, const Test::ShortShortSD&)>,
+                                     ::std::function<void(std::exception_ptr)>,
                                      const Ice::Current&);
 
     virtual void opIntIntSDAsync(Test::IntIntSD, Test::IntIntSD,
-                                 ::std::function<void (const Test::IntIntSD&, const Test::IntIntSD&)>,
-                                 ::std::function<void (std::exception_ptr)>,
+                                 ::std::function<void(const Test::IntIntSD&, const Test::IntIntSD&)>,
+                                 ::std::function<void(std::exception_ptr)>,
                                  const Ice::Current&);
 
     virtual void opLongLongSDAsync(Test::LongLongSD, Test::LongLongSD,
-                                   ::std::function<void (const Test::LongLongSD&, const Test::LongLongSD&)>,
-                                   ::std::function<void (std::exception_ptr)>,
+                                   ::std::function<void(const Test::LongLongSD&, const Test::LongLongSD&)>,
+                                   ::std::function<void(std::exception_ptr)>,
                                    const Ice::Current&);
 
     virtual void opStringFloatSDAsync(Test::StringFloatSD, Test::StringFloatSD,
-                                      ::std::function<void (const Test::StringFloatSD&, const Test::StringFloatSD&)>,
-                                      ::std::function<void (std::exception_ptr)>,
+                                      ::std::function<void(const Test::StringFloatSD&, const Test::StringFloatSD&)>,
+                                      ::std::function<void(std::exception_ptr)>,
                                       const Ice::Current&);
 
     virtual void opStringDoubleSDAsync(Test::StringDoubleSD, Test::StringDoubleSD,
-                                       ::std::function<void (const Test::StringDoubleSD&,
+                                       ::std::function<void(const Test::StringDoubleSD&,
                                                              const Test::StringDoubleSD&)>,
-                                       ::std::function<void (std::exception_ptr)>,
+                                       ::std::function<void(std::exception_ptr)>,
                                        const Ice::Current&);
 
     virtual void opStringStringSDAsync(Test::StringStringSD, Test::StringStringSD,
-                                       ::std::function<void (const Test::StringStringSD&,
+                                       ::std::function<void(const Test::StringStringSD&,
                                                              const Test::StringStringSD&)>,
-                                       ::std::function<void (std::exception_ptr)>,
+                                       ::std::function<void(std::exception_ptr)>,
                                        const Ice::Current&);
 
     virtual void opMyEnumMyEnumSDAsync(Test::MyEnumMyEnumSD, Test::MyEnumMyEnumSD,
-                                       ::std::function<void (const Test::MyEnumMyEnumSD&,
+                                       ::std::function<void(const Test::MyEnumMyEnumSD&,
                                                              const Test::MyEnumMyEnumSD&)>,
-                                       ::std::function<void (std::exception_ptr)>,
+                                       ::std::function<void(std::exception_ptr)>,
                                        const Ice::Current&);
 
     virtual void opIntSAsync(Test::IntS,
-                             ::std::function<void (const Test::IntS&)>,
-                             ::std::function<void (std::exception_ptr)>,
+                             ::std::function<void(const Test::IntS&)>,
+                             ::std::function<void(std::exception_ptr)>,
                              const Ice::Current&);
 
     virtual void opByteSOnewayAsync(Test::ByteS,
-                                    ::std::function<void ()>,
-                                    ::std::function<void (std::exception_ptr)>,
+                                    ::std::function<void()>,
+                                    ::std::function<void(std::exception_ptr)>,
                                     const Ice::Current&);
 
-    virtual void opByteSOnewayCallCountAsync(::std::function<void (int)>,
-                                             ::std::function<void (std::exception_ptr)>,
+    virtual void opByteSOnewayCallCountAsync(::std::function<void(int)>,
+                                             ::std::function<void(std::exception_ptr)>,
                                              const Ice::Current&);
 
-    virtual void opContextAsync(::std::function<void (const Ice::Context&)>,
-                                ::std::function<void (std::exception_ptr)>,
+    virtual void opContextAsync(::std::function<void(const Ice::Context&)>,
+                                ::std::function<void(std::exception_ptr)>,
                                 const Ice::Current&);
 
     virtual void opDoubleMarshalingAsync(Ice::Double, Test::DoubleS,
-                                         ::std::function<void ()>,
-                                         ::std::function<void (std::exception_ptr)>,
+                                         ::std::function<void()>,
+                                         ::std::function<void(std::exception_ptr)>,
                                          const Ice::Current&);
 
-    virtual void opIdempotentAsync(::std::function<void ()>,
-                                   ::std::function<void (std::exception_ptr)>,
+    virtual void opIdempotentAsync(::std::function<void()>,
+                                   ::std::function<void(std::exception_ptr)>,
                                    const Ice::Current&);
 
-    virtual void opNonmutatingAsync(::std::function<void ()>,
-                                    ::std::function<void (std::exception_ptr)>,
+    virtual void opNonmutatingAsync(::std::function<void()>,
+                                    ::std::function<void(std::exception_ptr)>,
                                     const Ice::Current&);
 
-    virtual void opDerivedAsync(::std::function<void ()>,
-                                ::std::function<void (std::exception_ptr)>,
+    virtual void opDerivedAsync(::std::function<void()>,
+                                ::std::function<void(std::exception_ptr)>,
                                 const Ice::Current&);
 
     virtual void opByte1Async(Ice::Byte,
-                              ::std::function<void (Ice::Byte)>,
-                              ::std::function<void (std::exception_ptr)>,
+                              ::std::function<void(Ice::Byte)>,
+                              ::std::function<void(std::exception_ptr)>,
                               const Ice::Current&);
 
     virtual void opShort1Async(Ice::Short,
-                               ::std::function<void (Ice::Short)>,
-                               ::std::function<void (std::exception_ptr)>,
+                               ::std::function<void(Ice::Short)>,
+                               ::std::function<void(std::exception_ptr)>,
                                const Ice::Current&);
 
     virtual void opInt1Async(Ice::Int,
-                             ::std::function<void (Ice::Int)>,
-                             ::std::function<void (std::exception_ptr)>,
+                             ::std::function<void(Ice::Int)>,
+                             ::std::function<void(std::exception_ptr)>,
                              const Ice::Current&);
 
     virtual void opLong1Async(Ice::Long,
-                              ::std::function<void (Ice::Long)>,
-                              ::std::function<void (std::exception_ptr)>,
+                              ::std::function<void(Ice::Long)>,
+                              ::std::function<void(std::exception_ptr)>,
                               const Ice::Current&);
 
     virtual void opFloat1Async(Ice::Float,
-                               ::std::function<void (Ice::Float)>,
-                               ::std::function<void (std::exception_ptr)>,
+                               ::std::function<void(Ice::Float)>,
+                               ::std::function<void(std::exception_ptr)>,
                                const Ice::Current&);
 
     virtual void opDouble1Async(Ice::Double,
-                                ::std::function<void (Ice::Double)>,
-                                ::std::function<void (std::exception_ptr)>,
+                                ::std::function<void(Ice::Double)>,
+                                ::std::function<void(std::exception_ptr)>,
                                 const Ice::Current&);
 
     virtual void opString1Async(std::string,
-                                ::std::function<void (const ::std::string&)>,
-                                ::std::function<void (std::exception_ptr)>,
+                                ::std::function<void(const ::std::string&)>,
+                                ::std::function<void(std::exception_ptr)>,
                                 const Ice::Current&);
 
     virtual void opStringS1Async(Test::StringS,
-                                 ::std::function<void (const Test::StringS&)>,
-                                 ::std::function<void (std::exception_ptr)>,
+                                 ::std::function<void(const Test::StringS&)>,
+                                 ::std::function<void(std::exception_ptr)>,
                                  const Ice::Current&);
 
     virtual void opByteBoolD1Async(Test::ByteBoolD,
-                                   ::std::function<void (const Test::ByteBoolD&)>,
-                                   ::std::function<void (std::exception_ptr)>,
+                                   ::std::function<void(const Test::ByteBoolD&)>,
+                                   ::std::function<void(std::exception_ptr)>,
                                    const Ice::Current&);
 
     virtual void opStringS2Async(Test::StringS,
-                                 ::std::function<void (const Test::StringS&)>,
-                                 ::std::function<void (std::exception_ptr)>,
+                                 ::std::function<void(const Test::StringS&)>,
+                                 ::std::function<void(std::exception_ptr)>,
                                  const Ice::Current&);
 
     virtual void opByteBoolD2Async(Test::ByteBoolD,
-                                   ::std::function<void (const Test::ByteBoolD&)>,
-                                   ::std::function<void (std::exception_ptr)>,
+                                   ::std::function<void(const Test::ByteBoolD&)>,
+                                   ::std::function<void(std::exception_ptr)>,
                                    const Ice::Current&);
 
     virtual void opMyStruct1Async(Test::MyStruct1,
-                                  ::std::function<void (const Test::MyStruct1&)>,
-                                  ::std::function<void (std::exception_ptr)>,
+                                  ::std::function<void(const Test::MyStruct1&)>,
+                                  ::std::function<void(std::exception_ptr)>,
                                   const Ice::Current&);
 
     virtual void opMyClass1Async(::std::shared_ptr<Test::MyClass1>,
-                                 ::std::function<void (const ::std::shared_ptr<Test::MyClass1>&)>,
-                                 ::std::function<void (std::exception_ptr)>,
+                                 ::std::function<void(const ::std::shared_ptr<Test::MyClass1>&)>,
+                                 ::std::function<void(std::exception_ptr)>,
                                  const Ice::Current&);
 
-    virtual void opStringLiteralsAsync(::std::function<void (const Test::StringS&)>,
-                                       ::std::function<void (std::exception_ptr)>,
+    virtual void opStringLiteralsAsync(::std::function<void(const Test::StringS&)>,
+                                       ::std::function<void(std::exception_ptr)>,
                                        const Ice::Current&);
 
-    virtual void opWStringLiteralsAsync(::std::function<void (const Test::WStringS&)>,
-                                        ::std::function<void (std::exception_ptr)>,
+    virtual void opWStringLiteralsAsync(::std::function<void(const Test::WStringS&)>,
+                                        ::std::function<void(std::exception_ptr)>,
                                         const Ice::Current&);
 #else
     virtual void shutdown_async(const Test::AMD_MyClass_shutdownPtr&,
diff --git a/cpp/test/Ice/operations/TwowaysAMI.cpp b/cpp/test/Ice/operations/TwowaysAMI.cpp
index 467f51bff5e..462670b423a 100644
--- a/cpp/test/Ice/operations/TwowaysAMI.cpp
+++ b/cpp/test/Ice/operations/TwowaysAMI.cpp
@@ -1038,7 +1038,7 @@ typedef IceUtil::Handle<Callback> CallbackPtr;
 }
 
 #ifdef ICE_CPP11_MAPPING
-function<void (exception_ptr)>
+function<void(exception_ptr)>
 makeExceptionClosure(CallbackPtr& cb)
 {
     return [&](exception_ptr e)
diff --git a/cpp/test/Ice/proxy/TestAMDI.cpp b/cpp/test/Ice/proxy/TestAMDI.cpp
index 8ed80f009f2..968ab15ad3a 100644
--- a/cpp/test/Ice/proxy/TestAMDI.cpp
+++ b/cpp/test/Ice/proxy/TestAMDI.cpp
@@ -21,8 +21,8 @@ MyDerivedClassI::MyDerivedClassI()
 void
 MyDerivedClassI::echoAsync(
     shared_ptr<Ice::ObjectPrx> obj,
-    function<void (const shared_ptr<Ice::ObjectPrx>&)> response,
-    function<void (exception_ptr)>,
+    function<void(const shared_ptr<Ice::ObjectPrx>&)> response,
+    function<void(exception_ptr)>,
     const Ice::Current&)
 {
     response(obj);
@@ -30,8 +30,8 @@ MyDerivedClassI::echoAsync(
 
 void
 MyDerivedClassI::shutdownAsync(
-    function<void ()> response,
-    function<void (exception_ptr)>,
+    function<void()> response,
+    function<void(exception_ptr)>,
     const Ice::Current& current)
 {
     current.adapter->getCommunicator()->shutdown();
@@ -40,8 +40,8 @@ MyDerivedClassI::shutdownAsync(
 
 void
 MyDerivedClassI::getContextAsync(
-    function<void (const Ice::Context&)> response,
-    function<void (exception_ptr)>,
+    function<void(const Ice::Context&)> response,
+    function<void(exception_ptr)>,
     const Ice::Current&)
 {
     response(_ctx);
diff --git a/cpp/test/Ice/proxy/TestAMDI.h b/cpp/test/Ice/proxy/TestAMDI.h
index 69f674c6be7..3f9d5aac1bf 100644
--- a/cpp/test/Ice/proxy/TestAMDI.h
+++ b/cpp/test/Ice/proxy/TestAMDI.h
@@ -26,18 +26,18 @@ public:
 #ifdef ICE_CPP11_MAPPING
     virtual void echoAsync(
         std::shared_ptr<Ice::ObjectPrx>,
-        ::std::function<void (const ::std::shared_ptr<Ice::ObjectPrx>&)>,
-        ::std::function<void (::std::exception_ptr)>,
+        ::std::function<void(const ::std::shared_ptr<Ice::ObjectPrx>&)>,
+        ::std::function<void(::std::exception_ptr)>,
         const Ice::Current&);
     
     virtual void shutdownAsync(
-        ::std::function<void ()>,
-        ::std::function<void (::std::exception_ptr)>,
+        ::std::function<void()>,
+        ::std::function<void(::std::exception_ptr)>,
         const Ice::Current&);
 
     virtual void getContextAsync(
-        ::std::function<void (const Ice::Context&)>,
-        ::std::function<void (::std::exception_ptr)>,
+        ::std::function<void(const Ice::Context&)>,
+        ::std::function<void(::std::exception_ptr)>,
         const Ice::Current&);
     
     virtual bool ice_isA(std::string, const Ice::Current&) const;
diff --git a/cpp/test/Ice/proxy/TestI.cpp b/cpp/test/Ice/proxy/TestI.cpp
index 302c3c774ef..bc4a2ff971f 100644
--- a/cpp/test/Ice/proxy/TestI.cpp
+++ b/cpp/test/Ice/proxy/TestI.cpp
@@ -57,4 +57,4 @@ MyDerivedClassI::ice_isA(const std::string& s, const Ice::Current& current) cons
     _ctx = current.ctx;
     return Test::MyDerivedClass::ice_isA(s, current);
 }
-#endif
\ No newline at end of file
+#endif
diff --git a/cpp/test/Ice/servantLocator/TestAMDI.cpp b/cpp/test/Ice/servantLocator/TestAMDI.cpp
index 5b674278c11..4db8d1a47ba 100644
--- a/cpp/test/Ice/servantLocator/TestAMDI.cpp
+++ b/cpp/test/Ice/servantLocator/TestAMDI.cpp
@@ -16,56 +16,56 @@ using namespace Ice;
 
 #ifdef ICE_CPP11_MAPPING
 void
-TestAMDI::requestFailedExceptionAsync(function<void ()> response, function<void (exception_ptr)>, const Current&)
+TestAMDI::requestFailedExceptionAsync(function<void()> response, function<void(exception_ptr)>, const Current&)
 {
     response();
 }
 
 void
-TestAMDI::unknownUserExceptionAsync(function<void ()> response, function<void (exception_ptr)>, const Current&)
+TestAMDI::unknownUserExceptionAsync(function<void()> response, function<void(exception_ptr)>, const Current&)
 {
     response();
 }
 
 void
-TestAMDI::unknownLocalExceptionAsync(function<void ()> response, function<void (exception_ptr)>, const Current&)
+TestAMDI::unknownLocalExceptionAsync(function<void()> response, function<void(exception_ptr)>, const Current&)
 {
     response();
 }
 
 void
-TestAMDI::unknownExceptionAsync(function<void ()> response, function<void (exception_ptr)>, const Current&)
+TestAMDI::unknownExceptionAsync(function<void()> response, function<void(exception_ptr)>, const Current&)
 {
     response();
 }
 
 void
-TestAMDI::userExceptionAsync(function<void ()> response, function<void (exception_ptr)>, const Current&)
+TestAMDI::userExceptionAsync(function<void()> response, function<void(exception_ptr)>, const Current&)
 {
     response();
 }
 
 void
-TestAMDI::localExceptionAsync(function<void ()> response, function<void (exception_ptr)>, const Current&)
+TestAMDI::localExceptionAsync(function<void()> response, function<void(exception_ptr)>, const Current&)
 {
     response();
 }
 
 void
-TestAMDI::stdExceptionAsync(function<void ()> response, function<void (exception_ptr)>, const Current&)
+TestAMDI::stdExceptionAsync(function<void()> response, function<void(exception_ptr)>, const Current&)
 {
     response();
 }
 
 void
-TestAMDI::cppExceptionAsync(function<void ()> response, function<void (exception_ptr)>, const Current&)
+TestAMDI::cppExceptionAsync(function<void()> response, function<void(exception_ptr)>, const Current&)
 {
     response();
 }
 
 void
-TestAMDI::unknownExceptionWithServantExceptionAsync(function<void ()>,
-                                                    function<void (exception_ptr)> error,
+TestAMDI::unknownExceptionWithServantExceptionAsync(function<void()>,
+                                                    function<void(exception_ptr)> error,
                                                     const Current&)
 {
     try
@@ -80,8 +80,8 @@ TestAMDI::unknownExceptionWithServantExceptionAsync(function<void ()>,
 
 void
 TestAMDI::impossibleExceptionAsync(bool _cpp_throw,
-                                   function<void (const string&)> response,
-                                   function<void (exception_ptr)> error,
+                                   function<void(const string&)> response,
+                                   function<void(exception_ptr)> error,
                                    const Current&)
 {
     if(_cpp_throw)
@@ -107,8 +107,8 @@ TestAMDI::impossibleExceptionAsync(bool _cpp_throw,
 
 void
 TestAMDI::intfUserExceptionAsync(bool _cpp_throw,
-                                 function<void (const string&)> response,
-                                 function<void (exception_ptr)> error,
+                                 function<void(const string&)> response,
+                                 function<void(exception_ptr)> error,
                                  const Current&)
 {
     if(_cpp_throw)
@@ -133,8 +133,8 @@ TestAMDI::intfUserExceptionAsync(bool _cpp_throw,
 }
 
 void
-TestAMDI::asyncResponseAsync(function<void ()> response,
-                             function<void (exception_ptr)>,
+TestAMDI::asyncResponseAsync(function<void()> response,
+                             function<void(exception_ptr)>,
                              const Current&)
 {
     response();
@@ -142,8 +142,8 @@ TestAMDI::asyncResponseAsync(function<void ()> response,
 }
 
 void
-TestAMDI::asyncExceptionAsync(function<void ()> response,
-                              function<void (exception_ptr)> error,
+TestAMDI::asyncExceptionAsync(function<void()> response,
+                              function<void(exception_ptr)> error,
                               const Current&)
 {
     try
@@ -158,8 +158,8 @@ TestAMDI::asyncExceptionAsync(function<void ()> response,
 }
 
 void
-TestAMDI::shutdownAsync(function<void ()> response,
-                        function<void (exception_ptr)> error,
+TestAMDI::shutdownAsync(function<void()> response,
+                        function<void(exception_ptr)> error,
                         const Current& current)
 {
     current.adapter->deactivate();
diff --git a/cpp/test/Ice/servantLocator/TestAMDI.h b/cpp/test/Ice/servantLocator/TestAMDI.h
index da5784195d2..a6b75a1af2e 100644
--- a/cpp/test/Ice/servantLocator/TestAMDI.h
+++ b/cpp/test/Ice/servantLocator/TestAMDI.h
@@ -18,75 +18,75 @@ public:
 
 #ifdef ICE_CPP11_MAPPING
     virtual void requestFailedExceptionAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const Ice::Current&);
     
     virtual void unknownUserExceptionAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const Ice::Current&);
 
     virtual void unknownLocalExceptionAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const Ice::Current&);
 
     virtual void unknownExceptionAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const Ice::Current&);
 
     virtual void userExceptionAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const Ice::Current&);
 
     virtual void localExceptionAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const Ice::Current&);
     
     virtual void stdExceptionAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const Ice::Current&);
 
     virtual void cppExceptionAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const Ice::Current&);
 
     virtual void unknownExceptionWithServantExceptionAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const Ice::Current&);
 
     virtual void impossibleExceptionAsync(
         bool,
-        std::function<void (const std::string&)>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void(const std::string&)>,
+        std::function<void(std::exception_ptr)>,
         const Ice::Current&);
 
     virtual void intfUserExceptionAsync(
         bool,
-        std::function<void (const std::string&)>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void(const std::string&)>,
+        std::function<void(std::exception_ptr)>,
         const Ice::Current&);
 
     virtual void asyncResponseAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const Ice::Current&);
 
     virtual void asyncExceptionAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const Ice::Current&);
 
     virtual void shutdownAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const Ice::Current&);
 #else
     virtual void requestFailedException_async(const Test::AMD_TestIntf_requestFailedExceptionPtr&, const Ice::Current&);
diff --git a/cpp/test/Ice/slicing/exceptions/TestAMDI.cpp b/cpp/test/Ice/slicing/exceptions/TestAMDI.cpp
index 4c88d61ecb8..16a50c8fd8c 100644
--- a/cpp/test/Ice/slicing/exceptions/TestAMDI.cpp
+++ b/cpp/test/Ice/slicing/exceptions/TestAMDI.cpp
@@ -20,7 +20,7 @@ TestI::TestI()
 
 #ifdef ICE_CPP11_MAPPING
 void
-TestI::baseAsBaseAsync(function<void ()>, function<void (exception_ptr)> error, const ::Ice::Current&)
+TestI::baseAsBaseAsync(function<void()>, function<void(exception_ptr)> error, const ::Ice::Current&)
 {
     try
     {
@@ -35,7 +35,7 @@ TestI::baseAsBaseAsync(function<void ()>, function<void (exception_ptr)> error,
 }
 
 void
-TestI::unknownDerivedAsBaseAsync(function<void ()>, function<void (exception_ptr)> error, const ::Ice::Current&)
+TestI::unknownDerivedAsBaseAsync(function<void()>, function<void(exception_ptr)> error, const ::Ice::Current&)
 {
     try
     {
@@ -51,7 +51,7 @@ TestI::unknownDerivedAsBaseAsync(function<void ()>, function<void (exception_ptr
 }
 
 void
-TestI::knownDerivedAsBaseAsync(function<void ()>, function<void (exception_ptr)> error, const ::Ice::Current&)
+TestI::knownDerivedAsBaseAsync(function<void()>, function<void(exception_ptr)> error, const ::Ice::Current&)
 {
     try
     {
@@ -67,7 +67,7 @@ TestI::knownDerivedAsBaseAsync(function<void ()>, function<void (exception_ptr)>
 }
 
 void
-TestI::knownDerivedAsKnownDerivedAsync(function<void ()>, function<void (exception_ptr)> error, const ::Ice::Current&)
+TestI::knownDerivedAsKnownDerivedAsync(function<void()>, function<void(exception_ptr)> error, const ::Ice::Current&)
 {
     try
     {
@@ -83,7 +83,7 @@ TestI::knownDerivedAsKnownDerivedAsync(function<void ()>, function<void (excepti
 }
 
 void
-TestI::unknownIntermediateAsBaseAsync(function<void ()>, function<void (exception_ptr)> error, const ::Ice::Current&)
+TestI::unknownIntermediateAsBaseAsync(function<void()>, function<void(exception_ptr)> error, const ::Ice::Current&)
 {
     try
     {
@@ -99,7 +99,7 @@ TestI::unknownIntermediateAsBaseAsync(function<void ()>, function<void (exceptio
 }
 
 void
-TestI::knownIntermediateAsBaseAsync(function<void ()>, function<void (exception_ptr)> error, const ::Ice::Current&)
+TestI::knownIntermediateAsBaseAsync(function<void()>, function<void(exception_ptr)> error, const ::Ice::Current&)
 {
     try
     {
@@ -115,7 +115,7 @@ TestI::knownIntermediateAsBaseAsync(function<void ()>, function<void (exception_
 }
 
 void
-TestI::knownMostDerivedAsBaseAsync(function<void ()>, function<void (exception_ptr)> error, const ::Ice::Current&)
+TestI::knownMostDerivedAsBaseAsync(function<void()>, function<void(exception_ptr)> error, const ::Ice::Current&)
 {
     try
     {
@@ -132,7 +132,7 @@ TestI::knownMostDerivedAsBaseAsync(function<void ()>, function<void (exception_p
 }
 
 void
-TestI::knownIntermediateAsKnownIntermediateAsync(function<void ()>, function<void (exception_ptr)> error,
+TestI::knownIntermediateAsKnownIntermediateAsync(function<void()>, function<void(exception_ptr)> error,
                                                  const ::Ice::Current&)
 {
     try
@@ -149,7 +149,7 @@ TestI::knownIntermediateAsKnownIntermediateAsync(function<void ()>, function<voi
 }
 
 void
-TestI::knownMostDerivedAsKnownIntermediateAsync(function<void ()>, function<void (exception_ptr)> error,
+TestI::knownMostDerivedAsKnownIntermediateAsync(function<void()>, function<void(exception_ptr)> error,
                                                 const ::Ice::Current&)
 {
     try
@@ -168,7 +168,7 @@ TestI::knownMostDerivedAsKnownIntermediateAsync(function<void ()>, function<void
 
 void
 TestI::
-knownMostDerivedAsKnownMostDerivedAsync(function<void ()>, function<void (exception_ptr)> error,
+knownMostDerivedAsKnownMostDerivedAsync(function<void()>, function<void(exception_ptr)> error,
                                         const ::Ice::Current&)
 {
     try
@@ -186,7 +186,7 @@ knownMostDerivedAsKnownMostDerivedAsync(function<void ()>, function<void (except
 }
 
 void
-TestI::unknownMostDerived1AsBaseAsync(function<void ()>, function<void (exception_ptr)> error, const ::Ice::Current&)
+TestI::unknownMostDerived1AsBaseAsync(function<void()>, function<void(exception_ptr)> error, const ::Ice::Current&)
 {
     try
     {
@@ -203,7 +203,7 @@ TestI::unknownMostDerived1AsBaseAsync(function<void ()>, function<void (exceptio
 }
 
 void
-TestI::unknownMostDerived1AsKnownIntermediateAsync(function<void ()>, function<void (exception_ptr)> error,
+TestI::unknownMostDerived1AsKnownIntermediateAsync(function<void()>, function<void(exception_ptr)> error,
                                                    const ::Ice::Current&)
 {
     try
@@ -221,7 +221,7 @@ TestI::unknownMostDerived1AsKnownIntermediateAsync(function<void ()>, function<v
 }
 
 void
-TestI::unknownMostDerived2AsBaseAsync(function<void ()>, function<void (exception_ptr)> error, const ::Ice::Current&)
+TestI::unknownMostDerived2AsBaseAsync(function<void()>, function<void(exception_ptr)> error, const ::Ice::Current&)
 {
     try
     {
@@ -238,7 +238,7 @@ TestI::unknownMostDerived2AsBaseAsync(function<void ()>, function<void (exceptio
 }
 
 void
-TestI::unknownMostDerived2AsBaseCompactAsync(function<void ()>, function<void (exception_ptr)> error,
+TestI::unknownMostDerived2AsBaseCompactAsync(function<void()>, function<void(exception_ptr)> error,
                                              const ::Ice::Current&)
 {
     try
@@ -256,7 +256,7 @@ TestI::unknownMostDerived2AsBaseCompactAsync(function<void ()>, function<void (e
 }
 
 void
-TestI::knownPreservedAsBaseAsync(function<void ()>, function<void (exception_ptr)> error, const ::Ice::Current&)
+TestI::knownPreservedAsBaseAsync(function<void()>, function<void(exception_ptr)> error, const ::Ice::Current&)
 {
     try
     {
@@ -273,7 +273,7 @@ TestI::knownPreservedAsBaseAsync(function<void ()>, function<void (exception_ptr
 }
 
 void
-TestI::knownPreservedAsKnownPreservedAsync(function<void ()>, function<void (exception_ptr)> error,
+TestI::knownPreservedAsKnownPreservedAsync(function<void()>, function<void(exception_ptr)> error,
                                            const ::Ice::Current&)
 {
     try
@@ -291,7 +291,7 @@ TestI::knownPreservedAsKnownPreservedAsync(function<void ()>, function<void (exc
 
 void
 TestI::relayKnownPreservedAsBaseAsync(shared_ptr<RelayPrx> r,
-                                      function<void ()>, function<void (exception_ptr)> error,
+                                      function<void()>, function<void(exception_ptr)> error,
                                       const ::Ice::Current&)
 {
     try
@@ -307,7 +307,7 @@ TestI::relayKnownPreservedAsBaseAsync(shared_ptr<RelayPrx> r,
 
 void
 TestI::relayKnownPreservedAsKnownPreservedAsync(shared_ptr<RelayPrx> r,
-                                                function<void ()>, function<void (exception_ptr)> error,
+                                                function<void()>, function<void(exception_ptr)> error,
                                                 const ::Ice::Current&)
 {
     try
@@ -322,7 +322,7 @@ TestI::relayKnownPreservedAsKnownPreservedAsync(shared_ptr<RelayPrx> r,
 }
 
 void
-TestI::unknownPreservedAsBaseAsync(function<void ()>, function<void (exception_ptr)> error, const ::Ice::Current&)
+TestI::unknownPreservedAsBaseAsync(function<void()>, function<void(exception_ptr)> error, const ::Ice::Current&)
 {
     try
     {
@@ -341,7 +341,7 @@ TestI::unknownPreservedAsBaseAsync(function<void ()>, function<void (exception_p
 }
 
 void
-TestI::unknownPreservedAsKnownPreservedAsync(function<void ()>, function<void (exception_ptr)> error,
+TestI::unknownPreservedAsKnownPreservedAsync(function<void()>, function<void(exception_ptr)> error,
                                              const ::Ice::Current&)
 {
     try
@@ -362,7 +362,7 @@ TestI::unknownPreservedAsKnownPreservedAsync(function<void ()>, function<void (e
 
 void
 TestI::relayUnknownPreservedAsBaseAsync(shared_ptr<RelayPrx> r,
-                                        function<void ()>, function<void (exception_ptr)> error,
+                                        function<void()>, function<void(exception_ptr)> error,
                                         const ::Ice::Current&)
 {
     try
@@ -378,7 +378,7 @@ TestI::relayUnknownPreservedAsBaseAsync(shared_ptr<RelayPrx> r,
 
 void
 TestI::relayUnknownPreservedAsKnownPreservedAsync(shared_ptr<RelayPrx> r,
-                                                  function<void ()>, function<void (exception_ptr)> error,
+                                                  function<void()>, function<void(exception_ptr)> error,
                                                   const ::Ice::Current&)
 {
     try
@@ -393,7 +393,7 @@ TestI::relayUnknownPreservedAsKnownPreservedAsync(shared_ptr<RelayPrx> r,
 }
 
 void
-TestI::shutdownAsync(function<void ()> response, function<void (exception_ptr)>, const ::Ice::Current& current)
+TestI::shutdownAsync(function<void()> response, function<void(exception_ptr)>, const ::Ice::Current& current)
 {
     current.adapter->getCommunicator()->shutdown();
     response();
diff --git a/cpp/test/Ice/slicing/exceptions/TestAMDI.h b/cpp/test/Ice/slicing/exceptions/TestAMDI.h
index b721e08aef3..64f05b40a65 100644
--- a/cpp/test/Ice/slicing/exceptions/TestAMDI.h
+++ b/cpp/test/Ice/slicing/exceptions/TestAMDI.h
@@ -19,122 +19,122 @@ public:
     TestI();
 #ifdef ICE_CPP11_MAPPING
     virtual void baseAsBaseAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const ::Ice::Current&);
 
     virtual void unknownDerivedAsBaseAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const ::Ice::Current&);
 
     virtual void knownDerivedAsBaseAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const ::Ice::Current&);
 
     virtual void knownDerivedAsKnownDerivedAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const ::Ice::Current&);
 
     virtual void unknownIntermediateAsBaseAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const ::Ice::Current&);
 
     virtual void knownIntermediateAsBaseAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const ::Ice::Current&);
 
     virtual void knownMostDerivedAsBaseAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const ::Ice::Current&);
 
     virtual void knownIntermediateAsKnownIntermediateAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const ::Ice::Current&);
 
     virtual void knownMostDerivedAsKnownIntermediateAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const ::Ice::Current&);
 
     virtual void knownMostDerivedAsKnownMostDerivedAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const ::Ice::Current&);
 
     virtual void unknownMostDerived1AsBaseAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const ::Ice::Current&);
 
     virtual void unknownMostDerived1AsKnownIntermediateAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const ::Ice::Current&);
 
     virtual void unknownMostDerived2AsBaseAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const ::Ice::Current&);
 
     virtual void unknownMostDerived2AsBaseCompactAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const ::Ice::Current&);
 
     virtual void knownPreservedAsBaseAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const ::Ice::Current&);
 
     virtual void knownPreservedAsKnownPreservedAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const ::Ice::Current&);
 
     virtual void relayKnownPreservedAsBaseAsync(
         std::shared_ptr<::Test::RelayPrx>,
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const ::Ice::Current&);
 
     virtual void relayKnownPreservedAsKnownPreservedAsync(
         std::shared_ptr<::Test::RelayPrx>,
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const ::Ice::Current&);
 
     virtual void unknownPreservedAsBaseAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const ::Ice::Current&);
 
     virtual void unknownPreservedAsKnownPreservedAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const ::Ice::Current&);
 
     virtual void relayUnknownPreservedAsBaseAsync(
         std::shared_ptr<::Test::RelayPrx>,
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const ::Ice::Current&);
 
     virtual void relayUnknownPreservedAsKnownPreservedAsync(
         std::shared_ptr<::Test::RelayPrx>,
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const ::Ice::Current&);
 
     virtual void shutdownAsync(
-        std::function<void ()>,
-        std::function<void (std::exception_ptr)>,
+        std::function<void()>,
+        std::function<void(std::exception_ptr)>,
         const ::Ice::Current&);
 #else
     virtual void baseAsBase_async(const ::Test::AMD_TestIntf_baseAsBasePtr&, const ::Ice::Current&);
diff --git a/cpp/test/Ice/slicing/objects/TestAMDI.cpp b/cpp/test/Ice/slicing/objects/TestAMDI.cpp
index d72d2121eda..ab4c26734e2 100644
--- a/cpp/test/Ice/slicing/objects/TestAMDI.cpp
+++ b/cpp/test/Ice/slicing/objects/TestAMDI.cpp
@@ -21,8 +21,8 @@ TestI::TestI()
 #ifdef ICE_CPP11_MAPPING
 
 void
-TestI::SBaseAsObjectAsync(function<void (const shared_ptr<Ice::Value>&)> response,
-                           function<void (exception_ptr)>,
+TestI::SBaseAsObjectAsync(function<void(const shared_ptr<Ice::Value>&)> response,
+                           function<void(exception_ptr)>,
                            const ::Ice::Current&)
 {
     auto sb = make_shared<SBase>();
@@ -31,8 +31,8 @@ TestI::SBaseAsObjectAsync(function<void (const shared_ptr<Ice::Value>&)> respons
 }
 
 void
-TestI::SBaseAsSBaseAsync(function<void (const shared_ptr<Test::SBase>&)> response,
-                          function<void (exception_ptr)>,
+TestI::SBaseAsSBaseAsync(function<void(const shared_ptr<Test::SBase>&)> response,
+                          function<void(exception_ptr)>,
                           const ::Ice::Current&)
 {
     auto sb = make_shared<SBase>();
@@ -41,8 +41,8 @@ TestI::SBaseAsSBaseAsync(function<void (const shared_ptr<Test::SBase>&)> respons
 }
 
 void
-TestI::SBSKnownDerivedAsSBaseAsync(function<void (const shared_ptr<Test::SBase>&)> response,
-                                    function<void (exception_ptr)>,
+TestI::SBSKnownDerivedAsSBaseAsync(function<void(const shared_ptr<Test::SBase>&)> response,
+                                    function<void(exception_ptr)>,
                                     const ::Ice::Current&)
 {
     auto sbskd = make_shared<SBSKnownDerived>();
@@ -52,8 +52,8 @@ TestI::SBSKnownDerivedAsSBaseAsync(function<void (const shared_ptr<Test::SBase>&
 }
 
 void
-TestI::SBSKnownDerivedAsSBSKnownDerivedAsync(function<void (const shared_ptr<Test::SBSKnownDerived>&)> response,
-                                              function<void (exception_ptr)>,
+TestI::SBSKnownDerivedAsSBSKnownDerivedAsync(function<void(const shared_ptr<Test::SBSKnownDerived>&)> response,
+                                              function<void(exception_ptr)>,
                                               const ::Ice::Current&)
 {
     auto sbskd = make_shared<SBSKnownDerived>();
@@ -64,8 +64,8 @@ TestI::SBSKnownDerivedAsSBSKnownDerivedAsync(function<void (const shared_ptr<Tes
 
 
 void
-TestI::SBSUnknownDerivedAsSBaseAsync(function<void (const shared_ptr<Test::SBase>&)> response,
-                                      function<void (exception_ptr)>,
+TestI::SBSUnknownDerivedAsSBaseAsync(function<void(const shared_ptr<Test::SBase>&)> response,
+                                      function<void(exception_ptr)>,
                                       const ::Ice::Current&)
 {
     auto sbsud = make_shared<SBSUnknownDerived>();
@@ -75,8 +75,8 @@ TestI::SBSUnknownDerivedAsSBaseAsync(function<void (const shared_ptr<Test::SBase
 }
 
 void
-TestI::SBSUnknownDerivedAsSBaseCompactAsync(function<void (const shared_ptr<Test::SBase>&)> response,
-                                             function<void (exception_ptr)>,
+TestI::SBSUnknownDerivedAsSBaseCompactAsync(function<void(const shared_ptr<Test::SBase>&)> response,
+                                             function<void(exception_ptr)>,
                                              const ::Ice::Current&)
 {
     auto sbsud = make_shared<SBSUnknownDerived>();
@@ -87,8 +87,8 @@ TestI::SBSUnknownDerivedAsSBaseCompactAsync(function<void (const shared_ptr<Test
 
 
 void
-TestI::SUnknownAsObjectAsync(function<void (const shared_ptr<Ice::Value>&)> response,
-                              function<void (exception_ptr)>,
+TestI::SUnknownAsObjectAsync(function<void(const shared_ptr<Ice::Value>&)> response,
+                              function<void(exception_ptr)>,
                               const ::Ice::Current&)
 {
     auto su = make_shared<SUnknown>();
@@ -98,8 +98,8 @@ TestI::SUnknownAsObjectAsync(function<void (const shared_ptr<Ice::Value>&)> resp
 
 void
 TestI::checkSUnknownAsync(Ice::ValuePtr obj,
-                           function<void ()> response,
-                           function<void (exception_ptr)>,
+                           function<void()> response,
+                           function<void(exception_ptr)>,
                            const ::Ice::Current& current)
 {
     auto su = dynamic_pointer_cast<SUnknown>(obj);
@@ -117,8 +117,8 @@ TestI::checkSUnknownAsync(Ice::ValuePtr obj,
 
 
 void
-TestI::oneElementCycleAsync(function<void (const shared_ptr<Test::B>&)> response,
-                             function<void (exception_ptr)>,
+TestI::oneElementCycleAsync(function<void(const shared_ptr<Test::B>&)> response,
+                             function<void(exception_ptr)>,
                              const ::Ice::Current&)
 {
     auto b = make_shared<B>();
@@ -128,8 +128,8 @@ TestI::oneElementCycleAsync(function<void (const shared_ptr<Test::B>&)> response
 }
 
 void
-TestI::twoElementCycleAsync(function<void (const shared_ptr<Test::B>&)> response,
-                             function<void (exception_ptr)>,
+TestI::twoElementCycleAsync(function<void(const shared_ptr<Test::B>&)> response,
+                             function<void(exception_ptr)>,
                              const ::Ice::Current&)
 {
     auto b1 = make_shared<B>();
@@ -142,8 +142,8 @@ TestI::twoElementCycleAsync(function<void (const shared_ptr<Test::B>&)> response
 }
 
 void
-TestI::D1AsBAsync(function<void (const shared_ptr<Test::B>&)> response,
-                   function<void (exception_ptr)>,
+TestI::D1AsBAsync(function<void(const shared_ptr<Test::B>&)> response,
+                   function<void(exception_ptr)>,
                    const ::Ice::Current&)
 {
     auto d1 = make_shared<D1>();
@@ -161,8 +161,8 @@ TestI::D1AsBAsync(function<void (const shared_ptr<Test::B>&)> response,
 
 
 void
-TestI::D1AsD1Async(function<void (const shared_ptr<Test::D1>&)> response,
-                    function<void (exception_ptr)>,
+TestI::D1AsD1Async(function<void(const shared_ptr<Test::D1>&)> response,
+                    function<void(exception_ptr)>,
                     const ::Ice::Current&)
 {
     auto d1 = make_shared<D1>();
@@ -179,8 +179,8 @@ TestI::D1AsD1Async(function<void (const shared_ptr<Test::D1>&)> response,
 }
 
 void
-TestI::D2AsBAsync(function<void (const shared_ptr<Test::B>&)> response,
-                   function<void (exception_ptr)>,
+TestI::D2AsBAsync(function<void(const shared_ptr<Test::B>&)> response,
+                   function<void(exception_ptr)>,
                    const ::Ice::Current&)
 {
     auto d2 = make_shared<D2>();
@@ -197,9 +197,9 @@ TestI::D2AsBAsync(function<void (const shared_ptr<Test::B>&)> response,
 }
 
 void
-TestI::paramTest1Async(function<void (const shared_ptr<Test::B>&,
+TestI::paramTest1Async(function<void(const shared_ptr<Test::B>&,
                                        const shared_ptr<Test::B>&)> response,
-                        function<void (exception_ptr)>,
+                        function<void(exception_ptr)>,
                         const ::Ice::Current&)
 {
     auto d1 = make_shared<D1>();
@@ -216,8 +216,8 @@ TestI::paramTest1Async(function<void (const shared_ptr<Test::B>&,
 }
 
 void
-TestI::paramTest2Async(function<void (const shared_ptr<Test::B>&, const shared_ptr<Test::B>&)> response,
-                        function<void (exception_ptr)>,
+TestI::paramTest2Async(function<void(const shared_ptr<Test::B>&, const shared_ptr<Test::B>&)> response,
+                        function<void(exception_ptr)>,
                         const ::Ice::Current&)
 {
     auto d1 = make_shared<D1>();
@@ -234,10 +234,10 @@ TestI::paramTest2Async(function<void (const shared_ptr<Test::B>&, const shared_p
 }
 
 void
-TestI::paramTest3Async(function<void (const shared_ptr<Test::B>&,
+TestI::paramTest3Async(function<void(const shared_ptr<Test::B>&,
                                        const shared_ptr<Test::B>&,
                                        const shared_ptr<Test::B>&)> response,
-                        function<void (exception_ptr)>,
+                        function<void(exception_ptr)>,
                         const ::Ice::Current&)
 {
     auto d2 = make_shared<D2>();
@@ -268,9 +268,9 @@ TestI::paramTest3Async(function<void (const shared_ptr<Test::B>&,
 }
 
 void
-TestI::paramTest4Async(function<void (const shared_ptr<Test::B>&,
+TestI::paramTest4Async(function<void(const shared_ptr<Test::B>&,
                                        const shared_ptr<Test::B>&)> response,
-                        function<void (exception_ptr)>,
+                        function<void(exception_ptr)>,
                         const ::Ice::Current&)
 {
     auto d4 = make_shared<D4>();
@@ -284,10 +284,10 @@ TestI::paramTest4Async(function<void (const shared_ptr<Test::B>&,
 }
 
 void
-TestI::returnTest1Async(function<void (const shared_ptr<Test::B>&,
+TestI::returnTest1Async(function<void(const shared_ptr<Test::B>&,
                                         const shared_ptr<Test::B>&,
                                         const shared_ptr<Test::B>&)> response,
-                         function<void (exception_ptr)>,
+                         function<void(exception_ptr)>,
                          const ::Ice::Current&)
 {
     auto d1 = make_shared<D1>();
@@ -305,10 +305,10 @@ TestI::returnTest1Async(function<void (const shared_ptr<Test::B>&,
 
 
 void
-TestI::returnTest2Async(function<void (const shared_ptr<Test::B>&,
+TestI::returnTest2Async(function<void(const shared_ptr<Test::B>&,
                                         const shared_ptr<Test::B>&,
                                         const shared_ptr<Test::B>&)> response,
-                         function<void (exception_ptr)>,
+                         function<void(exception_ptr)>,
                          const ::Ice::Current&)
 {
     auto d1 = make_shared<D1>();
@@ -327,8 +327,8 @@ TestI::returnTest2Async(function<void (const shared_ptr<Test::B>&,
 void
 TestI::returnTest3Async(shared_ptr<::Test::B> p1,
                          shared_ptr<::Test::B>,
-                         function<void (const shared_ptr<Test::B>&)> response,
-                         function<void (exception_ptr)>,
+                         function<void(const shared_ptr<Test::B>&)> response,
+                         function<void(exception_ptr)>,
                          const ::Ice::Current&)
 {
     response(p1);
@@ -338,8 +338,8 @@ TestI::returnTest3Async(shared_ptr<::Test::B> p1,
 void
 TestI::sequenceTestAsync(shared_ptr<::Test::SS1> p1,
                           shared_ptr<::Test::SS2> p2,
-                          function<void (const ::Test::SS3&)> response,
-                          function<void (exception_ptr)>,
+                          function<void(const ::Test::SS3&)> response,
+                          function<void(exception_ptr)>,
                           const ::Ice::Current&)
 {
     SS3 ss;
@@ -351,8 +351,8 @@ TestI::sequenceTestAsync(shared_ptr<::Test::SS1> p1,
 
 void
 TestI::dictionaryTestAsync(Test::BDict bin,
-                            function<void (const ::Test::BDict&, const ::Test::BDict&)> response,
-                            function<void (exception_ptr)>,
+                            function<void(const ::Test::BDict&, const ::Test::BDict&)> response,
+                            function<void(exception_ptr)>,
                             const ::Ice::Current&)
 {
     BDict bout;
@@ -384,8 +384,8 @@ TestI::dictionaryTestAsync(Test::BDict bin,
 
 void
 TestI::exchangePBaseAsync(shared_ptr<::Test::PBase> pb,
-                           function<void (const shared_ptr<::Test::PBase>&)> response,
-                           function<void (exception_ptr)>,
+                           function<void(const shared_ptr<::Test::PBase>&)> response,
+                           function<void(exception_ptr)>,
                            const ::Ice::Current&)
 {
     response(pb);
@@ -393,8 +393,8 @@ TestI::exchangePBaseAsync(shared_ptr<::Test::PBase> pb,
 
 
 void
-TestI::PBSUnknownAsPreservedAsync(function<void (const shared_ptr<::Test::Preserved>&)> response,
-                                   function<void (exception_ptr)>,
+TestI::PBSUnknownAsPreservedAsync(function<void(const shared_ptr<::Test::Preserved>&)> response,
+                                   function<void(exception_ptr)>,
                                    const ::Ice::Current& current)
 {
     auto r = make_shared<PSUnknown>();
@@ -415,8 +415,8 @@ TestI::PBSUnknownAsPreservedAsync(function<void (const shared_ptr<::Test::Preser
 
 void
 TestI::checkPBSUnknownAsync(shared_ptr<::Test::Preserved> p,
-                             function<void ()> response,
-                             function<void (exception_ptr)>,
+                             function<void()> response,
+                             function<void(exception_ptr)>,
                              const ::Ice::Current& current)
 {
     auto pu = dynamic_pointer_cast<PSUnknown>(p);
@@ -439,8 +439,8 @@ TestI::checkPBSUnknownAsync(shared_ptr<::Test::Preserved> p,
 }
 
 void
-TestI::PBSUnknownAsPreservedWithGraphAsync(function<void (const shared_ptr<::Test::Preserved>&)> response,
-                                            function<void (exception_ptr)>,
+TestI::PBSUnknownAsPreservedWithGraphAsync(function<void(const shared_ptr<::Test::Preserved>&)> response,
+                                            function<void(exception_ptr)>,
                                             const ::Ice::Current&)
 {
     auto r = make_shared<PSUnknown>();
@@ -458,8 +458,8 @@ TestI::PBSUnknownAsPreservedWithGraphAsync(function<void (const shared_ptr<::Tes
 
 void
 TestI::checkPBSUnknownWithGraphAsync(shared_ptr<::Test::Preserved> p,
-                                      function<void ()> response,
-                                      function<void (exception_ptr)>,
+                                      function<void()> response,
+                                      function<void(exception_ptr)>,
                                       const ::Ice::Current& current)
 {
     auto pu = dynamic_pointer_cast<PSUnknown>(p);
@@ -484,8 +484,8 @@ TestI::checkPBSUnknownWithGraphAsync(shared_ptr<::Test::Preserved> p,
 }
 
 void
-TestI::PBSUnknown2AsPreservedWithGraphAsync(function<void (const shared_ptr<::Test::Preserved>&)> response,
-                                             function<void (exception_ptr)>,
+TestI::PBSUnknown2AsPreservedWithGraphAsync(function<void(const shared_ptr<::Test::Preserved>&)> response,
+                                             function<void(exception_ptr)>,
                                              const ::Ice::Current&)
 {
     auto r = make_shared<PSUnknown2>();
@@ -498,8 +498,8 @@ TestI::PBSUnknown2AsPreservedWithGraphAsync(function<void (const shared_ptr<::Te
 
 void
 TestI::checkPBSUnknown2WithGraphAsync(shared_ptr<::Test::Preserved> p,
-                                       function<void ()> response,
-                                       function<void (exception_ptr)>,
+                                       function<void()> response,
+                                       function<void(exception_ptr)>,
                                        const ::Ice::Current& current)
 {
     auto pu = dynamic_pointer_cast<PSUnknown2>(p);
@@ -522,16 +522,16 @@ TestI::checkPBSUnknown2WithGraphAsync(shared_ptr<::Test::Preserved> p,
 
 void
 TestI::exchangePNodeAsync(shared_ptr<::Test::PNode> pn,
-                           function<void (const shared_ptr<::Test::PNode>&)> response,
-                           function<void (exception_ptr)>,
+                           function<void(const shared_ptr<::Test::PNode>&)> response,
+                           function<void(exception_ptr)>,
                            const ::Ice::Current&)
 {
     response(pn);
 }
 
 void
-TestI::throwBaseAsBaseAsync(function<void ()>,
-                             function<void (exception_ptr)> exception,
+TestI::throwBaseAsBaseAsync(function<void()>,
+                             function<void(exception_ptr)> exception,
                              const ::Ice::Current&)
 {
     try
@@ -550,8 +550,8 @@ TestI::throwBaseAsBaseAsync(function<void ()>,
 }
 
 void
-TestI::throwDerivedAsBaseAsync(function<void ()>,
-                                function<void (exception_ptr)> exception,
+TestI::throwDerivedAsBaseAsync(function<void()>,
+                                function<void(exception_ptr)> exception,
                                 const ::Ice::Current&)
 {
     try
@@ -576,8 +576,8 @@ TestI::throwDerivedAsBaseAsync(function<void ()>,
 }
 
 void
-TestI::throwDerivedAsDerivedAsync(function<void ()>,
-                                   function<void (exception_ptr)> exception,
+TestI::throwDerivedAsDerivedAsync(function<void()>,
+                                   function<void(exception_ptr)> exception,
                                    const ::Ice::Current&)
 {
     try
@@ -602,8 +602,8 @@ TestI::throwDerivedAsDerivedAsync(function<void ()>,
 }
 
 void
-TestI::throwUnknownDerivedAsBaseAsync(function<void ()>,
-                                       function<void (exception_ptr)> exception,
+TestI::throwUnknownDerivedAsBaseAsync(function<void()>,
+                                       function<void(exception_ptr)> exception,
                                        const ::Ice::Current&)
 {
     try
@@ -628,8 +628,8 @@ TestI::throwUnknownDerivedAsBaseAsync(function<void ()>,
 }
 
 void
-TestI::throwPreservedExceptionAsync(function<void ()>,
-                                     function<void (exception_ptr)> exception,
+TestI::throwPreservedExceptionAsync(function<void()>,
+                                     function<void(exception_ptr)> exception,
                                      const ::Ice::Current&)
 {
     try
@@ -649,8 +649,8 @@ TestI::throwPreservedExceptionAsync(function<void ()>,
 }
 
 void
-TestI::useForwardAsync(function<void (const shared_ptr<::Test::Forward>&)> response,
-                        function<void (exception_ptr)>,
+TestI::useForwardAsync(function<void(const shared_ptr<::Test::Forward>&)> response,
+                        function<void(exception_ptr)>,
                         const ::Ice::Current&)
 {
     auto f = make_shared<Forward>();
@@ -660,8 +660,8 @@ TestI::useForwardAsync(function<void (const shared_ptr<::Test::Forward>&)> respo
 }
 
 void
-TestI::shutdownAsync(function<void ()> response,
-                      function<void (exception_ptr)>,
+TestI::shutdownAsync(function<void()> response,
+                      function<void(exception_ptr)>,
                       const ::Ice::Current& current)
 {
     current.adapter->getCommunicator()->shutdown();
diff --git a/cpp/test/Ice/slicing/objects/TestAMDI.h b/cpp/test/Ice/slicing/objects/TestAMDI.h
index 06ac8e8cf43..fc8505fb36e 100644
--- a/cpp/test/Ice/slicing/objects/TestAMDI.h
+++ b/cpp/test/Ice/slicing/objects/TestAMDI.h
@@ -18,172 +18,172 @@ public:
 
     TestI();
 #ifdef ICE_CPP11_MAPPING
-    virtual void SBaseAsObjectAsync(std::function<void (const std::shared_ptr<Ice::Value>&)>,
-                                    std::function<void (std::exception_ptr)>,
+    virtual void SBaseAsObjectAsync(std::function<void(const std::shared_ptr<Ice::Value>&)>,
+                                    std::function<void(std::exception_ptr)>,
                                     const ::Ice::Current&);
 
-    virtual void SBaseAsSBaseAsync(std::function<void (const std::shared_ptr<Test::SBase>&)>,
-                                   std::function<void (std::exception_ptr)>,
+    virtual void SBaseAsSBaseAsync(std::function<void(const std::shared_ptr<Test::SBase>&)>,
+                                   std::function<void(std::exception_ptr)>,
                                    const ::Ice::Current&);
 
-    virtual void SBSKnownDerivedAsSBaseAsync(std::function<void (const std::shared_ptr<Test::SBase>&)>,
-                                             std::function<void (std::exception_ptr)>,
+    virtual void SBSKnownDerivedAsSBaseAsync(std::function<void(const std::shared_ptr<Test::SBase>&)>,
+                                             std::function<void(std::exception_ptr)>,
                                              const ::Ice::Current&);
 
-    virtual void SBSKnownDerivedAsSBSKnownDerivedAsync(std::function<void (const std::shared_ptr<Test::SBSKnownDerived>&)>,
-                                                       std::function<void (std::exception_ptr)>,
+    virtual void SBSKnownDerivedAsSBSKnownDerivedAsync(std::function<void(const std::shared_ptr<Test::SBSKnownDerived>&)>,
+                                                       std::function<void(std::exception_ptr)>,
                                                        const ::Ice::Current&);
 
-    virtual void SBSUnknownDerivedAsSBaseAsync(std::function<void (const std::shared_ptr<Test::SBase>&)>,
-                                               std::function<void (std::exception_ptr)>,
+    virtual void SBSUnknownDerivedAsSBaseAsync(std::function<void(const std::shared_ptr<Test::SBase>&)>,
+                                               std::function<void(std::exception_ptr)>,
                                                const ::Ice::Current&);
 
-    virtual void SBSUnknownDerivedAsSBaseCompactAsync(std::function<void (const std::shared_ptr<Test::SBase>&)>,
-                                                      std::function<void (std::exception_ptr)>,
+    virtual void SBSUnknownDerivedAsSBaseCompactAsync(std::function<void(const std::shared_ptr<Test::SBase>&)>,
+                                                      std::function<void(std::exception_ptr)>,
                                                       const ::Ice::Current&);
 
-    virtual void SUnknownAsObjectAsync(std::function<void (const std::shared_ptr<Ice::Value>&)>,
-                                       std::function<void (std::exception_ptr)>,
+    virtual void SUnknownAsObjectAsync(std::function<void(const std::shared_ptr<Ice::Value>&)>,
+                                       std::function<void(std::exception_ptr)>,
                                        const ::Ice::Current&);
 
     virtual void checkSUnknownAsync(std::shared_ptr<Ice::Value>,
-                                    std::function<void ()>,
-                                    std::function<void (std::exception_ptr)>,
+                                    std::function<void()>,
+                                    std::function<void(std::exception_ptr)>,
                                     const ::Ice::Current&);
 
-    virtual void oneElementCycleAsync(std::function<void (const std::shared_ptr<Test::B>&)>,
-                                      std::function<void (std::exception_ptr)>,
+    virtual void oneElementCycleAsync(std::function<void(const std::shared_ptr<Test::B>&)>,
+                                      std::function<void(std::exception_ptr)>,
                                       const ::Ice::Current&);
 
-    virtual void twoElementCycleAsync(std::function<void (const std::shared_ptr<Test::B>&)>,
-                                      std::function<void (std::exception_ptr)>,
+    virtual void twoElementCycleAsync(std::function<void(const std::shared_ptr<Test::B>&)>,
+                                      std::function<void(std::exception_ptr)>,
                                       const ::Ice::Current&);
 
-    virtual void D1AsBAsync(std::function<void (const std::shared_ptr<Test::B>&)>,
-                            std::function<void (std::exception_ptr)>,
+    virtual void D1AsBAsync(std::function<void(const std::shared_ptr<Test::B>&)>,
+                            std::function<void(std::exception_ptr)>,
                             const ::Ice::Current&);
 
-    virtual void D1AsD1Async(std::function<void (const std::shared_ptr<Test::D1>&)>,
-                             std::function<void (std::exception_ptr)>,
+    virtual void D1AsD1Async(std::function<void(const std::shared_ptr<Test::D1>&)>,
+                             std::function<void(std::exception_ptr)>,
                              const ::Ice::Current&);
 
-    virtual void D2AsBAsync(std::function<void (const std::shared_ptr<Test::B>&)>,
-                            std::function<void (std::exception_ptr)>,
+    virtual void D2AsBAsync(std::function<void(const std::shared_ptr<Test::B>&)>,
+                            std::function<void(std::exception_ptr)>,
                             const ::Ice::Current&);
 
-    virtual void paramTest1Async(std::function<void (const std::shared_ptr<Test::B>&,
+    virtual void paramTest1Async(std::function<void(const std::shared_ptr<Test::B>&,
                                                      const std::shared_ptr<Test::B>&)>,
-                                 std::function<void (std::exception_ptr)>,
+                                 std::function<void(std::exception_ptr)>,
                                  const ::Ice::Current&);
 
-    virtual void paramTest2Async(std::function<void (const std::shared_ptr<Test::B>&,
+    virtual void paramTest2Async(std::function<void(const std::shared_ptr<Test::B>&,
                                                      const std::shared_ptr<Test::B>&)>,
-                                 std::function<void (std::exception_ptr)>,
+                                 std::function<void(std::exception_ptr)>,
                                  const ::Ice::Current&);
 
-    virtual void paramTest3Async(std::function<void (const std::shared_ptr<Test::B>&,
+    virtual void paramTest3Async(std::function<void(const std::shared_ptr<Test::B>&,
                                                      const std::shared_ptr<Test::B>&,
                                                      const std::shared_ptr<Test::B>&)>,
-                                 std::function<void (std::exception_ptr)>,
+                                 std::function<void(std::exception_ptr)>,
                                  const ::Ice::Current&);
 
-    virtual void paramTest4Async(std::function<void (const std::shared_ptr<Test::B>&,
+    virtual void paramTest4Async(std::function<void(const std::shared_ptr<Test::B>&,
                                                      const std::shared_ptr<Test::B>&)>,
-                                 std::function<void (std::exception_ptr)>,
+                                 std::function<void(std::exception_ptr)>,
                                  const ::Ice::Current&);
 
-    virtual void returnTest1Async(std::function<void (const std::shared_ptr<Test::B>&,
+    virtual void returnTest1Async(std::function<void(const std::shared_ptr<Test::B>&,
                                                       const std::shared_ptr<Test::B>&,
                                                       const std::shared_ptr<Test::B>&)>,
-                                  std::function<void (std::exception_ptr)>,
+                                  std::function<void(std::exception_ptr)>,
                                   const ::Ice::Current&);
 
-    virtual void returnTest2Async(std::function<void (const std::shared_ptr<Test::B>&,
+    virtual void returnTest2Async(std::function<void(const std::shared_ptr<Test::B>&,
                                                       const std::shared_ptr<Test::B>&,
                                                       const std::shared_ptr<Test::B>&)>,
-                                  std::function<void (std::exception_ptr)>,
+                                  std::function<void(std::exception_ptr)>,
                                   const ::Ice::Current&);
 
     virtual void returnTest3Async(std::shared_ptr<::Test::B>,
                                   std::shared_ptr<::Test::B>,
-                                  std::function<void (const std::shared_ptr<Test::B>&)>,
-                                  std::function<void (std::exception_ptr)>,
+                                  std::function<void(const std::shared_ptr<Test::B>&)>,
+                                  std::function<void(std::exception_ptr)>,
                                   const ::Ice::Current&);
 
     virtual void sequenceTestAsync(std::shared_ptr<::Test::SS1>,
                                    std::shared_ptr<::Test::SS2>,
-                                   std::function<void (const ::Test::SS3&)>,
-                                   std::function<void (std::exception_ptr)>,
+                                   std::function<void(const ::Test::SS3&)>,
+                                   std::function<void(std::exception_ptr)>,
                                    const ::Ice::Current&);
 
     virtual void dictionaryTestAsync(Test::BDict,
-                                     std::function<void (const ::Test::BDict&, const ::Test::BDict&)>,
-                                     std::function<void (std::exception_ptr)>,
+                                     std::function<void(const ::Test::BDict&, const ::Test::BDict&)>,
+                                     std::function<void(std::exception_ptr)>,
                                      const ::Ice::Current&);
 
     virtual void exchangePBaseAsync(std::shared_ptr<::Test::PBase>,
-                                    std::function<void (const std::shared_ptr<::Test::PBase>&)>,
-                                    std::function<void (std::exception_ptr)>,
+                                    std::function<void(const std::shared_ptr<::Test::PBase>&)>,
+                                    std::function<void(std::exception_ptr)>,
                                     const ::Ice::Current&);
 
-    virtual void PBSUnknownAsPreservedAsync(std::function<void (const std::shared_ptr<::Test::Preserved>&)>,
-                                            std::function<void (std::exception_ptr)>,
+    virtual void PBSUnknownAsPreservedAsync(std::function<void(const std::shared_ptr<::Test::Preserved>&)>,
+                                            std::function<void(std::exception_ptr)>,
                                             const ::Ice::Current&);
 
     virtual void checkPBSUnknownAsync(std::shared_ptr<::Test::Preserved>,
-                                      std::function<void ()>,
-                                      std::function<void (std::exception_ptr)>,
+                                      std::function<void()>,
+                                      std::function<void(std::exception_ptr)>,
                                       const ::Ice::Current&);
 
-    virtual void PBSUnknownAsPreservedWithGraphAsync(std::function<void (const std::shared_ptr<::Test::Preserved>&)>,
-                                                     std::function<void (std::exception_ptr)>,
+    virtual void PBSUnknownAsPreservedWithGraphAsync(std::function<void(const std::shared_ptr<::Test::Preserved>&)>,
+                                                     std::function<void(std::exception_ptr)>,
                                                      const ::Ice::Current&);
 
     virtual void checkPBSUnknownWithGraphAsync(std::shared_ptr<::Test::Preserved>,
-                                               std::function<void ()>,
-                                               std::function<void (std::exception_ptr)>,
+                                               std::function<void()>,
+                                               std::function<void(std::exception_ptr)>,
                                                const ::Ice::Current&);
 
-    virtual void PBSUnknown2AsPreservedWithGraphAsync(std::function<void (const std::shared_ptr<::Test::Preserved>&)>,
-                                                      std::function<void (std::exception_ptr)>,
+    virtual void PBSUnknown2AsPreservedWithGraphAsync(std::function<void(const std::shared_ptr<::Test::Preserved>&)>,
+                                                      std::function<void(std::exception_ptr)>,
                                                       const ::Ice::Current&);
 
     virtual void checkPBSUnknown2WithGraphAsync(std::shared_ptr<::Test::Preserved>,
-                                                std::function<void ()>,
-                                                std::function<void (std::exception_ptr)>,
+                                                std::function<void()>,
+                                                std::function<void(std::exception_ptr)>,
                                                 const ::Ice::Current&);
 
     virtual void exchangePNodeAsync(std::shared_ptr<::Test::PNode>,
-                                    std::function<void (const std::shared_ptr<::Test::PNode>&)>,
-                                    std::function<void (std::exception_ptr)>,
+                                    std::function<void(const std::shared_ptr<::Test::PNode>&)>,
+                                    std::function<void(std::exception_ptr)>,
                                     const ::Ice::Current&);
 
-    virtual void throwBaseAsBaseAsync(std::function<void ()>,
-                                      std::function<void (std::exception_ptr)>,
+    virtual void throwBaseAsBaseAsync(std::function<void()>,
+                                      std::function<void(std::exception_ptr)>,
                                       const ::Ice::Current&);
 
-    virtual void throwDerivedAsBaseAsync(std::function<void ()>,
-                                         std::function<void (std::exception_ptr)>,
+    virtual void throwDerivedAsBaseAsync(std::function<void()>,
+                                         std::function<void(std::exception_ptr)>,
                                          const ::Ice::Current&);
 
-    virtual void throwDerivedAsDerivedAsync(std::function<void ()>,
-                                            std::function<void (std::exception_ptr)>,
+    virtual void throwDerivedAsDerivedAsync(std::function<void()>,
+                                            std::function<void(std::exception_ptr)>,
                                             const ::Ice::Current&);
 
-    virtual void throwUnknownDerivedAsBaseAsync(std::function<void ()>,
-                                                std::function<void (std::exception_ptr)>,
+    virtual void throwUnknownDerivedAsBaseAsync(std::function<void()>,
+                                                std::function<void(std::exception_ptr)>,
                                                 const ::Ice::Current&);
 
-    virtual void throwPreservedExceptionAsync(std::function<void ()>,
-                                              std::function<void (std::exception_ptr)>,
+    virtual void throwPreservedExceptionAsync(std::function<void()>,
+                                              std::function<void(std::exception_ptr)>,
                                               const ::Ice::Current&);
 
-    virtual void useForwardAsync(std::function<void (const std::shared_ptr<::Test::Forward>&)>,
-                                 std::function<void (std::exception_ptr)>,
+    virtual void useForwardAsync(std::function<void(const std::shared_ptr<::Test::Forward>&)>,
+                                 std::function<void(std::exception_ptr)>,
                                  const ::Ice::Current&);
 
-    virtual void shutdownAsync(std::function<void ()>,
-                               std::function<void (std::exception_ptr)>,
+    virtual void shutdownAsync(std::function<void()>,
+                               std::function<void(std::exception_ptr)>,
                                const ::Ice::Current&);
 #else
     virtual void SBaseAsObject_async(const ::Test::AMD_TestIntf_SBaseAsObjectPtr&, const ::Ice::Current&);
diff --git a/cpp/test/Ice/slicing/objects/TestI.cpp b/cpp/test/Ice/slicing/objects/TestI.cpp
index a68c64c764d..d3a654139c6 100644
--- a/cpp/test/Ice/slicing/objects/TestI.cpp
+++ b/cpp/test/Ice/slicing/objects/TestI.cpp
@@ -364,8 +364,8 @@ TestI::checkPBSUnknown(ICE_IN(Test::PreservedPtr) p, const Ice::Current& current
 
 #ifdef ICE_CPP11_MAPPING
 void
-TestI::PBSUnknownAsPreservedWithGraphAsync(function<void (const shared_ptr<Test::Preserved>&)> response,
-                                            function<void (exception_ptr)>,
+TestI::PBSUnknownAsPreservedWithGraphAsync(function<void(const shared_ptr<Test::Preserved>&)> response,
+                                            function<void(exception_ptr)>,
                                             const Ice::Current&)
 #else
 void
@@ -414,8 +414,8 @@ TestI::checkPBSUnknownWithGraph(ICE_IN(Test::PreservedPtr) p, const Ice::Current
 
 #ifdef ICE_CPP11_MAPPING
 void
-TestI::PBSUnknown2AsPreservedWithGraphAsync(function<void (const shared_ptr<Test::Preserved>&)> response,
-                                             function<void (exception_ptr)>,
+TestI::PBSUnknown2AsPreservedWithGraphAsync(function<void(const shared_ptr<Test::Preserved>&)> response,
+                                             function<void(exception_ptr)>,
                                              const Ice::Current&)
 #else
 void
@@ -538,8 +538,8 @@ TestI::throwUnknownDerivedAsBase(const ::Ice::Current&)
 
 #ifdef ICE_CPP11_MAPPING
 void
-TestI::throwPreservedExceptionAsync(function<void ()>,
-                                     function<void (exception_ptr)> exception,
+TestI::throwPreservedExceptionAsync(function<void()>,
+                                     function<void(exception_ptr)> exception,
                                      const ::Ice::Current&)
 #else
 void
diff --git a/cpp/test/Ice/slicing/objects/TestI.h b/cpp/test/Ice/slicing/objects/TestI.h
index 827d8d628ca..5d6eb96daac 100644
--- a/cpp/test/Ice/slicing/objects/TestI.h
+++ b/cpp/test/Ice/slicing/objects/TestI.h
@@ -57,8 +57,8 @@ public:
     virtual void checkPBSUnknown(ICE_IN(::Test::PreservedPtr), const ::Ice::Current&);
 
 #ifdef ICE_CPP11_MAPPING
-    virtual void PBSUnknownAsPreservedWithGraphAsync(std::function<void (const std::shared_ptr<Test::Preserved>&)>,
-                                                      std::function<void (std::exception_ptr)>,
+    virtual void PBSUnknownAsPreservedWithGraphAsync(std::function<void(const std::shared_ptr<Test::Preserved>&)>,
+                                                      std::function<void(std::exception_ptr)>,
                                                       const ::Ice::Current&);
 #else
     virtual void PBSUnknownAsPreservedWithGraph_async(const ::Test::AMD_TestIntf_PBSUnknownAsPreservedWithGraphPtr&,
@@ -67,8 +67,8 @@ public:
     virtual void checkPBSUnknownWithGraph(ICE_IN(::Test::PreservedPtr), const ::Ice::Current&);
 
 #ifdef ICE_CPP11_MAPPING
-    virtual void PBSUnknown2AsPreservedWithGraphAsync(std::function<void (const std::shared_ptr<Test::Preserved>&)>,
-                                                       std::function<void (std::exception_ptr)>,
+    virtual void PBSUnknown2AsPreservedWithGraphAsync(std::function<void(const std::shared_ptr<Test::Preserved>&)>,
+                                                       std::function<void(std::exception_ptr)>,
                                                        const ::Ice::Current&);
 #else
     virtual void PBSUnknown2AsPreservedWithGraph_async(const ::Test::AMD_TestIntf_PBSUnknown2AsPreservedWithGraphPtr&,
@@ -83,8 +83,8 @@ public:
     virtual void throwDerivedAsDerived(const ::Ice::Current&);
     virtual void throwUnknownDerivedAsBase(const ::Ice::Current&);
 #ifdef ICE_CPP11_MAPPING
-    virtual void throwPreservedExceptionAsync(std::function<void ()>,
-                                               std::function<void (std::exception_ptr)>,
+    virtual void throwPreservedExceptionAsync(std::function<void()>,
+                                               std::function<void(std::exception_ptr)>,
                                                const ::Ice::Current&);
 #else
     virtual void throwPreservedException_async(const ::Test::AMD_TestIntf_throwPreservedExceptionPtr&,
diff --git a/cpp/test/Ice/stream/Client.cpp b/cpp/test/Ice/stream/Client.cpp
index cc346e6738d..cff4982d542 100644
--- a/cpp/test/Ice/stream/Client.cpp
+++ b/cpp/test/Ice/stream/Client.cpp
@@ -161,7 +161,7 @@ public:
         return _factory(type);
     }
 
-    void setFactory(function<Ice::ValuePtr (const string&)> f)
+    void setFactory(function<Ice::ValuePtr(const string&)> f)
     {
         _factory = f;
     }
@@ -171,7 +171,7 @@ public:
         _factory = [](const string&) { return ICE_MAKE_SHARED(MyClass); };
     }
 
-    function<Ice::ValuePtr (const string&)> _factory;
+    function<Ice::ValuePtr(const string&)> _factory;
 };
 #else
 class MyClassFactoryWrapper : public Ice::ValueFactory
@@ -232,7 +232,7 @@ run(int, char**, const Ice::CommunicatorPtr& communicator)
 {
 #ifdef ICE_CPP11_MAPPING
     MyClassFactoryWrapper factoryWrapper;
-    function<Ice::ValuePtr (const string&)> f =
+    function<Ice::ValuePtr(const string&)> f =
         std::bind(&MyClassFactoryWrapper::create, &factoryWrapper, std::placeholders::_1);
     communicator->getValueFactoryManager()->add(f, MyClass::ice_staticId());
 #else
diff --git a/cpp/test/Slice/keyword/Client.cpp b/cpp/test/Slice/keyword/Client.cpp
index 3fc7c6a9f1f..0696a6e2edb 100644
--- a/cpp/test/Slice/keyword/Client.cpp
+++ b/cpp/test/Slice/keyword/Client.cpp
@@ -19,8 +19,8 @@ public:
 
 #ifdef ICE_CPP11_MAPPING
     virtual void caseAsync(::Ice::Int,
-                           function<void (int)> response,
-                           function<void (exception_ptr)>,
+                           function<void(int)> response,
+                           function<void(exception_ptr)>,
                            const ::Ice::Current&)
     {
         response(0);
@@ -64,8 +64,8 @@ class doI : public _cpp_and::_cpp_do
 public:
 #ifdef ICE_CPP11_MAPPING
     virtual void caseAsync(::Ice::Int,
-                           function<void (int)>,
-                           function<void (const exception_ptr&)>,
+                           function<void(int)>,
+                           function<void(const exception_ptr&)>,
                            const ::Ice::Current&)
     {
     }