zeroc-ice 3.6.5 → 3.7.0

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
 //
 // This copy of Ice is licensed to you under the terms described in the
 // ICE_LICENSE file included in this distribution.
@@ -24,8 +24,8 @@
 #include <Ice/ProtocolInstanceF.h>
 #include <Ice/EndpointTypes.h>
 
-#ifdef ICE_OS_WINRT
-#   include <Ice/EventHandlerF.h>
+#if defined(ICE_OS_UWP)
+#   include <ppltasks.h>
 #elif defined(_WIN32)
 #   include <winsock2.h>
 #   include <ws2tcpip.h>
@@ -43,14 +43,14 @@ typedef int ssize_t;
 #   include <netdb.h>
 #endif
 
-#if defined(__linux__) && !defined(ICE_NO_EPOLL)
+#if defined(__linux) && !defined(ICE_NO_EPOLL)
 #   define ICE_USE_EPOLL 1
 #elif (defined(__APPLE__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)) && TARGET_OS_IPHONE == 0 && !defined(ICE_NO_KQUEUE)
 #   define ICE_USE_KQUEUE 1
 #elif defined(__APPLE__) && !defined(ICE_NO_CFSTREAM)
 #   define ICE_USE_CFSTREAM 1
 #elif defined(_WIN32)
-#  if defined(ICE_OS_WINRT)
+#  if defined(ICE_OS_UWP)
 #  elif !defined(ICE_NO_IOCP)
 #     define ICE_USE_IOCP 1
 #  else
@@ -68,7 +68,7 @@ typedef int socklen_t;
 #   define SOCKET int
 #   define INVALID_SOCKET -1
 #   define SOCKET_ERROR -1
-#elif defined(ICE_OS_WINRT)
+#elif defined(ICE_OS_UWP)
     typedef Platform::Object^ SOCKET;
 #   define INVALID_SOCKET nullptr
 #   define SOCKET_ERROR -1
@@ -115,7 +115,7 @@ namespace IceInternal
 //
 // Use Address struct or union depending on the platform
 //
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
 struct ICE_API Address
 {
     Windows::Networking::HostName^ host;
@@ -152,17 +152,17 @@ enum SocketOperation
 };
 
 //
-// On WinRT, wait only for read to return, on IOCP/Win32 wait for
+// On UWP, wait only for read to return, on IOCP/Win32 wait for
 // both pending read and write operations to complete (#ICE-6695).
 //
-#if defined(ICE_OS_WINRT)
+#if defined(ICE_OS_UWP)
 const int SocketOperationWaitForClose = 1;
 #elif defined(ICE_USE_IOCP)
 const int SocketOperationWaitForClose = 3;
 #endif
 
 //
-// AsyncInfo struct for Windows IOCP or WinRT holds the result of
+// AsyncInfo struct for Windows IOCP or UWP holds the result of
 // asynchronous operations after it completed.
 //
 #if defined(ICE_USE_IOCP)
@@ -176,9 +176,10 @@ struct ICE_API AsyncInfo : WSAOVERLAPPED
     DWORD count;
     int error;
 };
-#elif defined(ICE_OS_WINRT)
+#elif defined(ICE_OS_UWP)
 struct ICE_API AsyncInfo
 {
+    Windows::Foundation::AsyncOperationCompletedHandler<unsigned int>^ completedHandler;
     int count;
     int error;
 };
@@ -186,11 +187,26 @@ struct ICE_API AsyncInfo
 delegate void SocketOperationCompletedHandler(int);
 #endif
 
-class ICE_API NativeInfo : virtual public IceUtil::Shared
+class ICE_API ReadyCallback : public virtual ::IceUtil::Shared
 {
 public:
 
+    virtual ~ReadyCallback();
+
+    virtual void ready(SocketOperation, bool) = 0;
+};
+typedef IceUtil::Handle<ReadyCallback> ReadyCallbackPtr;
+
+class ICE_API NativeInfo : public virtual IceUtil::Shared
+{
+public:
+
+    virtual ~NativeInfo();
+
     NativeInfo(SOCKET socketFd = INVALID_SOCKET) : _fd(socketFd)
+#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_UWP)
+        , _newFd(INVALID_SOCKET)
+#endif
     {
     }
 
@@ -199,27 +215,55 @@ public:
         return _fd;
     }
 
+    void setReadyCallback(const ReadyCallbackPtr& callback);
+
+    void ready(SocketOperation operation, bool value)
+    {
+        assert(_readyCallback);
+        _readyCallback->ready(operation, value);
+    }
+
     //
     // This is implemented by transceiver and acceptor implementations.
     //
 #if defined(ICE_USE_IOCP)
     virtual AsyncInfo* getAsyncInfo(SocketOperation) = 0;
     void initialize(HANDLE, ULONG_PTR);
-    void completed(SocketOperation operation);
-#elif defined(ICE_OS_WINRT)
-    virtual void setCompletedHandler(SocketOperationCompletedHandler^) = 0;
-    void completed(SocketOperation operation);
+    void completed(SocketOperation);
+#elif defined(ICE_OS_UWP)
+    virtual AsyncInfo* getAsyncInfo(SocketOperation) = 0;
+    void queueAction(SocketOperation, Windows::Foundation::IAsyncAction^, bool = false);
+    void queueOperation(SocketOperation, Windows::Foundation::IAsyncOperation<unsigned int>^);
+    void setCompletedHandler(SocketOperationCompletedHandler^);
+    void completed(SocketOperation);
+#else
+    bool newFd();
+    void setNewFd(SOCKET);
 #endif
 
 protected:
 
     SOCKET _fd;
+    ReadyCallbackPtr _readyCallback;
 
 #if defined(ICE_USE_IOCP)
     HANDLE _handle;
     ULONG_PTR _key;
-#elif defined(ICE_OS_WINRT)
+#elif defined(ICE_OS_UWP)
+    bool checkIfErrorOrCompleted(SocketOperation, Windows::Foundation::IAsyncInfo^, bool = false);
     SocketOperationCompletedHandler^ _completedHandler;
+#else
+    SOCKET _newFd;
+#endif
+
+private:
+
+#if defined(ICE_OS_UWP)
+    void queueActionCompleted(SocketOperation, AsyncInfo* asyncInfo, Windows::Foundation::IAsyncAction^,
+                              Windows::Foundation::AsyncStatus);
+    void queueOperationCompleted(SocketOperation, AsyncInfo* asyncInfo,
+                                 Windows::Foundation::IAsyncOperation<unsigned int>^,
+                                 Windows::Foundation::AsyncStatus);
 #endif
 };
 typedef IceUtil::Handle<NativeInfo> NativeInfoPtr;
@@ -229,7 +273,7 @@ ICE_API std::string errorToStringDNS(int);
 ICE_API std::vector<Address> getAddresses(const std::string&, int, ProtocolSupport, Ice::EndpointSelectionType, bool,
                                           bool);
 ICE_API ProtocolSupport getProtocolSupport(const Address&);
-ICE_API Address getAddressForServer(const std::string&, int, ProtocolSupport, bool);
+ICE_API Address getAddressForServer(const std::string&, int, ProtocolSupport, bool, bool);
 ICE_API int compareAddress(const Address&, const Address&);
 
 ICE_API bool isIPv6Supported();
@@ -249,6 +293,7 @@ ICE_API std::string addressesToString(const Address&, const Address&, bool);
 ICE_API bool isAddressValid(const Address&);
 
 ICE_API std::vector<std::string> getHostsForEndpointExpand(const std::string&, ProtocolSupport, bool);
+ICE_API std::vector<std::string> getInterfacesForMulticast(const std::string&, ProtocolSupport);
 
 ICE_API std::string inetAddrToString(const Address&);
 ICE_API int getPort(const Address&);
@@ -268,10 +313,10 @@ ICE_API void setMcastGroup(SOCKET, const Address&, const std::string&);
 ICE_API void setMcastInterface(SOCKET, const std::string&, const Address&);
 ICE_API void setMcastTtl(SOCKET, int, const Address&);
 ICE_API void setReuseAddress(SOCKET, bool);
+ICE_API Address doBind(SOCKET, const Address&, const std::string& intf = "");
+ICE_API void doListen(SOCKET, int);
 
-ICE_API Address doBind(SOCKET, const Address&);
-
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
 ICE_API bool interrupted();
 ICE_API bool acceptInterrupted();
 ICE_API bool noBuffers();
@@ -284,7 +329,6 @@ ICE_API bool connectionRefused();
 ICE_API bool connectInProgress();
 ICE_API bool connectionLost();
 
-ICE_API void doListen(SOCKET, int);
 ICE_API bool doConnect(SOCKET, const Address&, const Address&);
 ICE_API void doFinishConnect(SOCKET);
 ICE_API SOCKET doAccept(SOCKET);
@@ -295,14 +339,47 @@ ICE_API int getSocketErrno();
 
 ICE_API Address getNumericAddress(const std::string&);
 #else
-ICE_API void checkConnectErrorCode(const char*, int, HRESULT, Windows::Networking::HostName^);
+ICE_API void checkConnectErrorCode(const char*, int, HRESULT);
 ICE_API void checkErrorCode(const char*, int, HRESULT);
+
+//
+// UWP impose some restriction on operations that block when run from
+// STA thread and throws concurrency::invalid_operation. We cannot
+// directly call task::get or task::way, this helper method is used to
+// workaround this limitation.
+//
+template<typename T>
+T runSync(Windows::Foundation::IAsyncOperation<T>^ operation)
+{
+    std::promise<T> p;
+    concurrency::create_task(operation).then(
+        [&p](concurrency::task<T> t)
+        {
+            try
+            {
+                p.set_value(t.get());
+            }
+            catch(...)
+            {
+                p.set_exception(std::current_exception());
+            }
+        },
+        concurrency::task_continuation_context::use_arbitrary());
+
+    return p.get_future().get();
+}
+
+ICE_API void runSync(Windows::Foundation::IAsyncAction^ action);
+
 #endif
 
 #if defined(ICE_USE_IOCP)
 ICE_API void doConnectAsync(SOCKET, const Address&, const Address&, AsyncInfo&);
 ICE_API void doFinishConnectAsync(SOCKET, AsyncInfo&);
 #endif
+
+ICE_API bool isIpAddress(const std::string&);
+
 }
 
 #endif

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
 //
 // This copy of Ice is licensed to you under the terms described in the
 // ICE_LICENSE file included in this distribution.
@@ -17,7 +17,7 @@
 namespace IceInternal
 {
 
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
 struct ICE_API Address;
 #else
 union Address;

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
 //
 // This copy of Ice is licensed to you under the terms described in the
 // ICE_LICENSE file included in this distribution.
@@ -17,7 +17,12 @@ using namespace IceInternal;
 
 IceUtil::Shared* IceInternal::upCast(NetworkProxy* p) { return p; }
 
-#ifndef ICE_OS_WINRT
+NetworkProxy::~NetworkProxy()
+{
+    // Out of line to avoid weak vtable
+}
+
+#ifndef ICE_OS_UWP
 
 namespace
 {
@@ -76,6 +81,7 @@ private:
 SOCKSNetworkProxy::SOCKSNetworkProxy(const string& host, int port) : _host(host), _port(port)
 {
     assert(!host.empty());
+    memset(&_address, 0, sizeof(_address));
 }
 
 SOCKSNetworkProxy::SOCKSNetworkProxy(const Address& addr) : _port(0), _address(addr)
@@ -118,7 +124,7 @@ SOCKSNetworkProxy::beginWrite(const Address& addr, Buffer& buf)
 SocketOperation
 SOCKSNetworkProxy::endWrite(Buffer& buf)
 {
-    // Once the request is sent, read the response 
+    // Once the request is sent, read the response
     return buf.i != buf.b.end() ? SocketOperationWrite : SocketOperationRead;
 }
 
@@ -162,7 +168,7 @@ NetworkProxyPtr
 SOCKSNetworkProxy::resolveHost(ProtocolSupport protocol) const
 {
     assert(!_host.empty());
-    return new SOCKSNetworkProxy(getAddresses(_host, _port, protocol, Ice::Random, false, true)[0]);
+    return new SOCKSNetworkProxy(getAddresses(_host, _port, protocol, Ice::ICE_ENUM(EndpointSelectionType, Random), false, true)[0]);
 }
 
 Address
@@ -184,13 +190,14 @@ SOCKSNetworkProxy::getProtocolSupport() const
     return EnableIPv4;
 }
 
-HTTPNetworkProxy::HTTPNetworkProxy(const string& host, int port) : 
+HTTPNetworkProxy::HTTPNetworkProxy(const string& host, int port) :
     _host(host), _port(port), _protocol(EnableBoth)
 {
     assert(!host.empty());
+    memset(&_address, 0, sizeof(_address));
 }
 
-HTTPNetworkProxy::HTTPNetworkProxy(const Address& addr, ProtocolSupport protocol) : 
+HTTPNetworkProxy::HTTPNetworkProxy(const Address& addr, ProtocolSupport protocol) :
     _port(0), _address(addr), _protocol(protocol)
 {
 }
@@ -212,7 +219,7 @@ HTTPNetworkProxy::beginWrite(const Address& addr, Buffer& buf)
 SocketOperation
 HTTPNetworkProxy::endWrite(Buffer& buf)
 {
-    // Once the request is sent, read the response 
+    // Once the request is sent, read the response
     return buf.i != buf.b.end() ? SocketOperationWrite : SocketOperationRead;
 }
 
@@ -240,7 +247,7 @@ HTTPNetworkProxy::endRead(Buffer& buf)
         // Read one more byte, we can't easily read bytes in advance
         // since the transport implenentation might be be able to read
         // the data from the memory instead of the socket. This is for
-        // instance the case with the OpenSSL transport (or we would 
+        // instance the case with the OpenSSL transport (or we would
         // have to use a buffering BIO).
         //
         buf.b.resize(buf.b.size() + 1);
@@ -265,7 +272,7 @@ NetworkProxyPtr
 HTTPNetworkProxy::resolveHost(ProtocolSupport protocol) const
 {
     assert(!_host.empty());
-    return new HTTPNetworkProxy(getAddresses(_host, _port, protocol, Ice::Random, false, true)[0], protocol);
+    return new HTTPNetworkProxy(getAddresses(_host, _port, protocol, Ice::ICE_ENUM(EndpointSelectionType, Random), false, true)[0], protocol);
 }
 
 Address
@@ -297,8 +304,8 @@ IceInternal::createNetworkProxy(const Ice::PropertiesPtr& properties, ProtocolSu
     proxyHost = properties->getProperty("Ice.SOCKSProxyHost");
     if(!proxyHost.empty())
     {
-#ifdef ICE_OS_WINRT
-        throw Ice::InitializationException(__FILE__, __LINE__, "SOCKS proxy not supported with WinRT");
+#ifdef ICE_OS_UWP
+        throw Ice::InitializationException(__FILE__, __LINE__, "SOCKS proxy not supported with UWP");
 #else
         if(protocolSupport == EnableIPv6)
         {
@@ -312,12 +319,12 @@ IceInternal::createNetworkProxy(const Ice::PropertiesPtr& properties, ProtocolSu
     proxyHost = properties->getProperty("Ice.HTTPProxyHost");
     if(!proxyHost.empty())
     {
-#ifdef ICE_OS_WINRT
-        throw Ice::InitializationException(__FILE__, __LINE__, "HTTP proxy not supported with WinRT");
+#ifdef ICE_OS_UWP
+        throw Ice::InitializationException(__FILE__, __LINE__, "HTTP proxy not supported with UWP");
 #else
         return new HTTPNetworkProxy(proxyHost, properties->getPropertyAsIntWithDefault("Ice.HTTPProxyPort", 1080));
 #endif
     }
-    
+
     return 0;
 }

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
 //
 // This copy of Ice is licensed to you under the terms described in the
 // ICE_LICENSE file included in this distribution.
@@ -11,14 +11,17 @@
 #define ICE_NETWORK_PROXY_H
 
 #include <Ice/Network.h>
+#include <Ice/Buffer.h>
 
 namespace IceInternal
 {
 
-class ICE_API NetworkProxy : virtual public IceUtil::Shared
+class ICE_API NetworkProxy : public virtual IceUtil::Shared
 {
 public:
 
+    virtual ~NetworkProxy();
+
     //
     // Write the connection request on the connection established
     // with the network proxy server. This is called right after

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

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

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
 //
 // This copy of Ice is licensed to you under the terms described in the
 // ICE_LICENSE file included in this distribution.
@@ -12,17 +12,22 @@
 #include <Ice/IncomingAsync.h>
 #include <Ice/IncomingRequest.h>
 #include <Ice/LocalException.h>
-#include <Ice/Stream.h>
 #include <Ice/SlicedData.h>
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
+namespace Ice
+{
+const Current emptyCurrent = Current();
+}
+
+#ifndef ICE_CPP11_MAPPING
 Object* Ice::upCast(Object* p) { return p; }
 
-void 
-Ice::__patch(ObjectPtr& obj, const ObjectPtr& v)
+void
+Ice::_icePatchObjectPtr(ObjectPtr& obj, const ObjectPtr& v)
 {
     obj = v;
 }
@@ -38,22 +43,46 @@ Ice::Object::operator<(const Object& r) const
 {
     return this < &r;
 }
-
+#endif
 
 namespace
 {
 
-const string __Ice__Object_ids[] =
+const string object_ids[] =
 {
     "::Ice::Object"
 };
 
+const string object_all[] =
+{
+    "ice_id",
+    "ice_ids",
+    "ice_isA",
+    "ice_ping"
+};
+
+}
+
+#ifndef ICE_CPP11_MAPPING
+Ice::DispatchInterceptorAsyncCallback::~DispatchInterceptorAsyncCallback()
+{
+    // Out of line to avoid weak vtable
+}
+#endif
+
+Ice::Request::~Request()
+{
+    // Out of line to avoid weak vtable
 }
 
 bool
+#ifdef ICE_CPP11_MAPPING
+Ice::Object::ice_isA(string s, const Current&) const
+#else
 Ice::Object::ice_isA(const string& s, const Current&) const
+#endif
 {
-    return s == __Ice__Object_ids[0];
+    return s == object_ids[0];
 }
 
 void
@@ -65,21 +94,26 @@ Ice::Object::ice_ping(const Current&) const
 vector<string>
 Ice::Object::ice_ids(const Current&) const
 {
-    return vector<string>(&__Ice__Object_ids[0], &__Ice__Object_ids[1]);
+    return vector<string>(&object_ids[0], &object_ids[1]);
 }
 
+#ifdef ICE_CPP11_MAPPING
+string
+#else
 const string&
+#endif
 Ice::Object::ice_id(const Current&) const
 {
-    return __Ice__Object_ids[0];
+    return object_ids[0];
 }
 
 const ::std::string&
 Ice::Object::ice_staticId()
 {
-    return __Ice__Object_ids[0];
+    return object_ids[0];
 }
 
+#ifndef ICE_CPP11_MAPPING
 Ice::ObjectPtr
 Ice::Object::ice_clone() const
 {
@@ -87,191 +121,167 @@ Ice::Object::ice_clone() const
     return 0; // avoid warning with some compilers
 }
 
-void
-Ice::Object::ice_preMarshal()
-{
-}
-
-void
-Ice::Object::ice_postUnmarshal()
-{
-}
-
-DispatchStatus
-Ice::Object::___ice_isA(Incoming& __inS, const Current& __current)
+Ice::SlicedDataPtr
+Ice::Object::ice_getSlicedData() const
 {
-    BasicStream* __is = __inS.startReadParams();
-    string __id;
-    __is->read(__id, false);
-    __inS.endReadParams();
-    bool __ret = ice_isA(__id, __current);
-    BasicStream* __os = __inS.__startWriteParams(DefaultFormat);
-    __os->write(__ret);
-    __inS.__endWriteParams(true);
-    return DispatchOK;
+    return 0;
 }
+#endif
 
-DispatchStatus
-Ice::Object::___ice_ping(Incoming& __inS, const Current& __current)
-{
-    __inS.readEmptyParams();
-    ice_ping(__current);
-    __inS.__writeEmptyParams();
-    return DispatchOK;
+bool
+Ice::Object::_iceD_ice_isA(Incoming& inS, const Current& current)
+{
+    InputStream* istr = inS.startReadParams();
+    string iceP_id;
+    istr->read(iceP_id, false);
+    inS.endReadParams();
+#ifdef ICE_CPP11_MAPPING
+    bool ret = ice_isA(move(iceP_id), current);
+#else
+    bool ret = ice_isA(iceP_id, current);
+#endif
+    OutputStream* ostr = inS.startWriteParams();
+    ostr->write(ret);
+    inS.endWriteParams();
+    return true;
 }
 
-DispatchStatus
-Ice::Object::___ice_ids(Incoming& __inS, const Current& __current)
+bool
+Ice::Object::_iceD_ice_ping(Incoming& inS, const Current& current)
 {
-    __inS.readEmptyParams();
-    vector<string> __ret = ice_ids(__current);
-    BasicStream* __os = __inS.__startWriteParams(DefaultFormat);
-    __os->write(&__ret[0], &__ret[0] + __ret.size(), false);
-    __inS.__endWriteParams(true);
-    return DispatchOK;
+    inS.readEmptyParams();
+    ice_ping(current);
+    inS.writeEmptyParams();
+    return true;
 }
 
-DispatchStatus
-Ice::Object::___ice_id(Incoming& __inS, const Current& __current)
+bool
+Ice::Object::_iceD_ice_ids(Incoming& inS, const Current& current)
 {
-    __inS.readEmptyParams();
-    string __ret = ice_id(__current);
-    BasicStream* __os = __inS.__startWriteParams(DefaultFormat);
-    __os->write(__ret, false);
-    __inS.__endWriteParams(true);
-    return DispatchOK;
+    inS.readEmptyParams();
+    vector<string> ret = ice_ids(current);
+    OutputStream* ostr = inS.startWriteParams();
+    ostr->write(&ret[0], &ret[0] + ret.size(), false);
+    inS.endWriteParams();
+    return true;
 }
 
-Ice::Int
-Ice::Object::ice_operationAttributes(const string&) const
+bool
+Ice::Object::_iceD_ice_id(Incoming& inS, const Current& current)
 {
-    return 0;
+    inS.readEmptyParams();
+    string ret = ice_id(current);
+    OutputStream* ostr = inS.startWriteParams();
+    ostr->write(ret, false);
+    inS.endWriteParams();
+    return true;
 }
 
-
-string Ice::Object::__all[] =
-{
-    "ice_id",
-    "ice_ids",
-    "ice_isA",
-    "ice_ping"
-};
-
-
-DispatchStatus
+bool
+#ifdef ICE_CPP11_MAPPING
+Ice::Object::ice_dispatch(Request& request, std::function<bool()> r, std::function<bool(std::exception_ptr)> e)
+#else
 Ice::Object::ice_dispatch(Request& request, const DispatchInterceptorAsyncCallbackPtr& cb)
+#endif
 {
-    class PushCb
+    IceInternal::Incoming& in = dynamic_cast<IceInternal::IncomingRequest&>(request)._in;
+    in.startOver();
+#ifdef ICE_CPP11_MAPPING
+    if(r || e)
+    {
+        in.push(r, e);
+#else
+    if(cb)
     {
-    public:
-        PushCb(IceInternal::Incoming& in, const DispatchInterceptorAsyncCallbackPtr& cb) :
-            _in(in),
-            _cb(cb)
+        in.push(cb);
+#endif
+        try
         {
-            if(_cb != 0)
-            {
-                _in.push(_cb);
-            }
+            bool sync = _iceDispatch(in, in.getCurrent());
+            in.pop();
+            return sync;
         }
-
-        ~PushCb()
+        catch(...)
         {
-            if(_cb != 0)
-            {
-                _in.pop();
-            }
+            in.pop();
+            throw;
         }
-    private:
-        IceInternal::Incoming& _in;
-        const DispatchInterceptorAsyncCallbackPtr& _cb;
-    };
-
-
-    IceInternal::Incoming& in = dynamic_cast<IceInternal::IncomingRequest&>(request)._in;
-    
-    PushCb pusbCb(in, cb);
-    in.startOver(); // may raise ResponseSentException
-    return __dispatch(in, in.getCurrent());
+    }
+    else
+    {
+        return _iceDispatch(in, in.getCurrent());
+    }
 }
 
-DispatchStatus
-Ice::Object::__dispatch(Incoming& in, const Current& current)
+bool
+Ice::Object::_iceDispatch(Incoming& in, const Current& current)
 {
-    pair<string*, string*> r =
-        equal_range(__all, __all + sizeof(__all) / sizeof(string), current.operation);
+    pair<const string*, const string*> r = equal_range(object_all, object_all + sizeof(object_all) / sizeof(string), current.operation);
 
     if(r.first == r.second)
     {
         throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
-    }                                        
+    }
 
-    switch(r.first - __all)
+    switch(r.first - object_all)
     {
         case 0:
         {
-            return ___ice_id(in, current);
+            return _iceD_ice_id(in, current);
         }
         case 1:
         {
-            return ___ice_ids(in, current);
+            return _iceD_ice_ids(in, current);
         }
         case 2:
         {
-            return ___ice_isA(in, current);
+            return _iceD_ice_isA(in, current);
         }
         case 3:
         {
-            return ___ice_ping(in, current);
+            return _iceD_ice_ping(in, current);
+        }
+        default:
+        {
+            assert(false);
+            throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
         }
     }
-
-    assert(false);
-    throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
 }
 
+#ifndef ICE_CPP11_MAPPING
 void
-Ice::Object::__write(IceInternal::BasicStream* os) const
-{
-    os->startWriteObject(0);
-    __writeImpl(os);
-    os->endWriteObject();
-}
- 
-void 
-Ice::Object::__read(IceInternal::BasicStream* is)
+Ice::Object::ice_preMarshal()
 {
-   is->startReadObject();
-   __readImpl(is);
-   is->endReadObject(false);
 }
-    
-void 
-Ice::Object::__write(const OutputStreamPtr& os) const
+
+void
+Ice::Object::ice_postUnmarshal()
 {
-    os->startObject(0);
-    __writeImpl(os);
-    os->endObject();
 }
- 
-void 
-Ice::Object::__read(const InputStreamPtr& is)
+
+void
+Ice::Object::_iceWrite(Ice::OutputStream* os) const
 {
-    is->startObject();
-   __readImpl(is);
-   is->endObject(false);
+    os->startValue(0);
+    _iceWriteImpl(os);
+    os->endValue();
 }
- 
-void 
-Ice::Object::__writeImpl(const OutputStreamPtr&) const
+
+void
+Ice::Object::_iceRead(Ice::InputStream* is)
 {
-    throw MarshalException(__FILE__, __LINE__, "class was not generated with stream support");
+   is->startValue();
+   _iceReadImpl(is);
+   is->endValue(false);
 }
- 
-void 
-Ice::Object::__readImpl(const InputStreamPtr&)
+
+Ice::Int
+Ice::Object::ice_operationAttributes(const string&) const
 {
-    throw MarshalException(__FILE__, __LINE__, "class was not generated with stream support");
+    return 0;
 }
+#endif
 
 namespace
 {
@@ -281,34 +291,41 @@ operationModeToString(OperationMode mode)
 {
     switch(mode)
     {
-    case Normal:
+    case ICE_ENUM(OperationMode, Normal):
         return "::Ice::Normal";
 
-    case Nonmutating:
+    case ICE_ENUM(OperationMode, Nonmutating):
         return "::Ice::Nonmutating";
 
-    case Idempotent:
+    case ICE_ENUM(OperationMode, Idempotent):
         return "::Ice::Idempotent";
     }
-
+    //
+    // This could not happen with C++11 strong type enums
+    //
+#ifdef ICE_CPP11_MAPPING
+    assert(false);
+    return "";
+#else
     ostringstream os;
     os << "unknown value (" << mode << ")";
     return os.str();
+#endif
 }
 
 }
 
 void
-Ice::Object::__checkMode(OperationMode expected, OperationMode received)
+Ice::Object::_iceCheckMode(OperationMode expected, OperationMode received)
 {
     if(expected != received)
     {
-        if(expected == Idempotent && received == Nonmutating)
+        if(expected == ICE_ENUM(OperationMode, Idempotent) && received == ICE_ENUM(OperationMode, Nonmutating))
         {
-            // 
+            //
             // Fine: typically an old client still using the deprecated nonmutating keyword
             //
-            
+
             //
             // Note that expected == Nonmutating and received == Idempotent is not ok:
             // the server may still use the deprecated nonmutating keyword to detect updates
@@ -318,19 +335,19 @@ Ice::Object::__checkMode(OperationMode expected, OperationMode received)
         else
         {
             Ice::MarshalException ex(__FILE__, __LINE__);
-            std::ostringstream __reason;
-            __reason << "unexpected operation mode. expected = "
-                     << operationModeToString(expected)
-                     << " received = "
-                     << operationModeToString(received);
-            ex.reason = __reason.str();
+            std::ostringstream reason;
+            reason << "unexpected operation mode. expected = "
+                   << operationModeToString(expected)
+                   << " received = "
+                   << operationModeToString(received);
+            ex.reason = reason.str();
             throw ex;
         }
     }
 }
 
-DispatchStatus
-Ice::Blobject::__dispatch(Incoming& in, const Current& current)
+bool
+Ice::Blobject::_iceDispatch(Incoming& in, const Current& current)
 {
     const Byte* inEncaps;
     Int sz;
@@ -339,24 +356,17 @@ Ice::Blobject::__dispatch(Incoming& in, const Current& current)
     bool ok = ice_invoke(vector<Byte>(inEncaps, inEncaps + sz), outEncaps, current);
     if(outEncaps.empty())
     {
-        in.__writeParamEncaps(0, 0, ok);
-    }
-    else
-    {
-        in.__writeParamEncaps(&outEncaps[0], static_cast<Ice::Int>(outEncaps.size()), ok);
-    }
-    if(ok)
-    {
-        return DispatchOK;
+        in.writeParamEncaps(0, 0, ok);
     }
     else
     {
-        return DispatchUserException;
+        in.writeParamEncaps(&outEncaps[0], static_cast<Ice::Int>(outEncaps.size()), ok);
     }
+    return true;
 }
 
-DispatchStatus
-Ice::BlobjectArray::__dispatch(Incoming& in, const Current& current)
+bool
+Ice::BlobjectArray::_iceDispatch(Incoming& in, const Current& current)
 {
     pair<const Byte*, const Byte*> inEncaps;
     Int sz;
@@ -366,75 +376,61 @@ Ice::BlobjectArray::__dispatch(Incoming& in, const Current& current)
     bool ok = ice_invoke(inEncaps, outEncaps, current);
     if(outEncaps.empty())
     {
-        in.__writeParamEncaps(0, 0, ok);
-    }
-    else
-    {
-        in.__writeParamEncaps(&outEncaps[0], static_cast<Ice::Int>(outEncaps.size()), ok);
-    }
-    if(ok)
-    {
-        return DispatchOK;
+        in.writeParamEncaps(0, 0, ok);
     }
     else
     {
-        return DispatchUserException;
+        in.writeParamEncaps(&outEncaps[0], static_cast<Ice::Int>(outEncaps.size()), ok);
     }
+    return true;
 }
 
-DispatchStatus
-Ice::BlobjectAsync::__dispatch(Incoming& in, const Current& current)
+bool
+Ice::BlobjectAsync::_iceDispatch(Incoming& in, const Current& current)
 {
     const Byte* inEncaps;
     Int sz;
     in.readParamEncaps(inEncaps, sz);
-    AMD_Object_ice_invokePtr cb = new ::IceAsync::Ice::AMD_Object_ice_invoke(in);
-    try
-    {
-        ice_invoke_async(cb, vector<Byte>(inEncaps, inEncaps + sz), current);
-    }
-    catch(const ::std::exception& ex)
-    {
-        cb->ice_exception(ex);
-    }
-    catch(...)
-    {
-        cb->ice_exception();
-    }
-    return DispatchAsync;
+#ifdef ICE_CPP11_MAPPING
+    auto async = IncomingAsync::create(in);
+    ice_invokeAsync(vector<Byte>(inEncaps, inEncaps + sz),
+                    [async](bool ok, const vector<Byte>& outEncaps)
+                    {
+                        if(outEncaps.empty())
+                        {
+                            async->writeParamEncaps(0, 0, ok);
+                        }
+                        else
+                        {
+                            async->writeParamEncaps(&outEncaps[0], static_cast<Int>(outEncaps.size()), ok);
+                        }
+                        async->completed();
+                    },
+                    async->exception(), current);
+#else
+    ice_invoke_async(new ::IceAsync::Ice::AMD_Object_ice_invoke(in), vector<Byte>(inEncaps, inEncaps + sz), current);
+#endif
+    return false;
 }
 
-DispatchStatus
-Ice::BlobjectArrayAsync::__dispatch(Incoming& in, const Current& current)
+bool
+Ice::BlobjectArrayAsync::_iceDispatch(Incoming& in, const Current& current)
 {
     pair<const Byte*, const Byte*> inEncaps;
     Int sz;
     in.readParamEncaps(inEncaps.first, sz);
     inEncaps.second = inEncaps.first + sz;
-    AMD_Object_ice_invokePtr cb = new ::IceAsync::Ice::AMD_Object_ice_invoke(in);
-    try
-    {
-        ice_invoke_async(cb, inEncaps, current);
-    }
-    catch(const ::std::exception& ex)
-    {
-        cb->ice_exception(ex);
-    }
-    catch(...)
-    {
-        cb->ice_exception();
-    }
-    return DispatchAsync;
-}
-
-void
-Ice::ice_writeObject(const OutputStreamPtr& out, const ObjectPtr& p)
-{
-    out->write(p);
-}
-
-void
-Ice::ice_readObject(const InputStreamPtr& in, ObjectPtr& p)
-{
-    in->read(p);
+#ifdef ICE_CPP11_MAPPING
+    auto async = IncomingAsync::create(in);
+    ice_invokeAsync(inEncaps,
+                    [async](bool ok, const pair<const Byte*, const Byte*>& outE)
+                    {
+                        async->writeParamEncaps(outE.first, static_cast<Int>(outE.second - outE.first), ok);
+                        async->completed();
+                    },
+                    async->exception(), current);
+#else
+    ice_invoke_async(new ::IceAsync::Ice::AMD_Object_ice_invoke(in), inEncaps, current);
+#endif
+    return false;
 }