zeroc-ice 3.7.10 → 3.7.11

data/dist/ice/cpp/src/Ice/generated/Metrics.cpp

@@ -0,0 +1,2352 @@
+//
+// Copyright (c) ZeroC, Inc. All rights reserved.
+//
+//
+// Ice version 3.7.11
+//
+// <auto-generated>
+//
+// Generated from file `Metrics.ice'
+//
+// Warning: do not edit this file.
+//
+// </auto-generated>
+//
+
+#ifndef ICE_API_EXPORTS
+#   define ICE_API_EXPORTS
+#endif
+#include <Ice/Metrics.h>
+#include <IceUtil/PushDisableWarnings.h>
+#include <Ice/LocalException.h>
+#include <Ice/ValueFactory.h>
+#include <Ice/OutgoingAsync.h>
+#include <Ice/InputStream.h>
+#include <Ice/OutputStream.h>
+#include <Ice/LocalException.h>
+#include <IceUtil/PopDisableWarnings.h>
+
+#if defined(_MSC_VER)
+#   pragma warning(disable:4458) // declaration of ... hides class member
+#elif defined(__clang__)
+#   pragma clang diagnostic ignored "-Wshadow"
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic ignored "-Wshadow"
+#endif
+
+#ifndef ICE_IGNORE_VERSION
+#   if ICE_INT_VERSION / 100 != 307
+#       error Ice version mismatch!
+#   endif
+#   if ICE_INT_VERSION % 100 >= 50
+#       error Beta header file detected
+#   endif
+#   if ICE_INT_VERSION % 100 < 11
+#       error Ice patch level mismatch!
+#   endif
+#endif
+
+#ifdef ICE_CPP11_MAPPING // C++11 mapping
+
+namespace
+{
+
+const ::IceInternal::DefaultValueFactoryInit<::IceMX::Metrics> iceC_IceMX_Metrics_init("::IceMX::Metrics");
+
+const ::IceInternal::DefaultUserExceptionFactoryInit<::IceMX::UnknownMetricsView> iceC_IceMX_UnknownMetricsView_init("::IceMX::UnknownMetricsView");
+
+const ::std::string iceC_IceMX_MetricsAdmin_ids[2] =
+{
+    "::Ice::Object",
+    "::IceMX::MetricsAdmin"
+};
+const ::std::string iceC_IceMX_MetricsAdmin_ops[] =
+{
+    "disableMetricsView",
+    "enableMetricsView",
+    "getMapMetricsFailures",
+    "getMetricsFailures",
+    "getMetricsView",
+    "getMetricsViewNames",
+    "ice_id",
+    "ice_ids",
+    "ice_isA",
+    "ice_ping"
+};
+const ::std::string iceC_IceMX_MetricsAdmin_getMetricsViewNames_name = "getMetricsViewNames";
+const ::std::string iceC_IceMX_MetricsAdmin_enableMetricsView_name = "enableMetricsView";
+const ::std::string iceC_IceMX_MetricsAdmin_disableMetricsView_name = "disableMetricsView";
+const ::std::string iceC_IceMX_MetricsAdmin_getMetricsView_name = "getMetricsView";
+const ::std::string iceC_IceMX_MetricsAdmin_getMapMetricsFailures_name = "getMapMetricsFailures";
+const ::std::string iceC_IceMX_MetricsAdmin_getMetricsFailures_name = "getMetricsFailures";
+
+const ::IceInternal::DefaultValueFactoryInit<::IceMX::ThreadMetrics> iceC_IceMX_ThreadMetrics_init("::IceMX::ThreadMetrics");
+
+const ::IceInternal::DefaultValueFactoryInit<::IceMX::DispatchMetrics> iceC_IceMX_DispatchMetrics_init("::IceMX::DispatchMetrics");
+
+const ::IceInternal::DefaultValueFactoryInit<::IceMX::ChildInvocationMetrics> iceC_IceMX_ChildInvocationMetrics_init("::IceMX::ChildInvocationMetrics");
+
+const ::IceInternal::DefaultValueFactoryInit<::IceMX::CollocatedMetrics> iceC_IceMX_CollocatedMetrics_init("::IceMX::CollocatedMetrics");
+
+const ::IceInternal::DefaultValueFactoryInit<::IceMX::RemoteMetrics> iceC_IceMX_RemoteMetrics_init("::IceMX::RemoteMetrics");
+
+const ::IceInternal::DefaultValueFactoryInit<::IceMX::InvocationMetrics> iceC_IceMX_InvocationMetrics_init("::IceMX::InvocationMetrics");
+
+const ::IceInternal::DefaultValueFactoryInit<::IceMX::ConnectionMetrics> iceC_IceMX_ConnectionMetrics_init("::IceMX::ConnectionMetrics");
+
+}
+
+IceMX::UnknownMetricsView::~UnknownMetricsView()
+{
+}
+
+const ::std::string&
+IceMX::UnknownMetricsView::ice_staticId()
+{
+    static const ::std::string typeId = "::IceMX::UnknownMetricsView";
+    return typeId;
+}
+
+bool
+IceMX::MetricsAdmin::ice_isA(::std::string s, const ::Ice::Current&) const
+{
+    return ::std::binary_search(iceC_IceMX_MetricsAdmin_ids, iceC_IceMX_MetricsAdmin_ids + 2, s);
+}
+
+::std::vector<::std::string>
+IceMX::MetricsAdmin::ice_ids(const ::Ice::Current&) const
+{
+    return ::std::vector<::std::string>(&iceC_IceMX_MetricsAdmin_ids[0], &iceC_IceMX_MetricsAdmin_ids[2]);
+}
+
+::std::string
+IceMX::MetricsAdmin::ice_id(const ::Ice::Current&) const
+{
+    return ice_staticId();
+}
+
+const ::std::string&
+IceMX::MetricsAdmin::ice_staticId()
+{
+    static const ::std::string typeId = "::IceMX::MetricsAdmin";
+    return typeId;
+}
+
+/// \cond INTERNAL
+bool
+IceMX::MetricsAdmin::_iceD_getMetricsViewNames(::IceInternal::Incoming& inS, const ::Ice::Current& current)
+{
+    _iceCheckMode(::Ice::OperationMode::Normal, current.mode);
+    inS.readEmptyParams();
+    inS.setFormat(::Ice::FormatType::SlicedFormat);
+    ::Ice::StringSeq iceP_disabledViews;
+    ::Ice::StringSeq ret = this->getMetricsViewNames(iceP_disabledViews, current);
+    auto ostr = inS.startWriteParams();
+    ostr->writeAll(iceP_disabledViews, ret);
+    inS.endWriteParams();
+    return true;
+}
+/// \endcond
+
+/// \cond INTERNAL
+bool
+IceMX::MetricsAdmin::_iceD_enableMetricsView(::IceInternal::Incoming& inS, const ::Ice::Current& current)
+{
+    _iceCheckMode(::Ice::OperationMode::Normal, current.mode);
+    auto istr = inS.startReadParams();
+    ::std::string iceP_name;
+    istr->readAll(iceP_name);
+    inS.endReadParams();
+    inS.setFormat(::Ice::FormatType::SlicedFormat);
+    this->enableMetricsView(::std::move(iceP_name), current);
+    inS.writeEmptyParams();
+    return true;
+}
+/// \endcond
+
+/// \cond INTERNAL
+bool
+IceMX::MetricsAdmin::_iceD_disableMetricsView(::IceInternal::Incoming& inS, const ::Ice::Current& current)
+{
+    _iceCheckMode(::Ice::OperationMode::Normal, current.mode);
+    auto istr = inS.startReadParams();
+    ::std::string iceP_name;
+    istr->readAll(iceP_name);
+    inS.endReadParams();
+    inS.setFormat(::Ice::FormatType::SlicedFormat);
+    this->disableMetricsView(::std::move(iceP_name), current);
+    inS.writeEmptyParams();
+    return true;
+}
+/// \endcond
+
+/// \cond INTERNAL
+bool
+IceMX::MetricsAdmin::_iceD_getMetricsView(::IceInternal::Incoming& inS, const ::Ice::Current& current)
+{
+    _iceCheckMode(::Ice::OperationMode::Normal, current.mode);
+    auto istr = inS.startReadParams();
+    ::std::string iceP_view;
+    istr->readAll(iceP_view);
+    inS.endReadParams();
+    inS.setFormat(::Ice::FormatType::SlicedFormat);
+    long long int iceP_timestamp;
+    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)
+{
+    _iceCheckMode(::Ice::OperationMode::Normal, current.mode);
+    auto istr = inS.startReadParams();
+    ::std::string iceP_view;
+    ::std::string iceP_map;
+    istr->readAll(iceP_view, iceP_map);
+    inS.endReadParams();
+    inS.setFormat(::Ice::FormatType::SlicedFormat);
+    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)
+{
+    _iceCheckMode(::Ice::OperationMode::Normal, current.mode);
+    auto istr = inS.startReadParams();
+    ::std::string iceP_view;
+    ::std::string iceP_map;
+    ::std::string iceP_id;
+    istr->readAll(iceP_view, iceP_map, iceP_id);
+    inS.endReadParams();
+    inS.setFormat(::Ice::FormatType::SlicedFormat);
+    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)
+{
+    ::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_IceMX_MetricsAdmin_ops, iceC_IceMX_MetricsAdmin_ops + 10, current.operation);
+    if(r.first == r.second)
+    {
+        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
+    }
+
+    switch(r.first - iceC_IceMX_MetricsAdmin_ops)
+    {
+        case 0:
+        {
+            return _iceD_disableMetricsView(in, current);
+        }
+        case 1:
+        {
+            return _iceD_enableMetricsView(in, current);
+        }
+        case 2:
+        {
+            return _iceD_getMapMetricsFailures(in, current);
+        }
+        case 3:
+        {
+            return _iceD_getMetricsFailures(in, current);
+        }
+        case 4:
+        {
+            return _iceD_getMetricsView(in, current);
+        }
+        case 5:
+        {
+            return _iceD_getMetricsViewNames(in, current);
+        }
+        case 6:
+        {
+            return _iceD_ice_id(in, current);
+        }
+        case 7:
+        {
+            return _iceD_ice_ids(in, current);
+        }
+        case 8:
+        {
+            return _iceD_ice_isA(in, current);
+        }
+        case 9:
+        {
+            return _iceD_ice_ping(in, current);
+        }
+        default:
+        {
+            assert(false);
+            throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
+        }
+    }
+}
+/// \endcond
+
+IceMX::Metrics::~Metrics()
+{
+}
+
+const ::std::string&
+IceMX::Metrics::ice_staticId()
+{
+    static const ::std::string typeId = "::IceMX::Metrics";
+    return typeId;
+}
+
+IceMX::ThreadMetrics::~ThreadMetrics()
+{
+}
+
+const ::std::string&
+IceMX::ThreadMetrics::ice_staticId()
+{
+    static const ::std::string typeId = "::IceMX::ThreadMetrics";
+    return typeId;
+}
+
+IceMX::DispatchMetrics::~DispatchMetrics()
+{
+}
+
+const ::std::string&
+IceMX::DispatchMetrics::ice_staticId()
+{
+    static const ::std::string typeId = "::IceMX::DispatchMetrics";
+    return typeId;
+}
+
+IceMX::ChildInvocationMetrics::~ChildInvocationMetrics()
+{
+}
+
+const ::std::string&
+IceMX::ChildInvocationMetrics::ice_staticId()
+{
+    static const ::std::string typeId = "::IceMX::ChildInvocationMetrics";
+    return typeId;
+}
+
+IceMX::CollocatedMetrics::~CollocatedMetrics()
+{
+}
+
+const ::std::string&
+IceMX::CollocatedMetrics::ice_staticId()
+{
+    static const ::std::string typeId = "::IceMX::CollocatedMetrics";
+    return typeId;
+}
+
+IceMX::RemoteMetrics::~RemoteMetrics()
+{
+}
+
+const ::std::string&
+IceMX::RemoteMetrics::ice_staticId()
+{
+    static const ::std::string typeId = "::IceMX::RemoteMetrics";
+    return typeId;
+}
+
+IceMX::InvocationMetrics::~InvocationMetrics()
+{
+}
+
+const ::std::string&
+IceMX::InvocationMetrics::ice_staticId()
+{
+    static const ::std::string typeId = "::IceMX::InvocationMetrics";
+    return typeId;
+}
+
+IceMX::ConnectionMetrics::~ConnectionMetrics()
+{
+}
+
+const ::std::string&
+IceMX::ConnectionMetrics::ice_staticId()
+{
+    static const ::std::string typeId = "::IceMX::ConnectionMetrics";
+    return typeId;
+}
+
+/// \cond INTERNAL
+void
+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,
+        nullptr,
+        nullptr,
+        [](::Ice::InputStream* istr)
+        {
+            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)
+{
+    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_enableMetricsView_name);
+    outAsync->invoke(iceC_IceMX_MetricsAdmin_enableMetricsView_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::SlicedFormat, context,
+        [&](::Ice::OutputStream* ostr)
+        {
+            ostr->writeAll(iceP_name);
+        },
+        [](const ::Ice::UserException& ex)
+        {
+            try
+            {
+                ex.ice_throw();
+            }
+            catch(const UnknownMetricsView&)
+            {
+                throw;
+            }
+            catch(const ::Ice::UserException&)
+            {
+            }
+        });
+}
+/// \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)
+{
+    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_disableMetricsView_name);
+    outAsync->invoke(iceC_IceMX_MetricsAdmin_disableMetricsView_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::SlicedFormat, context,
+        [&](::Ice::OutputStream* ostr)
+        {
+            ostr->writeAll(iceP_name);
+        },
+        [](const ::Ice::UserException& ex)
+        {
+            try
+            {
+                ex.ice_throw();
+            }
+            catch(const UnknownMetricsView&)
+            {
+                throw;
+            }
+            catch(const ::Ice::UserException&)
+            {
+            }
+        });
+}
+/// \endcond
+
+/// \cond INTERNAL
+void
+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,
+        [&](::Ice::OutputStream* ostr)
+        {
+            ostr->writeAll(iceP_view);
+        },
+        [](const ::Ice::UserException& ex)
+        {
+            try
+            {
+                ex.ice_throw();
+            }
+            catch(const UnknownMetricsView&)
+            {
+                throw;
+            }
+            catch(const ::Ice::UserException&)
+            {
+            }
+        },
+        [](::Ice::InputStream* istr)
+        {
+            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)
+{
+    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_getMapMetricsFailures_name);
+    outAsync->invoke(iceC_IceMX_MetricsAdmin_getMapMetricsFailures_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::SlicedFormat, context,
+        [&](::Ice::OutputStream* ostr)
+        {
+            ostr->writeAll(iceP_view, iceP_map);
+        },
+        [](const ::Ice::UserException& ex)
+        {
+            try
+            {
+                ex.ice_throw();
+            }
+            catch(const UnknownMetricsView&)
+            {
+                throw;
+            }
+            catch(const ::Ice::UserException&)
+            {
+            }
+        });
+}
+/// \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)
+{
+    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_getMetricsFailures_name);
+    outAsync->invoke(iceC_IceMX_MetricsAdmin_getMetricsFailures_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::SlicedFormat, context,
+        [&](::Ice::OutputStream* ostr)
+        {
+            ostr->writeAll(iceP_view, iceP_map, iceP_id);
+        },
+        [](const ::Ice::UserException& ex)
+        {
+            try
+            {
+                ex.ice_throw();
+            }
+            catch(const UnknownMetricsView&)
+            {
+                throw;
+            }
+            catch(const ::Ice::UserException&)
+            {
+            }
+        });
+}
+/// \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 MetricsAdmin::ice_staticId();
+}
+
+namespace Ice
+{
+}
+
+#else // C++98 mapping
+
+namespace
+{
+
+const ::std::string iceC_IceMX_MetricsAdmin_getMetricsViewNames_name = "getMetricsViewNames";
+
+const ::std::string iceC_IceMX_MetricsAdmin_enableMetricsView_name = "enableMetricsView";
+
+const ::std::string iceC_IceMX_MetricsAdmin_disableMetricsView_name = "disableMetricsView";
+
+const ::std::string iceC_IceMX_MetricsAdmin_getMetricsView_name = "getMetricsView";
+
+const ::std::string iceC_IceMX_MetricsAdmin_getMapMetricsFailures_name = "getMapMetricsFailures";
+
+const ::std::string iceC_IceMX_MetricsAdmin_getMetricsFailures_name = "getMetricsFailures";
+
+}
+
+namespace
+{
+
+const ::IceInternal::DefaultUserExceptionFactoryInit< ::IceMX::UnknownMetricsView> iceC_IceMX_UnknownMetricsView_init("::IceMX::UnknownMetricsView");
+
+}
+
+#ifdef ICE_CPP11_COMPILER
+IceMX::UnknownMetricsView::~UnknownMetricsView()
+{
+}
+#else
+IceMX::UnknownMetricsView::~UnknownMetricsView() throw()
+{
+}
+#endif
+
+::std::string
+IceMX::UnknownMetricsView::ice_id() const
+{
+    return "::IceMX::UnknownMetricsView";
+}
+
+IceMX::UnknownMetricsView*
+IceMX::UnknownMetricsView::ice_clone() const
+{
+    return new UnknownMetricsView(*this);
+}
+
+void
+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< UnknownMetricsView, ::Ice::OutputStream>::write(ostr, *this);
+    ostr->endSlice();
+}
+
+void
+IceMX::UnknownMetricsView::_readImpl(::Ice::InputStream* istr)
+{
+    istr->startSlice();
+    ::Ice::StreamReader< UnknownMetricsView, ::Ice::InputStream>::read(istr, *this);
+    istr->endSlice();
+}
+/// \endcond
+
+/// \cond INTERNAL
+ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(Metrics* p) { return p; }
+
+void
+::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< Metrics>& v)
+{
+    ::Ice::ObjectPrx proxy;
+    istr->read(proxy);
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        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();
+}
+
+/// \cond INTERNAL
+ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(MetricsAdmin* p) { return p; }
+
+void
+::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< MetricsAdmin>& v)
+{
+    ::Ice::ObjectPrx proxy;
+    istr->read(proxy);
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        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)
+{
+    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_getMetricsViewNames_name, sync);
+    ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_IceMX_MetricsAdmin_getMetricsViewNames_name, del, cookie, sync);
+    try
+    {
+        result->prepare(iceC_IceMX_MetricsAdmin_getMetricsViewNames_name, ::Ice::Normal, context);
+        result->writeEmptyParams();
+        result->invoke(iceC_IceMX_MetricsAdmin_getMetricsViewNames_name);
+    }
+    catch(const ::Ice::Exception& ex)
+    {
+        result->abort(ex);
+    }
+    return result;
+}
+
+::Ice::StringSeq
+IceProxy::IceMX::MetricsAdmin::end_getMetricsViewNames(::Ice::StringSeq& iceP_disabledViews, const ::Ice::AsyncResultPtr& result)
+{
+    ::Ice::AsyncResult::_check(result, this, iceC_IceMX_MetricsAdmin_getMetricsViewNames_name);
+    ::Ice::StringSeq ret;
+    if(!result->_waitForResponse())
+    {
+        try
+        {
+            result->_throwUserException();
+        }
+        catch(const ::Ice::UserException& ex)
+        {
+            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
+        }
+    }
+    ::Ice::InputStream* istr = result->_startReadParams();
+    istr->read(iceP_disabledViews);
+    istr->read(ret);
+    result->_endReadParams();
+    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)
+{
+    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_enableMetricsView_name, sync);
+    ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_IceMX_MetricsAdmin_enableMetricsView_name, del, cookie, sync);
+    try
+    {
+        result->prepare(iceC_IceMX_MetricsAdmin_enableMetricsView_name, ::Ice::Normal, context);
+        ::Ice::OutputStream* ostr = result->startWriteParams(::Ice::SlicedFormat);
+        ostr->write(iceP_name);
+        result->endWriteParams();
+        result->invoke(iceC_IceMX_MetricsAdmin_enableMetricsView_name);
+    }
+    catch(const ::Ice::Exception& ex)
+    {
+        result->abort(ex);
+    }
+    return result;
+}
+
+void
+IceProxy::IceMX::MetricsAdmin::end_enableMetricsView(const ::Ice::AsyncResultPtr& result)
+{
+    ::Ice::AsyncResult::_check(result, this, iceC_IceMX_MetricsAdmin_enableMetricsView_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());
+        }
+    }
+    result->_readEmptyParams();
+}
+
+::Ice::AsyncResultPtr
+IceProxy::IceMX::MetricsAdmin::_iceI_begin_disableMetricsView(const ::std::string& iceP_name, const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
+{
+    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_disableMetricsView_name, sync);
+    ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_IceMX_MetricsAdmin_disableMetricsView_name, del, cookie, sync);
+    try
+    {
+        result->prepare(iceC_IceMX_MetricsAdmin_disableMetricsView_name, ::Ice::Normal, context);
+        ::Ice::OutputStream* ostr = result->startWriteParams(::Ice::SlicedFormat);
+        ostr->write(iceP_name);
+        result->endWriteParams();
+        result->invoke(iceC_IceMX_MetricsAdmin_disableMetricsView_name);
+    }
+    catch(const ::Ice::Exception& ex)
+    {
+        result->abort(ex);
+    }
+    return result;
+}
+
+void
+IceProxy::IceMX::MetricsAdmin::end_disableMetricsView(const ::Ice::AsyncResultPtr& result)
+{
+    ::Ice::AsyncResult::_check(result, this, iceC_IceMX_MetricsAdmin_disableMetricsView_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());
+        }
+    }
+    result->_readEmptyParams();
+}
+
+::Ice::AsyncResultPtr
+IceProxy::IceMX::MetricsAdmin::_iceI_begin_getMetricsView(const ::std::string& iceP_view, const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
+{
+    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_getMetricsView_name, sync);
+    ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_IceMX_MetricsAdmin_getMetricsView_name, del, cookie, sync);
+    try
+    {
+        result->prepare(iceC_IceMX_MetricsAdmin_getMetricsView_name, ::Ice::Normal, context);
+        ::Ice::OutputStream* ostr = result->startWriteParams(::Ice::SlicedFormat);
+        ostr->write(iceP_view);
+        result->endWriteParams();
+        result->invoke(iceC_IceMX_MetricsAdmin_getMetricsView_name);
+    }
+    catch(const ::Ice::Exception& ex)
+    {
+        result->abort(ex);
+    }
+    return result;
+}
+
+::IceMX::MetricsView
+IceProxy::IceMX::MetricsAdmin::end_getMetricsView(::Ice::Long& iceP_timestamp, const ::Ice::AsyncResultPtr& result)
+{
+    ::Ice::AsyncResult::_check(result, this, iceC_IceMX_MetricsAdmin_getMetricsView_name);
+    ::IceMX::MetricsView ret;
+    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();
+    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)
+{
+    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_getMapMetricsFailures_name, sync);
+    ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_IceMX_MetricsAdmin_getMapMetricsFailures_name, del, cookie, sync);
+    try
+    {
+        result->prepare(iceC_IceMX_MetricsAdmin_getMapMetricsFailures_name, ::Ice::Normal, context);
+        ::Ice::OutputStream* ostr = result->startWriteParams(::Ice::SlicedFormat);
+        ostr->write(iceP_view);
+        ostr->write(iceP_map);
+        result->endWriteParams();
+        result->invoke(iceC_IceMX_MetricsAdmin_getMapMetricsFailures_name);
+    }
+    catch(const ::Ice::Exception& ex)
+    {
+        result->abort(ex);
+    }
+    return result;
+}
+
+::IceMX::MetricsFailuresSeq
+IceProxy::IceMX::MetricsAdmin::end_getMapMetricsFailures(const ::Ice::AsyncResultPtr& result)
+{
+    ::Ice::AsyncResult::_check(result, this, iceC_IceMX_MetricsAdmin_getMapMetricsFailures_name);
+    ::IceMX::MetricsFailuresSeq ret;
+    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(ret);
+    result->_endReadParams();
+    return ret;
+}
+
+::Ice::AsyncResultPtr
+IceProxy::IceMX::MetricsAdmin::_iceI_begin_getMetricsFailures(const ::std::string& iceP_view, const ::std::string& iceP_map, const ::std::string& iceP_id, const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
+{
+    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_getMetricsFailures_name, sync);
+    ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_IceMX_MetricsAdmin_getMetricsFailures_name, del, cookie, sync);
+    try
+    {
+        result->prepare(iceC_IceMX_MetricsAdmin_getMetricsFailures_name, ::Ice::Normal, context);
+        ::Ice::OutputStream* ostr = result->startWriteParams(::Ice::SlicedFormat);
+        ostr->write(iceP_view);
+        ostr->write(iceP_map);
+        ostr->write(iceP_id);
+        result->endWriteParams();
+        result->invoke(iceC_IceMX_MetricsAdmin_getMetricsFailures_name);
+    }
+    catch(const ::Ice::Exception& ex)
+    {
+        result->abort(ex);
+    }
+    return result;
+}
+
+::IceMX::MetricsFailures
+IceProxy::IceMX::MetricsAdmin::end_getMetricsFailures(const ::Ice::AsyncResultPtr& result)
+{
+    ::Ice::AsyncResult::_check(result, this, iceC_IceMX_MetricsAdmin_getMetricsFailures_name);
+    ::IceMX::MetricsFailures ret;
+    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(ret);
+    result->_endReadParams();
+    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();
+}
+
+/// \cond INTERNAL
+ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(ThreadMetrics* p) { return p; }
+
+void
+::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ThreadMetrics>& v)
+{
+    ::Ice::ObjectPrx proxy;
+    istr->read(proxy);
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        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();
+}
+
+/// \cond INTERNAL
+ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(DispatchMetrics* p) { return p; }
+
+void
+::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< DispatchMetrics>& v)
+{
+    ::Ice::ObjectPrx proxy;
+    istr->read(proxy);
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        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();
+}
+
+/// \cond INTERNAL
+ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(ChildInvocationMetrics* p) { return p; }
+
+void
+::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ChildInvocationMetrics>& v)
+{
+    ::Ice::ObjectPrx proxy;
+    istr->read(proxy);
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        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();
+}
+
+/// \cond INTERNAL
+ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(CollocatedMetrics* p) { return p; }
+
+void
+::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< CollocatedMetrics>& v)
+{
+    ::Ice::ObjectPrx proxy;
+    istr->read(proxy);
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        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();
+}
+
+/// \cond INTERNAL
+ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(RemoteMetrics* p) { return p; }
+
+void
+::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< RemoteMetrics>& v)
+{
+    ::Ice::ObjectPrx proxy;
+    istr->read(proxy);
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        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();
+}
+
+/// \cond INTERNAL
+ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(InvocationMetrics* p) { return p; }
+
+void
+::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< InvocationMetrics>& v)
+{
+    ::Ice::ObjectPrx proxy;
+    istr->read(proxy);
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        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();
+}
+
+/// \cond INTERNAL
+ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(ConnectionMetrics* p) { return p; }
+
+void
+::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ConnectionMetrics>& v)
+{
+    ::Ice::ObjectPrx proxy;
+    istr->read(proxy);
+    if(!proxy)
+    {
+        v = 0;
+    }
+    else
+    {
+        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()
+{
+    return ::IceMX::ConnectionMetrics::ice_staticId();
+}
+
+IceMX::Metrics::~Metrics()
+{
+}
+
+/// \cond INTERNAL
+ICE_API ::Ice::Object* IceMX::upCast(Metrics* p) { return p; }
+
+/// \endcond
+::Ice::ObjectPtr
+IceMX::Metrics::ice_clone() const
+{
+    ::Ice::Object* p = new Metrics(*this);
+    return p;
+}
+
+namespace
+{
+const ::std::string iceC_IceMX_Metrics_ids[2] =
+{
+    "::Ice::Object",
+    "::IceMX::Metrics"
+};
+
+}
+
+bool
+IceMX::Metrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
+{
+    return ::std::binary_search(iceC_IceMX_Metrics_ids, iceC_IceMX_Metrics_ids + 2, s);
+}
+
+::std::vector< ::std::string>
+IceMX::Metrics::ice_ids(const ::Ice::Current&) const
+{
+    return ::std::vector< ::std::string>(&iceC_IceMX_Metrics_ids[0], &iceC_IceMX_Metrics_ids[2]);
+}
+
+const ::std::string&
+IceMX::Metrics::ice_id(const ::Ice::Current&) const
+{
+    return ice_staticId();
+}
+
+const ::std::string&
+IceMX::Metrics::ice_staticId()
+{
+#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
+    static const ::std::string typeId = "::IceMX::Metrics";
+    return typeId;
+#else
+    return iceC_IceMX_Metrics_ids[1];
+#endif
+}
+
+/// \cond STREAM
+void
+IceMX::Metrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
+{
+    ostr->startSlice(ice_staticId(), -1, true);
+    ::Ice::StreamWriter< Metrics, ::Ice::OutputStream>::write(ostr, *this);
+    ostr->endSlice();
+}
+
+void
+IceMX::Metrics::_iceReadImpl(::Ice::InputStream* istr)
+{
+    istr->startSlice();
+    ::Ice::StreamReader< Metrics, ::Ice::InputStream>::read(istr, *this);
+    istr->endSlice();
+}
+/// \endcond
+
+namespace
+{
+const ::IceInternal::DefaultValueFactoryInit< ::IceMX::Metrics> iceC_IceMX_Metrics_init("::IceMX::Metrics");
+}
+
+::Ice::ValueFactoryPtr
+IceMX::Metrics::ice_factory()
+{
+    return ::IceInternal::factoryTable->getValueFactory(::IceMX::Metrics::ice_staticId());
+}
+
+/// \cond INTERNAL
+void
+IceMX::_icePatchObjectPtr(MetricsPtr& handle, const ::Ice::ObjectPtr& v)
+{
+    handle = MetricsPtr::dynamicCast(v);
+    if(v && !handle)
+    {
+        IceInternal::Ex::throwUOE(Metrics::ice_staticId(), v);
+    }
+}
+/// \endcond
+
+IceMX::MetricsAdmin::~MetricsAdmin()
+{
+}
+
+/// \cond INTERNAL
+ICE_API ::Ice::Object* IceMX::upCast(MetricsAdmin* p) { return p; }
+
+/// \endcond
+
+namespace
+{
+const ::std::string iceC_IceMX_MetricsAdmin_ids[2] =
+{
+    "::Ice::Object",
+    "::IceMX::MetricsAdmin"
+};
+
+}
+
+bool
+IceMX::MetricsAdmin::ice_isA(const ::std::string& s, const ::Ice::Current&) const
+{
+    return ::std::binary_search(iceC_IceMX_MetricsAdmin_ids, iceC_IceMX_MetricsAdmin_ids + 2, s);
+}
+
+::std::vector< ::std::string>
+IceMX::MetricsAdmin::ice_ids(const ::Ice::Current&) const
+{
+    return ::std::vector< ::std::string>(&iceC_IceMX_MetricsAdmin_ids[0], &iceC_IceMX_MetricsAdmin_ids[2]);
+}
+
+const ::std::string&
+IceMX::MetricsAdmin::ice_id(const ::Ice::Current&) const
+{
+    return ice_staticId();
+}
+
+const ::std::string&
+IceMX::MetricsAdmin::ice_staticId()
+{
+#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
+    static const ::std::string typeId = "::IceMX::MetricsAdmin";
+    return typeId;
+#else
+    return iceC_IceMX_MetricsAdmin_ids[1];
+#endif
+}
+
+/// \cond INTERNAL
+bool
+IceMX::MetricsAdmin::_iceD_getMetricsViewNames(::IceInternal::Incoming& inS, const ::Ice::Current& current)
+{
+    _iceCheckMode(::Ice::Normal, current.mode);
+    inS.readEmptyParams();
+    inS.setFormat(::Ice::SlicedFormat);
+    ::Ice::StringSeq iceP_disabledViews;
+    ::Ice::StringSeq ret = this->getMetricsViewNames(iceP_disabledViews, current);
+    ::Ice::OutputStream* ostr = inS.startWriteParams();
+    ostr->write(iceP_disabledViews);
+    ostr->write(ret);
+    inS.endWriteParams();
+    return true;
+}
+/// \endcond
+
+/// \cond INTERNAL
+bool
+IceMX::MetricsAdmin::_iceD_enableMetricsView(::IceInternal::Incoming& inS, const ::Ice::Current& current)
+{
+    _iceCheckMode(::Ice::Normal, current.mode);
+    ::Ice::InputStream* istr = inS.startReadParams();
+    ::std::string iceP_name;
+    istr->read(iceP_name);
+    inS.endReadParams();
+    inS.setFormat(::Ice::SlicedFormat);
+    this->enableMetricsView(iceP_name, current);
+    inS.writeEmptyParams();
+    return true;
+}
+/// \endcond
+
+/// \cond INTERNAL
+bool
+IceMX::MetricsAdmin::_iceD_disableMetricsView(::IceInternal::Incoming& inS, const ::Ice::Current& current)
+{
+    _iceCheckMode(::Ice::Normal, current.mode);
+    ::Ice::InputStream* istr = inS.startReadParams();
+    ::std::string iceP_name;
+    istr->read(iceP_name);
+    inS.endReadParams();
+    inS.setFormat(::Ice::SlicedFormat);
+    this->disableMetricsView(iceP_name, current);
+    inS.writeEmptyParams();
+    return true;
+}
+/// \endcond
+
+/// \cond INTERNAL
+bool
+IceMX::MetricsAdmin::_iceD_getMetricsView(::IceInternal::Incoming& inS, const ::Ice::Current& current)
+{
+    _iceCheckMode(::Ice::Normal, current.mode);
+    ::Ice::InputStream* istr = inS.startReadParams();
+    ::std::string iceP_view;
+    istr->read(iceP_view);
+    inS.endReadParams();
+    inS.setFormat(::Ice::SlicedFormat);
+    ::Ice::Long iceP_timestamp;
+    MetricsView ret = this->getMetricsView(iceP_view, iceP_timestamp, current);
+    ::Ice::OutputStream* ostr = inS.startWriteParams();
+    ostr->write(iceP_timestamp);
+    ostr->write(ret);
+    ostr->writePendingValues();
+    inS.endWriteParams();
+    return true;
+}
+/// \endcond
+
+/// \cond INTERNAL
+bool
+IceMX::MetricsAdmin::_iceD_getMapMetricsFailures(::IceInternal::Incoming& inS, const ::Ice::Current& current)
+{
+    _iceCheckMode(::Ice::Normal, current.mode);
+    ::Ice::InputStream* istr = inS.startReadParams();
+    ::std::string iceP_view;
+    ::std::string iceP_map;
+    istr->read(iceP_view);
+    istr->read(iceP_map);
+    inS.endReadParams();
+    inS.setFormat(::Ice::SlicedFormat);
+    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)
+{
+    _iceCheckMode(::Ice::Normal, current.mode);
+    ::Ice::InputStream* istr = inS.startReadParams();
+    ::std::string iceP_view;
+    ::std::string iceP_map;
+    ::std::string iceP_id;
+    istr->read(iceP_view);
+    istr->read(iceP_map);
+    istr->read(iceP_id);
+    inS.endReadParams();
+    inS.setFormat(::Ice::SlicedFormat);
+    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
+{
+const ::std::string iceC_IceMX_MetricsAdmin_all[] =
+{
+    "disableMetricsView",
+    "enableMetricsView",
+    "getMapMetricsFailures",
+    "getMetricsFailures",
+    "getMetricsView",
+    "getMetricsViewNames",
+    "ice_id",
+    "ice_ids",
+    "ice_isA",
+    "ice_ping"
+};
+
+}
+
+/// \cond INTERNAL
+bool
+IceMX::MetricsAdmin::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
+{
+    ::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_IceMX_MetricsAdmin_all, iceC_IceMX_MetricsAdmin_all + 10, current.operation);
+    if(r.first == r.second)
+    {
+        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
+    }
+
+    switch(r.first - iceC_IceMX_MetricsAdmin_all)
+    {
+        case 0:
+        {
+            return _iceD_disableMetricsView(in, current);
+        }
+        case 1:
+        {
+            return _iceD_enableMetricsView(in, current);
+        }
+        case 2:
+        {
+            return _iceD_getMapMetricsFailures(in, current);
+        }
+        case 3:
+        {
+            return _iceD_getMetricsFailures(in, current);
+        }
+        case 4:
+        {
+            return _iceD_getMetricsView(in, current);
+        }
+        case 5:
+        {
+            return _iceD_getMetricsViewNames(in, current);
+        }
+        case 6:
+        {
+            return _iceD_ice_id(in, current);
+        }
+        case 7:
+        {
+            return _iceD_ice_ids(in, current);
+        }
+        case 8:
+        {
+            return _iceD_ice_isA(in, current);
+        }
+        case 9:
+        {
+            return _iceD_ice_ping(in, current);
+        }
+        default:
+        {
+            assert(false);
+            throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
+        }
+    }
+}
+/// \endcond
+
+/// \cond STREAM
+void
+IceMX::MetricsAdmin::_iceWriteImpl(::Ice::OutputStream* ostr) const
+{
+    ostr->startSlice(ice_staticId(), -1, true);
+    ::Ice::StreamWriter< MetricsAdmin, ::Ice::OutputStream>::write(ostr, *this);
+    ostr->endSlice();
+}
+
+void
+IceMX::MetricsAdmin::_iceReadImpl(::Ice::InputStream* istr)
+{
+    istr->startSlice();
+    ::Ice::StreamReader< MetricsAdmin, ::Ice::InputStream>::read(istr, *this);
+    istr->endSlice();
+}
+/// \endcond
+
+/// \cond INTERNAL
+void
+IceMX::_icePatchObjectPtr(MetricsAdminPtr& handle, const ::Ice::ObjectPtr& v)
+{
+    handle = MetricsAdminPtr::dynamicCast(v);
+    if(v && !handle)
+    {
+        IceInternal::Ex::throwUOE(MetricsAdmin::ice_staticId(), v);
+    }
+}
+/// \endcond
+
+IceMX::ThreadMetrics::~ThreadMetrics()
+{
+}
+
+/// \cond INTERNAL
+ICE_API ::Ice::Object* IceMX::upCast(ThreadMetrics* p) { return p; }
+
+/// \endcond
+::Ice::ObjectPtr
+IceMX::ThreadMetrics::ice_clone() const
+{
+    ::Ice::Object* p = new ThreadMetrics(*this);
+    return p;
+}
+
+namespace
+{
+const ::std::string iceC_IceMX_ThreadMetrics_ids[3] =
+{
+    "::Ice::Object",
+    "::IceMX::Metrics",
+    "::IceMX::ThreadMetrics"
+};
+
+}
+
+bool
+IceMX::ThreadMetrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
+{
+    return ::std::binary_search(iceC_IceMX_ThreadMetrics_ids, iceC_IceMX_ThreadMetrics_ids + 3, s);
+}
+
+::std::vector< ::std::string>
+IceMX::ThreadMetrics::ice_ids(const ::Ice::Current&) const
+{
+    return ::std::vector< ::std::string>(&iceC_IceMX_ThreadMetrics_ids[0], &iceC_IceMX_ThreadMetrics_ids[3]);
+}
+
+const ::std::string&
+IceMX::ThreadMetrics::ice_id(const ::Ice::Current&) const
+{
+    return ice_staticId();
+}
+
+const ::std::string&
+IceMX::ThreadMetrics::ice_staticId()
+{
+#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
+    static const ::std::string typeId = "::IceMX::ThreadMetrics";
+    return typeId;
+#else
+    return iceC_IceMX_ThreadMetrics_ids[2];
+#endif
+}
+
+/// \cond STREAM
+void
+IceMX::ThreadMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
+{
+    ostr->startSlice(ice_staticId(), -1, false);
+    ::Ice::StreamWriter< ThreadMetrics, ::Ice::OutputStream>::write(ostr, *this);
+    ostr->endSlice();
+    Metrics::_iceWriteImpl(ostr);
+}
+
+void
+IceMX::ThreadMetrics::_iceReadImpl(::Ice::InputStream* istr)
+{
+    istr->startSlice();
+    ::Ice::StreamReader< ThreadMetrics, ::Ice::InputStream>::read(istr, *this);
+    istr->endSlice();
+    Metrics::_iceReadImpl(istr);
+}
+/// \endcond
+
+namespace
+{
+const ::IceInternal::DefaultValueFactoryInit< ::IceMX::ThreadMetrics> iceC_IceMX_ThreadMetrics_init("::IceMX::ThreadMetrics");
+}
+
+::Ice::ValueFactoryPtr
+IceMX::ThreadMetrics::ice_factory()
+{
+    return ::IceInternal::factoryTable->getValueFactory(::IceMX::ThreadMetrics::ice_staticId());
+}
+
+/// \cond INTERNAL
+void
+IceMX::_icePatchObjectPtr(ThreadMetricsPtr& handle, const ::Ice::ObjectPtr& v)
+{
+    handle = ThreadMetricsPtr::dynamicCast(v);
+    if(v && !handle)
+    {
+        IceInternal::Ex::throwUOE(ThreadMetrics::ice_staticId(), v);
+    }
+}
+/// \endcond
+
+IceMX::DispatchMetrics::~DispatchMetrics()
+{
+}
+
+/// \cond INTERNAL
+ICE_API ::Ice::Object* IceMX::upCast(DispatchMetrics* p) { return p; }
+
+/// \endcond
+::Ice::ObjectPtr
+IceMX::DispatchMetrics::ice_clone() const
+{
+    ::Ice::Object* p = new DispatchMetrics(*this);
+    return p;
+}
+
+namespace
+{
+const ::std::string iceC_IceMX_DispatchMetrics_ids[3] =
+{
+    "::Ice::Object",
+    "::IceMX::DispatchMetrics",
+    "::IceMX::Metrics"
+};
+
+}
+
+bool
+IceMX::DispatchMetrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
+{
+    return ::std::binary_search(iceC_IceMX_DispatchMetrics_ids, iceC_IceMX_DispatchMetrics_ids + 3, s);
+}
+
+::std::vector< ::std::string>
+IceMX::DispatchMetrics::ice_ids(const ::Ice::Current&) const
+{
+    return ::std::vector< ::std::string>(&iceC_IceMX_DispatchMetrics_ids[0], &iceC_IceMX_DispatchMetrics_ids[3]);
+}
+
+const ::std::string&
+IceMX::DispatchMetrics::ice_id(const ::Ice::Current&) const
+{
+    return ice_staticId();
+}
+
+const ::std::string&
+IceMX::DispatchMetrics::ice_staticId()
+{
+#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
+    static const ::std::string typeId = "::IceMX::DispatchMetrics";
+    return typeId;
+#else
+    return iceC_IceMX_DispatchMetrics_ids[1];
+#endif
+}
+
+/// \cond STREAM
+void
+IceMX::DispatchMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
+{
+    ostr->startSlice(ice_staticId(), -1, false);
+    ::Ice::StreamWriter< DispatchMetrics, ::Ice::OutputStream>::write(ostr, *this);
+    ostr->endSlice();
+    Metrics::_iceWriteImpl(ostr);
+}
+
+void
+IceMX::DispatchMetrics::_iceReadImpl(::Ice::InputStream* istr)
+{
+    istr->startSlice();
+    ::Ice::StreamReader< DispatchMetrics, ::Ice::InputStream>::read(istr, *this);
+    istr->endSlice();
+    Metrics::_iceReadImpl(istr);
+}
+/// \endcond
+
+namespace
+{
+const ::IceInternal::DefaultValueFactoryInit< ::IceMX::DispatchMetrics> iceC_IceMX_DispatchMetrics_init("::IceMX::DispatchMetrics");
+}
+
+::Ice::ValueFactoryPtr
+IceMX::DispatchMetrics::ice_factory()
+{
+    return ::IceInternal::factoryTable->getValueFactory(::IceMX::DispatchMetrics::ice_staticId());
+}
+
+/// \cond INTERNAL
+void
+IceMX::_icePatchObjectPtr(DispatchMetricsPtr& handle, const ::Ice::ObjectPtr& v)
+{
+    handle = DispatchMetricsPtr::dynamicCast(v);
+    if(v && !handle)
+    {
+        IceInternal::Ex::throwUOE(DispatchMetrics::ice_staticId(), v);
+    }
+}
+/// \endcond
+
+IceMX::ChildInvocationMetrics::~ChildInvocationMetrics()
+{
+}
+
+/// \cond INTERNAL
+ICE_API ::Ice::Object* IceMX::upCast(ChildInvocationMetrics* p) { return p; }
+
+/// \endcond
+::Ice::ObjectPtr
+IceMX::ChildInvocationMetrics::ice_clone() const
+{
+    ::Ice::Object* p = new ChildInvocationMetrics(*this);
+    return p;
+}
+
+namespace
+{
+const ::std::string iceC_IceMX_ChildInvocationMetrics_ids[3] =
+{
+    "::Ice::Object",
+    "::IceMX::ChildInvocationMetrics",
+    "::IceMX::Metrics"
+};
+
+}
+
+bool
+IceMX::ChildInvocationMetrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
+{
+    return ::std::binary_search(iceC_IceMX_ChildInvocationMetrics_ids, iceC_IceMX_ChildInvocationMetrics_ids + 3, s);
+}
+
+::std::vector< ::std::string>
+IceMX::ChildInvocationMetrics::ice_ids(const ::Ice::Current&) const
+{
+    return ::std::vector< ::std::string>(&iceC_IceMX_ChildInvocationMetrics_ids[0], &iceC_IceMX_ChildInvocationMetrics_ids[3]);
+}
+
+const ::std::string&
+IceMX::ChildInvocationMetrics::ice_id(const ::Ice::Current&) const
+{
+    return ice_staticId();
+}
+
+const ::std::string&
+IceMX::ChildInvocationMetrics::ice_staticId()
+{
+#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
+    static const ::std::string typeId = "::IceMX::ChildInvocationMetrics";
+    return typeId;
+#else
+    return iceC_IceMX_ChildInvocationMetrics_ids[1];
+#endif
+}
+
+/// \cond STREAM
+void
+IceMX::ChildInvocationMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
+{
+    ostr->startSlice(ice_staticId(), -1, false);
+    ::Ice::StreamWriter< ChildInvocationMetrics, ::Ice::OutputStream>::write(ostr, *this);
+    ostr->endSlice();
+    Metrics::_iceWriteImpl(ostr);
+}
+
+void
+IceMX::ChildInvocationMetrics::_iceReadImpl(::Ice::InputStream* istr)
+{
+    istr->startSlice();
+    ::Ice::StreamReader< ChildInvocationMetrics, ::Ice::InputStream>::read(istr, *this);
+    istr->endSlice();
+    Metrics::_iceReadImpl(istr);
+}
+/// \endcond
+
+namespace
+{
+const ::IceInternal::DefaultValueFactoryInit< ::IceMX::ChildInvocationMetrics> iceC_IceMX_ChildInvocationMetrics_init("::IceMX::ChildInvocationMetrics");
+}
+
+::Ice::ValueFactoryPtr
+IceMX::ChildInvocationMetrics::ice_factory()
+{
+    return ::IceInternal::factoryTable->getValueFactory(::IceMX::ChildInvocationMetrics::ice_staticId());
+}
+
+/// \cond INTERNAL
+void
+IceMX::_icePatchObjectPtr(ChildInvocationMetricsPtr& handle, const ::Ice::ObjectPtr& v)
+{
+    handle = ChildInvocationMetricsPtr::dynamicCast(v);
+    if(v && !handle)
+    {
+        IceInternal::Ex::throwUOE(ChildInvocationMetrics::ice_staticId(), v);
+    }
+}
+/// \endcond
+
+IceMX::CollocatedMetrics::~CollocatedMetrics()
+{
+}
+
+/// \cond INTERNAL
+ICE_API ::Ice::Object* IceMX::upCast(CollocatedMetrics* p) { return p; }
+
+/// \endcond
+::Ice::ObjectPtr
+IceMX::CollocatedMetrics::ice_clone() const
+{
+    ::Ice::Object* p = new CollocatedMetrics(*this);
+    return p;
+}
+
+namespace
+{
+const ::std::string iceC_IceMX_CollocatedMetrics_ids[4] =
+{
+    "::Ice::Object",
+    "::IceMX::ChildInvocationMetrics",
+    "::IceMX::CollocatedMetrics",
+    "::IceMX::Metrics"
+};
+
+}
+
+bool
+IceMX::CollocatedMetrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
+{
+    return ::std::binary_search(iceC_IceMX_CollocatedMetrics_ids, iceC_IceMX_CollocatedMetrics_ids + 4, s);
+}
+
+::std::vector< ::std::string>
+IceMX::CollocatedMetrics::ice_ids(const ::Ice::Current&) const
+{
+    return ::std::vector< ::std::string>(&iceC_IceMX_CollocatedMetrics_ids[0], &iceC_IceMX_CollocatedMetrics_ids[4]);
+}
+
+const ::std::string&
+IceMX::CollocatedMetrics::ice_id(const ::Ice::Current&) const
+{
+    return ice_staticId();
+}
+
+const ::std::string&
+IceMX::CollocatedMetrics::ice_staticId()
+{
+#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
+    static const ::std::string typeId = "::IceMX::CollocatedMetrics";
+    return typeId;
+#else
+    return iceC_IceMX_CollocatedMetrics_ids[2];
+#endif
+}
+
+/// \cond STREAM
+void
+IceMX::CollocatedMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
+{
+    ostr->startSlice(ice_staticId(), -1, false);
+    ::Ice::StreamWriter< CollocatedMetrics, ::Ice::OutputStream>::write(ostr, *this);
+    ostr->endSlice();
+    ChildInvocationMetrics::_iceWriteImpl(ostr);
+}
+
+void
+IceMX::CollocatedMetrics::_iceReadImpl(::Ice::InputStream* istr)
+{
+    istr->startSlice();
+    ::Ice::StreamReader< CollocatedMetrics, ::Ice::InputStream>::read(istr, *this);
+    istr->endSlice();
+    ChildInvocationMetrics::_iceReadImpl(istr);
+}
+/// \endcond
+
+namespace
+{
+const ::IceInternal::DefaultValueFactoryInit< ::IceMX::CollocatedMetrics> iceC_IceMX_CollocatedMetrics_init("::IceMX::CollocatedMetrics");
+}
+
+::Ice::ValueFactoryPtr
+IceMX::CollocatedMetrics::ice_factory()
+{
+    return ::IceInternal::factoryTable->getValueFactory(::IceMX::CollocatedMetrics::ice_staticId());
+}
+
+/// \cond INTERNAL
+void
+IceMX::_icePatchObjectPtr(CollocatedMetricsPtr& handle, const ::Ice::ObjectPtr& v)
+{
+    handle = CollocatedMetricsPtr::dynamicCast(v);
+    if(v && !handle)
+    {
+        IceInternal::Ex::throwUOE(CollocatedMetrics::ice_staticId(), v);
+    }
+}
+/// \endcond
+
+IceMX::RemoteMetrics::~RemoteMetrics()
+{
+}
+
+/// \cond INTERNAL
+ICE_API ::Ice::Object* IceMX::upCast(RemoteMetrics* p) { return p; }
+
+/// \endcond
+::Ice::ObjectPtr
+IceMX::RemoteMetrics::ice_clone() const
+{
+    ::Ice::Object* p = new RemoteMetrics(*this);
+    return p;
+}
+
+namespace
+{
+const ::std::string iceC_IceMX_RemoteMetrics_ids[4] =
+{
+    "::Ice::Object",
+    "::IceMX::ChildInvocationMetrics",
+    "::IceMX::Metrics",
+    "::IceMX::RemoteMetrics"
+};
+
+}
+
+bool
+IceMX::RemoteMetrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
+{
+    return ::std::binary_search(iceC_IceMX_RemoteMetrics_ids, iceC_IceMX_RemoteMetrics_ids + 4, s);
+}
+
+::std::vector< ::std::string>
+IceMX::RemoteMetrics::ice_ids(const ::Ice::Current&) const
+{
+    return ::std::vector< ::std::string>(&iceC_IceMX_RemoteMetrics_ids[0], &iceC_IceMX_RemoteMetrics_ids[4]);
+}
+
+const ::std::string&
+IceMX::RemoteMetrics::ice_id(const ::Ice::Current&) const
+{
+    return ice_staticId();
+}
+
+const ::std::string&
+IceMX::RemoteMetrics::ice_staticId()
+{
+#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
+    static const ::std::string typeId = "::IceMX::RemoteMetrics";
+    return typeId;
+#else
+    return iceC_IceMX_RemoteMetrics_ids[3];
+#endif
+}
+
+/// \cond STREAM
+void
+IceMX::RemoteMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
+{
+    ostr->startSlice(ice_staticId(), -1, false);
+    ::Ice::StreamWriter< RemoteMetrics, ::Ice::OutputStream>::write(ostr, *this);
+    ostr->endSlice();
+    ChildInvocationMetrics::_iceWriteImpl(ostr);
+}
+
+void
+IceMX::RemoteMetrics::_iceReadImpl(::Ice::InputStream* istr)
+{
+    istr->startSlice();
+    ::Ice::StreamReader< RemoteMetrics, ::Ice::InputStream>::read(istr, *this);
+    istr->endSlice();
+    ChildInvocationMetrics::_iceReadImpl(istr);
+}
+/// \endcond
+
+namespace
+{
+const ::IceInternal::DefaultValueFactoryInit< ::IceMX::RemoteMetrics> iceC_IceMX_RemoteMetrics_init("::IceMX::RemoteMetrics");
+}
+
+::Ice::ValueFactoryPtr
+IceMX::RemoteMetrics::ice_factory()
+{
+    return ::IceInternal::factoryTable->getValueFactory(::IceMX::RemoteMetrics::ice_staticId());
+}
+
+/// \cond INTERNAL
+void
+IceMX::_icePatchObjectPtr(RemoteMetricsPtr& handle, const ::Ice::ObjectPtr& v)
+{
+    handle = RemoteMetricsPtr::dynamicCast(v);
+    if(v && !handle)
+    {
+        IceInternal::Ex::throwUOE(RemoteMetrics::ice_staticId(), v);
+    }
+}
+/// \endcond
+
+IceMX::InvocationMetrics::~InvocationMetrics()
+{
+}
+
+/// \cond INTERNAL
+ICE_API ::Ice::Object* IceMX::upCast(InvocationMetrics* p) { return p; }
+
+/// \endcond
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1900)
+#   pragma warning(push)
+#   pragma warning(disable:4589)
+#endif
+::Ice::ObjectPtr
+IceMX::InvocationMetrics::ice_clone() const
+{
+    ::Ice::Object* p = new InvocationMetrics(*this);
+    return p;
+}
+#if defined(_MSC_VER) && (_MSC_VER >= 1900)
+#   pragma warning(pop)
+#endif
+
+namespace
+{
+const ::std::string iceC_IceMX_InvocationMetrics_ids[3] =
+{
+    "::Ice::Object",
+    "::IceMX::InvocationMetrics",
+    "::IceMX::Metrics"
+};
+
+}
+
+bool
+IceMX::InvocationMetrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
+{
+    return ::std::binary_search(iceC_IceMX_InvocationMetrics_ids, iceC_IceMX_InvocationMetrics_ids + 3, s);
+}
+
+::std::vector< ::std::string>
+IceMX::InvocationMetrics::ice_ids(const ::Ice::Current&) const
+{
+    return ::std::vector< ::std::string>(&iceC_IceMX_InvocationMetrics_ids[0], &iceC_IceMX_InvocationMetrics_ids[3]);
+}
+
+const ::std::string&
+IceMX::InvocationMetrics::ice_id(const ::Ice::Current&) const
+{
+    return ice_staticId();
+}
+
+const ::std::string&
+IceMX::InvocationMetrics::ice_staticId()
+{
+#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
+    static const ::std::string typeId = "::IceMX::InvocationMetrics";
+    return typeId;
+#else
+    return iceC_IceMX_InvocationMetrics_ids[1];
+#endif
+}
+
+void
+IceMX::InvocationMetrics::_iceGcVisitMembers(::IceInternal::GCVisitor& v_)
+{
+    {
+        for(::IceMX::MetricsMap::iterator _i0 = remotes.begin(); _i0 != remotes.end(); ++_i0)
+        {
+            if((*_i0))
+            {
+                if((::IceMX::upCast((*_i0).get())->_iceGcVisit(v_)))
+                {
+                    (*_i0) = 0;
+                }
+            }
+        }
+    }
+    {
+        for(::IceMX::MetricsMap::iterator _i0 = collocated.begin(); _i0 != collocated.end(); ++_i0)
+        {
+            if((*_i0))
+            {
+                if((::IceMX::upCast((*_i0).get())->_iceGcVisit(v_)))
+                {
+                    (*_i0) = 0;
+                }
+            }
+        }
+    }
+}
+
+/// \cond STREAM
+void
+IceMX::InvocationMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
+{
+    ostr->startSlice(ice_staticId(), -1, false);
+    ::Ice::StreamWriter< InvocationMetrics, ::Ice::OutputStream>::write(ostr, *this);
+    ostr->endSlice();
+    Metrics::_iceWriteImpl(ostr);
+}
+
+void
+IceMX::InvocationMetrics::_iceReadImpl(::Ice::InputStream* istr)
+{
+    istr->startSlice();
+    ::Ice::StreamReader< InvocationMetrics, ::Ice::InputStream>::read(istr, *this);
+    istr->endSlice();
+    Metrics::_iceReadImpl(istr);
+}
+/// \endcond
+
+namespace
+{
+const ::IceInternal::DefaultValueFactoryInit< ::IceMX::InvocationMetrics> iceC_IceMX_InvocationMetrics_init("::IceMX::InvocationMetrics");
+}
+
+::Ice::ValueFactoryPtr
+IceMX::InvocationMetrics::ice_factory()
+{
+    return ::IceInternal::factoryTable->getValueFactory(::IceMX::InvocationMetrics::ice_staticId());
+}
+
+/// \cond INTERNAL
+void
+IceMX::_icePatchObjectPtr(InvocationMetricsPtr& handle, const ::Ice::ObjectPtr& v)
+{
+    handle = InvocationMetricsPtr::dynamicCast(v);
+    if(v && !handle)
+    {
+        IceInternal::Ex::throwUOE(InvocationMetrics::ice_staticId(), v);
+    }
+}
+/// \endcond
+
+IceMX::ConnectionMetrics::~ConnectionMetrics()
+{
+}
+
+/// \cond INTERNAL
+ICE_API ::Ice::Object* IceMX::upCast(ConnectionMetrics* p) { return p; }
+
+/// \endcond
+::Ice::ObjectPtr
+IceMX::ConnectionMetrics::ice_clone() const
+{
+    ::Ice::Object* p = new ConnectionMetrics(*this);
+    return p;
+}
+
+namespace
+{
+const ::std::string iceC_IceMX_ConnectionMetrics_ids[3] =
+{
+    "::Ice::Object",
+    "::IceMX::ConnectionMetrics",
+    "::IceMX::Metrics"
+};
+
+}
+
+bool
+IceMX::ConnectionMetrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
+{
+    return ::std::binary_search(iceC_IceMX_ConnectionMetrics_ids, iceC_IceMX_ConnectionMetrics_ids + 3, s);
+}
+
+::std::vector< ::std::string>
+IceMX::ConnectionMetrics::ice_ids(const ::Ice::Current&) const
+{
+    return ::std::vector< ::std::string>(&iceC_IceMX_ConnectionMetrics_ids[0], &iceC_IceMX_ConnectionMetrics_ids[3]);
+}
+
+const ::std::string&
+IceMX::ConnectionMetrics::ice_id(const ::Ice::Current&) const
+{
+    return ice_staticId();
+}
+
+const ::std::string&
+IceMX::ConnectionMetrics::ice_staticId()
+{
+#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
+    static const ::std::string typeId = "::IceMX::ConnectionMetrics";
+    return typeId;
+#else
+    return iceC_IceMX_ConnectionMetrics_ids[1];
+#endif
+}
+
+/// \cond STREAM
+void
+IceMX::ConnectionMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
+{
+    ostr->startSlice(ice_staticId(), -1, false);
+    ::Ice::StreamWriter< ConnectionMetrics, ::Ice::OutputStream>::write(ostr, *this);
+    ostr->endSlice();
+    Metrics::_iceWriteImpl(ostr);
+}
+
+void
+IceMX::ConnectionMetrics::_iceReadImpl(::Ice::InputStream* istr)
+{
+    istr->startSlice();
+    ::Ice::StreamReader< ConnectionMetrics, ::Ice::InputStream>::read(istr, *this);
+    istr->endSlice();
+    Metrics::_iceReadImpl(istr);
+}
+/// \endcond
+
+namespace
+{
+const ::IceInternal::DefaultValueFactoryInit< ::IceMX::ConnectionMetrics> iceC_IceMX_ConnectionMetrics_init("::IceMX::ConnectionMetrics");
+}
+
+::Ice::ValueFactoryPtr
+IceMX::ConnectionMetrics::ice_factory()
+{
+    return ::IceInternal::factoryTable->getValueFactory(::IceMX::ConnectionMetrics::ice_staticId());
+}
+
+/// \cond INTERNAL
+void
+IceMX::_icePatchObjectPtr(ConnectionMetricsPtr& handle, const ::Ice::ObjectPtr& v)
+{
+    handle = ConnectionMetricsPtr::dynamicCast(v);
+    if(v && !handle)
+    {
+        IceInternal::Ex::throwUOE(ConnectionMetrics::ice_staticId(), v);
+    }
+}
+/// \endcond
+
+namespace Ice
+{
+}
+
+#endif