zeroc-ice 3.7.0 → 3.7.1

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2018 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/Locator.cpp

@@ -1,13 +1,13 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2018 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.7.0
+// Ice version 3.7.1
 //
 // <auto-generated>
 //
@@ -46,7 +46,7 @@
 #   if ICE_INT_VERSION % 100 > 50
 #       error Beta header file detected
 #   endif
-#   if ICE_INT_VERSION % 100 < 0
+#   if ICE_INT_VERSION % 100 < 1
 #       error Ice patch level mismatch!
 #   endif
 #endif
@@ -177,19 +177,19 @@ Ice::ServerNotFoundException::ice_staticId()
 }
 
 bool
-Ice::Locator::ice_isA(::std::string s, const ::Ice::Current&) const
+Ice::Locator::ice_isA(::std::string s, const Current&) const
 {
     return ::std::binary_search(iceC_Ice_Locator_ids, iceC_Ice_Locator_ids + 2, s);
 }
 
 ::std::vector<::std::string>
-Ice::Locator::ice_ids(const ::Ice::Current&) const
+Ice::Locator::ice_ids(const Current&) const
 {
     return ::std::vector<::std::string>(&iceC_Ice_Locator_ids[0], &iceC_Ice_Locator_ids[2]);
 }
 
 ::std::string
-Ice::Locator::ice_id(const ::Ice::Current&) const
+Ice::Locator::ice_id(const Current&) const
 {
     return ice_staticId();
 }
@@ -201,16 +201,17 @@ Ice::Locator::ice_staticId()
     return typeId;
 }
 
+/// \cond INTERNAL
 bool
-Ice::Locator::_iceD_findObjectById(::IceInternal::Incoming& inS, const ::Ice::Current& current) const
+Ice::Locator::_iceD_findObjectById(::IceInternal::Incoming& inS, const Current& current) const
 {
-    _iceCheckMode(::Ice::OperationMode::Idempotent, current.mode);
+    _iceCheckMode(OperationMode::Idempotent, current.mode);
     auto istr = inS.startReadParams();
-    ::Ice::Identity iceP_id;
+    Identity iceP_id;
     istr->readAll(iceP_id);
     inS.endReadParams();
     auto inA = ::IceInternal::IncomingAsync::create(inS);
-    auto responseCB = [inA](const ::std::shared_ptr<::Ice::ObjectPrx>& ret)
+    auto responseCB = [inA](const ::std::shared_ptr<ObjectPrx>& ret)
     {
         auto ostr = inA->startWriteParams();
         ostr->writeAll(ret);
@@ -220,17 +221,19 @@ Ice::Locator::_iceD_findObjectById(::IceInternal::Incoming& inS, const ::Ice::Cu
     this->findObjectByIdAsync(::std::move(iceP_id), responseCB, inA->exception(), current);
     return false;
 }
+/// \endcond
 
+/// \cond INTERNAL
 bool
-Ice::Locator::_iceD_findAdapterById(::IceInternal::Incoming& inS, const ::Ice::Current& current) const
+Ice::Locator::_iceD_findAdapterById(::IceInternal::Incoming& inS, const Current& current) const
 {
-    _iceCheckMode(::Ice::OperationMode::Idempotent, current.mode);
+    _iceCheckMode(OperationMode::Idempotent, current.mode);
     auto istr = inS.startReadParams();
     ::std::string iceP_id;
     istr->readAll(iceP_id);
     inS.endReadParams();
     auto inA = ::IceInternal::IncomingAsync::create(inS);
-    auto responseCB = [inA](const ::std::shared_ptr<::Ice::ObjectPrx>& ret)
+    auto responseCB = [inA](const ::std::shared_ptr<ObjectPrx>& ret)
     {
         auto ostr = inA->startWriteParams();
         ostr->writeAll(ret);
@@ -240,26 +243,30 @@ Ice::Locator::_iceD_findAdapterById(::IceInternal::Incoming& inS, const ::Ice::C
     this->findAdapterByIdAsync(::std::move(iceP_id), responseCB, inA->exception(), current);
     return false;
 }
+/// \endcond
 
+/// \cond INTERNAL
 bool
-Ice::Locator::_iceD_getRegistry(::IceInternal::Incoming& inS, const ::Ice::Current& current) const
+Ice::Locator::_iceD_getRegistry(::IceInternal::Incoming& inS, const Current& current) const
 {
-    _iceCheckMode(::Ice::OperationMode::Idempotent, current.mode);
+    _iceCheckMode(OperationMode::Idempotent, current.mode);
     inS.readEmptyParams();
-    ::std::shared_ptr<::Ice::LocatorRegistryPrx> ret = this->getRegistry(current);
+    ::std::shared_ptr<LocatorRegistryPrx> ret = this->getRegistry(current);
     auto ostr = inS.startWriteParams();
     ostr->writeAll(ret);
     inS.endWriteParams();
     return true;
 }
+/// \endcond
 
+/// \cond INTERNAL
 bool
-Ice::Locator::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
+Ice::Locator::_iceDispatch(::IceInternal::Incoming& in, const Current& current)
 {
     ::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_Ice_Locator_ops, iceC_Ice_Locator_ops + 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 - iceC_Ice_Locator_ops)
@@ -295,25 +302,26 @@ Ice::Locator::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& cu
         default:
         {
             assert(false);
-            throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
+            throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
         }
     }
 }
+/// \endcond
 
 bool
-Ice::LocatorRegistry::ice_isA(::std::string s, const ::Ice::Current&) const
+Ice::LocatorRegistry::ice_isA(::std::string s, const Current&) const
 {
     return ::std::binary_search(iceC_Ice_LocatorRegistry_ids, iceC_Ice_LocatorRegistry_ids + 2, s);
 }
 
 ::std::vector<::std::string>
-Ice::LocatorRegistry::ice_ids(const ::Ice::Current&) const
+Ice::LocatorRegistry::ice_ids(const Current&) const
 {
     return ::std::vector<::std::string>(&iceC_Ice_LocatorRegistry_ids[0], &iceC_Ice_LocatorRegistry_ids[2]);
 }
 
 ::std::string
-Ice::LocatorRegistry::ice_id(const ::Ice::Current&) const
+Ice::LocatorRegistry::ice_id(const Current&) const
 {
     return ice_staticId();
 }
@@ -325,56 +333,63 @@ Ice::LocatorRegistry::ice_staticId()
     return typeId;
 }
 
+/// \cond INTERNAL
 bool
-Ice::LocatorRegistry::_iceD_setAdapterDirectProxy(::IceInternal::Incoming& inS, const ::Ice::Current& current)
+Ice::LocatorRegistry::_iceD_setAdapterDirectProxy(::IceInternal::Incoming& inS, const Current& current)
 {
-    _iceCheckMode(::Ice::OperationMode::Idempotent, current.mode);
+    _iceCheckMode(OperationMode::Idempotent, current.mode);
     auto istr = inS.startReadParams();
     ::std::string iceP_id;
-    ::std::shared_ptr<::Ice::ObjectPrx> iceP_proxy;
+    ::std::shared_ptr<ObjectPrx> iceP_proxy;
     istr->readAll(iceP_id, iceP_proxy);
     inS.endReadParams();
     auto inA = ::IceInternal::IncomingAsync::create(inS);
     this->setAdapterDirectProxyAsync(::std::move(iceP_id), ::std::move(iceP_proxy), inA->response(), inA->exception(), current);
     return false;
 }
+/// \endcond
 
+/// \cond INTERNAL
 bool
-Ice::LocatorRegistry::_iceD_setReplicatedAdapterDirectProxy(::IceInternal::Incoming& inS, const ::Ice::Current& current)
+Ice::LocatorRegistry::_iceD_setReplicatedAdapterDirectProxy(::IceInternal::Incoming& inS, const Current& current)
 {
-    _iceCheckMode(::Ice::OperationMode::Idempotent, current.mode);
+    _iceCheckMode(OperationMode::Idempotent, current.mode);
     auto istr = inS.startReadParams();
     ::std::string iceP_adapterId;
     ::std::string iceP_replicaGroupId;
-    ::std::shared_ptr<::Ice::ObjectPrx> iceP_p;
+    ::std::shared_ptr<ObjectPrx> iceP_p;
     istr->readAll(iceP_adapterId, iceP_replicaGroupId, iceP_p);
     inS.endReadParams();
     auto inA = ::IceInternal::IncomingAsync::create(inS);
     this->setReplicatedAdapterDirectProxyAsync(::std::move(iceP_adapterId), ::std::move(iceP_replicaGroupId), ::std::move(iceP_p), inA->response(), inA->exception(), current);
     return false;
 }
+/// \endcond
 
+/// \cond INTERNAL
 bool
-Ice::LocatorRegistry::_iceD_setServerProcessProxy(::IceInternal::Incoming& inS, const ::Ice::Current& current)
+Ice::LocatorRegistry::_iceD_setServerProcessProxy(::IceInternal::Incoming& inS, const Current& current)
 {
-    _iceCheckMode(::Ice::OperationMode::Idempotent, current.mode);
+    _iceCheckMode(OperationMode::Idempotent, current.mode);
     auto istr = inS.startReadParams();
     ::std::string iceP_id;
-    ::std::shared_ptr<::Ice::ProcessPrx> iceP_proxy;
+    ::std::shared_ptr<ProcessPrx> iceP_proxy;
     istr->readAll(iceP_id, iceP_proxy);
     inS.endReadParams();
     auto inA = ::IceInternal::IncomingAsync::create(inS);
     this->setServerProcessProxyAsync(::std::move(iceP_id), ::std::move(iceP_proxy), inA->response(), inA->exception(), current);
     return false;
 }
+/// \endcond
 
+/// \cond INTERNAL
 bool
-Ice::LocatorRegistry::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
+Ice::LocatorRegistry::_iceDispatch(::IceInternal::Incoming& in, const Current& current)
 {
     ::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_Ice_LocatorRegistry_ops, iceC_Ice_LocatorRegistry_ops + 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 - iceC_Ice_LocatorRegistry_ops)
@@ -410,25 +425,26 @@ Ice::LocatorRegistry::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Cur
         default:
         {
             assert(false);
-            throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
+            throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
         }
     }
 }
+/// \endcond
 
 bool
-Ice::LocatorFinder::ice_isA(::std::string s, const ::Ice::Current&) const
+Ice::LocatorFinder::ice_isA(::std::string s, const Current&) const
 {
     return ::std::binary_search(iceC_Ice_LocatorFinder_ids, iceC_Ice_LocatorFinder_ids + 2, s);
 }
 
 ::std::vector<::std::string>
-Ice::LocatorFinder::ice_ids(const ::Ice::Current&) const
+Ice::LocatorFinder::ice_ids(const Current&) const
 {
     return ::std::vector<::std::string>(&iceC_Ice_LocatorFinder_ids[0], &iceC_Ice_LocatorFinder_ids[2]);
 }
 
 ::std::string
-Ice::LocatorFinder::ice_id(const ::Ice::Current&) const
+Ice::LocatorFinder::ice_id(const Current&) const
 {
     return ice_staticId();
 }
@@ -440,25 +456,28 @@ Ice::LocatorFinder::ice_staticId()
     return typeId;
 }
 
+/// \cond INTERNAL
 bool
-Ice::LocatorFinder::_iceD_getLocator(::IceInternal::Incoming& inS, const ::Ice::Current& current)
+Ice::LocatorFinder::_iceD_getLocator(::IceInternal::Incoming& inS, const Current& current)
 {
-    _iceCheckMode(::Ice::OperationMode::Normal, current.mode);
+    _iceCheckMode(OperationMode::Normal, current.mode);
     inS.readEmptyParams();
-    ::std::shared_ptr<::Ice::LocatorPrx> ret = this->getLocator(current);
+    ::std::shared_ptr<LocatorPrx> ret = this->getLocator(current);
     auto ostr = inS.startWriteParams();
     ostr->writeAll(ret);
     inS.endWriteParams();
     return true;
 }
+/// \endcond
 
+/// \cond INTERNAL
 bool
-Ice::LocatorFinder::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
+Ice::LocatorFinder::_iceDispatch(::IceInternal::Incoming& in, const Current& current)
 {
     ::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_Ice_LocatorFinder_ops, iceC_Ice_LocatorFinder_ops + 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 - iceC_Ice_LocatorFinder_ops)
@@ -486,200 +505,221 @@ Ice::LocatorFinder::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Curre
         default:
         {
             assert(false);
-            throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
+            throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
         }
     }
 }
+/// \endcond
 
+/// \cond INTERNAL
 void
-Ice::LocatorPrx::_iceI_findObjectById(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::shared_ptr<::Ice::ObjectPrx>>>& outAsync, const ::Ice::Identity& iceP_id, const ::Ice::Context& context)
+Ice::LocatorPrx::_iceI_findObjectById(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::shared_ptr<ObjectPrx>>>& outAsync, const Identity& iceP_id, const Context& context)
 {
     _checkTwowayOnly(iceC_Ice_Locator_findObjectById_name);
-    outAsync->invoke(iceC_Ice_Locator_findObjectById_name, ::Ice::OperationMode::Nonmutating, ::Ice::FormatType::DefaultFormat, context,
-        [&](::Ice::OutputStream* ostr)
+    outAsync->invoke(iceC_Ice_Locator_findObjectById_name, OperationMode::Nonmutating, FormatType::DefaultFormat, context,
+        [&](OutputStream* ostr)
         {
             ostr->writeAll(iceP_id);
         },
-        [](const ::Ice::UserException& ex)
+        [](const UserException& ex)
         {
             try
             {
                 ex.ice_throw();
             }
-            catch(const ::Ice::ObjectNotFoundException&)
+            catch(const ObjectNotFoundException&)
             {
                 throw;
             }
-            catch(const ::Ice::UserException&)
+            catch(const UserException&)
             {
             }
         });
 }
+/// \endcond
 
+/// \cond INTERNAL
 void
-Ice::LocatorPrx::_iceI_findAdapterById(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::shared_ptr<::Ice::ObjectPrx>>>& outAsync, const ::std::string& iceP_id, const ::Ice::Context& context)
+Ice::LocatorPrx::_iceI_findAdapterById(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::shared_ptr<ObjectPrx>>>& outAsync, const ::std::string& iceP_id, const Context& context)
 {
     _checkTwowayOnly(iceC_Ice_Locator_findAdapterById_name);
-    outAsync->invoke(iceC_Ice_Locator_findAdapterById_name, ::Ice::OperationMode::Nonmutating, ::Ice::FormatType::DefaultFormat, context,
-        [&](::Ice::OutputStream* ostr)
+    outAsync->invoke(iceC_Ice_Locator_findAdapterById_name, OperationMode::Nonmutating, FormatType::DefaultFormat, context,
+        [&](OutputStream* ostr)
         {
             ostr->writeAll(iceP_id);
         },
-        [](const ::Ice::UserException& ex)
+        [](const UserException& ex)
         {
             try
             {
                 ex.ice_throw();
             }
-            catch(const ::Ice::AdapterNotFoundException&)
+            catch(const AdapterNotFoundException&)
             {
                 throw;
             }
-            catch(const ::Ice::UserException&)
+            catch(const UserException&)
             {
             }
         });
 }
+/// \endcond
 
+/// \cond INTERNAL
 void
-Ice::LocatorPrx::_iceI_getRegistry(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::shared_ptr<::Ice::LocatorRegistryPrx>>>& outAsync, const ::Ice::Context& context)
+Ice::LocatorPrx::_iceI_getRegistry(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::shared_ptr<LocatorRegistryPrx>>>& outAsync, const Context& context)
 {
     _checkTwowayOnly(iceC_Ice_Locator_getRegistry_name);
-    outAsync->invoke(iceC_Ice_Locator_getRegistry_name, ::Ice::OperationMode::Nonmutating, ::Ice::FormatType::DefaultFormat, context,
+    outAsync->invoke(iceC_Ice_Locator_getRegistry_name, OperationMode::Nonmutating, FormatType::DefaultFormat, context,
         nullptr,
         nullptr);
 }
+/// \endcond
 
+/// \cond INTERNAL
 ::std::shared_ptr<::Ice::ObjectPrx>
 Ice::LocatorPrx::_newInstance() const
 {
     return ::IceInternal::createProxy<LocatorPrx>();
 }
+/// \endcond
 
 const ::std::string&
 Ice::LocatorPrx::ice_staticId()
 {
-    return Ice::Locator::ice_staticId();
+    return Locator::ice_staticId();
 }
 
+/// \cond INTERNAL
 void
-Ice::LocatorRegistryPrx::_iceI_setAdapterDirectProxy(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>& outAsync, const ::std::string& iceP_id, const ::std::shared_ptr<::Ice::ObjectPrx>& iceP_proxy, const ::Ice::Context& context)
+Ice::LocatorRegistryPrx::_iceI_setAdapterDirectProxy(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>& outAsync, const ::std::string& iceP_id, const ::std::shared_ptr<ObjectPrx>& iceP_proxy, const Context& context)
 {
     _checkTwowayOnly(iceC_Ice_LocatorRegistry_setAdapterDirectProxy_name);
-    outAsync->invoke(iceC_Ice_LocatorRegistry_setAdapterDirectProxy_name, ::Ice::OperationMode::Idempotent, ::Ice::FormatType::DefaultFormat, context,
-        [&](::Ice::OutputStream* ostr)
+    outAsync->invoke(iceC_Ice_LocatorRegistry_setAdapterDirectProxy_name, OperationMode::Idempotent, FormatType::DefaultFormat, context,
+        [&](OutputStream* ostr)
         {
             ostr->writeAll(iceP_id, iceP_proxy);
         },
-        [](const ::Ice::UserException& ex)
+        [](const UserException& ex)
         {
             try
             {
                 ex.ice_throw();
             }
-            catch(const ::Ice::AdapterAlreadyActiveException&)
+            catch(const AdapterAlreadyActiveException&)
             {
                 throw;
             }
-            catch(const ::Ice::AdapterNotFoundException&)
+            catch(const AdapterNotFoundException&)
             {
                 throw;
             }
-            catch(const ::Ice::UserException&)
+            catch(const UserException&)
             {
             }
         });
 }
+/// \endcond
 
+/// \cond INTERNAL
 void
-Ice::LocatorRegistryPrx::_iceI_setReplicatedAdapterDirectProxy(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>& outAsync, const ::std::string& iceP_adapterId, const ::std::string& iceP_replicaGroupId, const ::std::shared_ptr<::Ice::ObjectPrx>& iceP_p, const ::Ice::Context& context)
+Ice::LocatorRegistryPrx::_iceI_setReplicatedAdapterDirectProxy(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>& outAsync, const ::std::string& iceP_adapterId, const ::std::string& iceP_replicaGroupId, const ::std::shared_ptr<ObjectPrx>& iceP_p, const Context& context)
 {
     _checkTwowayOnly(iceC_Ice_LocatorRegistry_setReplicatedAdapterDirectProxy_name);
-    outAsync->invoke(iceC_Ice_LocatorRegistry_setReplicatedAdapterDirectProxy_name, ::Ice::OperationMode::Idempotent, ::Ice::FormatType::DefaultFormat, context,
-        [&](::Ice::OutputStream* ostr)
+    outAsync->invoke(iceC_Ice_LocatorRegistry_setReplicatedAdapterDirectProxy_name, OperationMode::Idempotent, FormatType::DefaultFormat, context,
+        [&](OutputStream* ostr)
         {
             ostr->writeAll(iceP_adapterId, iceP_replicaGroupId, iceP_p);
         },
-        [](const ::Ice::UserException& ex)
+        [](const UserException& ex)
         {
             try
             {
                 ex.ice_throw();
             }
-            catch(const ::Ice::AdapterAlreadyActiveException&)
+            catch(const AdapterAlreadyActiveException&)
             {
                 throw;
             }
-            catch(const ::Ice::AdapterNotFoundException&)
+            catch(const AdapterNotFoundException&)
             {
                 throw;
             }
-            catch(const ::Ice::InvalidReplicaGroupIdException&)
+            catch(const InvalidReplicaGroupIdException&)
             {
                 throw;
             }
-            catch(const ::Ice::UserException&)
+            catch(const UserException&)
             {
             }
         });
 }
+/// \endcond
 
+/// \cond INTERNAL
 void
-Ice::LocatorRegistryPrx::_iceI_setServerProcessProxy(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>& outAsync, const ::std::string& iceP_id, const ::std::shared_ptr<::Ice::ProcessPrx>& iceP_proxy, const ::Ice::Context& context)
+Ice::LocatorRegistryPrx::_iceI_setServerProcessProxy(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>& outAsync, const ::std::string& iceP_id, const ::std::shared_ptr<ProcessPrx>& iceP_proxy, const Context& context)
 {
     _checkTwowayOnly(iceC_Ice_LocatorRegistry_setServerProcessProxy_name);
-    outAsync->invoke(iceC_Ice_LocatorRegistry_setServerProcessProxy_name, ::Ice::OperationMode::Idempotent, ::Ice::FormatType::DefaultFormat, context,
-        [&](::Ice::OutputStream* ostr)
+    outAsync->invoke(iceC_Ice_LocatorRegistry_setServerProcessProxy_name, OperationMode::Idempotent, FormatType::DefaultFormat, context,
+        [&](OutputStream* ostr)
         {
             ostr->writeAll(iceP_id, iceP_proxy);
         },
-        [](const ::Ice::UserException& ex)
+        [](const UserException& ex)
         {
             try
             {
                 ex.ice_throw();
             }
-            catch(const ::Ice::ServerNotFoundException&)
+            catch(const ServerNotFoundException&)
             {
                 throw;
             }
-            catch(const ::Ice::UserException&)
+            catch(const UserException&)
             {
             }
         });
 }
+/// \endcond
 
+/// \cond INTERNAL
 ::std::shared_ptr<::Ice::ObjectPrx>
 Ice::LocatorRegistryPrx::_newInstance() const
 {
     return ::IceInternal::createProxy<LocatorRegistryPrx>();
 }
+/// \endcond
 
 const ::std::string&
 Ice::LocatorRegistryPrx::ice_staticId()
 {
-    return Ice::LocatorRegistry::ice_staticId();
+    return LocatorRegistry::ice_staticId();
 }
 
+/// \cond INTERNAL
 void
-Ice::LocatorFinderPrx::_iceI_getLocator(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::shared_ptr<::Ice::LocatorPrx>>>& outAsync, const ::Ice::Context& context)
+Ice::LocatorFinderPrx::_iceI_getLocator(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::shared_ptr<LocatorPrx>>>& outAsync, const Context& context)
 {
     _checkTwowayOnly(iceC_Ice_LocatorFinder_getLocator_name);
-    outAsync->invoke(iceC_Ice_LocatorFinder_getLocator_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::DefaultFormat, context,
+    outAsync->invoke(iceC_Ice_LocatorFinder_getLocator_name, OperationMode::Normal, FormatType::DefaultFormat, context,
         nullptr,
         nullptr);
 }
+/// \endcond
 
+/// \cond INTERNAL
 ::std::shared_ptr<::Ice::ObjectPrx>
 Ice::LocatorFinderPrx::_newInstance() const
 {
     return ::IceInternal::createProxy<LocatorFinderPrx>();
 }
+/// \endcond
 
 const ::std::string&
 Ice::LocatorFinderPrx::ice_staticId()
 {
-    return Ice::LocatorFinder::ice_staticId();
+    return LocatorFinder::ice_staticId();
 }
 
 #else // C++98 mapping
@@ -732,21 +772,23 @@ Ice::AdapterNotFoundException::ice_throw() const
     throw *this;
 }
 
+/// \cond STREAM
 void
-Ice::AdapterNotFoundException::_writeImpl(::Ice::OutputStream* ostr) const
+Ice::AdapterNotFoundException::_writeImpl(OutputStream* ostr) const
 {
     ostr->startSlice("::Ice::AdapterNotFoundException", -1, true);
-    Ice::StreamWriter< ::Ice::AdapterNotFoundException, ::Ice::OutputStream>::write(ostr, *this);
+    StreamWriter< AdapterNotFoundException, OutputStream>::write(ostr, *this);
     ostr->endSlice();
 }
 
 void
-Ice::AdapterNotFoundException::_readImpl(::Ice::InputStream* istr)
+Ice::AdapterNotFoundException::_readImpl(InputStream* istr)
 {
     istr->startSlice();
-    Ice::StreamReader< ::Ice::AdapterNotFoundException, ::Ice::InputStream>::read(istr, *this);
+    StreamReader< AdapterNotFoundException, InputStream>::read(istr, *this);
     istr->endSlice();
 }
+/// \endcond
 
 namespace
 {
@@ -777,21 +819,23 @@ Ice::InvalidReplicaGroupIdException::ice_throw() const
     throw *this;
 }
 
+/// \cond STREAM
 void
-Ice::InvalidReplicaGroupIdException::_writeImpl(::Ice::OutputStream* ostr) const
+Ice::InvalidReplicaGroupIdException::_writeImpl(OutputStream* ostr) const
 {
     ostr->startSlice("::Ice::InvalidReplicaGroupIdException", -1, true);
-    Ice::StreamWriter< ::Ice::InvalidReplicaGroupIdException, ::Ice::OutputStream>::write(ostr, *this);
+    StreamWriter< InvalidReplicaGroupIdException, OutputStream>::write(ostr, *this);
     ostr->endSlice();
 }
 
 void
-Ice::InvalidReplicaGroupIdException::_readImpl(::Ice::InputStream* istr)
+Ice::InvalidReplicaGroupIdException::_readImpl(InputStream* istr)
 {
     istr->startSlice();
-    Ice::StreamReader< ::Ice::InvalidReplicaGroupIdException, ::Ice::InputStream>::read(istr, *this);
+    StreamReader< InvalidReplicaGroupIdException, InputStream>::read(istr, *this);
     istr->endSlice();
 }
+/// \endcond
 
 namespace
 {
@@ -822,21 +866,23 @@ Ice::AdapterAlreadyActiveException::ice_throw() const
     throw *this;
 }
 
+/// \cond STREAM
 void
-Ice::AdapterAlreadyActiveException::_writeImpl(::Ice::OutputStream* ostr) const
+Ice::AdapterAlreadyActiveException::_writeImpl(OutputStream* ostr) const
 {
     ostr->startSlice("::Ice::AdapterAlreadyActiveException", -1, true);
-    Ice::StreamWriter< ::Ice::AdapterAlreadyActiveException, ::Ice::OutputStream>::write(ostr, *this);
+    StreamWriter< AdapterAlreadyActiveException, OutputStream>::write(ostr, *this);
     ostr->endSlice();
 }
 
 void
-Ice::AdapterAlreadyActiveException::_readImpl(::Ice::InputStream* istr)
+Ice::AdapterAlreadyActiveException::_readImpl(InputStream* istr)
 {
     istr->startSlice();
-    Ice::StreamReader< ::Ice::AdapterAlreadyActiveException, ::Ice::InputStream>::read(istr, *this);
+    StreamReader< AdapterAlreadyActiveException, InputStream>::read(istr, *this);
     istr->endSlice();
 }
+/// \endcond
 
 namespace
 {
@@ -867,21 +913,23 @@ Ice::ObjectNotFoundException::ice_throw() const
     throw *this;
 }
 
+/// \cond STREAM
 void
-Ice::ObjectNotFoundException::_writeImpl(::Ice::OutputStream* ostr) const
+Ice::ObjectNotFoundException::_writeImpl(OutputStream* ostr) const
 {
     ostr->startSlice("::Ice::ObjectNotFoundException", -1, true);
-    Ice::StreamWriter< ::Ice::ObjectNotFoundException, ::Ice::OutputStream>::write(ostr, *this);
+    StreamWriter< ObjectNotFoundException, OutputStream>::write(ostr, *this);
     ostr->endSlice();
 }
 
 void
-Ice::ObjectNotFoundException::_readImpl(::Ice::InputStream* istr)
+Ice::ObjectNotFoundException::_readImpl(InputStream* istr)
 {
     istr->startSlice();
-    Ice::StreamReader< ::Ice::ObjectNotFoundException, ::Ice::InputStream>::read(istr, *this);
+    StreamReader< ObjectNotFoundException, InputStream>::read(istr, *this);
     istr->endSlice();
 }
+/// \endcond
 
 namespace
 {
@@ -912,21 +960,23 @@ Ice::ServerNotFoundException::ice_throw() const
     throw *this;
 }
 
+/// \cond STREAM
 void
-Ice::ServerNotFoundException::_writeImpl(::Ice::OutputStream* ostr) const
+Ice::ServerNotFoundException::_writeImpl(OutputStream* ostr) const
 {
     ostr->startSlice("::Ice::ServerNotFoundException", -1, true);
-    Ice::StreamWriter< ::Ice::ServerNotFoundException, ::Ice::OutputStream>::write(ostr, *this);
+    StreamWriter< ServerNotFoundException, OutputStream>::write(ostr, *this);
     ostr->endSlice();
 }
 
 void
-Ice::ServerNotFoundException::_readImpl(::Ice::InputStream* istr)
+Ice::ServerNotFoundException::_readImpl(InputStream* istr)
 {
     istr->startSlice();
-    Ice::StreamReader< ::Ice::ServerNotFoundException, ::Ice::InputStream>::read(istr, *this);
+    StreamReader< ServerNotFoundException, InputStream>::read(istr, *this);
     istr->endSlice();
 }
+/// \endcond
 
 Ice::AMD_Locator_findObjectById::~AMD_Locator_findObjectById()
 {
@@ -948,6 +998,7 @@ Ice::AMD_LocatorRegistry_setServerProcessProxy::~AMD_LocatorRegistry_setServerPr
 {
 }
 
+/// \cond INTERNAL
 IceAsync::Ice::AMD_Locator_findObjectById::AMD_Locator_findObjectById(::IceInternal::Incoming& in) :
     ::IceInternal::IncomingAsync(in)
 {
@@ -961,7 +1012,9 @@ IceAsync::Ice::AMD_Locator_findObjectById::ice_response(const ::Ice::ObjectPrx&
     endWriteParams();
     completed();
 }
+/// \endcond
 
+/// \cond INTERNAL
 IceAsync::Ice::AMD_Locator_findAdapterById::AMD_Locator_findAdapterById(::IceInternal::Incoming& in) :
     ::IceInternal::IncomingAsync(in)
 {
@@ -975,7 +1028,9 @@ IceAsync::Ice::AMD_Locator_findAdapterById::ice_response(const ::Ice::ObjectPrx&
     endWriteParams();
     completed();
 }
+/// \endcond
 
+/// \cond INTERNAL
 IceAsync::Ice::AMD_LocatorRegistry_setAdapterDirectProxy::AMD_LocatorRegistry_setAdapterDirectProxy(::IceInternal::Incoming& in) :
     ::IceInternal::IncomingAsync(in)
 {
@@ -987,7 +1042,9 @@ IceAsync::Ice::AMD_LocatorRegistry_setAdapterDirectProxy::ice_response()
     writeEmptyParams();
     completed();
 }
+/// \endcond
 
+/// \cond INTERNAL
 IceAsync::Ice::AMD_LocatorRegistry_setReplicatedAdapterDirectProxy::AMD_LocatorRegistry_setReplicatedAdapterDirectProxy(::IceInternal::Incoming& in) :
     ::IceInternal::IncomingAsync(in)
 {
@@ -999,7 +1056,9 @@ IceAsync::Ice::AMD_LocatorRegistry_setReplicatedAdapterDirectProxy::ice_response
     writeEmptyParams();
     completed();
 }
+/// \endcond
 
+/// \cond INTERNAL
 IceAsync::Ice::AMD_LocatorRegistry_setServerProcessProxy::AMD_LocatorRegistry_setServerProcessProxy(::IceInternal::Incoming& in) :
     ::IceInternal::IncomingAsync(in)
 {
@@ -1011,10 +1070,13 @@ IceAsync::Ice::AMD_LocatorRegistry_setServerProcessProxy::ice_response()
     writeEmptyParams();
     completed();
 }
-ICE_API ::IceProxy::Ice::Object* ::IceProxy::Ice::upCast(::IceProxy::Ice::Locator* p) { return p; }
+/// \endcond
+
+/// \cond INTERNAL
+ICE_API ::IceProxy::Ice::Object* ::IceProxy::Ice::upCast(Locator* p) { return p; }
 
 void
-::IceProxy::Ice::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ::IceProxy::Ice::Locator>& v)
+::IceProxy::Ice::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< Locator>& v)
 {
     ::Ice::ObjectPrx proxy;
     istr->read(proxy);
@@ -1024,10 +1086,11 @@ void
     }
     else
     {
-        v = new ::IceProxy::Ice::Locator;
+        v = new Locator;
         v->_copyFrom(proxy);
     }
 }
+/// \endcond
 
 ::Ice::AsyncResultPtr
 IceProxy::Ice::Locator::_iceI_begin_findObjectById(const ::Ice::Identity& iceP_id, const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
@@ -1161,21 +1224,25 @@ IceProxy::Ice::Locator::end_getRegistry(const ::Ice::AsyncResultPtr& result)
     return ret;
 }
 
+/// \cond INTERNAL
 ::IceProxy::Ice::Object*
 IceProxy::Ice::Locator::_newInstance() const
 {
     return new Locator;
 }
+/// \endcond
 
 const ::std::string&
 IceProxy::Ice::Locator::ice_staticId()
 {
     return ::Ice::Locator::ice_staticId();
 }
-ICE_API ::IceProxy::Ice::Object* ::IceProxy::Ice::upCast(::IceProxy::Ice::LocatorRegistry* p) { return p; }
+
+/// \cond INTERNAL
+ICE_API ::IceProxy::Ice::Object* ::IceProxy::Ice::upCast(LocatorRegistry* p) { return p; }
 
 void
-::IceProxy::Ice::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ::IceProxy::Ice::LocatorRegistry>& v)
+::IceProxy::Ice::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< LocatorRegistry>& v)
 {
     ::Ice::ObjectPrx proxy;
     istr->read(proxy);
@@ -1185,10 +1252,11 @@ void
     }
     else
     {
-        v = new ::IceProxy::Ice::LocatorRegistry;
+        v = new LocatorRegistry;
         v->_copyFrom(proxy);
     }
 }
+/// \endcond
 
 ::Ice::AsyncResultPtr
 IceProxy::Ice::LocatorRegistry::_iceI_begin_setAdapterDirectProxy(const ::std::string& iceP_id, const ::Ice::ObjectPrx& iceP_proxy, const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
@@ -1332,21 +1400,25 @@ IceProxy::Ice::LocatorRegistry::end_setServerProcessProxy(const ::Ice::AsyncResu
     result->_readEmptyParams();
 }
 
+/// \cond INTERNAL
 ::IceProxy::Ice::Object*
 IceProxy::Ice::LocatorRegistry::_newInstance() const
 {
     return new LocatorRegistry;
 }
+/// \endcond
 
 const ::std::string&
 IceProxy::Ice::LocatorRegistry::ice_staticId()
 {
     return ::Ice::LocatorRegistry::ice_staticId();
 }
-ICE_API ::IceProxy::Ice::Object* ::IceProxy::Ice::upCast(::IceProxy::Ice::LocatorFinder* p) { return p; }
+
+/// \cond INTERNAL
+ICE_API ::IceProxy::Ice::Object* ::IceProxy::Ice::upCast(LocatorFinder* p) { return p; }
 
 void
-::IceProxy::Ice::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ::IceProxy::Ice::LocatorFinder>& v)
+::IceProxy::Ice::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< LocatorFinder>& v)
 {
     ::Ice::ObjectPrx proxy;
     istr->read(proxy);
@@ -1356,10 +1428,11 @@ void
     }
     else
     {
-        v = new ::IceProxy::Ice::LocatorFinder;
+        v = new LocatorFinder;
         v->_copyFrom(proxy);
     }
 }
+/// \endcond
 
 ::Ice::AsyncResultPtr
 IceProxy::Ice::LocatorFinder::_iceI_begin_getLocator(const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
@@ -1401,11 +1474,13 @@ IceProxy::Ice::LocatorFinder::end_getLocator(const ::Ice::AsyncResultPtr& result
     return ret;
 }
 
+/// \cond INTERNAL
 ::IceProxy::Ice::Object*
 IceProxy::Ice::LocatorFinder::_newInstance() const
 {
     return new LocatorFinder;
 }
+/// \endcond
 
 const ::std::string&
 IceProxy::Ice::LocatorFinder::ice_staticId()
@@ -1417,8 +1492,10 @@ Ice::Locator::~Locator()
 {
 }
 
-ICE_API ::Ice::Object* Ice::upCast(::Ice::Locator* p) { return p; }
+/// \cond INTERNAL
+ICE_API ::Ice::Object* Ice::upCast(Locator* p) { return p; }
 
+/// \endcond
 
 namespace
 {
@@ -1431,19 +1508,19 @@ const ::std::string iceC_Ice_Locator_ids[2] =
 }
 
 bool
-Ice::Locator::ice_isA(const ::std::string& s, const ::Ice::Current&) const
+Ice::Locator::ice_isA(const ::std::string& s, const Current&) const
 {
     return ::std::binary_search(iceC_Ice_Locator_ids, iceC_Ice_Locator_ids + 2, s);
 }
 
 ::std::vector< ::std::string>
-Ice::Locator::ice_ids(const ::Ice::Current&) const
+Ice::Locator::ice_ids(const Current&) const
 {
     return ::std::vector< ::std::string>(&iceC_Ice_Locator_ids[0], &iceC_Ice_Locator_ids[2]);
 }
 
 const ::std::string&
-Ice::Locator::ice_id(const ::Ice::Current&) const
+Ice::Locator::ice_id(const Current&) const
 {
     return ice_staticId();
 }
@@ -1459,41 +1536,47 @@ Ice::Locator::ice_staticId()
 #endif
 }
 
+/// \cond INTERNAL
 bool
-Ice::Locator::_iceD_findObjectById(::IceInternal::Incoming& inS, const ::Ice::Current& current) const
+Ice::Locator::_iceD_findObjectById(::IceInternal::Incoming& inS, const Current& current) const
 {
     _iceCheckMode(::Ice::Idempotent, current.mode);
-    ::Ice::InputStream* istr = inS.startReadParams();
-    ::Ice::Identity iceP_id;
+    InputStream* istr = inS.startReadParams();
+    Identity iceP_id;
     istr->read(iceP_id);
     inS.endReadParams();
     this->findObjectById_async(new IceAsync::Ice::AMD_Locator_findObjectById(inS), iceP_id, current);
     return false;
 }
+/// \endcond
 
+/// \cond INTERNAL
 bool
-Ice::Locator::_iceD_findAdapterById(::IceInternal::Incoming& inS, const ::Ice::Current& current) const
+Ice::Locator::_iceD_findAdapterById(::IceInternal::Incoming& inS, const Current& current) const
 {
     _iceCheckMode(::Ice::Idempotent, current.mode);
-    ::Ice::InputStream* istr = inS.startReadParams();
+    InputStream* istr = inS.startReadParams();
     ::std::string iceP_id;
     istr->read(iceP_id);
     inS.endReadParams();
     this->findAdapterById_async(new IceAsync::Ice::AMD_Locator_findAdapterById(inS), iceP_id, current);
     return false;
 }
+/// \endcond
 
+/// \cond INTERNAL
 bool
-Ice::Locator::_iceD_getRegistry(::IceInternal::Incoming& inS, const ::Ice::Current& current) const
+Ice::Locator::_iceD_getRegistry(::IceInternal::Incoming& inS, const Current& current) const
 {
     _iceCheckMode(::Ice::Idempotent, current.mode);
     inS.readEmptyParams();
-    ::Ice::LocatorRegistryPrx ret = this->getRegistry(current);
-    ::Ice::OutputStream* ostr = inS.startWriteParams();
+    LocatorRegistryPrx ret = this->getRegistry(current);
+    OutputStream* ostr = inS.startWriteParams();
     ostr->write(ret);
     inS.endWriteParams();
     return true;
 }
+/// \endcond
 
 namespace
 {
@@ -1510,13 +1593,14 @@ const ::std::string iceC_Ice_Locator_all[] =
 
 }
 
+/// \cond INTERNAL
 bool
-Ice::Locator::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
+Ice::Locator::_iceDispatch(::IceInternal::Incoming& in, const Current& current)
 {
     ::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_Ice_Locator_all, iceC_Ice_Locator_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 - iceC_Ice_Locator_all)
@@ -1552,43 +1636,50 @@ Ice::Locator::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& cu
         default:
         {
             assert(false);
-            throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
+            throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
         }
     }
 }
+/// \endcond
 
+/// \cond STREAM
 void
-Ice::Locator::_iceWriteImpl(::Ice::OutputStream* ostr) const
+Ice::Locator::_iceWriteImpl(OutputStream* ostr) const
 {
     ostr->startSlice(ice_staticId(), -1, true);
-    Ice::StreamWriter< ::Ice::Locator, ::Ice::OutputStream>::write(ostr, *this);
+    StreamWriter< Locator, OutputStream>::write(ostr, *this);
     ostr->endSlice();
 }
 
 void
-Ice::Locator::_iceReadImpl(::Ice::InputStream* istr)
+Ice::Locator::_iceReadImpl(InputStream* istr)
 {
     istr->startSlice();
-    Ice::StreamReader< ::Ice::Locator, ::Ice::InputStream>::read(istr, *this);
+    StreamReader< Locator, InputStream>::read(istr, *this);
     istr->endSlice();
 }
+/// \endcond
 
+/// \cond INTERNAL
 void
-Ice::_icePatchObjectPtr(LocatorPtr& handle, const ::Ice::ObjectPtr& v)
+Ice::_icePatchObjectPtr(LocatorPtr& handle, const ObjectPtr& v)
 {
-    handle = ::Ice::LocatorPtr::dynamicCast(v);
+    handle = LocatorPtr::dynamicCast(v);
     if(v && !handle)
     {
-        IceInternal::Ex::throwUOE(::Ice::Locator::ice_staticId(), v);
+        IceInternal::Ex::throwUOE(Locator::ice_staticId(), v);
     }
 }
+/// \endcond
 
 Ice::LocatorRegistry::~LocatorRegistry()
 {
 }
 
-ICE_API ::Ice::Object* Ice::upCast(::Ice::LocatorRegistry* p) { return p; }
+/// \cond INTERNAL
+ICE_API ::Ice::Object* Ice::upCast(LocatorRegistry* p) { return p; }
 
+/// \endcond
 
 namespace
 {
@@ -1601,19 +1692,19 @@ const ::std::string iceC_Ice_LocatorRegistry_ids[2] =
 }
 
 bool
-Ice::LocatorRegistry::ice_isA(const ::std::string& s, const ::Ice::Current&) const
+Ice::LocatorRegistry::ice_isA(const ::std::string& s, const Current&) const
 {
     return ::std::binary_search(iceC_Ice_LocatorRegistry_ids, iceC_Ice_LocatorRegistry_ids + 2, s);
 }
 
 ::std::vector< ::std::string>
-Ice::LocatorRegistry::ice_ids(const ::Ice::Current&) const
+Ice::LocatorRegistry::ice_ids(const Current&) const
 {
     return ::std::vector< ::std::string>(&iceC_Ice_LocatorRegistry_ids[0], &iceC_Ice_LocatorRegistry_ids[2]);
 }
 
 const ::std::string&
-Ice::LocatorRegistry::ice_id(const ::Ice::Current&) const
+Ice::LocatorRegistry::ice_id(const Current&) const
 {
     return ice_staticId();
 }
@@ -1629,28 +1720,31 @@ Ice::LocatorRegistry::ice_staticId()
 #endif
 }
 
+/// \cond INTERNAL
 bool
-Ice::LocatorRegistry::_iceD_setAdapterDirectProxy(::IceInternal::Incoming& inS, const ::Ice::Current& current)
+Ice::LocatorRegistry::_iceD_setAdapterDirectProxy(::IceInternal::Incoming& inS, const Current& current)
 {
     _iceCheckMode(::Ice::Idempotent, current.mode);
-    ::Ice::InputStream* istr = inS.startReadParams();
+    InputStream* istr = inS.startReadParams();
     ::std::string iceP_id;
-    ::Ice::ObjectPrx iceP_proxy;
+    ObjectPrx iceP_proxy;
     istr->read(iceP_id);
     istr->read(iceP_proxy);
     inS.endReadParams();
     this->setAdapterDirectProxy_async(new IceAsync::Ice::AMD_LocatorRegistry_setAdapterDirectProxy(inS), iceP_id, iceP_proxy, current);
     return false;
 }
+/// \endcond
 
+/// \cond INTERNAL
 bool
-Ice::LocatorRegistry::_iceD_setReplicatedAdapterDirectProxy(::IceInternal::Incoming& inS, const ::Ice::Current& current)
+Ice::LocatorRegistry::_iceD_setReplicatedAdapterDirectProxy(::IceInternal::Incoming& inS, const Current& current)
 {
     _iceCheckMode(::Ice::Idempotent, current.mode);
-    ::Ice::InputStream* istr = inS.startReadParams();
+    InputStream* istr = inS.startReadParams();
     ::std::string iceP_adapterId;
     ::std::string iceP_replicaGroupId;
-    ::Ice::ObjectPrx iceP_p;
+    ObjectPrx iceP_p;
     istr->read(iceP_adapterId);
     istr->read(iceP_replicaGroupId);
     istr->read(iceP_p);
@@ -1658,20 +1752,23 @@ Ice::LocatorRegistry::_iceD_setReplicatedAdapterDirectProxy(::IceInternal::Incom
     this->setReplicatedAdapterDirectProxy_async(new IceAsync::Ice::AMD_LocatorRegistry_setReplicatedAdapterDirectProxy(inS), iceP_adapterId, iceP_replicaGroupId, iceP_p, current);
     return false;
 }
+/// \endcond
 
+/// \cond INTERNAL
 bool
-Ice::LocatorRegistry::_iceD_setServerProcessProxy(::IceInternal::Incoming& inS, const ::Ice::Current& current)
+Ice::LocatorRegistry::_iceD_setServerProcessProxy(::IceInternal::Incoming& inS, const Current& current)
 {
     _iceCheckMode(::Ice::Idempotent, current.mode);
-    ::Ice::InputStream* istr = inS.startReadParams();
+    InputStream* istr = inS.startReadParams();
     ::std::string iceP_id;
-    ::Ice::ProcessPrx iceP_proxy;
+    ProcessPrx iceP_proxy;
     istr->read(iceP_id);
     istr->read(iceP_proxy);
     inS.endReadParams();
     this->setServerProcessProxy_async(new IceAsync::Ice::AMD_LocatorRegistry_setServerProcessProxy(inS), iceP_id, iceP_proxy, current);
     return false;
 }
+/// \endcond
 
 namespace
 {
@@ -1688,13 +1785,14 @@ const ::std::string iceC_Ice_LocatorRegistry_all[] =
 
 }
 
+/// \cond INTERNAL
 bool
-Ice::LocatorRegistry::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
+Ice::LocatorRegistry::_iceDispatch(::IceInternal::Incoming& in, const Current& current)
 {
     ::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_Ice_LocatorRegistry_all, iceC_Ice_LocatorRegistry_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 - iceC_Ice_LocatorRegistry_all)
@@ -1730,43 +1828,50 @@ Ice::LocatorRegistry::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Cur
         default:
         {
             assert(false);
-            throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
+            throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
         }
     }
 }
+/// \endcond
 
+/// \cond STREAM
 void
-Ice::LocatorRegistry::_iceWriteImpl(::Ice::OutputStream* ostr) const
+Ice::LocatorRegistry::_iceWriteImpl(OutputStream* ostr) const
 {
     ostr->startSlice(ice_staticId(), -1, true);
-    Ice::StreamWriter< ::Ice::LocatorRegistry, ::Ice::OutputStream>::write(ostr, *this);
+    StreamWriter< LocatorRegistry, OutputStream>::write(ostr, *this);
     ostr->endSlice();
 }
 
 void
-Ice::LocatorRegistry::_iceReadImpl(::Ice::InputStream* istr)
+Ice::LocatorRegistry::_iceReadImpl(InputStream* istr)
 {
     istr->startSlice();
-    Ice::StreamReader< ::Ice::LocatorRegistry, ::Ice::InputStream>::read(istr, *this);
+    StreamReader< LocatorRegistry, InputStream>::read(istr, *this);
     istr->endSlice();
 }
+/// \endcond
 
+/// \cond INTERNAL
 void
-Ice::_icePatchObjectPtr(LocatorRegistryPtr& handle, const ::Ice::ObjectPtr& v)
+Ice::_icePatchObjectPtr(LocatorRegistryPtr& handle, const ObjectPtr& v)
 {
-    handle = ::Ice::LocatorRegistryPtr::dynamicCast(v);
+    handle = LocatorRegistryPtr::dynamicCast(v);
     if(v && !handle)
     {
-        IceInternal::Ex::throwUOE(::Ice::LocatorRegistry::ice_staticId(), v);
+        IceInternal::Ex::throwUOE(LocatorRegistry::ice_staticId(), v);
     }
 }
+/// \endcond
 
 Ice::LocatorFinder::~LocatorFinder()
 {
 }
 
-ICE_API ::Ice::Object* Ice::upCast(::Ice::LocatorFinder* p) { return p; }
+/// \cond INTERNAL
+ICE_API ::Ice::Object* Ice::upCast(LocatorFinder* p) { return p; }
 
+/// \endcond
 
 namespace
 {
@@ -1779,19 +1884,19 @@ const ::std::string iceC_Ice_LocatorFinder_ids[2] =
 }
 
 bool
-Ice::LocatorFinder::ice_isA(const ::std::string& s, const ::Ice::Current&) const
+Ice::LocatorFinder::ice_isA(const ::std::string& s, const Current&) const
 {
     return ::std::binary_search(iceC_Ice_LocatorFinder_ids, iceC_Ice_LocatorFinder_ids + 2, s);
 }
 
 ::std::vector< ::std::string>
-Ice::LocatorFinder::ice_ids(const ::Ice::Current&) const
+Ice::LocatorFinder::ice_ids(const Current&) const
 {
     return ::std::vector< ::std::string>(&iceC_Ice_LocatorFinder_ids[0], &iceC_Ice_LocatorFinder_ids[2]);
 }
 
 const ::std::string&
-Ice::LocatorFinder::ice_id(const ::Ice::Current&) const
+Ice::LocatorFinder::ice_id(const Current&) const
 {
     return ice_staticId();
 }
@@ -1807,17 +1912,19 @@ Ice::LocatorFinder::ice_staticId()
 #endif
 }
 
+/// \cond INTERNAL
 bool
-Ice::LocatorFinder::_iceD_getLocator(::IceInternal::Incoming& inS, const ::Ice::Current& current)
+Ice::LocatorFinder::_iceD_getLocator(::IceInternal::Incoming& inS, const Current& current)
 {
     _iceCheckMode(::Ice::Normal, current.mode);
     inS.readEmptyParams();
-    ::Ice::LocatorPrx ret = this->getLocator(current);
-    ::Ice::OutputStream* ostr = inS.startWriteParams();
+    LocatorPrx ret = this->getLocator(current);
+    OutputStream* ostr = inS.startWriteParams();
     ostr->write(ret);
     inS.endWriteParams();
     return true;
 }
+/// \endcond
 
 namespace
 {
@@ -1832,13 +1939,14 @@ const ::std::string iceC_Ice_LocatorFinder_all[] =
 
 }
 
+/// \cond INTERNAL
 bool
-Ice::LocatorFinder::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
+Ice::LocatorFinder::_iceDispatch(::IceInternal::Incoming& in, const Current& current)
 {
     ::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_Ice_LocatorFinder_all, iceC_Ice_LocatorFinder_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 - iceC_Ice_LocatorFinder_all)
@@ -1866,36 +1974,41 @@ Ice::LocatorFinder::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Curre
         default:
         {
             assert(false);
-            throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
+            throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
         }
     }
 }
+/// \endcond
 
+/// \cond STREAM
 void
-Ice::LocatorFinder::_iceWriteImpl(::Ice::OutputStream* ostr) const
+Ice::LocatorFinder::_iceWriteImpl(OutputStream* ostr) const
 {
     ostr->startSlice(ice_staticId(), -1, true);
-    Ice::StreamWriter< ::Ice::LocatorFinder, ::Ice::OutputStream>::write(ostr, *this);
+    StreamWriter< LocatorFinder, OutputStream>::write(ostr, *this);
     ostr->endSlice();
 }
 
 void
-Ice::LocatorFinder::_iceReadImpl(::Ice::InputStream* istr)
+Ice::LocatorFinder::_iceReadImpl(InputStream* istr)
 {
     istr->startSlice();
-    Ice::StreamReader< ::Ice::LocatorFinder, ::Ice::InputStream>::read(istr, *this);
+    StreamReader< LocatorFinder, InputStream>::read(istr, *this);
     istr->endSlice();
 }
+/// \endcond
 
+/// \cond INTERNAL
 void
-Ice::_icePatchObjectPtr(LocatorFinderPtr& handle, const ::Ice::ObjectPtr& v)
+Ice::_icePatchObjectPtr(LocatorFinderPtr& handle, const ObjectPtr& v)
 {
-    handle = ::Ice::LocatorFinderPtr::dynamicCast(v);
+    handle = LocatorFinderPtr::dynamicCast(v);
     if(v && !handle)
     {
-        IceInternal::Ex::throwUOE(::Ice::LocatorFinder::ice_staticId(), v);
+        IceInternal::Ex::throwUOE(LocatorFinder::ice_staticId(), v);
     }
 }
+/// \endcond
 
 namespace Ice
 {