zeroc-ice 3.6.5 → 3.7.4

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

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

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #include <Ice/RequestHandler.h>
 #include <Ice/Reference.h>
@@ -13,17 +8,19 @@
 using namespace std;
 using namespace IceInternal;
 
+#ifndef ICE_CPP11_MAPPING
 IceUtil::Shared* IceInternal::upCast(RequestHandler* p) { return p; }
 IceUtil::Shared* IceInternal::upCast(CancellationHandler* p) { return p; }
+#endif
 
 RetryException::RetryException(const Ice::LocalException& ex)
 {
-    _ex.reset(ex.ice_clone());
+    ICE_SET_EXCEPTION_FROM_CLONE(_ex, ex.ice_clone());
 }
 
 RetryException::RetryException(const RetryException& ex)
 {
-    _ex.reset(ex.get()->ice_clone());
+    ICE_SET_EXCEPTION_FROM_CLONE(_ex, ex.get()->ice_clone());
 }
 
 const Ice::LocalException*

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

@@ -1,17 +1,12 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #ifndef ICE_REQUEST_HANDLER_H
 #define ICE_REQUEST_HANDLER_H
 
 #include <IceUtil/Shared.h>
-#include <IceUtil/UniquePtr.h>
+#include <Ice/UniquePtr.h>
 
 #include <Ice/RequestHandlerF.h>
 #include <Ice/ReferenceF.h>
@@ -24,16 +19,11 @@ namespace Ice
 
 class LocalException;
 
-};
+}
 
 namespace IceInternal
 {
 
-class BasicStream;
-
-class OutgoingBase;
-class ProxyOutgoingBase;
-
 //
 // An exception wrapper, which is used to notify that the request
 // handler should be cleared and the invocation retried.
@@ -49,14 +39,16 @@ public:
 
 private:
 
-    IceUtil::UniquePtr<Ice::LocalException> _ex;
+    IceInternal::UniquePtr<Ice::LocalException> _ex;
 };
 
-class CancellationHandler : virtual public IceUtil::Shared
+class CancellationHandler
+#ifndef ICE_CPP11_MAPPING
+    : public virtual IceUtil::Shared
+#endif
 {
 public:
 
-    virtual void requestCanceled(OutgoingBase*, const Ice::LocalException&) = 0;
     virtual void asyncRequestCanceled(const OutgoingAsyncBasePtr&, const Ice::LocalException&) = 0;
 };
 
@@ -64,9 +56,10 @@ class RequestHandler : public CancellationHandler
 {
 public:
 
+    RequestHandler(const ReferencePtr&);
+
     virtual RequestHandlerPtr update(const RequestHandlerPtr&, const RequestHandlerPtr&) = 0;
 
-    virtual bool sendRequest(ProxyOutgoingBase*) = 0;
     virtual AsyncStatus sendAsyncRequest(const ProxyOutgoingAsyncBasePtr&) = 0;
 
     const ReferencePtr& getReference() const { return _reference; } // Inlined for performances.
@@ -76,7 +69,6 @@ public:
 
 protected:
 
-    RequestHandler(const ReferencePtr&);
     const ReferencePtr _reference;
     const bool _response;
 };

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #include <Ice/RequestHandlerFactory.h>
 #include <Ice/CollocatedRequestHandler.h>
@@ -23,14 +18,14 @@ RequestHandlerFactory::RequestHandlerFactory(const InstancePtr& instance) : _ins
 }
 
 RequestHandlerPtr
-IceInternal::RequestHandlerFactory::getRequestHandler(const RoutableReferencePtr& ref, const Ice::ObjectPrx& proxy)
+IceInternal::RequestHandlerFactory::getRequestHandler(const RoutableReferencePtr& ref, const Ice::ObjectPrxPtr& proxy)
 {
     if(ref->getCollocationOptimized())
     {
         Ice::ObjectAdapterPtr adapter = _instance->objectAdapterFactory()->findObjectAdapter(proxy);
         if(adapter)
         {
-            return proxy->__setRequestHandler(new CollocatedRequestHandler(ref, adapter));
+            return proxy->_setRequestHandler(ICE_MAKE_SHARED(CollocatedRequestHandler, ref, adapter));
         }
     }
 
@@ -42,7 +37,7 @@ IceInternal::RequestHandlerFactory::getRequestHandler(const RoutableReferencePtr
         map<ReferencePtr, ConnectRequestHandlerPtr>::iterator p = _handlers.find(ref);
         if(p == _handlers.end())
         {
-            handler = new ConnectRequestHandler(ref, proxy);
+            handler = ICE_MAKE_SHARED(ConnectRequestHandler, ref, proxy);
             _handlers.insert(make_pair(ref, handler));
             connect = true;
         }
@@ -53,14 +48,18 @@ IceInternal::RequestHandlerFactory::getRequestHandler(const RoutableReferencePtr
     }
     else
     {
-        handler = new ConnectRequestHandler(ref, proxy);
+        handler = ICE_MAKE_SHARED(ConnectRequestHandler, ref, proxy);
         connect = true;
     }
     if(connect)
     {
+#ifdef ICE_CPP11_MAPPING
+        ref->getConnection(handler);
+#else
         ref->getConnection(handler.get());
+#endif
     }
-    return proxy->__setRequestHandler(handler->connect(proxy));
+    return proxy->_setRequestHandler(handler->connect(proxy));
 }
 
 void

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #ifndef ICE_REQUEST_HANDLER_FACTORY_H
 #define ICE_REQUEST_HANDLER_FACTORY_H
@@ -28,7 +23,7 @@ public:
 
     RequestHandlerFactory(const InstancePtr&);
 
-    RequestHandlerPtr getRequestHandler(const RoutableReferencePtr&, const Ice::ObjectPrx&);
+    RequestHandlerPtr getRequestHandler(const RoutableReferencePtr&, const Ice::ObjectPrxPtr&);
     void removeRequestHandler(const ReferencePtr&, const RequestHandlerPtr&);
 
 private:

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

@@ -1,20 +1,12 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #include <Ice/ResponseHandler.h>
 
 using namespace std;
 using namespace IceInternal;
 
+#ifndef ICE_CPP11_MAPPING
 IceUtil::Shared* IceInternal::upCast(ResponseHandler* obj) { return obj; }
-
-ResponseHandler::~ResponseHandler()
-{
-}
-
+#endif

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #ifndef ICE_RESPONSE_HANDLER_H
 #define ICE_RESPONSE_HANDLER_H
@@ -16,19 +11,28 @@
 #include <Ice/Config.h>
 #include <Ice/LocalException.h>
 #include <Ice/ResponseHandlerF.h>
+#include <Ice/VirtualShared.h>
 
-namespace IceInternal
+namespace Ice
 {
 
-class BasicStream;
+class OutputStream;
 
-class ResponseHandler : virtual public ::IceUtil::Shared
+}
+
+namespace IceInternal
 {
-public:
 
-    virtual ~ResponseHandler();
+class ResponseHandler :
+#ifdef ICE_CPP11_MAPPING
+        public EnableSharedFromThis<ResponseHandler>
+#else
+        public virtual IceUtil::Shared
+#endif
+{
+public:
 
-    virtual void sendResponse(Ice::Int, BasicStream*, Ice::Byte, bool) = 0;
+    virtual void sendResponse(Ice::Int, Ice::OutputStream*, Ice::Byte, bool) = 0;
     virtual void sendNoResponse() = 0;
     virtual bool systemException(Ice::Int, const Ice::SystemException&, bool) = 0;
     virtual void invokeException(Ice::Int, const Ice::LocalException&, int, bool) = 0;

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #include <Ice/RetryQueue.h>
 #include <Ice/OutgoingAsync.h>
@@ -40,28 +35,22 @@ IceInternal::RetryTask::runTimerTask()
     // (we still need the client thread pool at this point to call
     // exception callbacks with CommunicatorDestroyedException).
     //
-    _queue->remove(this);
+    _queue->remove(ICE_SHARED_FROM_THIS);
 }
 
 void
-IceInternal::RetryTask::requestCanceled(OutgoingBase*, const Ice::LocalException&)
+IceInternal::RetryTask::asyncRequestCanceled(const OutgoingAsyncBasePtr& /*outAsync*/, const Ice::LocalException& ex)
 {
-    assert(false);
-}
-
-void
-IceInternal::RetryTask::asyncRequestCanceled(const OutgoingAsyncBasePtr& outAsync, const Ice::LocalException& ex)
-{
-    if(_queue->cancel(this))
+    if(_queue->cancel(ICE_SHARED_FROM_THIS))
     {
         if(_instance->traceLevels()->retry >= 1)
         {
             Trace out(_instance->initializationData().logger, _instance->traceLevels()->retryCat);
             out << "operation retry canceled\n" << ex;
         }
-        if(_outAsync->completed(ex))
+        if(_outAsync->exception(ex))
         {
-            _outAsync->invokeCompletedAsync();
+            _outAsync->invokeExceptionAsync();
         }
     }
 }
@@ -97,7 +86,7 @@ IceInternal::RetryQueue::add(const ProxyOutgoingAsyncBasePtr& out, int interval)
     {
         throw CommunicatorDestroyedException(__FILE__, __LINE__);
     }
-    RetryTaskPtr task = new RetryTask(_instance, this, out);
+    RetryTaskPtr task = ICE_MAKE_SHARED(RetryTask, _instance, this, out);
     out->cancelable(task); // This will throw if the request is canceled.
     try
     {
@@ -155,11 +144,14 @@ IceInternal::RetryQueue::cancel(const RetryTaskPtr& task)
     Lock sync(*this);
     if(_requests.erase(task) > 0)
     {
-        if(!_instance && _requests.empty())
+        if(_instance)
+        {
+            return _instance->timer()->cancel(task);
+        }
+        else if(_requests.empty())
         {
             notify(); // If we are destroying the queue, destroy is probably waiting on the queue to be empty.
         }
-        return _instance->timer()->cancel(task);
     }
     return false;
 }

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #ifndef ICE_RETRY_QUEUE_H
 #define ICE_RETRY_QUEUE_H
@@ -21,7 +16,11 @@
 namespace IceInternal
 {
 
-class RetryTask : public IceUtil::TimerTask, public CancellationHandler
+class RetryTask : public IceUtil::TimerTask,
+                  public CancellationHandler
+#ifdef ICE_CPP11_MAPPING
+                , public std::enable_shared_from_this<RetryTask>
+#endif
 {
 public:
 
@@ -29,21 +28,19 @@ public:
 
     virtual void runTimerTask();
 
-    virtual void requestCanceled(OutgoingBase*, const Ice::LocalException&);
     virtual void asyncRequestCanceled(const OutgoingAsyncBasePtr&, const Ice::LocalException&);
 
     void destroy();
 
     bool operator<(const RetryTask&) const;
 
-
 private:
 
     const InstancePtr _instance;
     const RetryQueuePtr _queue;
     const ProxyOutgoingAsyncBasePtr _outAsync;
 };
-typedef IceUtil::Handle<RetryTask> RetryTaskPtr;
+ICE_DEFINE_PTR(RetryTaskPtr, RetryTask);
 
 class RetryQueue : public IceUtil::Shared, public IceUtil::Monitor<IceUtil::Mutex>
 {
@@ -67,4 +64,3 @@ private:
 }
 
 #endif
-

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

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

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

@@ -1,13 +1,8 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
 //
-// **********************************************************************
-//
-// Ice version 3.6.5
+// Ice version 3.7.4
 //
 // <auto-generated>
 //
@@ -24,550 +19,634 @@
 #include <Ice/Router.h>
 #include <IceUtil/PushDisableWarnings.h>
 #include <Ice/LocalException.h>
-#include <Ice/ObjectFactory.h>
-#include <Ice/Outgoing.h>
+#include <Ice/ValueFactory.h>
 #include <Ice/OutgoingAsync.h>
-#include <Ice/BasicStream.h>
-#include <IceUtil/Iterator.h>
+#include <Ice/InputStream.h>
+#include <Ice/OutputStream.h>
 #include <IceUtil/PopDisableWarnings.h>
 
+#if defined(_MSC_VER)
+#   pragma warning(disable:4458) // declaration of ... hides class member
+#elif defined(__clang__)
+#   pragma clang diagnostic ignored "-Wshadow"
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic ignored "-Wshadow"
+#endif
+
 #ifndef ICE_IGNORE_VERSION
-#   if ICE_INT_VERSION / 100 != 306
+#   if ICE_INT_VERSION / 100 != 307
 #       error Ice version mismatch!
 #   endif
-#   if ICE_INT_VERSION % 100 > 50
+#   if ICE_INT_VERSION % 100 >= 50
 #       error Beta header file detected
 #   endif
-#   if ICE_INT_VERSION % 100 < 5
+#   if ICE_INT_VERSION % 100 < 4
 #       error Ice patch level mismatch!
 #   endif
 #endif
 
+#ifdef ICE_CPP11_MAPPING // C++11 mapping
+
 namespace
 {
 
-const ::std::string __Ice__Router__getClientProxy_name = "getClientProxy";
+const ::std::string iceC_Ice_Router_ids[2] =
+{
+    "::Ice::Object",
+    "::Ice::Router"
+};
+const ::std::string iceC_Ice_Router_ops[] =
+{
+    "addProxies",
+    "getClientProxy",
+    "getServerProxy",
+    "ice_id",
+    "ice_ids",
+    "ice_isA",
+    "ice_ping"
+};
+const ::std::string iceC_Ice_Router_getClientProxy_name = "getClientProxy";
+const ::std::string iceC_Ice_Router_getServerProxy_name = "getServerProxy";
+const ::std::string iceC_Ice_Router_addProxies_name = "addProxies";
 
-const ::std::string __Ice__Router__getServerProxy_name = "getServerProxy";
+const ::std::string iceC_Ice_RouterFinder_ids[2] =
+{
+    "::Ice::Object",
+    "::Ice::RouterFinder"
+};
+const ::std::string iceC_Ice_RouterFinder_ops[] =
+{
+    "getRouter",
+    "ice_id",
+    "ice_ids",
+    "ice_isA",
+    "ice_ping"
+};
+const ::std::string iceC_Ice_RouterFinder_getRouter_name = "getRouter";
 
-const ::std::string __Ice__Router__addProxies_name = "addProxies";
+}
 
-const ::std::string __Ice__RouterFinder__getRouter_name = "getRouter";
+bool
+Ice::Router::ice_isA(::std::string s, const Current&) const
+{
+    return ::std::binary_search(iceC_Ice_Router_ids, iceC_Ice_Router_ids + 2, s);
+}
 
+::std::vector<::std::string>
+Ice::Router::ice_ids(const Current&) const
+{
+    return ::std::vector<::std::string>(&iceC_Ice_Router_ids[0], &iceC_Ice_Router_ids[2]);
 }
-#ifdef __SUNPRO_CC
-class ICE_API IceProxy::Ice::Router;
-#endif
-ICE_API ::IceProxy::Ice::Object* ::IceProxy::Ice::upCast(::IceProxy::Ice::Router* p) { return p; }
 
-void
-::IceProxy::Ice::__read(::IceInternal::BasicStream* __is, ::IceInternal::ProxyHandle< ::IceProxy::Ice::Router>& v)
+::std::string
+Ice::Router::ice_id(const Current&) const
 {
-    ::Ice::ObjectPrx proxy;
-    __is->read(proxy);
-    if(!proxy)
-    {
-        v = 0;
-    }
-    else
-    {
-        v = new ::IceProxy::Ice::Router;
-        v->__copyFrom(proxy);
-    }
+    return ice_staticId();
 }
 
-::Ice::ObjectPrx
-IceProxy::Ice::Router::getClientProxy(const ::Ice::Context* __ctx)
+const ::std::string&
+Ice::Router::ice_staticId()
 {
-    __checkTwowayOnly(__Ice__Router__getClientProxy_name);
-    ::IceInternal::Outgoing __og(this, __Ice__Router__getClientProxy_name, ::Ice::Nonmutating, __ctx);
-    __og.writeEmptyParams();
-    if(!__og.invoke())
+    static const ::std::string typeId = "::Ice::Router";
+    return typeId;
+}
+
+/// \cond INTERNAL
+bool
+Ice::Router::_iceD_getClientProxy(::IceInternal::Incoming& inS, const Current& current) const
+{
+    _iceCheckMode(::Ice::OperationMode::Idempotent, current.mode);
+    inS.readEmptyParams();
+    Ice::optional<bool> iceP_hasRoutingTable;
+    ::std::shared_ptr<ObjectPrx> ret = this->getClientProxy(iceP_hasRoutingTable, current);
+    auto ostr = inS.startWriteParams();
+    ostr->writeAll(ret);
+    ostr->writeAll({1}, iceP_hasRoutingTable);
+    inS.endWriteParams();
+    return true;
+}
+/// \endcond
+
+/// \cond INTERNAL
+bool
+Ice::Router::_iceD_getServerProxy(::IceInternal::Incoming& inS, const Current& current) const
+{
+    _iceCheckMode(::Ice::OperationMode::Idempotent, current.mode);
+    inS.readEmptyParams();
+    ::std::shared_ptr<ObjectPrx> ret = this->getServerProxy(current);
+    auto ostr = inS.startWriteParams();
+    ostr->writeAll(ret);
+    inS.endWriteParams();
+    return true;
+}
+/// \endcond
+
+/// \cond INTERNAL
+bool
+Ice::Router::_iceD_addProxies(::IceInternal::Incoming& inS, const Current& current)
+{
+    _iceCheckMode(::Ice::OperationMode::Idempotent, current.mode);
+    auto istr = inS.startReadParams();
+    ObjectProxySeq iceP_proxies;
+    istr->readAll(iceP_proxies);
+    inS.endReadParams();
+    ObjectProxySeq ret = this->addProxies(::std::move(iceP_proxies), current);
+    auto ostr = inS.startWriteParams();
+    ostr->writeAll(ret);
+    inS.endWriteParams();
+    return true;
+}
+/// \endcond
+
+/// \cond INTERNAL
+bool
+Ice::Router::_iceDispatch(::IceInternal::Incoming& in, const Current& current)
+{
+    ::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_Ice_Router_ops, iceC_Ice_Router_ops + 7, current.operation);
+    if(r.first == r.second)
     {
-        try
+        throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
+    }
+
+    switch(r.first - iceC_Ice_Router_ops)
+    {
+        case 0:
         {
-            __og.throwUserException();
+            return _iceD_addProxies(in, current);
         }
-        catch(const ::Ice::UserException& __ex)
+        case 1:
         {
-            ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
-            throw __uue;
+            return _iceD_getClientProxy(in, current);
+        }
+        case 2:
+        {
+            return _iceD_getServerProxy(in, current);
+        }
+        case 3:
+        {
+            return _iceD_ice_id(in, current);
+        }
+        case 4:
+        {
+            return _iceD_ice_ids(in, current);
+        }
+        case 5:
+        {
+            return _iceD_ice_isA(in, current);
+        }
+        case 6:
+        {
+            return _iceD_ice_ping(in, current);
+        }
+        default:
+        {
+            assert(false);
+            throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
         }
     }
-    ::Ice::ObjectPrx __ret;
-    ::IceInternal::BasicStream* __is = __og.startReadParams();
-    __is->read(__ret);
-    __og.endReadParams();
-    return __ret;
 }
+/// \endcond
 
-::Ice::AsyncResultPtr
-IceProxy::Ice::Router::begin_getClientProxy(const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
+bool
+Ice::RouterFinder::ice_isA(::std::string s, const Current&) const
 {
-    __checkAsyncTwowayOnly(__Ice__Router__getClientProxy_name);
-    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Ice__Router__getClientProxy_name, __del, __cookie);
-    try
-    {
-        __result->prepare(__Ice__Router__getClientProxy_name, ::Ice::Nonmutating, __ctx);
-        __result->writeEmptyParams();
-        __result->invoke();
-    }
-    catch(const ::Ice::Exception& __ex)
-    {
-        __result->abort(__ex);
-    }
-    return __result;
+    return ::std::binary_search(iceC_Ice_RouterFinder_ids, iceC_Ice_RouterFinder_ids + 2, s);
 }
 
-#ifdef ICE_CPP11
+::std::vector<::std::string>
+Ice::RouterFinder::ice_ids(const Current&) const
+{
+    return ::std::vector<::std::string>(&iceC_Ice_RouterFinder_ids[0], &iceC_Ice_RouterFinder_ids[2]);
+}
 
-::Ice::AsyncResultPtr
-IceProxy::Ice::Router::__begin_getClientProxy(const ::Ice::Context* __ctx, const ::IceInternal::Function<void (const ::Ice::ObjectPrx&)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent)
+::std::string
+Ice::RouterFinder::ice_id(const Current&) const
 {
-    class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
-    {
-    public:
-
-        Cpp11CB(const ::std::function<void (const ::Ice::ObjectPrx&)>& responseFunc, const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, const ::std::function<void (bool)>& sentFunc) :
-            ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
-            _response(responseFunc)
-        {
-            CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
-        }
-
-        virtual void completed(const ::Ice::AsyncResultPtr& __result) const
-        {
-            ::Ice::RouterPrx __proxy = ::Ice::RouterPrx::uncheckedCast(__result->getProxy());
-            ::Ice::ObjectPrx __ret;
-            try
-            {
-                __ret = __proxy->end_getClientProxy(__result);
-            }
-            catch(const ::Ice::Exception& ex)
-            {
-                Cpp11FnCallbackNC::exception(__result, ex);
-                return;
-            }
-            if(_response != nullptr)
-            {
-                _response(__ret);
-            }
-        }
-    
-    private:
-        
-        ::std::function<void (const ::Ice::ObjectPrx&)> _response;
-    };
-    return begin_getClientProxy(__ctx, new Cpp11CB(__response, __exception, __sent));
+    return ice_staticId();
 }
-#endif
 
-::Ice::ObjectPrx
-IceProxy::Ice::Router::end_getClientProxy(const ::Ice::AsyncResultPtr& __result)
+const ::std::string&
+Ice::RouterFinder::ice_staticId()
 {
-    ::Ice::AsyncResult::__check(__result, this, __Ice__Router__getClientProxy_name);
-    ::Ice::ObjectPrx __ret;
-    if(!__result->__wait())
+    static const ::std::string typeId = "::Ice::RouterFinder";
+    return typeId;
+}
+
+/// \cond INTERNAL
+bool
+Ice::RouterFinder::_iceD_getRouter(::IceInternal::Incoming& inS, const Current& current)
+{
+    _iceCheckMode(::Ice::OperationMode::Normal, current.mode);
+    inS.readEmptyParams();
+    ::std::shared_ptr<RouterPrx> ret = this->getRouter(current);
+    auto ostr = inS.startWriteParams();
+    ostr->writeAll(ret);
+    inS.endWriteParams();
+    return true;
+}
+/// \endcond
+
+/// \cond INTERNAL
+bool
+Ice::RouterFinder::_iceDispatch(::IceInternal::Incoming& in, const Current& current)
+{
+    ::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_Ice_RouterFinder_ops, iceC_Ice_RouterFinder_ops + 5, current.operation);
+    if(r.first == r.second)
     {
-        try
+        throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
+    }
+
+    switch(r.first - iceC_Ice_RouterFinder_ops)
+    {
+        case 0:
         {
-            __result->__throwUserException();
+            return _iceD_getRouter(in, current);
         }
-        catch(const ::Ice::UserException& __ex)
+        case 1:
         {
-            throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
+            return _iceD_ice_id(in, current);
+        }
+        case 2:
+        {
+            return _iceD_ice_ids(in, current);
+        }
+        case 3:
+        {
+            return _iceD_ice_isA(in, current);
+        }
+        case 4:
+        {
+            return _iceD_ice_ping(in, current);
+        }
+        default:
+        {
+            assert(false);
+            throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
         }
     }
-    ::IceInternal::BasicStream* __is = __result->__startReadParams();
-    __is->read(__ret);
-    __result->__endReadParams();
-    return __ret;
 }
+/// \endcond
 
-::Ice::ObjectPrx
-IceProxy::Ice::Router::getServerProxy(const ::Ice::Context* __ctx)
+/// \cond INTERNAL
+void
+Ice::RouterPrx::_iceI_getClientProxy(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<Router::GetClientProxyResult>>& outAsync, const Context& context)
 {
-    __checkTwowayOnly(__Ice__Router__getServerProxy_name);
-    ::IceInternal::Outgoing __og(this, __Ice__Router__getServerProxy_name, ::Ice::Nonmutating, __ctx);
-    __og.writeEmptyParams();
-    if(!__og.invoke())
-    {
-        try
+    _checkTwowayOnly(iceC_Ice_Router_getClientProxy_name);
+    outAsync->invoke(iceC_Ice_Router_getClientProxy_name, ::Ice::OperationMode::Nonmutating, ::Ice::FormatType::DefaultFormat, context,
+        nullptr,
+        nullptr,
+        [](InputStream* istr)
         {
-            __og.throwUserException();
-        }
-        catch(const ::Ice::UserException& __ex)
+            Router::GetClientProxyResult v;
+            istr->readAll(v.returnValue);
+            istr->readAll({1}, v.hasRoutingTable);
+            return v;
+        });
+}
+/// \endcond
+
+/// \cond INTERNAL
+void
+Ice::RouterPrx::_iceI_getServerProxy(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::shared_ptr<::Ice::ObjectPrx>>>& outAsync, const Context& context)
+{
+    _checkTwowayOnly(iceC_Ice_Router_getServerProxy_name);
+    outAsync->invoke(iceC_Ice_Router_getServerProxy_name, ::Ice::OperationMode::Nonmutating, ::Ice::FormatType::DefaultFormat, context,
+        nullptr,
+        nullptr);
+}
+/// \endcond
+
+/// \cond INTERNAL
+void
+Ice::RouterPrx::_iceI_addProxies(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::Ice::ObjectProxySeq>>& outAsync, const ObjectProxySeq& iceP_proxies, const Context& context)
+{
+    _checkTwowayOnly(iceC_Ice_Router_addProxies_name);
+    outAsync->invoke(iceC_Ice_Router_addProxies_name, ::Ice::OperationMode::Idempotent, ::Ice::FormatType::DefaultFormat, context,
+        [&](OutputStream* ostr)
         {
-            ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
-            throw __uue;
-        }
-    }
-    ::Ice::ObjectPrx __ret;
-    ::IceInternal::BasicStream* __is = __og.startReadParams();
-    __is->read(__ret);
-    __og.endReadParams();
-    return __ret;
+            ostr->writeAll(iceP_proxies);
+        },
+        nullptr);
 }
+/// \endcond
 
-::Ice::AsyncResultPtr
-IceProxy::Ice::Router::begin_getServerProxy(const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
+/// \cond INTERNAL
+::std::shared_ptr<::Ice::ObjectPrx>
+Ice::RouterPrx::_newInstance() const
 {
-    __checkAsyncTwowayOnly(__Ice__Router__getServerProxy_name);
-    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Ice__Router__getServerProxy_name, __del, __cookie);
-    try
+    return ::IceInternal::createProxy<RouterPrx>();
+}
+/// \endcond
+
+const ::std::string&
+Ice::RouterPrx::ice_staticId()
+{
+    return Router::ice_staticId();
+}
+
+/// \cond INTERNAL
+void
+Ice::RouterFinderPrx::_iceI_getRouter(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::shared_ptr<::Ice::RouterPrx>>>& outAsync, const Context& context)
+{
+    _checkTwowayOnly(iceC_Ice_RouterFinder_getRouter_name);
+    outAsync->invoke(iceC_Ice_RouterFinder_getRouter_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::DefaultFormat, context,
+        nullptr,
+        nullptr);
+}
+/// \endcond
+
+/// \cond INTERNAL
+::std::shared_ptr<::Ice::ObjectPrx>
+Ice::RouterFinderPrx::_newInstance() const
+{
+    return ::IceInternal::createProxy<RouterFinderPrx>();
+}
+/// \endcond
+
+const ::std::string&
+Ice::RouterFinderPrx::ice_staticId()
+{
+    return RouterFinder::ice_staticId();
+}
+
+#else // C++98 mapping
+
+namespace
+{
+
+const ::std::string iceC_Ice_Router_getClientProxy_name = "getClientProxy";
+
+const ::std::string iceC_Ice_Router_getServerProxy_name = "getServerProxy";
+
+const ::std::string iceC_Ice_Router_addProxies_name = "addProxies";
+
+const ::std::string iceC_Ice_RouterFinder_getRouter_name = "getRouter";
+
+}
+
+/// \cond INTERNAL
+ICE_API ::IceProxy::Ice::Object* ::IceProxy::Ice::upCast(Router* p) { return p; }
+
+void
+::IceProxy::Ice::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< Router>& v)
+{
+    ::Ice::ObjectPrx proxy;
+    istr->read(proxy);
+    if(!proxy)
     {
-        __result->prepare(__Ice__Router__getServerProxy_name, ::Ice::Nonmutating, __ctx);
-        __result->writeEmptyParams();
-        __result->invoke();
+        v = 0;
     }
-    catch(const ::Ice::Exception& __ex)
+    else
     {
-        __result->abort(__ex);
+        v = new Router;
+        v->_copyFrom(proxy);
     }
-    return __result;
 }
-
-#ifdef ICE_CPP11
+/// \endcond
 
 ::Ice::AsyncResultPtr
-IceProxy::Ice::Router::__begin_getServerProxy(const ::Ice::Context* __ctx, const ::IceInternal::Function<void (const ::Ice::ObjectPrx&)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent)
+IceProxy::Ice::Router::_iceI_begin_getClientProxy(const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
 {
-    class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
+    _checkTwowayOnly(iceC_Ice_Router_getClientProxy_name, sync);
+    ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_Ice_Router_getClientProxy_name, del, cookie, sync);
+    try
+    {
+        result->prepare(iceC_Ice_Router_getClientProxy_name, ::Ice::Nonmutating, context);
+        result->writeEmptyParams();
+        result->invoke(iceC_Ice_Router_getClientProxy_name);
+    }
+    catch(const ::Ice::Exception& ex)
     {
-    public:
-
-        Cpp11CB(const ::std::function<void (const ::Ice::ObjectPrx&)>& responseFunc, const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, const ::std::function<void (bool)>& sentFunc) :
-            ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
-            _response(responseFunc)
-        {
-            CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
-        }
-
-        virtual void completed(const ::Ice::AsyncResultPtr& __result) const
-        {
-            ::Ice::RouterPrx __proxy = ::Ice::RouterPrx::uncheckedCast(__result->getProxy());
-            ::Ice::ObjectPrx __ret;
-            try
-            {
-                __ret = __proxy->end_getServerProxy(__result);
-            }
-            catch(const ::Ice::Exception& ex)
-            {
-                Cpp11FnCallbackNC::exception(__result, ex);
-                return;
-            }
-            if(_response != nullptr)
-            {
-                _response(__ret);
-            }
-        }
-    
-    private:
-        
-        ::std::function<void (const ::Ice::ObjectPrx&)> _response;
-    };
-    return begin_getServerProxy(__ctx, new Cpp11CB(__response, __exception, __sent));
+        result->abort(ex);
+    }
+    return result;
 }
-#endif
 
 ::Ice::ObjectPrx
-IceProxy::Ice::Router::end_getServerProxy(const ::Ice::AsyncResultPtr& __result)
+IceProxy::Ice::Router::end_getClientProxy(IceUtil::Optional<bool>& iceP_hasRoutingTable, const ::Ice::AsyncResultPtr& result)
 {
-    ::Ice::AsyncResult::__check(__result, this, __Ice__Router__getServerProxy_name);
-    ::Ice::ObjectPrx __ret;
-    if(!__result->__wait())
+    ::Ice::AsyncResult::_check(result, this, iceC_Ice_Router_getClientProxy_name);
+    ::Ice::ObjectPrx ret;
+    if(!result->_waitForResponse())
     {
         try
         {
-            __result->__throwUserException();
+            result->_throwUserException();
         }
-        catch(const ::Ice::UserException& __ex)
+        catch(const ::Ice::UserException& ex)
         {
-            throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
+            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
         }
     }
-    ::IceInternal::BasicStream* __is = __result->__startReadParams();
-    __is->read(__ret);
-    __result->__endReadParams();
-    return __ret;
+    ::Ice::InputStream* istr = result->_startReadParams();
+    istr->read(ret);
+    istr->read(1, iceP_hasRoutingTable);
+    result->_endReadParams();
+    return ret;
 }
 
-::Ice::ObjectProxySeq
-IceProxy::Ice::Router::addProxies(const ::Ice::ObjectProxySeq& __p_proxies, const ::Ice::Context* __ctx)
+void IceProxy::Ice::Router::_iceI_end_getClientProxy(IceUtil::Optional<bool>& iceP_hasRoutingTable, ::Ice::ObjectPrxPtr& ret, const ::Ice::AsyncResultPtr& result)
 {
-    __checkTwowayOnly(__Ice__Router__addProxies_name);
-    ::IceInternal::Outgoing __og(this, __Ice__Router__addProxies_name, ::Ice::Idempotent, __ctx);
-    try
-    {
-        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
-        __os->write(__p_proxies);
-        __og.endWriteParams();
-    }
-    catch(const ::Ice::LocalException& __ex)
-    {
-        __og.abort(__ex);
-    }
-    if(!__og.invoke())
+    ::Ice::AsyncResult::_check(result, this, iceC_Ice_Router_getClientProxy_name);
+    if(!result->_waitForResponse())
     {
         try
         {
-            __og.throwUserException();
+            result->_throwUserException();
         }
-        catch(const ::Ice::UserException& __ex)
+        catch(const ::Ice::UserException& ex)
         {
-            ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
-            throw __uue;
+            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
         }
     }
-    ::Ice::ObjectProxySeq __ret;
-    ::IceInternal::BasicStream* __is = __og.startReadParams();
-    __is->read(__ret);
-    __og.endReadParams();
-    return __ret;
+    ::Ice::InputStream* istr = result->_startReadParams();
+    istr->read(ret);
+    istr->read(1, iceP_hasRoutingTable);
+    result->_endReadParams();
 }
 
 ::Ice::AsyncResultPtr
-IceProxy::Ice::Router::begin_addProxies(const ::Ice::ObjectProxySeq& __p_proxies, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
+IceProxy::Ice::Router::_iceI_begin_getServerProxy(const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
 {
-    __checkAsyncTwowayOnly(__Ice__Router__addProxies_name);
-    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Ice__Router__addProxies_name, __del, __cookie);
+    _checkTwowayOnly(iceC_Ice_Router_getServerProxy_name, sync);
+    ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_Ice_Router_getServerProxy_name, del, cookie, sync);
     try
     {
-        __result->prepare(__Ice__Router__addProxies_name, ::Ice::Idempotent, __ctx);
-        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
-        __os->write(__p_proxies);
-        __result->endWriteParams();
-        __result->invoke();
+        result->prepare(iceC_Ice_Router_getServerProxy_name, ::Ice::Nonmutating, context);
+        result->writeEmptyParams();
+        result->invoke(iceC_Ice_Router_getServerProxy_name);
     }
-    catch(const ::Ice::Exception& __ex)
+    catch(const ::Ice::Exception& ex)
     {
-        __result->abort(__ex);
+        result->abort(ex);
     }
-    return __result;
+    return result;
 }
 
-#ifdef ICE_CPP11
+::Ice::ObjectPrx
+IceProxy::Ice::Router::end_getServerProxy(const ::Ice::AsyncResultPtr& result)
+{
+    ::Ice::AsyncResult::_check(result, this, iceC_Ice_Router_getServerProxy_name);
+    ::Ice::ObjectPrx ret;
+    if(!result->_waitForResponse())
+    {
+        try
+        {
+            result->_throwUserException();
+        }
+        catch(const ::Ice::UserException& ex)
+        {
+            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
+        }
+    }
+    ::Ice::InputStream* istr = result->_startReadParams();
+    istr->read(ret);
+    result->_endReadParams();
+    return ret;
+}
 
 ::Ice::AsyncResultPtr
-IceProxy::Ice::Router::__begin_addProxies(const ::Ice::ObjectProxySeq& __p_proxies, const ::Ice::Context* __ctx, const ::IceInternal::Function<void (const ::Ice::ObjectProxySeq&)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent)
+IceProxy::Ice::Router::_iceI_begin_addProxies(const ::Ice::ObjectProxySeq& iceP_proxies, const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
 {
-    class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
+    _checkTwowayOnly(iceC_Ice_Router_addProxies_name, sync);
+    ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_Ice_Router_addProxies_name, del, cookie, sync);
+    try
+    {
+        result->prepare(iceC_Ice_Router_addProxies_name, ::Ice::Idempotent, context);
+        ::Ice::OutputStream* ostr = result->startWriteParams(::Ice::DefaultFormat);
+        ostr->write(iceP_proxies);
+        result->endWriteParams();
+        result->invoke(iceC_Ice_Router_addProxies_name);
+    }
+    catch(const ::Ice::Exception& ex)
     {
-    public:
-
-        Cpp11CB(const ::std::function<void (const ::Ice::ObjectProxySeq&)>& responseFunc, const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, const ::std::function<void (bool)>& sentFunc) :
-            ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
-            _response(responseFunc)
-        {
-            CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
-        }
-
-        virtual void completed(const ::Ice::AsyncResultPtr& __result) const
-        {
-            ::Ice::RouterPrx __proxy = ::Ice::RouterPrx::uncheckedCast(__result->getProxy());
-            ::Ice::ObjectProxySeq __ret;
-            try
-            {
-                __ret = __proxy->end_addProxies(__result);
-            }
-            catch(const ::Ice::Exception& ex)
-            {
-                Cpp11FnCallbackNC::exception(__result, ex);
-                return;
-            }
-            if(_response != nullptr)
-            {
-                _response(__ret);
-            }
-        }
-    
-    private:
-        
-        ::std::function<void (const ::Ice::ObjectProxySeq&)> _response;
-    };
-    return begin_addProxies(__p_proxies, __ctx, new Cpp11CB(__response, __exception, __sent));
+        result->abort(ex);
+    }
+    return result;
 }
-#endif
 
 ::Ice::ObjectProxySeq
-IceProxy::Ice::Router::end_addProxies(const ::Ice::AsyncResultPtr& __result)
+IceProxy::Ice::Router::end_addProxies(const ::Ice::AsyncResultPtr& result)
 {
-    ::Ice::AsyncResult::__check(__result, this, __Ice__Router__addProxies_name);
-    ::Ice::ObjectProxySeq __ret;
-    if(!__result->__wait())
+    ::Ice::AsyncResult::_check(result, this, iceC_Ice_Router_addProxies_name);
+    ::Ice::ObjectProxySeq ret;
+    if(!result->_waitForResponse())
     {
         try
         {
-            __result->__throwUserException();
+            result->_throwUserException();
         }
-        catch(const ::Ice::UserException& __ex)
+        catch(const ::Ice::UserException& ex)
         {
-            throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
+            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
         }
     }
-    ::IceInternal::BasicStream* __is = __result->__startReadParams();
-    __is->read(__ret);
-    __result->__endReadParams();
-    return __ret;
+    ::Ice::InputStream* istr = result->_startReadParams();
+    istr->read(ret);
+    result->_endReadParams();
+    return ret;
 }
 
+/// \cond INTERNAL
+::IceProxy::Ice::Object*
+IceProxy::Ice::Router::_newInstance() const
+{
+    return new Router;
+}
+/// \endcond
+
 const ::std::string&
 IceProxy::Ice::Router::ice_staticId()
 {
     return ::Ice::Router::ice_staticId();
 }
 
-::IceProxy::Ice::Object*
-IceProxy::Ice::Router::__newInstance() const
-{
-    return new Router;
-}
-#ifdef __SUNPRO_CC
-class ICE_API IceProxy::Ice::RouterFinder;
-#endif
-ICE_API ::IceProxy::Ice::Object* ::IceProxy::Ice::upCast(::IceProxy::Ice::RouterFinder* p) { return p; }
+/// \cond INTERNAL
+ICE_API ::IceProxy::Ice::Object* ::IceProxy::Ice::upCast(RouterFinder* p) { return p; }
 
 void
-::IceProxy::Ice::__read(::IceInternal::BasicStream* __is, ::IceInternal::ProxyHandle< ::IceProxy::Ice::RouterFinder>& v)
+::IceProxy::Ice::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< RouterFinder>& v)
 {
     ::Ice::ObjectPrx proxy;
-    __is->read(proxy);
+    istr->read(proxy);
     if(!proxy)
     {
         v = 0;
     }
     else
     {
-        v = new ::IceProxy::Ice::RouterFinder;
-        v->__copyFrom(proxy);
+        v = new RouterFinder;
+        v->_copyFrom(proxy);
     }
 }
-
-::Ice::RouterPrx
-IceProxy::Ice::RouterFinder::getRouter(const ::Ice::Context* __ctx)
-{
-    __checkTwowayOnly(__Ice__RouterFinder__getRouter_name);
-    ::IceInternal::Outgoing __og(this, __Ice__RouterFinder__getRouter_name, ::Ice::Normal, __ctx);
-    __og.writeEmptyParams();
-    if(!__og.invoke())
-    {
-        try
-        {
-            __og.throwUserException();
-        }
-        catch(const ::Ice::UserException& __ex)
-        {
-            ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
-            throw __uue;
-        }
-    }
-    ::Ice::RouterPrx __ret;
-    ::IceInternal::BasicStream* __is = __og.startReadParams();
-    __is->read(__ret);
-    __og.endReadParams();
-    return __ret;
-}
+/// \endcond
 
 ::Ice::AsyncResultPtr
-IceProxy::Ice::RouterFinder::begin_getRouter(const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
+IceProxy::Ice::RouterFinder::_iceI_begin_getRouter(const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
 {
-    __checkAsyncTwowayOnly(__Ice__RouterFinder__getRouter_name);
-    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Ice__RouterFinder__getRouter_name, __del, __cookie);
+    _checkTwowayOnly(iceC_Ice_RouterFinder_getRouter_name, sync);
+    ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_Ice_RouterFinder_getRouter_name, del, cookie, sync);
     try
     {
-        __result->prepare(__Ice__RouterFinder__getRouter_name, ::Ice::Normal, __ctx);
-        __result->writeEmptyParams();
-        __result->invoke();
+        result->prepare(iceC_Ice_RouterFinder_getRouter_name, ::Ice::Normal, context);
+        result->writeEmptyParams();
+        result->invoke(iceC_Ice_RouterFinder_getRouter_name);
     }
-    catch(const ::Ice::Exception& __ex)
+    catch(const ::Ice::Exception& ex)
     {
-        __result->abort(__ex);
+        result->abort(ex);
     }
-    return __result;
-}
-
-#ifdef ICE_CPP11
-
-::Ice::AsyncResultPtr
-IceProxy::Ice::RouterFinder::__begin_getRouter(const ::Ice::Context* __ctx, const ::IceInternal::Function<void (const ::Ice::RouterPrx&)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent)
-{
-    class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
-    {
-    public:
-
-        Cpp11CB(const ::std::function<void (const ::Ice::RouterPrx&)>& responseFunc, const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, const ::std::function<void (bool)>& sentFunc) :
-            ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
-            _response(responseFunc)
-        {
-            CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
-        }
-
-        virtual void completed(const ::Ice::AsyncResultPtr& __result) const
-        {
-            ::Ice::RouterFinderPrx __proxy = ::Ice::RouterFinderPrx::uncheckedCast(__result->getProxy());
-            ::Ice::RouterPrx __ret;
-            try
-            {
-                __ret = __proxy->end_getRouter(__result);
-            }
-            catch(const ::Ice::Exception& ex)
-            {
-                Cpp11FnCallbackNC::exception(__result, ex);
-                return;
-            }
-            if(_response != nullptr)
-            {
-                _response(__ret);
-            }
-        }
-    
-    private:
-        
-        ::std::function<void (const ::Ice::RouterPrx&)> _response;
-    };
-    return begin_getRouter(__ctx, new Cpp11CB(__response, __exception, __sent));
+    return result;
 }
-#endif
 
 ::Ice::RouterPrx
-IceProxy::Ice::RouterFinder::end_getRouter(const ::Ice::AsyncResultPtr& __result)
+IceProxy::Ice::RouterFinder::end_getRouter(const ::Ice::AsyncResultPtr& result)
 {
-    ::Ice::AsyncResult::__check(__result, this, __Ice__RouterFinder__getRouter_name);
-    ::Ice::RouterPrx __ret;
-    if(!__result->__wait())
+    ::Ice::AsyncResult::_check(result, this, iceC_Ice_RouterFinder_getRouter_name);
+    ::Ice::RouterPrx ret;
+    if(!result->_waitForResponse())
     {
         try
         {
-            __result->__throwUserException();
+            result->_throwUserException();
         }
-        catch(const ::Ice::UserException& __ex)
+        catch(const ::Ice::UserException& ex)
         {
-            throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
+            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
         }
     }
-    ::IceInternal::BasicStream* __is = __result->__startReadParams();
-    __is->read(__ret);
-    __result->__endReadParams();
-    return __ret;
+    ::Ice::InputStream* istr = result->_startReadParams();
+    istr->read(ret);
+    result->_endReadParams();
+    return ret;
 }
 
+/// \cond INTERNAL
+::IceProxy::Ice::Object*
+IceProxy::Ice::RouterFinder::_newInstance() const
+{
+    return new RouterFinder;
+}
+/// \endcond
+
 const ::std::string&
 IceProxy::Ice::RouterFinder::ice_staticId()
 {
     return ::Ice::RouterFinder::ice_staticId();
 }
 
-::IceProxy::Ice::Object*
-IceProxy::Ice::RouterFinder::__newInstance() const
+Ice::Router::~Router()
 {
-    return new RouterFinder;
 }
 
-ICE_API ::Ice::Object* Ice::upCast(::Ice::Router* p) { return p; }
+/// \cond INTERNAL
+ICE_API ::Ice::Object* Ice::upCast(Router* p) { return p; }
+
+/// \endcond
 
 namespace
 {
-const ::std::string __Ice__Router_ids[2] =
+const ::std::string iceC_Ice_Router_ids[2] =
 {
     "::Ice::Object",
     "::Ice::Router"
@@ -576,21 +655,21 @@ const ::std::string __Ice__Router_ids[2] =
 }
 
 bool
-Ice::Router::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
+Ice::Router::ice_isA(const ::std::string& s, const Current&) const
 {
-    return ::std::binary_search(__Ice__Router_ids, __Ice__Router_ids + 2, _s);
+    return ::std::binary_search(iceC_Ice_Router_ids, iceC_Ice_Router_ids + 2, s);
 }
 
 ::std::vector< ::std::string>
-Ice::Router::ice_ids(const ::Ice::Current&) const
+Ice::Router::ice_ids(const Current&) const
 {
-    return ::std::vector< ::std::string>(&__Ice__Router_ids[0], &__Ice__Router_ids[2]);
+    return ::std::vector< ::std::string>(&iceC_Ice_Router_ids[0], &iceC_Ice_Router_ids[2]);
 }
 
 const ::std::string&
-Ice::Router::ice_id(const ::Ice::Current&) const
+Ice::Router::ice_id(const Current&) const
 {
-    return __Ice__Router_ids[1];
+    return ice_staticId();
 }
 
 const ::std::string&
@@ -600,52 +679,60 @@ Ice::Router::ice_staticId()
     static const ::std::string typeId = "::Ice::Router";
     return typeId;
 #else
-    return __Ice__Router_ids[1];
+    return iceC_Ice_Router_ids[1];
 #endif
 }
 
-::Ice::DispatchStatus
-Ice::Router::___getClientProxy(::IceInternal::Incoming& __inS, const ::Ice::Current& __current) const
+/// \cond INTERNAL
+bool
+Ice::Router::_iceD_getClientProxy(::IceInternal::Incoming& inS, const Current& current) const
 {
-    __checkMode(::Ice::Idempotent, __current.mode);
-    __inS.readEmptyParams();
-    ::Ice::ObjectPrx __ret = getClientProxy(__current);
-    ::IceInternal::BasicStream* __os = __inS.__startWriteParams(::Ice::DefaultFormat);
-    __os->write(__ret);
-    __inS.__endWriteParams(true);
-    return ::Ice::DispatchOK;
+    _iceCheckMode(::Ice::Idempotent, current.mode);
+    inS.readEmptyParams();
+    IceUtil::Optional<bool> iceP_hasRoutingTable;
+    ObjectPrx ret = this->getClientProxy(iceP_hasRoutingTable, current);
+    OutputStream* ostr = inS.startWriteParams();
+    ostr->write(ret);
+    ostr->write(1, iceP_hasRoutingTable);
+    inS.endWriteParams();
+    return true;
 }
+/// \endcond
 
-::Ice::DispatchStatus
-Ice::Router::___getServerProxy(::IceInternal::Incoming& __inS, const ::Ice::Current& __current) const
+/// \cond INTERNAL
+bool
+Ice::Router::_iceD_getServerProxy(::IceInternal::Incoming& inS, const Current& current) const
 {
-    __checkMode(::Ice::Idempotent, __current.mode);
-    __inS.readEmptyParams();
-    ::Ice::ObjectPrx __ret = getServerProxy(__current);
-    ::IceInternal::BasicStream* __os = __inS.__startWriteParams(::Ice::DefaultFormat);
-    __os->write(__ret);
-    __inS.__endWriteParams(true);
-    return ::Ice::DispatchOK;
+    _iceCheckMode(::Ice::Idempotent, current.mode);
+    inS.readEmptyParams();
+    ObjectPrx ret = this->getServerProxy(current);
+    OutputStream* ostr = inS.startWriteParams();
+    ostr->write(ret);
+    inS.endWriteParams();
+    return true;
 }
+/// \endcond
 
-::Ice::DispatchStatus
-Ice::Router::___addProxies(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
+/// \cond INTERNAL
+bool
+Ice::Router::_iceD_addProxies(::IceInternal::Incoming& inS, const Current& current)
 {
-    __checkMode(::Ice::Idempotent, __current.mode);
-    ::IceInternal::BasicStream* __is = __inS.startReadParams();
-    ::Ice::ObjectProxySeq __p_proxies;
-    __is->read(__p_proxies);
-    __inS.endReadParams();
-    ::Ice::ObjectProxySeq __ret = addProxies(__p_proxies, __current);
-    ::IceInternal::BasicStream* __os = __inS.__startWriteParams(::Ice::DefaultFormat);
-    __os->write(__ret);
-    __inS.__endWriteParams(true);
-    return ::Ice::DispatchOK;
+    _iceCheckMode(::Ice::Idempotent, current.mode);
+    InputStream* istr = inS.startReadParams();
+    ObjectProxySeq iceP_proxies;
+    istr->read(iceP_proxies);
+    inS.endReadParams();
+    ObjectProxySeq ret = this->addProxies(iceP_proxies, current);
+    OutputStream* ostr = inS.startWriteParams();
+    ostr->write(ret);
+    inS.endWriteParams();
+    return true;
 }
+/// \endcond
 
 namespace
 {
-const ::std::string __Ice__Router_all[] =
+const ::std::string iceC_Ice_Router_all[] =
 {
     "addProxies",
     "getClientProxy",
@@ -658,80 +745,97 @@ const ::std::string __Ice__Router_all[] =
 
 }
 
-::Ice::DispatchStatus
-Ice::Router::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
+/// \cond INTERNAL
+bool
+Ice::Router::_iceDispatch(::IceInternal::Incoming& in, const Current& current)
 {
-    ::std::pair< const ::std::string*, const ::std::string*> r = ::std::equal_range(__Ice__Router_all, __Ice__Router_all + 7, current.operation);
+    ::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_Ice_Router_all, iceC_Ice_Router_all + 7, current.operation);
     if(r.first == r.second)
     {
-        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
+        throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
     }
 
-    switch(r.first - __Ice__Router_all)
+    switch(r.first - iceC_Ice_Router_all)
     {
         case 0:
         {
-            return ___addProxies(in, current);
+            return _iceD_addProxies(in, current);
         }
         case 1:
         {
-            return ___getClientProxy(in, current);
+            return _iceD_getClientProxy(in, current);
         }
         case 2:
         {
-            return ___getServerProxy(in, current);
+            return _iceD_getServerProxy(in, current);
         }
         case 3:
         {
-            return ___ice_id(in, current);
+            return _iceD_ice_id(in, current);
         }
         case 4:
         {
-            return ___ice_ids(in, current);
+            return _iceD_ice_ids(in, current);
         }
         case 5:
         {
-            return ___ice_isA(in, current);
+            return _iceD_ice_isA(in, current);
         }
         case 6:
         {
-            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 ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
 }
+/// \endcond
 
+/// \cond STREAM
 void
-Ice::Router::__writeImpl(::IceInternal::BasicStream* __os) const
+Ice::Router::_iceWriteImpl(OutputStream* ostr) const
 {
-    __os->startWriteSlice(ice_staticId(), -1, true);
-    __os->endWriteSlice();
+    ostr->startSlice(ice_staticId(), -1, true);
+    StreamWriter< Router, OutputStream>::write(ostr, *this);
+    ostr->endSlice();
 }
 
 void
-Ice::Router::__readImpl(::IceInternal::BasicStream* __is)
+Ice::Router::_iceReadImpl(InputStream* istr)
 {
-    __is->startReadSlice();
-    __is->endReadSlice();
+    istr->startSlice();
+    StreamReader< Router, InputStream>::read(istr, *this);
+    istr->endSlice();
 }
+/// \endcond
 
-void ICE_API 
-Ice::__patch(RouterPtr& handle, const ::Ice::ObjectPtr& v)
+/// \cond INTERNAL
+void
+Ice::_icePatchObjectPtr(RouterPtr& handle, const ObjectPtr& v)
 {
-    handle = ::Ice::RouterPtr::dynamicCast(v);
+    handle = RouterPtr::dynamicCast(v);
     if(v && !handle)
     {
-        IceInternal::Ex::throwUOE(::Ice::Router::ice_staticId(), v);
+        IceInternal::Ex::throwUOE(Router::ice_staticId(), v);
     }
 }
+/// \endcond
+
+Ice::RouterFinder::~RouterFinder()
+{
+}
 
-ICE_API ::Ice::Object* Ice::upCast(::Ice::RouterFinder* p) { return p; }
+/// \cond INTERNAL
+ICE_API ::Ice::Object* Ice::upCast(RouterFinder* p) { return p; }
+
+/// \endcond
 
 namespace
 {
-const ::std::string __Ice__RouterFinder_ids[2] =
+const ::std::string iceC_Ice_RouterFinder_ids[2] =
 {
     "::Ice::Object",
     "::Ice::RouterFinder"
@@ -740,21 +844,21 @@ const ::std::string __Ice__RouterFinder_ids[2] =
 }
 
 bool
-Ice::RouterFinder::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
+Ice::RouterFinder::ice_isA(const ::std::string& s, const Current&) const
 {
-    return ::std::binary_search(__Ice__RouterFinder_ids, __Ice__RouterFinder_ids + 2, _s);
+    return ::std::binary_search(iceC_Ice_RouterFinder_ids, iceC_Ice_RouterFinder_ids + 2, s);
 }
 
 ::std::vector< ::std::string>
-Ice::RouterFinder::ice_ids(const ::Ice::Current&) const
+Ice::RouterFinder::ice_ids(const Current&) const
 {
-    return ::std::vector< ::std::string>(&__Ice__RouterFinder_ids[0], &__Ice__RouterFinder_ids[2]);
+    return ::std::vector< ::std::string>(&iceC_Ice_RouterFinder_ids[0], &iceC_Ice_RouterFinder_ids[2]);
 }
 
 const ::std::string&
-Ice::RouterFinder::ice_id(const ::Ice::Current&) const
+Ice::RouterFinder::ice_id(const Current&) const
 {
-    return __Ice__RouterFinder_ids[1];
+    return ice_staticId();
 }
 
 const ::std::string&
@@ -764,25 +868,27 @@ Ice::RouterFinder::ice_staticId()
     static const ::std::string typeId = "::Ice::RouterFinder";
     return typeId;
 #else
-    return __Ice__RouterFinder_ids[1];
+    return iceC_Ice_RouterFinder_ids[1];
 #endif
 }
 
-::Ice::DispatchStatus
-Ice::RouterFinder::___getRouter(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
+/// \cond INTERNAL
+bool
+Ice::RouterFinder::_iceD_getRouter(::IceInternal::Incoming& inS, const Current& current)
 {
-    __checkMode(::Ice::Normal, __current.mode);
-    __inS.readEmptyParams();
-    ::Ice::RouterPrx __ret = getRouter(__current);
-    ::IceInternal::BasicStream* __os = __inS.__startWriteParams(::Ice::DefaultFormat);
-    __os->write(__ret);
-    __inS.__endWriteParams(true);
-    return ::Ice::DispatchOK;
+    _iceCheckMode(::Ice::Normal, current.mode);
+    inS.readEmptyParams();
+    RouterPrx ret = this->getRouter(current);
+    OutputStream* ostr = inS.startWriteParams();
+    ostr->write(ret);
+    inS.endWriteParams();
+    return true;
 }
+/// \endcond
 
 namespace
 {
-const ::std::string __Ice__RouterFinder_all[] =
+const ::std::string iceC_Ice_RouterFinder_all[] =
 {
     "getRouter",
     "ice_id",
@@ -793,63 +899,79 @@ const ::std::string __Ice__RouterFinder_all[] =
 
 }
 
-::Ice::DispatchStatus
-Ice::RouterFinder::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
+/// \cond INTERNAL
+bool
+Ice::RouterFinder::_iceDispatch(::IceInternal::Incoming& in, const Current& current)
 {
-    ::std::pair< const ::std::string*, const ::std::string*> r = ::std::equal_range(__Ice__RouterFinder_all, __Ice__RouterFinder_all + 5, current.operation);
+    ::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_Ice_RouterFinder_all, iceC_Ice_RouterFinder_all + 5, current.operation);
     if(r.first == r.second)
     {
-        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
+        throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
     }
 
-    switch(r.first - __Ice__RouterFinder_all)
+    switch(r.first - iceC_Ice_RouterFinder_all)
     {
         case 0:
         {
-            return ___getRouter(in, current);
+            return _iceD_getRouter(in, current);
         }
         case 1:
         {
-            return ___ice_id(in, current);
+            return _iceD_ice_id(in, current);
         }
         case 2:
         {
-            return ___ice_ids(in, current);
+            return _iceD_ice_ids(in, current);
         }
         case 3:
         {
-            return ___ice_isA(in, current);
+            return _iceD_ice_isA(in, current);
         }
         case 4:
         {
-            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 ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
 }
+/// \endcond
 
+/// \cond STREAM
 void
-Ice::RouterFinder::__writeImpl(::IceInternal::BasicStream* __os) const
+Ice::RouterFinder::_iceWriteImpl(OutputStream* ostr) const
 {
-    __os->startWriteSlice(ice_staticId(), -1, true);
-    __os->endWriteSlice();
+    ostr->startSlice(ice_staticId(), -1, true);
+    StreamWriter< RouterFinder, OutputStream>::write(ostr, *this);
+    ostr->endSlice();
 }
 
 void
-Ice::RouterFinder::__readImpl(::IceInternal::BasicStream* __is)
+Ice::RouterFinder::_iceReadImpl(InputStream* istr)
 {
-    __is->startReadSlice();
-    __is->endReadSlice();
+    istr->startSlice();
+    StreamReader< RouterFinder, InputStream>::read(istr, *this);
+    istr->endSlice();
 }
+/// \endcond
 
-void ICE_API 
-Ice::__patch(RouterFinderPtr& handle, const ::Ice::ObjectPtr& v)
+/// \cond INTERNAL
+void
+Ice::_icePatchObjectPtr(RouterFinderPtr& handle, const ObjectPtr& v)
 {
-    handle = ::Ice::RouterFinderPtr::dynamicCast(v);
+    handle = RouterFinderPtr::dynamicCast(v);
     if(v && !handle)
     {
-        IceInternal::Ex::throwUOE(::Ice::RouterFinder::ice_staticId(), v);
+        IceInternal::Ex::throwUOE(RouterFinder::ice_staticId(), v);
     }
 }
+/// \endcond
+
+namespace Ice
+{
+}
+
+#endif