zeroc-ice 3.7.0 → 3.7.5

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2017 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_LOGGER_I_H
 #define ICE_LOGGER_I_H

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

@@ -1,12 +1,7 @@
 
-// **********************************************************************
 //
-// Copyright (c) 2003-2017 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/LoggerUtil.h>
 #include <Ice/Logger.h>

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

@@ -1,13 +1,8 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2017 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.7.0
+// Ice version 3.7.5
 //
 // <auto-generated>
 //
@@ -43,10 +38,10 @@
 #   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 < 0
+#   if ICE_INT_VERSION % 100 < 5
 #       error Ice patch level mismatch!
 #   endif
 #endif
@@ -137,6 +132,7 @@ IceMX::MetricsAdmin::ice_staticId()
     return typeId;
 }
 
+/// \cond INTERNAL
 bool
 IceMX::MetricsAdmin::_iceD_getMetricsViewNames(::IceInternal::Incoming& inS, const ::Ice::Current& current)
 {
@@ -150,7 +146,9 @@ IceMX::MetricsAdmin::_iceD_getMetricsViewNames(::IceInternal::Incoming& inS, con
     inS.endWriteParams();
     return true;
 }
+/// \endcond
 
+/// \cond INTERNAL
 bool
 IceMX::MetricsAdmin::_iceD_enableMetricsView(::IceInternal::Incoming& inS, const ::Ice::Current& current)
 {
@@ -164,7 +162,9 @@ IceMX::MetricsAdmin::_iceD_enableMetricsView(::IceInternal::Incoming& inS, const
     inS.writeEmptyParams();
     return true;
 }
+/// \endcond
 
+/// \cond INTERNAL
 bool
 IceMX::MetricsAdmin::_iceD_disableMetricsView(::IceInternal::Incoming& inS, const ::Ice::Current& current)
 {
@@ -178,7 +178,9 @@ IceMX::MetricsAdmin::_iceD_disableMetricsView(::IceInternal::Incoming& inS, cons
     inS.writeEmptyParams();
     return true;
 }
+/// \endcond
 
+/// \cond INTERNAL
 bool
 IceMX::MetricsAdmin::_iceD_getMetricsView(::IceInternal::Incoming& inS, const ::Ice::Current& current)
 {
@@ -189,14 +191,16 @@ IceMX::MetricsAdmin::_iceD_getMetricsView(::IceInternal::Incoming& inS, const ::
     inS.endReadParams();
     inS.setFormat(::Ice::FormatType::SlicedFormat);
     long long int iceP_timestamp;
-    ::IceMX::MetricsView ret = this->getMetricsView(::std::move(iceP_view), iceP_timestamp, current);
+    MetricsView ret = this->getMetricsView(::std::move(iceP_view), iceP_timestamp, current);
     auto ostr = inS.startWriteParams();
     ostr->writeAll(iceP_timestamp, ret);
     ostr->writePendingValues();
     inS.endWriteParams();
     return true;
 }
+/// \endcond
 
+/// \cond INTERNAL
 bool
 IceMX::MetricsAdmin::_iceD_getMapMetricsFailures(::IceInternal::Incoming& inS, const ::Ice::Current& current)
 {
@@ -207,13 +211,15 @@ IceMX::MetricsAdmin::_iceD_getMapMetricsFailures(::IceInternal::Incoming& inS, c
     istr->readAll(iceP_view, iceP_map);
     inS.endReadParams();
     inS.setFormat(::Ice::FormatType::SlicedFormat);
-    ::IceMX::MetricsFailuresSeq ret = this->getMapMetricsFailures(::std::move(iceP_view), ::std::move(iceP_map), current);
+    MetricsFailuresSeq ret = this->getMapMetricsFailures(::std::move(iceP_view), ::std::move(iceP_map), current);
     auto ostr = inS.startWriteParams();
     ostr->writeAll(ret);
     inS.endWriteParams();
     return true;
 }
+/// \endcond
 
+/// \cond INTERNAL
 bool
 IceMX::MetricsAdmin::_iceD_getMetricsFailures(::IceInternal::Incoming& inS, const ::Ice::Current& current)
 {
@@ -225,13 +231,15 @@ IceMX::MetricsAdmin::_iceD_getMetricsFailures(::IceInternal::Incoming& inS, cons
     istr->readAll(iceP_view, iceP_map, iceP_id);
     inS.endReadParams();
     inS.setFormat(::Ice::FormatType::SlicedFormat);
-    ::IceMX::MetricsFailures ret = this->getMetricsFailures(::std::move(iceP_view), ::std::move(iceP_map), ::std::move(iceP_id), current);
+    MetricsFailures ret = this->getMetricsFailures(::std::move(iceP_view), ::std::move(iceP_map), ::std::move(iceP_id), current);
     auto ostr = inS.startWriteParams();
     ostr->writeAll(ret);
     inS.endWriteParams();
     return true;
 }
+/// \endcond
 
+/// \cond INTERNAL
 bool
 IceMX::MetricsAdmin::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
 {
@@ -290,6 +298,7 @@ IceMX::MetricsAdmin::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Curr
         }
     }
 }
+/// \endcond
 
 IceMX::Metrics::~Metrics()
 {
@@ -379,8 +388,9 @@ IceMX::ConnectionMetrics::ice_staticId()
     return typeId;
 }
 
+/// \cond INTERNAL
 void
-IceMX::MetricsAdminPrx::_iceI_getMetricsViewNames(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::IceMX::MetricsAdmin::GetMetricsViewNamesResult>>& outAsync, const ::Ice::Context& context)
+IceMX::MetricsAdminPrx::_iceI_getMetricsViewNames(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<MetricsAdmin::GetMetricsViewNamesResult>>& outAsync, const ::Ice::Context& context)
 {
     _checkTwowayOnly(iceC_IceMX_MetricsAdmin_getMetricsViewNames_name);
     outAsync->invoke(iceC_IceMX_MetricsAdmin_getMetricsViewNames_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::SlicedFormat, context,
@@ -388,12 +398,14 @@ IceMX::MetricsAdminPrx::_iceI_getMetricsViewNames(const ::std::shared_ptr<::IceI
         nullptr,
         [](::Ice::InputStream* istr)
         {
-            ::IceMX::MetricsAdmin::GetMetricsViewNamesResult v;
+            MetricsAdmin::GetMetricsViewNamesResult v;
             istr->readAll(v.disabledViews, v.returnValue);
             return v;
         });
 }
+/// \endcond
 
+/// \cond INTERNAL
 void
 IceMX::MetricsAdminPrx::_iceI_enableMetricsView(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>& outAsync, const ::std::string& iceP_name, const ::Ice::Context& context)
 {
@@ -409,7 +421,7 @@ IceMX::MetricsAdminPrx::_iceI_enableMetricsView(const ::std::shared_ptr<::IceInt
             {
                 ex.ice_throw();
             }
-            catch(const ::IceMX::UnknownMetricsView&)
+            catch(const UnknownMetricsView&)
             {
                 throw;
             }
@@ -418,7 +430,9 @@ IceMX::MetricsAdminPrx::_iceI_enableMetricsView(const ::std::shared_ptr<::IceInt
             }
         });
 }
+/// \endcond
 
+/// \cond INTERNAL
 void
 IceMX::MetricsAdminPrx::_iceI_disableMetricsView(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>& outAsync, const ::std::string& iceP_name, const ::Ice::Context& context)
 {
@@ -434,7 +448,7 @@ IceMX::MetricsAdminPrx::_iceI_disableMetricsView(const ::std::shared_ptr<::IceIn
             {
                 ex.ice_throw();
             }
-            catch(const ::IceMX::UnknownMetricsView&)
+            catch(const UnknownMetricsView&)
             {
                 throw;
             }
@@ -443,9 +457,11 @@ IceMX::MetricsAdminPrx::_iceI_disableMetricsView(const ::std::shared_ptr<::IceIn
             }
         });
 }
+/// \endcond
 
+/// \cond INTERNAL
 void
-IceMX::MetricsAdminPrx::_iceI_getMetricsView(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::IceMX::MetricsAdmin::GetMetricsViewResult>>& outAsync, const ::std::string& iceP_view, const ::Ice::Context& context)
+IceMX::MetricsAdminPrx::_iceI_getMetricsView(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<MetricsAdmin::GetMetricsViewResult>>& outAsync, const ::std::string& iceP_view, const ::Ice::Context& context)
 {
     _checkTwowayOnly(iceC_IceMX_MetricsAdmin_getMetricsView_name);
     outAsync->invoke(iceC_IceMX_MetricsAdmin_getMetricsView_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::SlicedFormat, context,
@@ -459,7 +475,7 @@ IceMX::MetricsAdminPrx::_iceI_getMetricsView(const ::std::shared_ptr<::IceIntern
             {
                 ex.ice_throw();
             }
-            catch(const ::IceMX::UnknownMetricsView&)
+            catch(const UnknownMetricsView&)
             {
                 throw;
             }
@@ -469,13 +485,15 @@ IceMX::MetricsAdminPrx::_iceI_getMetricsView(const ::std::shared_ptr<::IceIntern
         },
         [](::Ice::InputStream* istr)
         {
-            ::IceMX::MetricsAdmin::GetMetricsViewResult v;
+            MetricsAdmin::GetMetricsViewResult v;
             istr->readAll(v.timestamp, v.returnValue);
             istr->readPendingValues();
             return v;
         });
 }
+/// \endcond
 
+/// \cond INTERNAL
 void
 IceMX::MetricsAdminPrx::_iceI_getMapMetricsFailures(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::IceMX::MetricsFailuresSeq>>& outAsync, const ::std::string& iceP_view, const ::std::string& iceP_map, const ::Ice::Context& context)
 {
@@ -491,7 +509,7 @@ IceMX::MetricsAdminPrx::_iceI_getMapMetricsFailures(const ::std::shared_ptr<::Ic
             {
                 ex.ice_throw();
             }
-            catch(const ::IceMX::UnknownMetricsView&)
+            catch(const UnknownMetricsView&)
             {
                 throw;
             }
@@ -500,7 +518,9 @@ IceMX::MetricsAdminPrx::_iceI_getMapMetricsFailures(const ::std::shared_ptr<::Ic
             }
         });
 }
+/// \endcond
 
+/// \cond INTERNAL
 void
 IceMX::MetricsAdminPrx::_iceI_getMetricsFailures(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::IceMX::MetricsFailures>>& outAsync, const ::std::string& iceP_view, const ::std::string& iceP_map, const ::std::string& iceP_id, const ::Ice::Context& context)
 {
@@ -516,7 +536,7 @@ IceMX::MetricsAdminPrx::_iceI_getMetricsFailures(const ::std::shared_ptr<::IceIn
             {
                 ex.ice_throw();
             }
-            catch(const ::IceMX::UnknownMetricsView&)
+            catch(const UnknownMetricsView&)
             {
                 throw;
             }
@@ -525,17 +545,20 @@ IceMX::MetricsAdminPrx::_iceI_getMetricsFailures(const ::std::shared_ptr<::IceIn
             }
         });
 }
+/// \endcond
 
+/// \cond INTERNAL
 ::std::shared_ptr<::Ice::ObjectPrx>
 IceMX::MetricsAdminPrx::_newInstance() const
 {
     return ::IceInternal::createProxy<MetricsAdminPrx>();
 }
+/// \endcond
 
 const ::std::string&
 IceMX::MetricsAdminPrx::ice_staticId()
 {
-    return IceMX::MetricsAdmin::ice_staticId();
+    return MetricsAdmin::ice_staticId();
 }
 
 namespace Ice
@@ -590,11 +613,12 @@ IceMX::UnknownMetricsView::ice_throw() const
     throw *this;
 }
 
+/// \cond STREAM
 void
 IceMX::UnknownMetricsView::_writeImpl(::Ice::OutputStream* ostr) const
 {
     ostr->startSlice("::IceMX::UnknownMetricsView", -1, true);
-    Ice::StreamWriter< ::IceMX::UnknownMetricsView, ::Ice::OutputStream>::write(ostr, *this);
+    ::Ice::StreamWriter< UnknownMetricsView, ::Ice::OutputStream>::write(ostr, *this);
     ostr->endSlice();
 }
 
@@ -602,13 +626,16 @@ void
 IceMX::UnknownMetricsView::_readImpl(::Ice::InputStream* istr)
 {
     istr->startSlice();
-    Ice::StreamReader< ::IceMX::UnknownMetricsView, ::Ice::InputStream>::read(istr, *this);
+    ::Ice::StreamReader< UnknownMetricsView, ::Ice::InputStream>::read(istr, *this);
     istr->endSlice();
 }
-ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(::IceProxy::IceMX::Metrics* p) { return p; }
+/// \endcond
+
+/// \cond INTERNAL
+ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(Metrics* p) { return p; }
 
 void
-::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ::IceProxy::IceMX::Metrics>& v)
+::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< Metrics>& v)
 {
     ::Ice::ObjectPrx proxy;
     istr->read(proxy);
@@ -618,26 +645,31 @@ void
     }
     else
     {
-        v = new ::IceProxy::IceMX::Metrics;
+        v = new Metrics;
         v->_copyFrom(proxy);
     }
 }
+/// \endcond
 
+/// \cond INTERNAL
 ::IceProxy::Ice::Object*
 IceProxy::IceMX::Metrics::_newInstance() const
 {
     return new Metrics;
 }
+/// \endcond
 
 const ::std::string&
 IceProxy::IceMX::Metrics::ice_staticId()
 {
     return ::IceMX::Metrics::ice_staticId();
 }
-ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(::IceProxy::IceMX::MetricsAdmin* p) { return p; }
+
+/// \cond INTERNAL
+ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(MetricsAdmin* p) { return p; }
 
 void
-::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ::IceProxy::IceMX::MetricsAdmin>& v)
+::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< MetricsAdmin>& v)
 {
     ::Ice::ObjectPrx proxy;
     istr->read(proxy);
@@ -647,10 +679,11 @@ void
     }
     else
     {
-        v = new ::IceProxy::IceMX::MetricsAdmin;
+        v = new MetricsAdmin;
         v->_copyFrom(proxy);
     }
 }
+/// \endcond
 
 ::Ice::AsyncResultPtr
 IceProxy::IceMX::MetricsAdmin::_iceI_begin_getMetricsViewNames(const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
@@ -693,6 +726,26 @@ IceProxy::IceMX::MetricsAdmin::end_getMetricsViewNames(::Ice::StringSeq& iceP_di
     return ret;
 }
 
+void IceProxy::IceMX::MetricsAdmin::_iceI_end_getMetricsViewNames(::Ice::StringSeq& iceP_disabledViews, ::Ice::StringSeq& ret, const ::Ice::AsyncResultPtr& result)
+{
+    ::Ice::AsyncResult::_check(result, this, iceC_IceMX_MetricsAdmin_getMetricsViewNames_name);
+    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(iceP_disabledViews);
+    istr->read(ret);
+    result->_endReadParams();
+}
+
 ::Ice::AsyncResultPtr
 IceProxy::IceMX::MetricsAdmin::_iceI_begin_enableMetricsView(const ::std::string& iceP_name, const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
 {
@@ -825,6 +878,31 @@ IceProxy::IceMX::MetricsAdmin::end_getMetricsView(::Ice::Long& iceP_timestamp, c
     return ret;
 }
 
+void IceProxy::IceMX::MetricsAdmin::_iceI_end_getMetricsView(::Ice::Long& iceP_timestamp, ::IceMX::MetricsView& ret, const ::Ice::AsyncResultPtr& result)
+{
+    ::Ice::AsyncResult::_check(result, this, iceC_IceMX_MetricsAdmin_getMetricsView_name);
+    if(!result->_waitForResponse())
+    {
+        try
+        {
+            result->_throwUserException();
+        }
+        catch(const ::IceMX::UnknownMetricsView&)
+        {
+            throw;
+        }
+        catch(const ::Ice::UserException& ex)
+        {
+            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
+        }
+    }
+    ::Ice::InputStream* istr = result->_startReadParams();
+    istr->read(iceP_timestamp);
+    istr->read(ret);
+    istr->readPendingValues();
+    result->_endReadParams();
+}
+
 ::Ice::AsyncResultPtr
 IceProxy::IceMX::MetricsAdmin::_iceI_begin_getMapMetricsFailures(const ::std::string& iceP_view, const ::std::string& iceP_map, const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
 {
@@ -920,21 +998,25 @@ IceProxy::IceMX::MetricsAdmin::end_getMetricsFailures(const ::Ice::AsyncResultPt
     return ret;
 }
 
+/// \cond INTERNAL
 ::IceProxy::Ice::Object*
 IceProxy::IceMX::MetricsAdmin::_newInstance() const
 {
     return new MetricsAdmin;
 }
+/// \endcond
 
 const ::std::string&
 IceProxy::IceMX::MetricsAdmin::ice_staticId()
 {
     return ::IceMX::MetricsAdmin::ice_staticId();
 }
-ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(::IceProxy::IceMX::ThreadMetrics* p) { return p; }
+
+/// \cond INTERNAL
+ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(ThreadMetrics* p) { return p; }
 
 void
-::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ::IceProxy::IceMX::ThreadMetrics>& v)
+::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ThreadMetrics>& v)
 {
     ::Ice::ObjectPrx proxy;
     istr->read(proxy);
@@ -944,26 +1026,31 @@ void
     }
     else
     {
-        v = new ::IceProxy::IceMX::ThreadMetrics;
+        v = new ThreadMetrics;
         v->_copyFrom(proxy);
     }
 }
+/// \endcond
 
+/// \cond INTERNAL
 ::IceProxy::Ice::Object*
 IceProxy::IceMX::ThreadMetrics::_newInstance() const
 {
     return new ThreadMetrics;
 }
+/// \endcond
 
 const ::std::string&
 IceProxy::IceMX::ThreadMetrics::ice_staticId()
 {
     return ::IceMX::ThreadMetrics::ice_staticId();
 }
-ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(::IceProxy::IceMX::DispatchMetrics* p) { return p; }
+
+/// \cond INTERNAL
+ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(DispatchMetrics* p) { return p; }
 
 void
-::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ::IceProxy::IceMX::DispatchMetrics>& v)
+::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< DispatchMetrics>& v)
 {
     ::Ice::ObjectPrx proxy;
     istr->read(proxy);
@@ -973,26 +1060,31 @@ void
     }
     else
     {
-        v = new ::IceProxy::IceMX::DispatchMetrics;
+        v = new DispatchMetrics;
         v->_copyFrom(proxy);
     }
 }
+/// \endcond
 
+/// \cond INTERNAL
 ::IceProxy::Ice::Object*
 IceProxy::IceMX::DispatchMetrics::_newInstance() const
 {
     return new DispatchMetrics;
 }
+/// \endcond
 
 const ::std::string&
 IceProxy::IceMX::DispatchMetrics::ice_staticId()
 {
     return ::IceMX::DispatchMetrics::ice_staticId();
 }
-ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(::IceProxy::IceMX::ChildInvocationMetrics* p) { return p; }
+
+/// \cond INTERNAL
+ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(ChildInvocationMetrics* p) { return p; }
 
 void
-::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ::IceProxy::IceMX::ChildInvocationMetrics>& v)
+::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ChildInvocationMetrics>& v)
 {
     ::Ice::ObjectPrx proxy;
     istr->read(proxy);
@@ -1002,26 +1094,31 @@ void
     }
     else
     {
-        v = new ::IceProxy::IceMX::ChildInvocationMetrics;
+        v = new ChildInvocationMetrics;
         v->_copyFrom(proxy);
     }
 }
+/// \endcond
 
+/// \cond INTERNAL
 ::IceProxy::Ice::Object*
 IceProxy::IceMX::ChildInvocationMetrics::_newInstance() const
 {
     return new ChildInvocationMetrics;
 }
+/// \endcond
 
 const ::std::string&
 IceProxy::IceMX::ChildInvocationMetrics::ice_staticId()
 {
     return ::IceMX::ChildInvocationMetrics::ice_staticId();
 }
-ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(::IceProxy::IceMX::CollocatedMetrics* p) { return p; }
+
+/// \cond INTERNAL
+ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(CollocatedMetrics* p) { return p; }
 
 void
-::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ::IceProxy::IceMX::CollocatedMetrics>& v)
+::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< CollocatedMetrics>& v)
 {
     ::Ice::ObjectPrx proxy;
     istr->read(proxy);
@@ -1031,26 +1128,31 @@ void
     }
     else
     {
-        v = new ::IceProxy::IceMX::CollocatedMetrics;
+        v = new CollocatedMetrics;
         v->_copyFrom(proxy);
     }
 }
+/// \endcond
 
+/// \cond INTERNAL
 ::IceProxy::Ice::Object*
 IceProxy::IceMX::CollocatedMetrics::_newInstance() const
 {
     return new CollocatedMetrics;
 }
+/// \endcond
 
 const ::std::string&
 IceProxy::IceMX::CollocatedMetrics::ice_staticId()
 {
     return ::IceMX::CollocatedMetrics::ice_staticId();
 }
-ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(::IceProxy::IceMX::RemoteMetrics* p) { return p; }
+
+/// \cond INTERNAL
+ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(RemoteMetrics* p) { return p; }
 
 void
-::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ::IceProxy::IceMX::RemoteMetrics>& v)
+::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< RemoteMetrics>& v)
 {
     ::Ice::ObjectPrx proxy;
     istr->read(proxy);
@@ -1060,26 +1162,31 @@ void
     }
     else
     {
-        v = new ::IceProxy::IceMX::RemoteMetrics;
+        v = new RemoteMetrics;
         v->_copyFrom(proxy);
     }
 }
+/// \endcond
 
+/// \cond INTERNAL
 ::IceProxy::Ice::Object*
 IceProxy::IceMX::RemoteMetrics::_newInstance() const
 {
     return new RemoteMetrics;
 }
+/// \endcond
 
 const ::std::string&
 IceProxy::IceMX::RemoteMetrics::ice_staticId()
 {
     return ::IceMX::RemoteMetrics::ice_staticId();
 }
-ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(::IceProxy::IceMX::InvocationMetrics* p) { return p; }
+
+/// \cond INTERNAL
+ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(InvocationMetrics* p) { return p; }
 
 void
-::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ::IceProxy::IceMX::InvocationMetrics>& v)
+::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< InvocationMetrics>& v)
 {
     ::Ice::ObjectPrx proxy;
     istr->read(proxy);
@@ -1089,26 +1196,31 @@ void
     }
     else
     {
-        v = new ::IceProxy::IceMX::InvocationMetrics;
+        v = new InvocationMetrics;
         v->_copyFrom(proxy);
     }
 }
+/// \endcond
 
+/// \cond INTERNAL
 ::IceProxy::Ice::Object*
 IceProxy::IceMX::InvocationMetrics::_newInstance() const
 {
     return new InvocationMetrics;
 }
+/// \endcond
 
 const ::std::string&
 IceProxy::IceMX::InvocationMetrics::ice_staticId()
 {
     return ::IceMX::InvocationMetrics::ice_staticId();
 }
-ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(::IceProxy::IceMX::ConnectionMetrics* p) { return p; }
+
+/// \cond INTERNAL
+ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(ConnectionMetrics* p) { return p; }
 
 void
-::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ::IceProxy::IceMX::ConnectionMetrics>& v)
+::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ConnectionMetrics>& v)
 {
     ::Ice::ObjectPrx proxy;
     istr->read(proxy);
@@ -1118,16 +1230,19 @@ void
     }
     else
     {
-        v = new ::IceProxy::IceMX::ConnectionMetrics;
+        v = new ConnectionMetrics;
         v->_copyFrom(proxy);
     }
 }
+/// \endcond
 
+/// \cond INTERNAL
 ::IceProxy::Ice::Object*
 IceProxy::IceMX::ConnectionMetrics::_newInstance() const
 {
     return new ConnectionMetrics;
 }
+/// \endcond
 
 const ::std::string&
 IceProxy::IceMX::ConnectionMetrics::ice_staticId()
@@ -1139,8 +1254,10 @@ IceMX::Metrics::~Metrics()
 {
 }
 
-ICE_API ::Ice::Object* IceMX::upCast(::IceMX::Metrics* p) { return p; }
+/// \cond INTERNAL
+ICE_API ::Ice::Object* IceMX::upCast(Metrics* p) { return p; }
 
+/// \endcond
 ::Ice::ObjectPtr
 IceMX::Metrics::ice_clone() const
 {
@@ -1187,11 +1304,12 @@ IceMX::Metrics::ice_staticId()
 #endif
 }
 
+/// \cond STREAM
 void
 IceMX::Metrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
 {
     ostr->startSlice(ice_staticId(), -1, true);
-    Ice::StreamWriter< ::IceMX::Metrics, ::Ice::OutputStream>::write(ostr, *this);
+    ::Ice::StreamWriter< Metrics, ::Ice::OutputStream>::write(ostr, *this);
     ostr->endSlice();
 }
 
@@ -1199,9 +1317,10 @@ void
 IceMX::Metrics::_iceReadImpl(::Ice::InputStream* istr)
 {
     istr->startSlice();
-    Ice::StreamReader< ::IceMX::Metrics, ::Ice::InputStream>::read(istr, *this);
+    ::Ice::StreamReader< Metrics, ::Ice::InputStream>::read(istr, *this);
     istr->endSlice();
 }
+/// \endcond
 
 namespace
 {
@@ -1214,22 +1333,26 @@ IceMX::Metrics::ice_factory()
     return ::IceInternal::factoryTable->getValueFactory(::IceMX::Metrics::ice_staticId());
 }
 
+/// \cond INTERNAL
 void
 IceMX::_icePatchObjectPtr(MetricsPtr& handle, const ::Ice::ObjectPtr& v)
 {
-    handle = ::IceMX::MetricsPtr::dynamicCast(v);
+    handle = MetricsPtr::dynamicCast(v);
     if(v && !handle)
     {
-        IceInternal::Ex::throwUOE(::IceMX::Metrics::ice_staticId(), v);
+        IceInternal::Ex::throwUOE(Metrics::ice_staticId(), v);
     }
 }
+/// \endcond
 
 IceMX::MetricsAdmin::~MetricsAdmin()
 {
 }
 
-ICE_API ::Ice::Object* IceMX::upCast(::IceMX::MetricsAdmin* p) { return p; }
+/// \cond INTERNAL
+ICE_API ::Ice::Object* IceMX::upCast(MetricsAdmin* p) { return p; }
 
+/// \endcond
 
 namespace
 {
@@ -1270,6 +1393,7 @@ IceMX::MetricsAdmin::ice_staticId()
 #endif
 }
 
+/// \cond INTERNAL
 bool
 IceMX::MetricsAdmin::_iceD_getMetricsViewNames(::IceInternal::Incoming& inS, const ::Ice::Current& current)
 {
@@ -1284,7 +1408,9 @@ IceMX::MetricsAdmin::_iceD_getMetricsViewNames(::IceInternal::Incoming& inS, con
     inS.endWriteParams();
     return true;
 }
+/// \endcond
 
+/// \cond INTERNAL
 bool
 IceMX::MetricsAdmin::_iceD_enableMetricsView(::IceInternal::Incoming& inS, const ::Ice::Current& current)
 {
@@ -1298,7 +1424,9 @@ IceMX::MetricsAdmin::_iceD_enableMetricsView(::IceInternal::Incoming& inS, const
     inS.writeEmptyParams();
     return true;
 }
+/// \endcond
 
+/// \cond INTERNAL
 bool
 IceMX::MetricsAdmin::_iceD_disableMetricsView(::IceInternal::Incoming& inS, const ::Ice::Current& current)
 {
@@ -1312,7 +1440,9 @@ IceMX::MetricsAdmin::_iceD_disableMetricsView(::IceInternal::Incoming& inS, cons
     inS.writeEmptyParams();
     return true;
 }
+/// \endcond
 
+/// \cond INTERNAL
 bool
 IceMX::MetricsAdmin::_iceD_getMetricsView(::IceInternal::Incoming& inS, const ::Ice::Current& current)
 {
@@ -1323,7 +1453,7 @@ IceMX::MetricsAdmin::_iceD_getMetricsView(::IceInternal::Incoming& inS, const ::
     inS.endReadParams();
     inS.setFormat(::Ice::SlicedFormat);
     ::Ice::Long iceP_timestamp;
-    ::IceMX::MetricsView ret = this->getMetricsView(iceP_view, iceP_timestamp, current);
+    MetricsView ret = this->getMetricsView(iceP_view, iceP_timestamp, current);
     ::Ice::OutputStream* ostr = inS.startWriteParams();
     ostr->write(iceP_timestamp);
     ostr->write(ret);
@@ -1331,7 +1461,9 @@ IceMX::MetricsAdmin::_iceD_getMetricsView(::IceInternal::Incoming& inS, const ::
     inS.endWriteParams();
     return true;
 }
+/// \endcond
 
+/// \cond INTERNAL
 bool
 IceMX::MetricsAdmin::_iceD_getMapMetricsFailures(::IceInternal::Incoming& inS, const ::Ice::Current& current)
 {
@@ -1343,13 +1475,15 @@ IceMX::MetricsAdmin::_iceD_getMapMetricsFailures(::IceInternal::Incoming& inS, c
     istr->read(iceP_map);
     inS.endReadParams();
     inS.setFormat(::Ice::SlicedFormat);
-    ::IceMX::MetricsFailuresSeq ret = this->getMapMetricsFailures(iceP_view, iceP_map, current);
+    MetricsFailuresSeq ret = this->getMapMetricsFailures(iceP_view, iceP_map, current);
     ::Ice::OutputStream* ostr = inS.startWriteParams();
     ostr->write(ret);
     inS.endWriteParams();
     return true;
 }
+/// \endcond
 
+/// \cond INTERNAL
 bool
 IceMX::MetricsAdmin::_iceD_getMetricsFailures(::IceInternal::Incoming& inS, const ::Ice::Current& current)
 {
@@ -1363,12 +1497,13 @@ IceMX::MetricsAdmin::_iceD_getMetricsFailures(::IceInternal::Incoming& inS, cons
     istr->read(iceP_id);
     inS.endReadParams();
     inS.setFormat(::Ice::SlicedFormat);
-    ::IceMX::MetricsFailures ret = this->getMetricsFailures(iceP_view, iceP_map, iceP_id, current);
+    MetricsFailures ret = this->getMetricsFailures(iceP_view, iceP_map, iceP_id, current);
     ::Ice::OutputStream* ostr = inS.startWriteParams();
     ostr->write(ret);
     inS.endWriteParams();
     return true;
 }
+/// \endcond
 
 namespace
 {
@@ -1388,6 +1523,7 @@ const ::std::string iceC_IceMX_MetricsAdmin_all[] =
 
 }
 
+/// \cond INTERNAL
 bool
 IceMX::MetricsAdmin::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
 {
@@ -1446,12 +1582,14 @@ IceMX::MetricsAdmin::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Curr
         }
     }
 }
+/// \endcond
 
+/// \cond STREAM
 void
 IceMX::MetricsAdmin::_iceWriteImpl(::Ice::OutputStream* ostr) const
 {
     ostr->startSlice(ice_staticId(), -1, true);
-    Ice::StreamWriter< ::IceMX::MetricsAdmin, ::Ice::OutputStream>::write(ostr, *this);
+    ::Ice::StreamWriter< MetricsAdmin, ::Ice::OutputStream>::write(ostr, *this);
     ostr->endSlice();
 }
 
@@ -1459,26 +1597,31 @@ void
 IceMX::MetricsAdmin::_iceReadImpl(::Ice::InputStream* istr)
 {
     istr->startSlice();
-    Ice::StreamReader< ::IceMX::MetricsAdmin, ::Ice::InputStream>::read(istr, *this);
+    ::Ice::StreamReader< MetricsAdmin, ::Ice::InputStream>::read(istr, *this);
     istr->endSlice();
 }
+/// \endcond
 
+/// \cond INTERNAL
 void
 IceMX::_icePatchObjectPtr(MetricsAdminPtr& handle, const ::Ice::ObjectPtr& v)
 {
-    handle = ::IceMX::MetricsAdminPtr::dynamicCast(v);
+    handle = MetricsAdminPtr::dynamicCast(v);
     if(v && !handle)
     {
-        IceInternal::Ex::throwUOE(::IceMX::MetricsAdmin::ice_staticId(), v);
+        IceInternal::Ex::throwUOE(MetricsAdmin::ice_staticId(), v);
     }
 }
+/// \endcond
 
 IceMX::ThreadMetrics::~ThreadMetrics()
 {
 }
 
-ICE_API ::Ice::Object* IceMX::upCast(::IceMX::ThreadMetrics* p) { return p; }
+/// \cond INTERNAL
+ICE_API ::Ice::Object* IceMX::upCast(ThreadMetrics* p) { return p; }
 
+/// \endcond
 ::Ice::ObjectPtr
 IceMX::ThreadMetrics::ice_clone() const
 {
@@ -1526,23 +1669,25 @@ IceMX::ThreadMetrics::ice_staticId()
 #endif
 }
 
+/// \cond STREAM
 void
 IceMX::ThreadMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
 {
     ostr->startSlice(ice_staticId(), -1, false);
-    Ice::StreamWriter< ::IceMX::ThreadMetrics, ::Ice::OutputStream>::write(ostr, *this);
+    ::Ice::StreamWriter< ThreadMetrics, ::Ice::OutputStream>::write(ostr, *this);
     ostr->endSlice();
-    ::IceMX::Metrics::_iceWriteImpl(ostr);
+    Metrics::_iceWriteImpl(ostr);
 }
 
 void
 IceMX::ThreadMetrics::_iceReadImpl(::Ice::InputStream* istr)
 {
     istr->startSlice();
-    Ice::StreamReader< ::IceMX::ThreadMetrics, ::Ice::InputStream>::read(istr, *this);
+    ::Ice::StreamReader< ThreadMetrics, ::Ice::InputStream>::read(istr, *this);
     istr->endSlice();
-    ::IceMX::Metrics::_iceReadImpl(istr);
+    Metrics::_iceReadImpl(istr);
 }
+/// \endcond
 
 namespace
 {
@@ -1555,22 +1700,26 @@ IceMX::ThreadMetrics::ice_factory()
     return ::IceInternal::factoryTable->getValueFactory(::IceMX::ThreadMetrics::ice_staticId());
 }
 
+/// \cond INTERNAL
 void
 IceMX::_icePatchObjectPtr(ThreadMetricsPtr& handle, const ::Ice::ObjectPtr& v)
 {
-    handle = ::IceMX::ThreadMetricsPtr::dynamicCast(v);
+    handle = ThreadMetricsPtr::dynamicCast(v);
     if(v && !handle)
     {
-        IceInternal::Ex::throwUOE(::IceMX::ThreadMetrics::ice_staticId(), v);
+        IceInternal::Ex::throwUOE(ThreadMetrics::ice_staticId(), v);
     }
 }
+/// \endcond
 
 IceMX::DispatchMetrics::~DispatchMetrics()
 {
 }
 
-ICE_API ::Ice::Object* IceMX::upCast(::IceMX::DispatchMetrics* p) { return p; }
+/// \cond INTERNAL
+ICE_API ::Ice::Object* IceMX::upCast(DispatchMetrics* p) { return p; }
 
+/// \endcond
 ::Ice::ObjectPtr
 IceMX::DispatchMetrics::ice_clone() const
 {
@@ -1618,23 +1767,25 @@ IceMX::DispatchMetrics::ice_staticId()
 #endif
 }
 
+/// \cond STREAM
 void
 IceMX::DispatchMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
 {
     ostr->startSlice(ice_staticId(), -1, false);
-    Ice::StreamWriter< ::IceMX::DispatchMetrics, ::Ice::OutputStream>::write(ostr, *this);
+    ::Ice::StreamWriter< DispatchMetrics, ::Ice::OutputStream>::write(ostr, *this);
     ostr->endSlice();
-    ::IceMX::Metrics::_iceWriteImpl(ostr);
+    Metrics::_iceWriteImpl(ostr);
 }
 
 void
 IceMX::DispatchMetrics::_iceReadImpl(::Ice::InputStream* istr)
 {
     istr->startSlice();
-    Ice::StreamReader< ::IceMX::DispatchMetrics, ::Ice::InputStream>::read(istr, *this);
+    ::Ice::StreamReader< DispatchMetrics, ::Ice::InputStream>::read(istr, *this);
     istr->endSlice();
-    ::IceMX::Metrics::_iceReadImpl(istr);
+    Metrics::_iceReadImpl(istr);
 }
+/// \endcond
 
 namespace
 {
@@ -1647,22 +1798,26 @@ IceMX::DispatchMetrics::ice_factory()
     return ::IceInternal::factoryTable->getValueFactory(::IceMX::DispatchMetrics::ice_staticId());
 }
 
+/// \cond INTERNAL
 void
 IceMX::_icePatchObjectPtr(DispatchMetricsPtr& handle, const ::Ice::ObjectPtr& v)
 {
-    handle = ::IceMX::DispatchMetricsPtr::dynamicCast(v);
+    handle = DispatchMetricsPtr::dynamicCast(v);
     if(v && !handle)
     {
-        IceInternal::Ex::throwUOE(::IceMX::DispatchMetrics::ice_staticId(), v);
+        IceInternal::Ex::throwUOE(DispatchMetrics::ice_staticId(), v);
     }
 }
+/// \endcond
 
 IceMX::ChildInvocationMetrics::~ChildInvocationMetrics()
 {
 }
 
-ICE_API ::Ice::Object* IceMX::upCast(::IceMX::ChildInvocationMetrics* p) { return p; }
+/// \cond INTERNAL
+ICE_API ::Ice::Object* IceMX::upCast(ChildInvocationMetrics* p) { return p; }
 
+/// \endcond
 ::Ice::ObjectPtr
 IceMX::ChildInvocationMetrics::ice_clone() const
 {
@@ -1710,23 +1865,25 @@ IceMX::ChildInvocationMetrics::ice_staticId()
 #endif
 }
 
+/// \cond STREAM
 void
 IceMX::ChildInvocationMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
 {
     ostr->startSlice(ice_staticId(), -1, false);
-    Ice::StreamWriter< ::IceMX::ChildInvocationMetrics, ::Ice::OutputStream>::write(ostr, *this);
+    ::Ice::StreamWriter< ChildInvocationMetrics, ::Ice::OutputStream>::write(ostr, *this);
     ostr->endSlice();
-    ::IceMX::Metrics::_iceWriteImpl(ostr);
+    Metrics::_iceWriteImpl(ostr);
 }
 
 void
 IceMX::ChildInvocationMetrics::_iceReadImpl(::Ice::InputStream* istr)
 {
     istr->startSlice();
-    Ice::StreamReader< ::IceMX::ChildInvocationMetrics, ::Ice::InputStream>::read(istr, *this);
+    ::Ice::StreamReader< ChildInvocationMetrics, ::Ice::InputStream>::read(istr, *this);
     istr->endSlice();
-    ::IceMX::Metrics::_iceReadImpl(istr);
+    Metrics::_iceReadImpl(istr);
 }
+/// \endcond
 
 namespace
 {
@@ -1739,22 +1896,26 @@ IceMX::ChildInvocationMetrics::ice_factory()
     return ::IceInternal::factoryTable->getValueFactory(::IceMX::ChildInvocationMetrics::ice_staticId());
 }
 
+/// \cond INTERNAL
 void
 IceMX::_icePatchObjectPtr(ChildInvocationMetricsPtr& handle, const ::Ice::ObjectPtr& v)
 {
-    handle = ::IceMX::ChildInvocationMetricsPtr::dynamicCast(v);
+    handle = ChildInvocationMetricsPtr::dynamicCast(v);
     if(v && !handle)
     {
-        IceInternal::Ex::throwUOE(::IceMX::ChildInvocationMetrics::ice_staticId(), v);
+        IceInternal::Ex::throwUOE(ChildInvocationMetrics::ice_staticId(), v);
     }
 }
+/// \endcond
 
 IceMX::CollocatedMetrics::~CollocatedMetrics()
 {
 }
 
-ICE_API ::Ice::Object* IceMX::upCast(::IceMX::CollocatedMetrics* p) { return p; }
+/// \cond INTERNAL
+ICE_API ::Ice::Object* IceMX::upCast(CollocatedMetrics* p) { return p; }
 
+/// \endcond
 ::Ice::ObjectPtr
 IceMX::CollocatedMetrics::ice_clone() const
 {
@@ -1803,23 +1964,25 @@ IceMX::CollocatedMetrics::ice_staticId()
 #endif
 }
 
+/// \cond STREAM
 void
 IceMX::CollocatedMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
 {
     ostr->startSlice(ice_staticId(), -1, false);
-    Ice::StreamWriter< ::IceMX::CollocatedMetrics, ::Ice::OutputStream>::write(ostr, *this);
+    ::Ice::StreamWriter< CollocatedMetrics, ::Ice::OutputStream>::write(ostr, *this);
     ostr->endSlice();
-    ::IceMX::ChildInvocationMetrics::_iceWriteImpl(ostr);
+    ChildInvocationMetrics::_iceWriteImpl(ostr);
 }
 
 void
 IceMX::CollocatedMetrics::_iceReadImpl(::Ice::InputStream* istr)
 {
     istr->startSlice();
-    Ice::StreamReader< ::IceMX::CollocatedMetrics, ::Ice::InputStream>::read(istr, *this);
+    ::Ice::StreamReader< CollocatedMetrics, ::Ice::InputStream>::read(istr, *this);
     istr->endSlice();
-    ::IceMX::ChildInvocationMetrics::_iceReadImpl(istr);
+    ChildInvocationMetrics::_iceReadImpl(istr);
 }
+/// \endcond
 
 namespace
 {
@@ -1832,22 +1995,26 @@ IceMX::CollocatedMetrics::ice_factory()
     return ::IceInternal::factoryTable->getValueFactory(::IceMX::CollocatedMetrics::ice_staticId());
 }
 
+/// \cond INTERNAL
 void
 IceMX::_icePatchObjectPtr(CollocatedMetricsPtr& handle, const ::Ice::ObjectPtr& v)
 {
-    handle = ::IceMX::CollocatedMetricsPtr::dynamicCast(v);
+    handle = CollocatedMetricsPtr::dynamicCast(v);
     if(v && !handle)
     {
-        IceInternal::Ex::throwUOE(::IceMX::CollocatedMetrics::ice_staticId(), v);
+        IceInternal::Ex::throwUOE(CollocatedMetrics::ice_staticId(), v);
     }
 }
+/// \endcond
 
 IceMX::RemoteMetrics::~RemoteMetrics()
 {
 }
 
-ICE_API ::Ice::Object* IceMX::upCast(::IceMX::RemoteMetrics* p) { return p; }
+/// \cond INTERNAL
+ICE_API ::Ice::Object* IceMX::upCast(RemoteMetrics* p) { return p; }
 
+/// \endcond
 ::Ice::ObjectPtr
 IceMX::RemoteMetrics::ice_clone() const
 {
@@ -1896,23 +2063,25 @@ IceMX::RemoteMetrics::ice_staticId()
 #endif
 }
 
+/// \cond STREAM
 void
 IceMX::RemoteMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
 {
     ostr->startSlice(ice_staticId(), -1, false);
-    Ice::StreamWriter< ::IceMX::RemoteMetrics, ::Ice::OutputStream>::write(ostr, *this);
+    ::Ice::StreamWriter< RemoteMetrics, ::Ice::OutputStream>::write(ostr, *this);
     ostr->endSlice();
-    ::IceMX::ChildInvocationMetrics::_iceWriteImpl(ostr);
+    ChildInvocationMetrics::_iceWriteImpl(ostr);
 }
 
 void
 IceMX::RemoteMetrics::_iceReadImpl(::Ice::InputStream* istr)
 {
     istr->startSlice();
-    Ice::StreamReader< ::IceMX::RemoteMetrics, ::Ice::InputStream>::read(istr, *this);
+    ::Ice::StreamReader< RemoteMetrics, ::Ice::InputStream>::read(istr, *this);
     istr->endSlice();
-    ::IceMX::ChildInvocationMetrics::_iceReadImpl(istr);
+    ChildInvocationMetrics::_iceReadImpl(istr);
 }
+/// \endcond
 
 namespace
 {
@@ -1925,22 +2094,26 @@ IceMX::RemoteMetrics::ice_factory()
     return ::IceInternal::factoryTable->getValueFactory(::IceMX::RemoteMetrics::ice_staticId());
 }
 
+/// \cond INTERNAL
 void
 IceMX::_icePatchObjectPtr(RemoteMetricsPtr& handle, const ::Ice::ObjectPtr& v)
 {
-    handle = ::IceMX::RemoteMetricsPtr::dynamicCast(v);
+    handle = RemoteMetricsPtr::dynamicCast(v);
     if(v && !handle)
     {
-        IceInternal::Ex::throwUOE(::IceMX::RemoteMetrics::ice_staticId(), v);
+        IceInternal::Ex::throwUOE(RemoteMetrics::ice_staticId(), v);
     }
 }
+/// \endcond
 
 IceMX::InvocationMetrics::~InvocationMetrics()
 {
 }
 
-ICE_API ::Ice::Object* IceMX::upCast(::IceMX::InvocationMetrics* p) { return p; }
+/// \cond INTERNAL
+ICE_API ::Ice::Object* IceMX::upCast(InvocationMetrics* p) { return p; }
 
+/// \endcond
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1900)
 #   pragma warning(push)
@@ -2025,23 +2198,25 @@ IceMX::InvocationMetrics::_iceGcVisitMembers(::IceInternal::GCVisitor& v_)
     }
 }
 
+/// \cond STREAM
 void
 IceMX::InvocationMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
 {
     ostr->startSlice(ice_staticId(), -1, false);
-    Ice::StreamWriter< ::IceMX::InvocationMetrics, ::Ice::OutputStream>::write(ostr, *this);
+    ::Ice::StreamWriter< InvocationMetrics, ::Ice::OutputStream>::write(ostr, *this);
     ostr->endSlice();
-    ::IceMX::Metrics::_iceWriteImpl(ostr);
+    Metrics::_iceWriteImpl(ostr);
 }
 
 void
 IceMX::InvocationMetrics::_iceReadImpl(::Ice::InputStream* istr)
 {
     istr->startSlice();
-    Ice::StreamReader< ::IceMX::InvocationMetrics, ::Ice::InputStream>::read(istr, *this);
+    ::Ice::StreamReader< InvocationMetrics, ::Ice::InputStream>::read(istr, *this);
     istr->endSlice();
-    ::IceMX::Metrics::_iceReadImpl(istr);
+    Metrics::_iceReadImpl(istr);
 }
+/// \endcond
 
 namespace
 {
@@ -2054,22 +2229,26 @@ IceMX::InvocationMetrics::ice_factory()
     return ::IceInternal::factoryTable->getValueFactory(::IceMX::InvocationMetrics::ice_staticId());
 }
 
+/// \cond INTERNAL
 void
 IceMX::_icePatchObjectPtr(InvocationMetricsPtr& handle, const ::Ice::ObjectPtr& v)
 {
-    handle = ::IceMX::InvocationMetricsPtr::dynamicCast(v);
+    handle = InvocationMetricsPtr::dynamicCast(v);
     if(v && !handle)
     {
-        IceInternal::Ex::throwUOE(::IceMX::InvocationMetrics::ice_staticId(), v);
+        IceInternal::Ex::throwUOE(InvocationMetrics::ice_staticId(), v);
     }
 }
+/// \endcond
 
 IceMX::ConnectionMetrics::~ConnectionMetrics()
 {
 }
 
-ICE_API ::Ice::Object* IceMX::upCast(::IceMX::ConnectionMetrics* p) { return p; }
+/// \cond INTERNAL
+ICE_API ::Ice::Object* IceMX::upCast(ConnectionMetrics* p) { return p; }
 
+/// \endcond
 ::Ice::ObjectPtr
 IceMX::ConnectionMetrics::ice_clone() const
 {
@@ -2117,23 +2296,25 @@ IceMX::ConnectionMetrics::ice_staticId()
 #endif
 }
 
+/// \cond STREAM
 void
 IceMX::ConnectionMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
 {
     ostr->startSlice(ice_staticId(), -1, false);
-    Ice::StreamWriter< ::IceMX::ConnectionMetrics, ::Ice::OutputStream>::write(ostr, *this);
+    ::Ice::StreamWriter< ConnectionMetrics, ::Ice::OutputStream>::write(ostr, *this);
     ostr->endSlice();
-    ::IceMX::Metrics::_iceWriteImpl(ostr);
+    Metrics::_iceWriteImpl(ostr);
 }
 
 void
 IceMX::ConnectionMetrics::_iceReadImpl(::Ice::InputStream* istr)
 {
     istr->startSlice();
-    Ice::StreamReader< ::IceMX::ConnectionMetrics, ::Ice::InputStream>::read(istr, *this);
+    ::Ice::StreamReader< ConnectionMetrics, ::Ice::InputStream>::read(istr, *this);
     istr->endSlice();
-    ::IceMX::Metrics::_iceReadImpl(istr);
+    Metrics::_iceReadImpl(istr);
 }
+/// \endcond
 
 namespace
 {
@@ -2146,15 +2327,17 @@ IceMX::ConnectionMetrics::ice_factory()
     return ::IceInternal::factoryTable->getValueFactory(::IceMX::ConnectionMetrics::ice_staticId());
 }
 
+/// \cond INTERNAL
 void
 IceMX::_icePatchObjectPtr(ConnectionMetricsPtr& handle, const ::Ice::ObjectPtr& v)
 {
-    handle = ::IceMX::ConnectionMetricsPtr::dynamicCast(v);
+    handle = ConnectionMetricsPtr::dynamicCast(v);
     if(v && !handle)
     {
-        IceInternal::Ex::throwUOE(::IceMX::ConnectionMetrics::ice_staticId(), v);
+        IceInternal::Ex::throwUOE(ConnectionMetrics::ice_staticId(), v);
     }
 }
+/// \endcond
 
 namespace Ice
 {