zeroc-ice 3.6.5 → 3.7.0

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
 //
 // This copy of Ice is licensed to you under the terms described in the
 // ICE_LICENSE file included in this distribution.
@@ -34,11 +34,11 @@ public:
     // Destroy this logger, in particular join any thread
     // that this logger may have started
     //
-    virtual void destroy() = 0; 
+    virtual void destroy() = 0;
 };
-typedef Handle<LoggerAdminLogger> LoggerAdminLoggerPtr;
+ICE_DEFINE_PTR(LoggerAdminLoggerPtr, LoggerAdminLogger);
 
-LoggerAdminLoggerPtr 
+LoggerAdminLoggerPtr
 createLoggerAdminLogger(const Ice::PropertiesPtr&, const Ice::LoggerPtr&);
 
 }

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

@@ -1,13 +1,13 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
 //
 // This copy of Ice is licensed to you under the terms described in the
 // ICE_LICENSE file included in this distribution.
 //
 // **********************************************************************
 //
-// Ice version 3.6.5
+// Ice version 3.7.0
 //
 // <auto-generated>
 //
@@ -23,22 +23,44 @@
 #endif
 #include <Ice/LoggerF.h>
 #include <IceUtil/PushDisableWarnings.h>
-#include <IceUtil/Iterator.h>
 #include <IceUtil/PopDisableWarnings.h>
 
+#if defined(_MSC_VER)
+#   pragma warning(disable:4458) // declaration of ... hides class member
+#elif defined(__clang__)
+#   pragma clang diagnostic ignored "-Wshadow"
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic ignored "-Wshadow"
+#endif
+
 #ifndef ICE_IGNORE_VERSION
-#   if ICE_INT_VERSION / 100 != 306
+#   if ICE_INT_VERSION / 100 != 307
 #       error Ice version mismatch!
 #   endif
 #   if ICE_INT_VERSION % 100 > 50
 #       error Beta header file detected
 #   endif
-#   if ICE_INT_VERSION % 100 < 5
+#   if ICE_INT_VERSION % 100 < 0
 #       error Ice patch level mismatch!
 #   endif
 #endif
 
+#ifdef ICE_CPP11_MAPPING // C++11 mapping
+
+namespace
+{
+
+}
+
+#else // C++98 mapping
+
 namespace
 {
 
 }
+
+namespace Ice
+{
+}
+
+#endif

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
 //
 // This copy of Ice is licensed to you under the terms described in the
 // ICE_LICENSE file included in this distribution.
@@ -13,15 +13,13 @@
 #include <IceUtil/Mutex.h>
 #include <IceUtil/MutexPtrLock.h>
 
-#ifdef _WIN32
-#  include <IceUtil/ScopedArray.h>
-#endif
-
 #include <Ice/LocalException.h>
+#include <IceUtil/FileUtil.h>
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
+using namespace IceUtilInternal;
 
 namespace
 {
@@ -55,15 +53,11 @@ const IceUtil::Time retryTimeout = IceUtil::Time::seconds(5 * 60);
 }
 
 Ice::LoggerI::LoggerI(const string& prefix, const string& file,
-                      bool convert, const IceUtil::StringConverterPtr& converter,
-                      size_t sizeMax) :
+                      bool convert, size_t sizeMax) :
     _prefix(prefix),
     _convert(convert),
-    _converter(converter),
+    _converter(getProcessStringConverter()),
     _sizeMax(sizeMax)
-#if defined(_WIN32) && !defined(ICE_OS_WINRT)
-    ,_consoleConverter(new IceUtil::WindowsStringConverter(GetConsoleOutputCP()))
-#endif
 {
     if(!prefix.empty())
     {
@@ -73,7 +67,7 @@ Ice::LoggerI::LoggerI(const string& prefix, const string& file,
     if(!file.empty())
     {
         _file = file;
-        _out.open(file, fstream::out | fstream::app);
+        _out.open(IceUtilInternal::streamFilename(file).c_str(), fstream::out | fstream::app);
         if(!_out.is_open())
         {
             throw InitializationException(__FILE__, __LINE__, "FileLogger: cannot open " + _file);
@@ -134,7 +128,8 @@ Ice::LoggerI::getPrefix()
 LoggerPtr
 Ice::LoggerI::cloneWithPrefix(const std::string& prefix)
 {
-    return new LoggerI(prefix, _file, _convert, _converter);
+    IceUtilInternal::MutexPtrLock<IceUtil::Mutex> sync(outputMutex); // for _sizeMax
+    return ICE_MAKE_SHARED(LoggerI, prefix, _file, _convert, _sizeMax);
 }
 
 void
@@ -202,7 +197,7 @@ Ice::LoggerI::write(const string& message, bool indent)
 
                 int err = IceUtilInternal::rename(_file, archive);
 
-                _out.open(_file, fstream::out | fstream::app);
+                _out.open(IceUtilInternal::streamFilename(_file).c_str(), fstream::out | fstream::app);
 
                 if(err)
                 {
@@ -230,15 +225,14 @@ Ice::LoggerI::write(const string& message, bool indent)
                     error("FileLogger: cannot open `" + _file + "':\nlog messages will be sent to stderr");
                     write(message, indent);
                     return;
-                }
-            }
+                }            }
         }
         _out << s << endl;
     }
     else
     {
-#if defined(ICE_OS_WINRT)
-        OutputDebugString(IceUtil::stringToWstring(s).c_str());
+#if defined(ICE_OS_UWP)
+        OutputDebugString(stringToWstring(s).c_str());
 #elif defined(_WIN32)
         //
         // Convert the message from the native narrow string encoding to the console
@@ -252,36 +246,12 @@ Ice::LoggerI::write(const string& message, bool indent)
             // to Windows console. When _convert is set to false we always output
             // UTF-8 encoded messages.
             //
-            fprintf_s(stderr, "%s\n", IceUtil::nativeToUTF8(s, _converter).c_str());
+            fprintf_s(stderr, "%s\n", nativeToUTF8(s, _converter).c_str());
             fflush(stderr);
         }
         else
         {
-            try
-            {
-                // Convert message to UTF-8
-                string u8s = IceUtil::nativeToUTF8(s, _converter);
-
-                // Then from UTF-8 to console CP
-                string consoleString;
-                _consoleConverter->fromUTF8(reinterpret_cast<const Byte*>(u8s.data()),
-                                            reinterpret_cast<const Byte*>(u8s.data() + u8s.size()),
-                                            consoleString);
-
-                // We cannot use cerr here as writing to console using cerr
-                // will do its own conversion and will corrupt the messages.
-                //
-                fprintf_s(stderr, "%s\n", consoleString.c_str());
-            }
-            catch(const IceUtil::IllegalConversionException&)
-            {
-                //
-                // If there is a problem with the encoding conversions we just
-                // write the original message without encoding conversions.
-                //
-                fprintf_s(stderr, "%s\n", s.c_str());
-            }
-            fflush(stderr);
+            consoleErr << s << endl;
         }
 #else
         cerr << s << endl;

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
 //
 // This copy of Ice is licensed to you under the terms described in the
 // ICE_LICENSE file included in this distribution.
@@ -11,8 +11,8 @@
 #define ICE_LOGGER_I_H
 
 #include <Ice/Logger.h>
-#include <IceUtil/FileUtil.h>
-#include <IceUtil/StringConverter.h>
+#include <Ice/StringConverter.h>
+#include <fstream>
 
 namespace Ice
 {
@@ -21,8 +21,7 @@ class LoggerI : public Logger
 {
 public:
 
-    LoggerI(const std::string&, const std::string&, bool convert = true,
-            const IceUtil::StringConverterPtr& converter = 0, std::size_t sizeMax = 0);
+    LoggerI(const std::string&, const std::string&, bool convert = true, std::size_t sizeMax = 0);
     ~LoggerI();
 
     virtual void print(const std::string&);
@@ -39,8 +38,8 @@ private:
     const std::string _prefix;
     std::string _formattedPrefix;
     const bool _convert;
-    const IceUtil::StringConverterPtr _converter;
-    IceUtilInternal::ofstream _out;
+    const StringConverterPtr _converter;
+    std::ofstream _out;
 
     std::string _file;
     std::size_t _sizeMax;
@@ -50,13 +49,8 @@ private:
     // after which rename could be attempted again. Otherwise is set to zero.
     //
     IceUtil::Time _nextRetry;
-#if defined(_WIN32) && !defined(ICE_OS_WINRT)
-    const IceUtil::StringConverterPtr _consoleConverter;
-#endif
-
 };
-
-typedef IceUtil::Handle<LoggerI> LoggerIPtr;
+ICE_DEFINE_PTR(LoggerIPtr, LoggerI);
 
 }
 

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

@@ -1,7 +1,7 @@
 
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
 //
 // This copy of Ice is licensed to you under the terms described in the
 // ICE_LICENSE file included in this distribution.
@@ -19,26 +19,26 @@ using namespace std;
 namespace IceUtilInternal
 {
 
-extern bool ICE_UTIL_API printStackTraces;
+extern bool printStackTraces;
 
 }
 
 string
 Ice::LoggerOutputBase::str() const
 {
-    return _str.str();
+    return _os.str();
 }
 
 ostringstream&
-Ice::LoggerOutputBase::__str()
+Ice::LoggerOutputBase::_stream()
 {
-    return _str;
+    return _os;
 }
 
 Ice::LoggerOutputBase&
 Ice::operator<<(Ice::LoggerOutputBase& out, ios_base& (*val)(ios_base&))
 {
-    out.__str() << val;
+    out._stream() << val;
     return out;
 }
 
@@ -47,16 +47,15 @@ Ice::loggerInsert(Ice::LoggerOutputBase& out, const IceUtil::Exception& ex)
 {
     if(IceUtilInternal::printStackTraces)
     {
-        out.__str() << ex.what() << '\n' << ex.ice_stackTrace();
+        out._stream() << ex.what() << '\n' << ex.ice_stackTrace();
     }
     else
     {
-        out.__str() << ex.what();
+        out._stream() << ex.what();
     }
     return out;
 }
 
-
 Ice::Trace::Trace(const LoggerPtr& logger, const string& category) :
     _logger(logger),
     _category(category)
@@ -71,15 +70,14 @@ Ice::Trace::~Trace()
 void
 Ice::Trace::flush()
 {
-    string s = __str().str();
+    string s = _stream().str();
     if(!s.empty())
     {
         _logger->trace(_category, s);
     }
-    __str().str("");
+    _stream().str("");
 }
 
-
 Ice::LoggerPlugin::LoggerPlugin(const CommunicatorPtr& communicator, const LoggerPtr& logger)
 {
     if(communicator == 0)

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

@@ -1,13 +1,13 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
 //
 // This copy of Ice is licensed to you under the terms described in the
 // ICE_LICENSE file included in this distribution.
 //
 // **********************************************************************
 //
-// Ice version 3.6.5
+// Ice version 3.7.0
 //
 // <auto-generated>
 //
@@ -24,903 +24,920 @@
 #include <Ice/Metrics.h>
 #include <IceUtil/PushDisableWarnings.h>
 #include <Ice/LocalException.h>
-#include <Ice/ObjectFactory.h>
-#include <Ice/Outgoing.h>
+#include <Ice/ValueFactory.h>
 #include <Ice/OutgoingAsync.h>
-#include <Ice/BasicStream.h>
-#include <IceUtil/Iterator.h>
+#include <Ice/InputStream.h>
+#include <Ice/OutputStream.h>
+#include <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 != 306
+#   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 < 5
+#   if ICE_INT_VERSION % 100 < 0
 #       error Ice patch level mismatch!
 #   endif
 #endif
 
+#ifdef ICE_CPP11_MAPPING // C++11 mapping
+
 namespace
 {
 
-const ::std::string __IceMX__MetricsAdmin__getMetricsViewNames_name = "getMetricsViewNames";
+const ::IceInternal::DefaultValueFactoryInit<::IceMX::Metrics> iceC_IceMX_Metrics_init("::IceMX::Metrics");
 
-const ::std::string __IceMX__MetricsAdmin__enableMetricsView_name = "enableMetricsView";
+const ::IceInternal::DefaultUserExceptionFactoryInit<::IceMX::UnknownMetricsView> iceC_IceMX_UnknownMetricsView_init("::IceMX::UnknownMetricsView");
 
-const ::std::string __IceMX__MetricsAdmin__disableMetricsView_name = "disableMetricsView";
+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 ::std::string __IceMX__MetricsAdmin__getMetricsView_name = "getMetricsView";
+const ::IceInternal::DefaultValueFactoryInit<::IceMX::ChildInvocationMetrics> iceC_IceMX_ChildInvocationMetrics_init("::IceMX::ChildInvocationMetrics");
 
-const ::std::string __IceMX__MetricsAdmin__getMapMetricsFailures_name = "getMapMetricsFailures";
+const ::IceInternal::DefaultValueFactoryInit<::IceMX::CollocatedMetrics> iceC_IceMX_CollocatedMetrics_init("::IceMX::CollocatedMetrics");
 
-const ::std::string __IceMX__MetricsAdmin__getMetricsFailures_name = "getMetricsFailures";
+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");
 
 }
 
-namespace
+IceMX::UnknownMetricsView::~UnknownMetricsView()
 {
+}
 
-const ::IceInternal::DefaultUserExceptionFactoryInit< ::IceMX::UnknownMetricsView> __IceMX__UnknownMetricsView_init("::IceMX::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);
 }
 
-IceMX::UnknownMetricsView::~UnknownMetricsView() throw()
+::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::UnknownMetricsView::ice_name() const
+IceMX::MetricsAdmin::ice_id(const ::Ice::Current&) const
 {
-    return "IceMX::UnknownMetricsView";
+    return ice_staticId();
 }
 
-IceMX::UnknownMetricsView*
-IceMX::UnknownMetricsView::ice_clone() const
+const ::std::string&
+IceMX::MetricsAdmin::ice_staticId()
 {
-    return new UnknownMetricsView(*this);
+    static const ::std::string typeId = "::IceMX::MetricsAdmin";
+    return typeId;
 }
 
-void
-IceMX::UnknownMetricsView::ice_throw() const
+bool
+IceMX::MetricsAdmin::_iceD_getMetricsViewNames(::IceInternal::Incoming& inS, const ::Ice::Current& current)
 {
-    throw *this;
+    _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;
 }
 
-void
-IceMX::UnknownMetricsView::__writeImpl(::IceInternal::BasicStream* __os) const
+bool
+IceMX::MetricsAdmin::_iceD_enableMetricsView(::IceInternal::Incoming& inS, const ::Ice::Current& current)
 {
-    __os->startWriteSlice("::IceMX::UnknownMetricsView", -1, true);
-    __os->endWriteSlice();
+    _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;
 }
 
-void
-IceMX::UnknownMetricsView::__readImpl(::IceInternal::BasicStream* __is)
+bool
+IceMX::MetricsAdmin::_iceD_disableMetricsView(::IceInternal::Incoming& inS, const ::Ice::Current& current)
 {
-    __is->startReadSlice();
-    __is->endReadSlice();
+    _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;
 }
 
-namespace Ice
-{
-#if defined(ICE_HAS_DECLSPEC_IMPORT_EXPORT) && !defined(ICE_STATIC_LIBS)
-template struct ICE_API StreamWriter< ::IceMX::MetricsFailures, ::IceInternal::BasicStream>;
-template struct ICE_API StreamReader< ::IceMX::MetricsFailures, ::IceInternal::BasicStream>;
-#endif
+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;
+    ::IceMX::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;
 }
-#ifdef __SUNPRO_CC
-class ICE_API IceProxy::IceMX::Metrics;
-#endif
-ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(::IceProxy::IceMX::Metrics* p) { return p; }
 
-void
-::IceProxy::IceMX::__read(::IceInternal::BasicStream* __is, ::IceInternal::ProxyHandle< ::IceProxy::IceMX::Metrics>& v)
+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);
+    ::IceMX::MetricsFailuresSeq ret = this->getMapMetricsFailures(::std::move(iceP_view), ::std::move(iceP_map), current);
+    auto ostr = inS.startWriteParams();
+    ostr->writeAll(ret);
+    inS.endWriteParams();
+    return true;
+}
+
+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);
+    ::IceMX::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;
+}
+
+bool
+IceMX::MetricsAdmin::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
 {
-    ::Ice::ObjectPrx proxy;
-    __is->read(proxy);
-    if(!proxy)
+    ::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)
     {
-        v = 0;
+        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
     }
-    else
+
+    switch(r.first - iceC_IceMX_MetricsAdmin_ops)
     {
-        v = new ::IceProxy::IceMX::Metrics;
-        v->__copyFrom(proxy);
+        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);
+        }
     }
 }
 
+IceMX::Metrics::~Metrics()
+{
+}
+
 const ::std::string&
-IceProxy::IceMX::Metrics::ice_staticId()
+IceMX::Metrics::ice_staticId()
 {
-    return ::IceMX::Metrics::ice_staticId();
+    static const ::std::string typeId = "::IceMX::Metrics";
+    return typeId;
 }
 
-::IceProxy::Ice::Object*
-IceProxy::IceMX::Metrics::__newInstance() const
+IceMX::ThreadMetrics::~ThreadMetrics()
 {
-    return new Metrics;
 }
-#ifdef __SUNPRO_CC
-class ICE_API IceProxy::IceMX::MetricsAdmin;
-#endif
-ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(::IceProxy::IceMX::MetricsAdmin* p) { return p; }
 
-void
-::IceProxy::IceMX::__read(::IceInternal::BasicStream* __is, ::IceInternal::ProxyHandle< ::IceProxy::IceMX::MetricsAdmin>& v)
+const ::std::string&
+IceMX::ThreadMetrics::ice_staticId()
 {
-    ::Ice::ObjectPrx proxy;
-    __is->read(proxy);
-    if(!proxy)
-    {
-        v = 0;
-    }
-    else
-    {
-        v = new ::IceProxy::IceMX::MetricsAdmin;
-        v->__copyFrom(proxy);
-    }
+    static const ::std::string typeId = "::IceMX::ThreadMetrics";
+    return typeId;
 }
 
-::Ice::StringSeq
-IceProxy::IceMX::MetricsAdmin::getMetricsViewNames(::Ice::StringSeq& __p_disabledViews, const ::Ice::Context* __ctx)
+IceMX::DispatchMetrics::~DispatchMetrics()
 {
-    __checkTwowayOnly(__IceMX__MetricsAdmin__getMetricsViewNames_name);
-    ::IceInternal::Outgoing __og(this, __IceMX__MetricsAdmin__getMetricsViewNames_name, ::Ice::Normal, __ctx);
-    __og.writeEmptyParams();
-    if(!__og.invoke())
-    {
-        try
-        {
-            __og.throwUserException();
-        }
-        catch(const ::Ice::UserException& __ex)
-        {
-            ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
-            throw __uue;
-        }
-    }
-    ::Ice::StringSeq __ret;
-    ::IceInternal::BasicStream* __is = __og.startReadParams();
-    __is->read(__p_disabledViews);
-    __is->read(__ret);
-    __og.endReadParams();
-    return __ret;
 }
 
-::Ice::AsyncResultPtr
-IceProxy::IceMX::MetricsAdmin::begin_getMetricsViewNames(const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
+const ::std::string&
+IceMX::DispatchMetrics::ice_staticId()
+{
+    static const ::std::string typeId = "::IceMX::DispatchMetrics";
+    return typeId;
+}
+
+IceMX::ChildInvocationMetrics::~ChildInvocationMetrics()
 {
-    __checkAsyncTwowayOnly(__IceMX__MetricsAdmin__getMetricsViewNames_name);
-    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __IceMX__MetricsAdmin__getMetricsViewNames_name, __del, __cookie);
-    try
-    {
-        __result->prepare(__IceMX__MetricsAdmin__getMetricsViewNames_name, ::Ice::Normal, __ctx);
-        __result->writeEmptyParams();
-        __result->invoke();
-    }
-    catch(const ::Ice::Exception& __ex)
-    {
-        __result->abort(__ex);
-    }
-    return __result;
 }
 
-#ifdef ICE_CPP11
+const ::std::string&
+IceMX::ChildInvocationMetrics::ice_staticId()
+{
+    static const ::std::string typeId = "::IceMX::ChildInvocationMetrics";
+    return typeId;
+}
 
-::Ice::AsyncResultPtr
-IceProxy::IceMX::MetricsAdmin::__begin_getMetricsViewNames(const ::Ice::Context* __ctx, const ::IceInternal::Function<void (const ::Ice::StringSeq&, const ::Ice::StringSeq&)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent)
+IceMX::CollocatedMetrics::~CollocatedMetrics()
 {
-    class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
-    {
-    public:
+}
+
+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;
+}
 
-        Cpp11CB(const ::std::function<void (const ::Ice::StringSeq&, const ::Ice::StringSeq&)>& responseFunc, const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, const ::std::function<void (bool)>& sentFunc) :
-            ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
-            _response(responseFunc)
+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;
+}
+
+void
+IceMX::MetricsAdminPrx::_iceI_getMetricsViewNames(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::IceMX::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)
         {
-            CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
-        }
+            ::IceMX::MetricsAdmin::GetMetricsViewNamesResult v;
+            istr->readAll(v.disabledViews, v.returnValue);
+            return v;
+        });
+}
 
-        virtual void completed(const ::Ice::AsyncResultPtr& __result) const
+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)
         {
-            ::IceMX::MetricsAdminPrx __proxy = ::IceMX::MetricsAdminPrx::uncheckedCast(__result->getProxy());
-            ::Ice::StringSeq __p_disabledViews;
-            ::Ice::StringSeq __ret;
             try
             {
-                __ret = __proxy->end_getMetricsViewNames(__p_disabledViews, __result);
+                ex.ice_throw();
             }
-            catch(const ::Ice::Exception& ex)
+            catch(const ::IceMX::UnknownMetricsView&)
             {
-                Cpp11FnCallbackNC::exception(__result, ex);
-                return;
+                throw;
             }
-            if(_response != nullptr)
+            catch(const ::Ice::UserException&)
             {
-                _response(__ret, __p_disabledViews);
             }
-        }
-    
-    private:
-        
-        ::std::function<void (const ::Ice::StringSeq&, const ::Ice::StringSeq&)> _response;
-    };
-    return begin_getMetricsViewNames(__ctx, new Cpp11CB(__response, __exception, __sent));
+        });
 }
-#endif
 
-::Ice::StringSeq
-IceProxy::IceMX::MetricsAdmin::end_getMetricsViewNames(::Ice::StringSeq& __p_disabledViews, const ::Ice::AsyncResultPtr& __result)
+void
+IceMX::MetricsAdminPrx::_iceI_disableMetricsView(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>& outAsync, const ::std::string& iceP_name, const ::Ice::Context& context)
 {
-    ::Ice::AsyncResult::__check(__result, this, __IceMX__MetricsAdmin__getMetricsViewNames_name);
-    ::Ice::StringSeq __ret;
-    if(!__result->__wait())
-    {
-        try
+    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_disableMetricsView_name);
+    outAsync->invoke(iceC_IceMX_MetricsAdmin_disableMetricsView_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::SlicedFormat, context,
+        [&](::Ice::OutputStream* ostr)
         {
-            __result->__throwUserException();
-        }
-        catch(const ::Ice::UserException& __ex)
+            ostr->writeAll(iceP_name);
+        },
+        [](const ::Ice::UserException& ex)
         {
-            throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
-        }
-    }
-    ::IceInternal::BasicStream* __is = __result->__startReadParams();
-    __is->read(__p_disabledViews);
-    __is->read(__ret);
-    __result->__endReadParams();
-    return __ret;
+            try
+            {
+                ex.ice_throw();
+            }
+            catch(const ::IceMX::UnknownMetricsView&)
+            {
+                throw;
+            }
+            catch(const ::Ice::UserException&)
+            {
+            }
+        });
 }
 
 void
-IceProxy::IceMX::MetricsAdmin::enableMetricsView(const ::std::string& __p_name, const ::Ice::Context* __ctx)
+IceMX::MetricsAdminPrx::_iceI_getMetricsView(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::IceMX::MetricsAdmin::GetMetricsViewResult>>& outAsync, const ::std::string& iceP_view, const ::Ice::Context& context)
 {
-    __checkTwowayOnly(__IceMX__MetricsAdmin__enableMetricsView_name);
-    ::IceInternal::Outgoing __og(this, __IceMX__MetricsAdmin__enableMetricsView_name, ::Ice::Normal, __ctx);
-    try
-    {
-        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::SlicedFormat);
-        __os->write(__p_name);
-        __og.endWriteParams();
-    }
-    catch(const ::Ice::LocalException& __ex)
-    {
-        __og.abort(__ex);
-    }
-    if(!__og.invoke())
-    {
-        try
+    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_getMetricsView_name);
+    outAsync->invoke(iceC_IceMX_MetricsAdmin_getMetricsView_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::SlicedFormat, context,
+        [&](::Ice::OutputStream* ostr)
         {
-            __og.throwUserException();
-        }
-        catch(const ::IceMX::UnknownMetricsView&)
+            ostr->writeAll(iceP_view);
+        },
+        [](const ::Ice::UserException& ex)
         {
-            throw;
-        }
-        catch(const ::Ice::UserException& __ex)
+            try
+            {
+                ex.ice_throw();
+            }
+            catch(const ::IceMX::UnknownMetricsView&)
+            {
+                throw;
+            }
+            catch(const ::Ice::UserException&)
+            {
+            }
+        },
+        [](::Ice::InputStream* istr)
         {
-            ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
-            throw __uue;
-        }
-    }
+            ::IceMX::MetricsAdmin::GetMetricsViewResult v;
+            istr->readAll(v.timestamp, v.returnValue);
+            istr->readPendingValues();
+            return v;
+        });
 }
 
-::Ice::AsyncResultPtr
-IceProxy::IceMX::MetricsAdmin::begin_enableMetricsView(const ::std::string& __p_name, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
+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)
 {
-    __checkAsyncTwowayOnly(__IceMX__MetricsAdmin__enableMetricsView_name);
-    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __IceMX__MetricsAdmin__enableMetricsView_name, __del, __cookie);
-    try
-    {
-        __result->prepare(__IceMX__MetricsAdmin__enableMetricsView_name, ::Ice::Normal, __ctx);
-        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::SlicedFormat);
-        __os->write(__p_name);
-        __result->endWriteParams();
-        __result->invoke();
-    }
-    catch(const ::Ice::Exception& __ex)
-    {
-        __result->abort(__ex);
-    }
-    return __result;
+    _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 ::IceMX::UnknownMetricsView&)
+            {
+                throw;
+            }
+            catch(const ::Ice::UserException&)
+            {
+            }
+        });
 }
 
-#ifdef ICE_CPP11
-
-::Ice::AsyncResultPtr
-IceProxy::IceMX::MetricsAdmin::__begin_enableMetricsView(const ::std::string& __p_name, const ::Ice::Context* __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent)
+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)
 {
-    class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
-    {
-    public:
-
-        Cpp11CB(const ::std::function<void ()>& responseFunc, const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, const ::std::function<void (bool)>& sentFunc) :
-            ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
-            _response(responseFunc)
+    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_getMetricsFailures_name);
+    outAsync->invoke(iceC_IceMX_MetricsAdmin_getMetricsFailures_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::SlicedFormat, context,
+        [&](::Ice::OutputStream* ostr)
         {
-            CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
-        }
-
-        virtual void completed(const ::Ice::AsyncResultPtr& __result) const
+            ostr->writeAll(iceP_view, iceP_map, iceP_id);
+        },
+        [](const ::Ice::UserException& ex)
         {
-            ::IceMX::MetricsAdminPrx __proxy = ::IceMX::MetricsAdminPrx::uncheckedCast(__result->getProxy());
             try
             {
-                __proxy->end_enableMetricsView(__result);
+                ex.ice_throw();
             }
-            catch(const ::Ice::Exception& ex)
+            catch(const ::IceMX::UnknownMetricsView&)
             {
-                Cpp11FnCallbackNC::exception(__result, ex);
-                return;
+                throw;
             }
-            if(_response != nullptr)
+            catch(const ::Ice::UserException&)
             {
-                _response();
             }
-        }
-    
-    private:
-        
-        ::std::function<void ()> _response;
-    };
-    return begin_enableMetricsView(__p_name, __ctx, new Cpp11CB(__response, __exception, __sent));
+        });
+}
+
+::std::shared_ptr<::Ice::ObjectPrx>
+IceMX::MetricsAdminPrx::_newInstance() const
+{
+    return ::IceInternal::createProxy<MetricsAdminPrx>();
+}
+
+const ::std::string&
+IceMX::MetricsAdminPrx::ice_staticId()
+{
+    return IceMX::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");
+
+}
+
+IceMX::UnknownMetricsView::~UnknownMetricsView() throw()
+{
+}
+
+::std::string
+IceMX::UnknownMetricsView::ice_id() const
+{
+    return "::IceMX::UnknownMetricsView";
+}
+
+IceMX::UnknownMetricsView*
+IceMX::UnknownMetricsView::ice_clone() const
+{
+    return new UnknownMetricsView(*this);
 }
-#endif
 
 void
-IceProxy::IceMX::MetricsAdmin::end_enableMetricsView(const ::Ice::AsyncResultPtr& __result)
+IceMX::UnknownMetricsView::ice_throw() const
 {
-    ::Ice::AsyncResult::__check(__result, this, __IceMX__MetricsAdmin__enableMetricsView_name);
-    if(!__result->__wait())
-    {
-        try
-        {
-            __result->__throwUserException();
-        }
-        catch(const ::IceMX::UnknownMetricsView&)
-        {
-            throw;
-        }
-        catch(const ::Ice::UserException& __ex)
-        {
-            throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
-        }
-    }
-    __result->__readEmptyParams();
+    throw *this;
 }
 
 void
-IceProxy::IceMX::MetricsAdmin::disableMetricsView(const ::std::string& __p_name, const ::Ice::Context* __ctx)
+IceMX::UnknownMetricsView::_writeImpl(::Ice::OutputStream* ostr) const
 {
-    __checkTwowayOnly(__IceMX__MetricsAdmin__disableMetricsView_name);
-    ::IceInternal::Outgoing __og(this, __IceMX__MetricsAdmin__disableMetricsView_name, ::Ice::Normal, __ctx);
-    try
-    {
-        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::SlicedFormat);
-        __os->write(__p_name);
-        __og.endWriteParams();
-    }
-    catch(const ::Ice::LocalException& __ex)
-    {
-        __og.abort(__ex);
-    }
-    if(!__og.invoke())
-    {
-        try
-        {
-            __og.throwUserException();
-        }
-        catch(const ::IceMX::UnknownMetricsView&)
-        {
-            throw;
-        }
-        catch(const ::Ice::UserException& __ex)
-        {
-            ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
-            throw __uue;
-        }
-    }
+    ostr->startSlice("::IceMX::UnknownMetricsView", -1, true);
+    Ice::StreamWriter< ::IceMX::UnknownMetricsView, ::Ice::OutputStream>::write(ostr, *this);
+    ostr->endSlice();
 }
 
-::Ice::AsyncResultPtr
-IceProxy::IceMX::MetricsAdmin::begin_disableMetricsView(const ::std::string& __p_name, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
+void
+IceMX::UnknownMetricsView::_readImpl(::Ice::InputStream* istr)
 {
-    __checkAsyncTwowayOnly(__IceMX__MetricsAdmin__disableMetricsView_name);
-    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __IceMX__MetricsAdmin__disableMetricsView_name, __del, __cookie);
-    try
+    istr->startSlice();
+    Ice::StreamReader< ::IceMX::UnknownMetricsView, ::Ice::InputStream>::read(istr, *this);
+    istr->endSlice();
+}
+ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(::IceProxy::IceMX::Metrics* p) { return p; }
+
+void
+::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ::IceProxy::IceMX::Metrics>& v)
+{
+    ::Ice::ObjectPrx proxy;
+    istr->read(proxy);
+    if(!proxy)
     {
-        __result->prepare(__IceMX__MetricsAdmin__disableMetricsView_name, ::Ice::Normal, __ctx);
-        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::SlicedFormat);
-        __os->write(__p_name);
-        __result->endWriteParams();
-        __result->invoke();
+        v = 0;
     }
-    catch(const ::Ice::Exception& __ex)
+    else
     {
-        __result->abort(__ex);
+        v = new ::IceProxy::IceMX::Metrics;
+        v->_copyFrom(proxy);
     }
-    return __result;
 }
 
-#ifdef ICE_CPP11
-
-::Ice::AsyncResultPtr
-IceProxy::IceMX::MetricsAdmin::__begin_disableMetricsView(const ::std::string& __p_name, const ::Ice::Context* __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent)
+::IceProxy::Ice::Object*
+IceProxy::IceMX::Metrics::_newInstance() const
 {
-    class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
-    {
-    public:
-
-        Cpp11CB(const ::std::function<void ()>& responseFunc, const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, const ::std::function<void (bool)>& sentFunc) :
-            ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
-            _response(responseFunc)
-        {
-            CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
-        }
+    return new Metrics;
+}
 
-        virtual void completed(const ::Ice::AsyncResultPtr& __result) const
-        {
-            ::IceMX::MetricsAdminPrx __proxy = ::IceMX::MetricsAdminPrx::uncheckedCast(__result->getProxy());
-            try
-            {
-                __proxy->end_disableMetricsView(__result);
-            }
-            catch(const ::Ice::Exception& ex)
-            {
-                Cpp11FnCallbackNC::exception(__result, ex);
-                return;
-            }
-            if(_response != nullptr)
-            {
-                _response();
-            }
-        }
-    
-    private:
-        
-        ::std::function<void ()> _response;
-    };
-    return begin_disableMetricsView(__p_name, __ctx, new Cpp11CB(__response, __exception, __sent));
+const ::std::string&
+IceProxy::IceMX::Metrics::ice_staticId()
+{
+    return ::IceMX::Metrics::ice_staticId();
 }
-#endif
+ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(::IceProxy::IceMX::MetricsAdmin* p) { return p; }
 
 void
-IceProxy::IceMX::MetricsAdmin::end_disableMetricsView(const ::Ice::AsyncResultPtr& __result)
+::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ::IceProxy::IceMX::MetricsAdmin>& v)
 {
-    ::Ice::AsyncResult::__check(__result, this, __IceMX__MetricsAdmin__disableMetricsView_name);
-    if(!__result->__wait())
+    ::Ice::ObjectPrx proxy;
+    istr->read(proxy);
+    if(!proxy)
     {
-        try
-        {
-            __result->__throwUserException();
-        }
-        catch(const ::IceMX::UnknownMetricsView&)
-        {
-            throw;
-        }
-        catch(const ::Ice::UserException& __ex)
-        {
-            throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
-        }
+        v = 0;
+    }
+    else
+    {
+        v = new ::IceProxy::IceMX::MetricsAdmin;
+        v->_copyFrom(proxy);
     }
-    __result->__readEmptyParams();
 }
 
-::IceMX::MetricsView
-IceProxy::IceMX::MetricsAdmin::getMetricsView(const ::std::string& __p_view, ::Ice::Long& __p_timestamp, const ::Ice::Context* __ctx)
+::Ice::AsyncResultPtr
+IceProxy::IceMX::MetricsAdmin::_iceI_begin_getMetricsViewNames(const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
 {
-    __checkTwowayOnly(__IceMX__MetricsAdmin__getMetricsView_name);
-    ::IceInternal::Outgoing __og(this, __IceMX__MetricsAdmin__getMetricsView_name, ::Ice::Normal, __ctx);
+    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_getMetricsViewNames_name, sync);
+    ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_IceMX_MetricsAdmin_getMetricsViewNames_name, del, cookie, sync);
     try
     {
-        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::SlicedFormat);
-        __os->write(__p_view);
-        __og.endWriteParams();
+        result->prepare(iceC_IceMX_MetricsAdmin_getMetricsViewNames_name, ::Ice::Normal, context);
+        result->writeEmptyParams();
+        result->invoke(iceC_IceMX_MetricsAdmin_getMetricsViewNames_name);
     }
-    catch(const ::Ice::LocalException& __ex)
+    catch(const ::Ice::Exception& ex)
     {
-        __og.abort(__ex);
+        result->abort(ex);
     }
-    if(!__og.invoke())
+    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
-        {
-            __og.throwUserException();
-        }
-        catch(const ::IceMX::UnknownMetricsView&)
+        try
         {
-            throw;
+            result->_throwUserException();
         }
-        catch(const ::Ice::UserException& __ex)
+        catch(const ::Ice::UserException& ex)
         {
-            ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
-            throw __uue;
+            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
         }
     }
-    ::IceMX::MetricsView __ret;
-    ::IceInternal::BasicStream* __is = __og.startReadParams();
-    __is->read(__p_timestamp);
-    __is->read(__ret);
-    __is->readPendingObjects();
-    __og.endReadParams();
-    return __ret;
+    ::Ice::InputStream* istr = result->_startReadParams();
+    istr->read(iceP_disabledViews);
+    istr->read(ret);
+    result->_endReadParams();
+    return ret;
 }
 
 ::Ice::AsyncResultPtr
-IceProxy::IceMX::MetricsAdmin::begin_getMetricsView(const ::std::string& __p_view, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
+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)
 {
-    __checkAsyncTwowayOnly(__IceMX__MetricsAdmin__getMetricsView_name);
-    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __IceMX__MetricsAdmin__getMetricsView_name, __del, __cookie);
+    _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(__IceMX__MetricsAdmin__getMetricsView_name, ::Ice::Normal, __ctx);
-        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::SlicedFormat);
-        __os->write(__p_view);
-        __result->endWriteParams();
-        __result->invoke();
+        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)
+    catch(const ::Ice::Exception& ex)
     {
-        __result->abort(__ex);
+        result->abort(ex);
     }
-    return __result;
-}
-
-#ifdef ICE_CPP11
-
-::Ice::AsyncResultPtr
-IceProxy::IceMX::MetricsAdmin::__begin_getMetricsView(const ::std::string& __p_view, const ::Ice::Context* __ctx, const ::IceInternal::Function<void (const ::IceMX::MetricsView&, ::Ice::Long)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent)
-{
-    class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
-    {
-    public:
-
-        Cpp11CB(const ::std::function<void (const ::IceMX::MetricsView&, ::Ice::Long)>& responseFunc, const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, const ::std::function<void (bool)>& sentFunc) :
-            ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
-            _response(responseFunc)
-        {
-            CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
-        }
-
-        virtual void completed(const ::Ice::AsyncResultPtr& __result) const
-        {
-            ::IceMX::MetricsAdminPrx __proxy = ::IceMX::MetricsAdminPrx::uncheckedCast(__result->getProxy());
-            ::Ice::Long __p_timestamp;
-            ::IceMX::MetricsView __ret;
-            try
-            {
-                __ret = __proxy->end_getMetricsView(__p_timestamp, __result);
-            }
-            catch(const ::Ice::Exception& ex)
-            {
-                Cpp11FnCallbackNC::exception(__result, ex);
-                return;
-            }
-            if(_response != nullptr)
-            {
-                _response(__ret, __p_timestamp);
-            }
-        }
-    
-    private:
-        
-        ::std::function<void (const ::IceMX::MetricsView&, ::Ice::Long)> _response;
-    };
-    return begin_getMetricsView(__p_view, __ctx, new Cpp11CB(__response, __exception, __sent));
+    return result;
 }
-#endif
 
-::IceMX::MetricsView
-IceProxy::IceMX::MetricsAdmin::end_getMetricsView(::Ice::Long& __p_timestamp, const ::Ice::AsyncResultPtr& __result)
+void
+IceProxy::IceMX::MetricsAdmin::end_enableMetricsView(const ::Ice::AsyncResultPtr& result)
 {
-    ::Ice::AsyncResult::__check(__result, this, __IceMX__MetricsAdmin__getMetricsView_name);
-    ::IceMX::MetricsView __ret;
-    if(!__result->__wait())
+    ::Ice::AsyncResult::_check(result, this, iceC_IceMX_MetricsAdmin_enableMetricsView_name);
+    if(!result->_waitForResponse())
     {
         try
         {
-            __result->__throwUserException();
+            result->_throwUserException();
         }
         catch(const ::IceMX::UnknownMetricsView&)
         {
             throw;
         }
-        catch(const ::Ice::UserException& __ex)
+        catch(const ::Ice::UserException& ex)
         {
-            throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
+            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
         }
     }
-    ::IceInternal::BasicStream* __is = __result->__startReadParams();
-    __is->read(__p_timestamp);
-    __is->read(__ret);
-    __is->readPendingObjects();
-    __result->__endReadParams();
-    return __ret;
+    result->_readEmptyParams();
 }
 
-::IceMX::MetricsFailuresSeq
-IceProxy::IceMX::MetricsAdmin::getMapMetricsFailures(const ::std::string& __p_view, const ::std::string& __p_map, const ::Ice::Context* __ctx)
+::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(__IceMX__MetricsAdmin__getMapMetricsFailures_name);
-    ::IceInternal::Outgoing __og(this, __IceMX__MetricsAdmin__getMapMetricsFailures_name, ::Ice::Normal, __ctx);
+    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_disableMetricsView_name, sync);
+    ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_IceMX_MetricsAdmin_disableMetricsView_name, del, cookie, sync);
     try
     {
-        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::SlicedFormat);
-        __os->write(__p_view);
-        __os->write(__p_map);
-        __og.endWriteParams();
+        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::LocalException& __ex)
+    catch(const ::Ice::Exception& ex)
     {
-        __og.abort(__ex);
+        result->abort(ex);
     }
-    if(!__og.invoke())
+    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
         {
-            __og.throwUserException();
+            result->_throwUserException();
         }
         catch(const ::IceMX::UnknownMetricsView&)
         {
             throw;
         }
-        catch(const ::Ice::UserException& __ex)
+        catch(const ::Ice::UserException& ex)
         {
-            ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
-            throw __uue;
+            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
         }
     }
-    ::IceMX::MetricsFailuresSeq __ret;
-    ::IceInternal::BasicStream* __is = __og.startReadParams();
-    __is->read(__ret);
-    __og.endReadParams();
-    return __ret;
+    result->_readEmptyParams();
 }
 
 ::Ice::AsyncResultPtr
-IceProxy::IceMX::MetricsAdmin::begin_getMapMetricsFailures(const ::std::string& __p_view, const ::std::string& __p_map, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
+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)
 {
-    __checkAsyncTwowayOnly(__IceMX__MetricsAdmin__getMapMetricsFailures_name);
-    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __IceMX__MetricsAdmin__getMapMetricsFailures_name, __del, __cookie);
+    _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(__IceMX__MetricsAdmin__getMapMetricsFailures_name, ::Ice::Normal, __ctx);
-        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::SlicedFormat);
-        __os->write(__p_view);
-        __os->write(__p_map);
-        __result->endWriteParams();
-        __result->invoke();
+        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)
+    catch(const ::Ice::Exception& ex)
     {
-        __result->abort(__ex);
+        result->abort(ex);
     }
-    return __result;
-}
-
-#ifdef ICE_CPP11
-
-::Ice::AsyncResultPtr
-IceProxy::IceMX::MetricsAdmin::__begin_getMapMetricsFailures(const ::std::string& __p_view, const ::std::string& __p_map, const ::Ice::Context* __ctx, const ::IceInternal::Function<void (const ::IceMX::MetricsFailuresSeq&)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent)
-{
-    class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
-    {
-    public:
-
-        Cpp11CB(const ::std::function<void (const ::IceMX::MetricsFailuresSeq&)>& responseFunc, const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, const ::std::function<void (bool)>& sentFunc) :
-            ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
-            _response(responseFunc)
-        {
-            CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
-        }
-
-        virtual void completed(const ::Ice::AsyncResultPtr& __result) const
-        {
-            ::IceMX::MetricsAdminPrx __proxy = ::IceMX::MetricsAdminPrx::uncheckedCast(__result->getProxy());
-            ::IceMX::MetricsFailuresSeq __ret;
-            try
-            {
-                __ret = __proxy->end_getMapMetricsFailures(__result);
-            }
-            catch(const ::Ice::Exception& ex)
-            {
-                Cpp11FnCallbackNC::exception(__result, ex);
-                return;
-            }
-            if(_response != nullptr)
-            {
-                _response(__ret);
-            }
-        }
-    
-    private:
-        
-        ::std::function<void (const ::IceMX::MetricsFailuresSeq&)> _response;
-    };
-    return begin_getMapMetricsFailures(__p_view, __p_map, __ctx, new Cpp11CB(__response, __exception, __sent));
+    return result;
 }
-#endif
 
-::IceMX::MetricsFailuresSeq
-IceProxy::IceMX::MetricsAdmin::end_getMapMetricsFailures(const ::Ice::AsyncResultPtr& __result)
+::IceMX::MetricsView
+IceProxy::IceMX::MetricsAdmin::end_getMetricsView(::Ice::Long& iceP_timestamp, const ::Ice::AsyncResultPtr& result)
 {
-    ::Ice::AsyncResult::__check(__result, this, __IceMX__MetricsAdmin__getMapMetricsFailures_name);
-    ::IceMX::MetricsFailuresSeq __ret;
-    if(!__result->__wait())
+    ::Ice::AsyncResult::_check(result, this, iceC_IceMX_MetricsAdmin_getMetricsView_name);
+    ::IceMX::MetricsView ret;
+    if(!result->_waitForResponse())
     {
         try
         {
-            __result->__throwUserException();
+            result->_throwUserException();
         }
         catch(const ::IceMX::UnknownMetricsView&)
         {
             throw;
         }
-        catch(const ::Ice::UserException& __ex)
+        catch(const ::Ice::UserException& ex)
         {
-            throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
+            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
         }
     }
-    ::IceInternal::BasicStream* __is = __result->__startReadParams();
-    __is->read(__ret);
-    __result->__endReadParams();
-    return __ret;
+    ::Ice::InputStream* istr = result->_startReadParams();
+    istr->read(iceP_timestamp);
+    istr->read(ret);
+    istr->readPendingValues();
+    result->_endReadParams();
+    return ret;
 }
 
-::IceMX::MetricsFailures
-IceProxy::IceMX::MetricsAdmin::getMetricsFailures(const ::std::string& __p_view, const ::std::string& __p_map, const ::std::string& __p_id, const ::Ice::Context* __ctx)
+::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(__IceMX__MetricsAdmin__getMetricsFailures_name);
-    ::IceInternal::Outgoing __og(this, __IceMX__MetricsAdmin__getMetricsFailures_name, ::Ice::Normal, __ctx);
+    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_getMapMetricsFailures_name, sync);
+    ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_IceMX_MetricsAdmin_getMapMetricsFailures_name, del, cookie, sync);
     try
     {
-        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::SlicedFormat);
-        __os->write(__p_view);
-        __os->write(__p_map);
-        __os->write(__p_id);
-        __og.endWriteParams();
+        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::LocalException& __ex)
+    catch(const ::Ice::Exception& ex)
     {
-        __og.abort(__ex);
+        result->abort(ex);
     }
-    if(!__og.invoke())
+    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
         {
-            __og.throwUserException();
+            result->_throwUserException();
         }
         catch(const ::IceMX::UnknownMetricsView&)
         {
             throw;
         }
-        catch(const ::Ice::UserException& __ex)
+        catch(const ::Ice::UserException& ex)
         {
-            ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
-            throw __uue;
+            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
         }
     }
-    ::IceMX::MetricsFailures __ret;
-    ::IceInternal::BasicStream* __is = __og.startReadParams();
-    __is->read(__ret);
-    __og.endReadParams();
-    return __ret;
+    ::Ice::InputStream* istr = result->_startReadParams();
+    istr->read(ret);
+    result->_endReadParams();
+    return ret;
 }
 
 ::Ice::AsyncResultPtr
-IceProxy::IceMX::MetricsAdmin::begin_getMetricsFailures(const ::std::string& __p_view, const ::std::string& __p_map, const ::std::string& __p_id, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
+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)
 {
-    __checkAsyncTwowayOnly(__IceMX__MetricsAdmin__getMetricsFailures_name);
-    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __IceMX__MetricsAdmin__getMetricsFailures_name, __del, __cookie);
+    _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(__IceMX__MetricsAdmin__getMetricsFailures_name, ::Ice::Normal, __ctx);
-        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::SlicedFormat);
-        __os->write(__p_view);
-        __os->write(__p_map);
-        __os->write(__p_id);
-        __result->endWriteParams();
-        __result->invoke();
+        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)
+    catch(const ::Ice::Exception& ex)
     {
-        __result->abort(__ex);
+        result->abort(ex);
     }
-    return __result;
-}
-
-#ifdef ICE_CPP11
-
-::Ice::AsyncResultPtr
-IceProxy::IceMX::MetricsAdmin::__begin_getMetricsFailures(const ::std::string& __p_view, const ::std::string& __p_map, const ::std::string& __p_id, const ::Ice::Context* __ctx, const ::IceInternal::Function<void (const ::IceMX::MetricsFailures&)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent)
-{
-    class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
-    {
-    public:
-
-        Cpp11CB(const ::std::function<void (const ::IceMX::MetricsFailures&)>& responseFunc, const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, const ::std::function<void (bool)>& sentFunc) :
-            ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
-            _response(responseFunc)
-        {
-            CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
-        }
-
-        virtual void completed(const ::Ice::AsyncResultPtr& __result) const
-        {
-            ::IceMX::MetricsAdminPrx __proxy = ::IceMX::MetricsAdminPrx::uncheckedCast(__result->getProxy());
-            ::IceMX::MetricsFailures __ret;
-            try
-            {
-                __ret = __proxy->end_getMetricsFailures(__result);
-            }
-            catch(const ::Ice::Exception& ex)
-            {
-                Cpp11FnCallbackNC::exception(__result, ex);
-                return;
-            }
-            if(_response != nullptr)
-            {
-                _response(__ret);
-            }
-        }
-    
-    private:
-        
-        ::std::function<void (const ::IceMX::MetricsFailures&)> _response;
-    };
-    return begin_getMetricsFailures(__p_view, __p_map, __p_id, __ctx, new Cpp11CB(__response, __exception, __sent));
+    return result;
 }
-#endif
 
 ::IceMX::MetricsFailures
-IceProxy::IceMX::MetricsAdmin::end_getMetricsFailures(const ::Ice::AsyncResultPtr& __result)
+IceProxy::IceMX::MetricsAdmin::end_getMetricsFailures(const ::Ice::AsyncResultPtr& result)
 {
-    ::Ice::AsyncResult::__check(__result, this, __IceMX__MetricsAdmin__getMetricsFailures_name);
-    ::IceMX::MetricsFailures __ret;
-    if(!__result->__wait())
+    ::Ice::AsyncResult::_check(result, this, iceC_IceMX_MetricsAdmin_getMetricsFailures_name);
+    ::IceMX::MetricsFailures ret;
+    if(!result->_waitForResponse())
     {
         try
         {
-            __result->__throwUserException();
+            result->_throwUserException();
         }
         catch(const ::IceMX::UnknownMetricsView&)
         {
             throw;
         }
-        catch(const ::Ice::UserException& __ex)
+        catch(const ::Ice::UserException& ex)
         {
-            throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
+            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
         }
     }
-    ::IceInternal::BasicStream* __is = __result->__startReadParams();
-    __is->read(__ret);
-    __result->__endReadParams();
-    return __ret;
+    ::Ice::InputStream* istr = result->_startReadParams();
+    istr->read(ret);
+    result->_endReadParams();
+    return ret;
 }
 
-const ::std::string&
-IceProxy::IceMX::MetricsAdmin::ice_staticId()
+::IceProxy::Ice::Object*
+IceProxy::IceMX::MetricsAdmin::_newInstance() const
 {
-    return ::IceMX::MetricsAdmin::ice_staticId();
+    return new MetricsAdmin;
 }
 
-::IceProxy::Ice::Object*
-IceProxy::IceMX::MetricsAdmin::__newInstance() const
+const ::std::string&
+IceProxy::IceMX::MetricsAdmin::ice_staticId()
 {
-    return new MetricsAdmin;
+    return ::IceMX::MetricsAdmin::ice_staticId();
 }
-#ifdef __SUNPRO_CC
-class ICE_API IceProxy::IceMX::ThreadMetrics;
-#endif
 ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(::IceProxy::IceMX::ThreadMetrics* p) { return p; }
 
 void
-::IceProxy::IceMX::__read(::IceInternal::BasicStream* __is, ::IceInternal::ProxyHandle< ::IceProxy::IceMX::ThreadMetrics>& v)
+::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ::IceProxy::IceMX::ThreadMetrics>& v)
 {
     ::Ice::ObjectPrx proxy;
-    __is->read(proxy);
+    istr->read(proxy);
     if(!proxy)
     {
         v = 0;
@@ -928,31 +945,28 @@ void
     else
     {
         v = new ::IceProxy::IceMX::ThreadMetrics;
-        v->__copyFrom(proxy);
+        v->_copyFrom(proxy);
     }
 }
 
-const ::std::string&
-IceProxy::IceMX::ThreadMetrics::ice_staticId()
+::IceProxy::Ice::Object*
+IceProxy::IceMX::ThreadMetrics::_newInstance() const
 {
-    return ::IceMX::ThreadMetrics::ice_staticId();
+    return new ThreadMetrics;
 }
 
-::IceProxy::Ice::Object*
-IceProxy::IceMX::ThreadMetrics::__newInstance() const
+const ::std::string&
+IceProxy::IceMX::ThreadMetrics::ice_staticId()
 {
-    return new ThreadMetrics;
+    return ::IceMX::ThreadMetrics::ice_staticId();
 }
-#ifdef __SUNPRO_CC
-class ICE_API IceProxy::IceMX::DispatchMetrics;
-#endif
 ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(::IceProxy::IceMX::DispatchMetrics* p) { return p; }
 
 void
-::IceProxy::IceMX::__read(::IceInternal::BasicStream* __is, ::IceInternal::ProxyHandle< ::IceProxy::IceMX::DispatchMetrics>& v)
+::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ::IceProxy::IceMX::DispatchMetrics>& v)
 {
     ::Ice::ObjectPrx proxy;
-    __is->read(proxy);
+    istr->read(proxy);
     if(!proxy)
     {
         v = 0;
@@ -960,31 +974,28 @@ void
     else
     {
         v = new ::IceProxy::IceMX::DispatchMetrics;
-        v->__copyFrom(proxy);
+        v->_copyFrom(proxy);
     }
 }
 
-const ::std::string&
-IceProxy::IceMX::DispatchMetrics::ice_staticId()
+::IceProxy::Ice::Object*
+IceProxy::IceMX::DispatchMetrics::_newInstance() const
 {
-    return ::IceMX::DispatchMetrics::ice_staticId();
+    return new DispatchMetrics;
 }
 
-::IceProxy::Ice::Object*
-IceProxy::IceMX::DispatchMetrics::__newInstance() const
+const ::std::string&
+IceProxy::IceMX::DispatchMetrics::ice_staticId()
 {
-    return new DispatchMetrics;
+    return ::IceMX::DispatchMetrics::ice_staticId();
 }
-#ifdef __SUNPRO_CC
-class ICE_API IceProxy::IceMX::ChildInvocationMetrics;
-#endif
 ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(::IceProxy::IceMX::ChildInvocationMetrics* p) { return p; }
 
 void
-::IceProxy::IceMX::__read(::IceInternal::BasicStream* __is, ::IceInternal::ProxyHandle< ::IceProxy::IceMX::ChildInvocationMetrics>& v)
+::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ::IceProxy::IceMX::ChildInvocationMetrics>& v)
 {
     ::Ice::ObjectPrx proxy;
-    __is->read(proxy);
+    istr->read(proxy);
     if(!proxy)
     {
         v = 0;
@@ -992,31 +1003,28 @@ void
     else
     {
         v = new ::IceProxy::IceMX::ChildInvocationMetrics;
-        v->__copyFrom(proxy);
+        v->_copyFrom(proxy);
     }
 }
 
-const ::std::string&
-IceProxy::IceMX::ChildInvocationMetrics::ice_staticId()
+::IceProxy::Ice::Object*
+IceProxy::IceMX::ChildInvocationMetrics::_newInstance() const
 {
-    return ::IceMX::ChildInvocationMetrics::ice_staticId();
+    return new ChildInvocationMetrics;
 }
 
-::IceProxy::Ice::Object*
-IceProxy::IceMX::ChildInvocationMetrics::__newInstance() const
+const ::std::string&
+IceProxy::IceMX::ChildInvocationMetrics::ice_staticId()
 {
-    return new ChildInvocationMetrics;
+    return ::IceMX::ChildInvocationMetrics::ice_staticId();
 }
-#ifdef __SUNPRO_CC
-class ICE_API IceProxy::IceMX::CollocatedMetrics;
-#endif
 ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(::IceProxy::IceMX::CollocatedMetrics* p) { return p; }
 
 void
-::IceProxy::IceMX::__read(::IceInternal::BasicStream* __is, ::IceInternal::ProxyHandle< ::IceProxy::IceMX::CollocatedMetrics>& v)
+::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ::IceProxy::IceMX::CollocatedMetrics>& v)
 {
     ::Ice::ObjectPrx proxy;
-    __is->read(proxy);
+    istr->read(proxy);
     if(!proxy)
     {
         v = 0;
@@ -1024,31 +1032,28 @@ void
     else
     {
         v = new ::IceProxy::IceMX::CollocatedMetrics;
-        v->__copyFrom(proxy);
+        v->_copyFrom(proxy);
     }
 }
 
-const ::std::string&
-IceProxy::IceMX::CollocatedMetrics::ice_staticId()
+::IceProxy::Ice::Object*
+IceProxy::IceMX::CollocatedMetrics::_newInstance() const
 {
-    return ::IceMX::CollocatedMetrics::ice_staticId();
+    return new CollocatedMetrics;
 }
 
-::IceProxy::Ice::Object*
-IceProxy::IceMX::CollocatedMetrics::__newInstance() const
+const ::std::string&
+IceProxy::IceMX::CollocatedMetrics::ice_staticId()
 {
-    return new CollocatedMetrics;
+    return ::IceMX::CollocatedMetrics::ice_staticId();
 }
-#ifdef __SUNPRO_CC
-class ICE_API IceProxy::IceMX::RemoteMetrics;
-#endif
 ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(::IceProxy::IceMX::RemoteMetrics* p) { return p; }
 
 void
-::IceProxy::IceMX::__read(::IceInternal::BasicStream* __is, ::IceInternal::ProxyHandle< ::IceProxy::IceMX::RemoteMetrics>& v)
+::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ::IceProxy::IceMX::RemoteMetrics>& v)
 {
     ::Ice::ObjectPrx proxy;
-    __is->read(proxy);
+    istr->read(proxy);
     if(!proxy)
     {
         v = 0;
@@ -1056,31 +1061,28 @@ void
     else
     {
         v = new ::IceProxy::IceMX::RemoteMetrics;
-        v->__copyFrom(proxy);
+        v->_copyFrom(proxy);
     }
 }
 
-const ::std::string&
-IceProxy::IceMX::RemoteMetrics::ice_staticId()
+::IceProxy::Ice::Object*
+IceProxy::IceMX::RemoteMetrics::_newInstance() const
 {
-    return ::IceMX::RemoteMetrics::ice_staticId();
+    return new RemoteMetrics;
 }
 
-::IceProxy::Ice::Object*
-IceProxy::IceMX::RemoteMetrics::__newInstance() const
+const ::std::string&
+IceProxy::IceMX::RemoteMetrics::ice_staticId()
 {
-    return new RemoteMetrics;
+    return ::IceMX::RemoteMetrics::ice_staticId();
 }
-#ifdef __SUNPRO_CC
-class ICE_API IceProxy::IceMX::InvocationMetrics;
-#endif
 ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(::IceProxy::IceMX::InvocationMetrics* p) { return p; }
 
 void
-::IceProxy::IceMX::__read(::IceInternal::BasicStream* __is, ::IceInternal::ProxyHandle< ::IceProxy::IceMX::InvocationMetrics>& v)
+::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ::IceProxy::IceMX::InvocationMetrics>& v)
 {
     ::Ice::ObjectPrx proxy;
-    __is->read(proxy);
+    istr->read(proxy);
     if(!proxy)
     {
         v = 0;
@@ -1088,31 +1090,28 @@ void
     else
     {
         v = new ::IceProxy::IceMX::InvocationMetrics;
-        v->__copyFrom(proxy);
+        v->_copyFrom(proxy);
     }
 }
 
-const ::std::string&
-IceProxy::IceMX::InvocationMetrics::ice_staticId()
+::IceProxy::Ice::Object*
+IceProxy::IceMX::InvocationMetrics::_newInstance() const
 {
-    return ::IceMX::InvocationMetrics::ice_staticId();
+    return new InvocationMetrics;
 }
 
-::IceProxy::Ice::Object*
-IceProxy::IceMX::InvocationMetrics::__newInstance() const
+const ::std::string&
+IceProxy::IceMX::InvocationMetrics::ice_staticId()
 {
-    return new InvocationMetrics;
+    return ::IceMX::InvocationMetrics::ice_staticId();
 }
-#ifdef __SUNPRO_CC
-class ICE_API IceProxy::IceMX::ConnectionMetrics;
-#endif
 ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(::IceProxy::IceMX::ConnectionMetrics* p) { return p; }
 
 void
-::IceProxy::IceMX::__read(::IceInternal::BasicStream* __is, ::IceInternal::ProxyHandle< ::IceProxy::IceMX::ConnectionMetrics>& v)
+::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ::IceProxy::IceMX::ConnectionMetrics>& v)
 {
     ::Ice::ObjectPrx proxy;
-    __is->read(proxy);
+    istr->read(proxy);
     if(!proxy)
     {
         v = 0;
@@ -1120,33 +1119,38 @@ void
     else
     {
         v = new ::IceProxy::IceMX::ConnectionMetrics;
-        v->__copyFrom(proxy);
+        v->_copyFrom(proxy);
     }
 }
 
+::IceProxy::Ice::Object*
+IceProxy::IceMX::ConnectionMetrics::_newInstance() const
+{
+    return new ConnectionMetrics;
+}
+
 const ::std::string&
 IceProxy::IceMX::ConnectionMetrics::ice_staticId()
 {
     return ::IceMX::ConnectionMetrics::ice_staticId();
 }
 
-::IceProxy::Ice::Object*
-IceProxy::IceMX::ConnectionMetrics::__newInstance() const
+IceMX::Metrics::~Metrics()
 {
-    return new ConnectionMetrics;
 }
 
 ICE_API ::Ice::Object* IceMX::upCast(::IceMX::Metrics* p) { return p; }
+
 ::Ice::ObjectPtr
 IceMX::Metrics::ice_clone() const
 {
-    ::Ice::Object* __p = new Metrics(*this);
-    return __p;
+    ::Ice::Object* p = new Metrics(*this);
+    return p;
 }
 
 namespace
 {
-const ::std::string __IceMX__Metrics_ids[2] =
+const ::std::string iceC_IceMX_Metrics_ids[2] =
 {
     "::Ice::Object",
     "::IceMX::Metrics"
@@ -1155,21 +1159,21 @@ const ::std::string __IceMX__Metrics_ids[2] =
 }
 
 bool
-IceMX::Metrics::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
+IceMX::Metrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
 {
-    return ::std::binary_search(__IceMX__Metrics_ids, __IceMX__Metrics_ids + 2, _s);
+    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>(&__IceMX__Metrics_ids[0], &__IceMX__Metrics_ids[2]);
+    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 __IceMX__Metrics_ids[1];
+    return ice_staticId();
 }
 
 const ::std::string&
@@ -1179,48 +1183,39 @@ IceMX::Metrics::ice_staticId()
     static const ::std::string typeId = "::IceMX::Metrics";
     return typeId;
 #else
-    return __IceMX__Metrics_ids[1];
+    return iceC_IceMX_Metrics_ids[1];
 #endif
 }
 
 void
-IceMX::Metrics::__writeImpl(::IceInternal::BasicStream* __os) const
+IceMX::Metrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
 {
-    __os->startWriteSlice(ice_staticId(), -1, true);
-    __os->write(id);
-    __os->write(total);
-    __os->write(current);
-    __os->write(totalLifetime);
-    __os->write(failures);
-    __os->endWriteSlice();
+    ostr->startSlice(ice_staticId(), -1, true);
+    Ice::StreamWriter< ::IceMX::Metrics, ::Ice::OutputStream>::write(ostr, *this);
+    ostr->endSlice();
 }
 
 void
-IceMX::Metrics::__readImpl(::IceInternal::BasicStream* __is)
+IceMX::Metrics::_iceReadImpl(::Ice::InputStream* istr)
 {
-    __is->startReadSlice();
-    __is->read(id);
-    __is->read(total);
-    __is->read(current);
-    __is->read(totalLifetime);
-    __is->read(failures);
-    __is->endReadSlice();
+    istr->startSlice();
+    Ice::StreamReader< ::IceMX::Metrics, ::Ice::InputStream>::read(istr, *this);
+    istr->endSlice();
 }
 
 namespace
 {
-
-const ::IceInternal::DefaultObjectFactoryInit< ::IceMX::Metrics> __IceMX__Metrics_init("::IceMX::Metrics");
+const ::IceInternal::DefaultValueFactoryInit< ::IceMX::Metrics> iceC_IceMX_Metrics_init("::IceMX::Metrics");
 }
 
-::Ice::ObjectFactoryPtr
+::Ice::ValueFactoryPtr
 IceMX::Metrics::ice_factory()
 {
-    return ::IceInternal::factoryTable->getObjectFactory(::IceMX::Metrics::ice_staticId());
+    return ::IceInternal::factoryTable->getValueFactory(::IceMX::Metrics::ice_staticId());
 }
 
-void ICE_API 
-IceMX::__patch(MetricsPtr& handle, const ::Ice::ObjectPtr& v)
+void
+IceMX::_icePatchObjectPtr(MetricsPtr& handle, const ::Ice::ObjectPtr& v)
 {
     handle = ::IceMX::MetricsPtr::dynamicCast(v);
     if(v && !handle)
@@ -1229,11 +1224,16 @@ IceMX::__patch(MetricsPtr& handle, const ::Ice::ObjectPtr& v)
     }
 }
 
+IceMX::MetricsAdmin::~MetricsAdmin()
+{
+}
+
 ICE_API ::Ice::Object* IceMX::upCast(::IceMX::MetricsAdmin* p) { return p; }
 
+
 namespace
 {
-const ::std::string __IceMX__MetricsAdmin_ids[2] =
+const ::std::string iceC_IceMX_MetricsAdmin_ids[2] =
 {
     "::Ice::Object",
     "::IceMX::MetricsAdmin"
@@ -1242,21 +1242,21 @@ const ::std::string __IceMX__MetricsAdmin_ids[2] =
 }
 
 bool
-IceMX::MetricsAdmin::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
+IceMX::MetricsAdmin::ice_isA(const ::std::string& s, const ::Ice::Current&) const
 {
-    return ::std::binary_search(__IceMX__MetricsAdmin_ids, __IceMX__MetricsAdmin_ids + 2, _s);
+    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>(&__IceMX__MetricsAdmin_ids[0], &__IceMX__MetricsAdmin_ids[2]);
+    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 __IceMX__MetricsAdmin_ids[1];
+    return ice_staticId();
 }
 
 const ::std::string&
@@ -1266,147 +1266,113 @@ IceMX::MetricsAdmin::ice_staticId()
     static const ::std::string typeId = "::IceMX::MetricsAdmin";
     return typeId;
 #else
-    return __IceMX__MetricsAdmin_ids[1];
+    return iceC_IceMX_MetricsAdmin_ids[1];
 #endif
 }
 
-::Ice::DispatchStatus
-IceMX::MetricsAdmin::___getMetricsViewNames(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
+bool
+IceMX::MetricsAdmin::_iceD_getMetricsViewNames(::IceInternal::Incoming& inS, const ::Ice::Current& current)
 {
-    __checkMode(::Ice::Normal, __current.mode);
-    __inS.readEmptyParams();
-    ::Ice::StringSeq __p_disabledViews;
-    ::Ice::StringSeq __ret = getMetricsViewNames(__p_disabledViews, __current);
-    ::IceInternal::BasicStream* __os = __inS.__startWriteParams(::Ice::SlicedFormat);
-    __os->write(__p_disabledViews);
-    __os->write(__ret);
-    __inS.__endWriteParams(true);
-    return ::Ice::DispatchOK;
+    _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;
 }
 
-::Ice::DispatchStatus
-IceMX::MetricsAdmin::___enableMetricsView(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
+bool
+IceMX::MetricsAdmin::_iceD_enableMetricsView(::IceInternal::Incoming& inS, const ::Ice::Current& current)
 {
-    __checkMode(::Ice::Normal, __current.mode);
-    ::IceInternal::BasicStream* __is = __inS.startReadParams();
-    ::std::string __p_name;
-    __is->read(__p_name);
-    __inS.endReadParams();
-    try
-    {
-        enableMetricsView(__p_name, __current);
-        __inS.__writeEmptyParams();
-        return ::Ice::DispatchOK;
-    }
-    catch(const ::IceMX::UnknownMetricsView& __ex)
-    {
-        __inS.__writeUserException(__ex, ::Ice::SlicedFormat);
-    }
-    return ::Ice::DispatchUserException;
+    _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;
 }
 
-::Ice::DispatchStatus
-IceMX::MetricsAdmin::___disableMetricsView(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
+bool
+IceMX::MetricsAdmin::_iceD_disableMetricsView(::IceInternal::Incoming& inS, const ::Ice::Current& current)
 {
-    __checkMode(::Ice::Normal, __current.mode);
-    ::IceInternal::BasicStream* __is = __inS.startReadParams();
-    ::std::string __p_name;
-    __is->read(__p_name);
-    __inS.endReadParams();
-    try
-    {
-        disableMetricsView(__p_name, __current);
-        __inS.__writeEmptyParams();
-        return ::Ice::DispatchOK;
-    }
-    catch(const ::IceMX::UnknownMetricsView& __ex)
-    {
-        __inS.__writeUserException(__ex, ::Ice::SlicedFormat);
-    }
-    return ::Ice::DispatchUserException;
+    _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;
 }
 
-::Ice::DispatchStatus
-IceMX::MetricsAdmin::___getMetricsView(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
-{
-    __checkMode(::Ice::Normal, __current.mode);
-    ::IceInternal::BasicStream* __is = __inS.startReadParams();
-    ::std::string __p_view;
-    __is->read(__p_view);
-    __inS.endReadParams();
-    ::Ice::Long __p_timestamp;
-    try
-    {
-        ::IceMX::MetricsView __ret = getMetricsView(__p_view, __p_timestamp, __current);
-        ::IceInternal::BasicStream* __os = __inS.__startWriteParams(::Ice::SlicedFormat);
-        __os->write(__p_timestamp);
-        __os->write(__ret);
-        __os->writePendingObjects();
-        __inS.__endWriteParams(true);
-        return ::Ice::DispatchOK;
-    }
-    catch(const ::IceMX::UnknownMetricsView& __ex)
-    {
-        __inS.__writeUserException(__ex, ::Ice::SlicedFormat);
-    }
-    return ::Ice::DispatchUserException;
+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;
+    ::IceMX::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;
 }
 
-::Ice::DispatchStatus
-IceMX::MetricsAdmin::___getMapMetricsFailures(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
-{
-    __checkMode(::Ice::Normal, __current.mode);
-    ::IceInternal::BasicStream* __is = __inS.startReadParams();
-    ::std::string __p_view;
-    ::std::string __p_map;
-    __is->read(__p_view);
-    __is->read(__p_map);
-    __inS.endReadParams();
-    try
-    {
-        ::IceMX::MetricsFailuresSeq __ret = getMapMetricsFailures(__p_view, __p_map, __current);
-        ::IceInternal::BasicStream* __os = __inS.__startWriteParams(::Ice::SlicedFormat);
-        __os->write(__ret);
-        __inS.__endWriteParams(true);
-        return ::Ice::DispatchOK;
-    }
-    catch(const ::IceMX::UnknownMetricsView& __ex)
-    {
-        __inS.__writeUserException(__ex, ::Ice::SlicedFormat);
-    }
-    return ::Ice::DispatchUserException;
+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);
+    ::IceMX::MetricsFailuresSeq ret = this->getMapMetricsFailures(iceP_view, iceP_map, current);
+    ::Ice::OutputStream* ostr = inS.startWriteParams();
+    ostr->write(ret);
+    inS.endWriteParams();
+    return true;
 }
 
-::Ice::DispatchStatus
-IceMX::MetricsAdmin::___getMetricsFailures(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
-{
-    __checkMode(::Ice::Normal, __current.mode);
-    ::IceInternal::BasicStream* __is = __inS.startReadParams();
-    ::std::string __p_view;
-    ::std::string __p_map;
-    ::std::string __p_id;
-    __is->read(__p_view);
-    __is->read(__p_map);
-    __is->read(__p_id);
-    __inS.endReadParams();
-    try
-    {
-        ::IceMX::MetricsFailures __ret = getMetricsFailures(__p_view, __p_map, __p_id, __current);
-        ::IceInternal::BasicStream* __os = __inS.__startWriteParams(::Ice::SlicedFormat);
-        __os->write(__ret);
-        __inS.__endWriteParams(true);
-        return ::Ice::DispatchOK;
-    }
-    catch(const ::IceMX::UnknownMetricsView& __ex)
-    {
-        __inS.__writeUserException(__ex, ::Ice::SlicedFormat);
-    }
-    return ::Ice::DispatchUserException;
+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);
+    ::IceMX::MetricsFailures ret = this->getMetricsFailures(iceP_view, iceP_map, iceP_id, current);
+    ::Ice::OutputStream* ostr = inS.startWriteParams();
+    ostr->write(ret);
+    inS.endWriteParams();
+    return true;
 }
 
 namespace
 {
-const ::std::string __IceMX__MetricsAdmin_all[] =
+const ::std::string iceC_IceMX_MetricsAdmin_all[] =
 {
     "disableMetricsView",
     "enableMetricsView",
@@ -1422,79 +1388,83 @@ const ::std::string __IceMX__MetricsAdmin_all[] =
 
 }
 
-::Ice::DispatchStatus
-IceMX::MetricsAdmin::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
+bool
+IceMX::MetricsAdmin::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
 {
-    ::std::pair< const ::std::string*, const ::std::string*> r = ::std::equal_range(__IceMX__MetricsAdmin_all, __IceMX__MetricsAdmin_all + 10, current.operation);
+    ::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 - __IceMX__MetricsAdmin_all)
+    switch(r.first - iceC_IceMX_MetricsAdmin_all)
     {
         case 0:
         {
-            return ___disableMetricsView(in, current);
+            return _iceD_disableMetricsView(in, current);
         }
         case 1:
         {
-            return ___enableMetricsView(in, current);
+            return _iceD_enableMetricsView(in, current);
         }
         case 2:
         {
-            return ___getMapMetricsFailures(in, current);
+            return _iceD_getMapMetricsFailures(in, current);
         }
         case 3:
         {
-            return ___getMetricsFailures(in, current);
+            return _iceD_getMetricsFailures(in, current);
         }
         case 4:
         {
-            return ___getMetricsView(in, current);
+            return _iceD_getMetricsView(in, current);
         }
         case 5:
         {
-            return ___getMetricsViewNames(in, current);
+            return _iceD_getMetricsViewNames(in, current);
         }
         case 6:
         {
-            return ___ice_id(in, current);
+            return _iceD_ice_id(in, current);
         }
         case 7:
         {
-            return ___ice_ids(in, current);
+            return _iceD_ice_ids(in, current);
         }
         case 8:
         {
-            return ___ice_isA(in, current);
+            return _iceD_ice_isA(in, current);
         }
         case 9:
         {
-            return ___ice_ping(in, current);
+            return _iceD_ice_ping(in, current);
+        }
+        default:
+        {
+            assert(false);
+            throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
         }
     }
-
-    assert(false);
-    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
 }
 
 void
-IceMX::MetricsAdmin::__writeImpl(::IceInternal::BasicStream* __os) const
+IceMX::MetricsAdmin::_iceWriteImpl(::Ice::OutputStream* ostr) const
 {
-    __os->startWriteSlice(ice_staticId(), -1, true);
-    __os->endWriteSlice();
+    ostr->startSlice(ice_staticId(), -1, true);
+    Ice::StreamWriter< ::IceMX::MetricsAdmin, ::Ice::OutputStream>::write(ostr, *this);
+    ostr->endSlice();
 }
 
 void
-IceMX::MetricsAdmin::__readImpl(::IceInternal::BasicStream* __is)
+IceMX::MetricsAdmin::_iceReadImpl(::Ice::InputStream* istr)
 {
-    __is->startReadSlice();
-    __is->endReadSlice();
+    istr->startSlice();
+    Ice::StreamReader< ::IceMX::MetricsAdmin, ::Ice::InputStream>::read(istr, *this);
+    istr->endSlice();
 }
 
-void ICE_API 
-IceMX::__patch(MetricsAdminPtr& handle, const ::Ice::ObjectPtr& v)
+void
+IceMX::_icePatchObjectPtr(MetricsAdminPtr& handle, const ::Ice::ObjectPtr& v)
 {
     handle = ::IceMX::MetricsAdminPtr::dynamicCast(v);
     if(v && !handle)
@@ -1503,17 +1473,22 @@ IceMX::__patch(MetricsAdminPtr& handle, const ::Ice::ObjectPtr& v)
     }
 }
 
+IceMX::ThreadMetrics::~ThreadMetrics()
+{
+}
+
 ICE_API ::Ice::Object* IceMX::upCast(::IceMX::ThreadMetrics* p) { return p; }
+
 ::Ice::ObjectPtr
 IceMX::ThreadMetrics::ice_clone() const
 {
-    ::Ice::Object* __p = new ThreadMetrics(*this);
-    return __p;
+    ::Ice::Object* p = new ThreadMetrics(*this);
+    return p;
 }
 
 namespace
 {
-const ::std::string __IceMX__ThreadMetrics_ids[3] =
+const ::std::string iceC_IceMX_ThreadMetrics_ids[3] =
 {
     "::Ice::Object",
     "::IceMX::Metrics",
@@ -1523,21 +1498,21 @@ const ::std::string __IceMX__ThreadMetrics_ids[3] =
 }
 
 bool
-IceMX::ThreadMetrics::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
+IceMX::ThreadMetrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
 {
-    return ::std::binary_search(__IceMX__ThreadMetrics_ids, __IceMX__ThreadMetrics_ids + 3, _s);
+    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>(&__IceMX__ThreadMetrics_ids[0], &__IceMX__ThreadMetrics_ids[3]);
+    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 __IceMX__ThreadMetrics_ids[2];
+    return ice_staticId();
 }
 
 const ::std::string&
@@ -1547,46 +1522,41 @@ IceMX::ThreadMetrics::ice_staticId()
     static const ::std::string typeId = "::IceMX::ThreadMetrics";
     return typeId;
 #else
-    return __IceMX__ThreadMetrics_ids[2];
+    return iceC_IceMX_ThreadMetrics_ids[2];
 #endif
 }
 
 void
-IceMX::ThreadMetrics::__writeImpl(::IceInternal::BasicStream* __os) const
+IceMX::ThreadMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
 {
-    __os->startWriteSlice(ice_staticId(), -1, false);
-    __os->write(inUseForIO);
-    __os->write(inUseForUser);
-    __os->write(inUseForOther);
-    __os->endWriteSlice();
-    ::IceMX::Metrics::__writeImpl(__os);
+    ostr->startSlice(ice_staticId(), -1, false);
+    Ice::StreamWriter< ::IceMX::ThreadMetrics, ::Ice::OutputStream>::write(ostr, *this);
+    ostr->endSlice();
+    ::IceMX::Metrics::_iceWriteImpl(ostr);
 }
 
 void
-IceMX::ThreadMetrics::__readImpl(::IceInternal::BasicStream* __is)
+IceMX::ThreadMetrics::_iceReadImpl(::Ice::InputStream* istr)
 {
-    __is->startReadSlice();
-    __is->read(inUseForIO);
-    __is->read(inUseForUser);
-    __is->read(inUseForOther);
-    __is->endReadSlice();
-    ::IceMX::Metrics::__readImpl(__is);
+    istr->startSlice();
+    Ice::StreamReader< ::IceMX::ThreadMetrics, ::Ice::InputStream>::read(istr, *this);
+    istr->endSlice();
+    ::IceMX::Metrics::_iceReadImpl(istr);
 }
 
 namespace
 {
-
-const ::IceInternal::DefaultObjectFactoryInit< ::IceMX::ThreadMetrics> __IceMX__ThreadMetrics_init("::IceMX::ThreadMetrics");
+const ::IceInternal::DefaultValueFactoryInit< ::IceMX::ThreadMetrics> iceC_IceMX_ThreadMetrics_init("::IceMX::ThreadMetrics");
 }
 
-::Ice::ObjectFactoryPtr
+::Ice::ValueFactoryPtr
 IceMX::ThreadMetrics::ice_factory()
 {
-    return ::IceInternal::factoryTable->getObjectFactory(::IceMX::ThreadMetrics::ice_staticId());
+    return ::IceInternal::factoryTable->getValueFactory(::IceMX::ThreadMetrics::ice_staticId());
 }
 
-void ICE_API 
-IceMX::__patch(ThreadMetricsPtr& handle, const ::Ice::ObjectPtr& v)
+void
+IceMX::_icePatchObjectPtr(ThreadMetricsPtr& handle, const ::Ice::ObjectPtr& v)
 {
     handle = ::IceMX::ThreadMetricsPtr::dynamicCast(v);
     if(v && !handle)
@@ -1595,17 +1565,22 @@ IceMX::__patch(ThreadMetricsPtr& handle, const ::Ice::ObjectPtr& v)
     }
 }
 
+IceMX::DispatchMetrics::~DispatchMetrics()
+{
+}
+
 ICE_API ::Ice::Object* IceMX::upCast(::IceMX::DispatchMetrics* p) { return p; }
+
 ::Ice::ObjectPtr
 IceMX::DispatchMetrics::ice_clone() const
 {
-    ::Ice::Object* __p = new DispatchMetrics(*this);
-    return __p;
+    ::Ice::Object* p = new DispatchMetrics(*this);
+    return p;
 }
 
 namespace
 {
-const ::std::string __IceMX__DispatchMetrics_ids[3] =
+const ::std::string iceC_IceMX_DispatchMetrics_ids[3] =
 {
     "::Ice::Object",
     "::IceMX::DispatchMetrics",
@@ -1615,21 +1590,21 @@ const ::std::string __IceMX__DispatchMetrics_ids[3] =
 }
 
 bool
-IceMX::DispatchMetrics::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
+IceMX::DispatchMetrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
 {
-    return ::std::binary_search(__IceMX__DispatchMetrics_ids, __IceMX__DispatchMetrics_ids + 3, _s);
+    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>(&__IceMX__DispatchMetrics_ids[0], &__IceMX__DispatchMetrics_ids[3]);
+    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 __IceMX__DispatchMetrics_ids[1];
+    return ice_staticId();
 }
 
 const ::std::string&
@@ -1639,46 +1614,41 @@ IceMX::DispatchMetrics::ice_staticId()
     static const ::std::string typeId = "::IceMX::DispatchMetrics";
     return typeId;
 #else
-    return __IceMX__DispatchMetrics_ids[1];
+    return iceC_IceMX_DispatchMetrics_ids[1];
 #endif
 }
 
 void
-IceMX::DispatchMetrics::__writeImpl(::IceInternal::BasicStream* __os) const
+IceMX::DispatchMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
 {
-    __os->startWriteSlice(ice_staticId(), -1, false);
-    __os->write(userException);
-    __os->write(size);
-    __os->write(replySize);
-    __os->endWriteSlice();
-    ::IceMX::Metrics::__writeImpl(__os);
+    ostr->startSlice(ice_staticId(), -1, false);
+    Ice::StreamWriter< ::IceMX::DispatchMetrics, ::Ice::OutputStream>::write(ostr, *this);
+    ostr->endSlice();
+    ::IceMX::Metrics::_iceWriteImpl(ostr);
 }
 
 void
-IceMX::DispatchMetrics::__readImpl(::IceInternal::BasicStream* __is)
+IceMX::DispatchMetrics::_iceReadImpl(::Ice::InputStream* istr)
 {
-    __is->startReadSlice();
-    __is->read(userException);
-    __is->read(size);
-    __is->read(replySize);
-    __is->endReadSlice();
-    ::IceMX::Metrics::__readImpl(__is);
+    istr->startSlice();
+    Ice::StreamReader< ::IceMX::DispatchMetrics, ::Ice::InputStream>::read(istr, *this);
+    istr->endSlice();
+    ::IceMX::Metrics::_iceReadImpl(istr);
 }
 
 namespace
 {
-
-const ::IceInternal::DefaultObjectFactoryInit< ::IceMX::DispatchMetrics> __IceMX__DispatchMetrics_init("::IceMX::DispatchMetrics");
+const ::IceInternal::DefaultValueFactoryInit< ::IceMX::DispatchMetrics> iceC_IceMX_DispatchMetrics_init("::IceMX::DispatchMetrics");
 }
 
-::Ice::ObjectFactoryPtr
+::Ice::ValueFactoryPtr
 IceMX::DispatchMetrics::ice_factory()
 {
-    return ::IceInternal::factoryTable->getObjectFactory(::IceMX::DispatchMetrics::ice_staticId());
+    return ::IceInternal::factoryTable->getValueFactory(::IceMX::DispatchMetrics::ice_staticId());
 }
 
-void ICE_API 
-IceMX::__patch(DispatchMetricsPtr& handle, const ::Ice::ObjectPtr& v)
+void
+IceMX::_icePatchObjectPtr(DispatchMetricsPtr& handle, const ::Ice::ObjectPtr& v)
 {
     handle = ::IceMX::DispatchMetricsPtr::dynamicCast(v);
     if(v && !handle)
@@ -1687,17 +1657,22 @@ IceMX::__patch(DispatchMetricsPtr& handle, const ::Ice::ObjectPtr& v)
     }
 }
 
+IceMX::ChildInvocationMetrics::~ChildInvocationMetrics()
+{
+}
+
 ICE_API ::Ice::Object* IceMX::upCast(::IceMX::ChildInvocationMetrics* p) { return p; }
+
 ::Ice::ObjectPtr
 IceMX::ChildInvocationMetrics::ice_clone() const
 {
-    ::Ice::Object* __p = new ChildInvocationMetrics(*this);
-    return __p;
+    ::Ice::Object* p = new ChildInvocationMetrics(*this);
+    return p;
 }
 
 namespace
 {
-const ::std::string __IceMX__ChildInvocationMetrics_ids[3] =
+const ::std::string iceC_IceMX_ChildInvocationMetrics_ids[3] =
 {
     "::Ice::Object",
     "::IceMX::ChildInvocationMetrics",
@@ -1707,21 +1682,21 @@ const ::std::string __IceMX__ChildInvocationMetrics_ids[3] =
 }
 
 bool
-IceMX::ChildInvocationMetrics::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
+IceMX::ChildInvocationMetrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
 {
-    return ::std::binary_search(__IceMX__ChildInvocationMetrics_ids, __IceMX__ChildInvocationMetrics_ids + 3, _s);
+    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>(&__IceMX__ChildInvocationMetrics_ids[0], &__IceMX__ChildInvocationMetrics_ids[3]);
+    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 __IceMX__ChildInvocationMetrics_ids[1];
+    return ice_staticId();
 }
 
 const ::std::string&
@@ -1731,44 +1706,41 @@ IceMX::ChildInvocationMetrics::ice_staticId()
     static const ::std::string typeId = "::IceMX::ChildInvocationMetrics";
     return typeId;
 #else
-    return __IceMX__ChildInvocationMetrics_ids[1];
+    return iceC_IceMX_ChildInvocationMetrics_ids[1];
 #endif
 }
 
 void
-IceMX::ChildInvocationMetrics::__writeImpl(::IceInternal::BasicStream* __os) const
+IceMX::ChildInvocationMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
 {
-    __os->startWriteSlice(ice_staticId(), -1, false);
-    __os->write(size);
-    __os->write(replySize);
-    __os->endWriteSlice();
-    ::IceMX::Metrics::__writeImpl(__os);
+    ostr->startSlice(ice_staticId(), -1, false);
+    Ice::StreamWriter< ::IceMX::ChildInvocationMetrics, ::Ice::OutputStream>::write(ostr, *this);
+    ostr->endSlice();
+    ::IceMX::Metrics::_iceWriteImpl(ostr);
 }
 
 void
-IceMX::ChildInvocationMetrics::__readImpl(::IceInternal::BasicStream* __is)
+IceMX::ChildInvocationMetrics::_iceReadImpl(::Ice::InputStream* istr)
 {
-    __is->startReadSlice();
-    __is->read(size);
-    __is->read(replySize);
-    __is->endReadSlice();
-    ::IceMX::Metrics::__readImpl(__is);
+    istr->startSlice();
+    Ice::StreamReader< ::IceMX::ChildInvocationMetrics, ::Ice::InputStream>::read(istr, *this);
+    istr->endSlice();
+    ::IceMX::Metrics::_iceReadImpl(istr);
 }
 
 namespace
 {
-
-const ::IceInternal::DefaultObjectFactoryInit< ::IceMX::ChildInvocationMetrics> __IceMX__ChildInvocationMetrics_init("::IceMX::ChildInvocationMetrics");
+const ::IceInternal::DefaultValueFactoryInit< ::IceMX::ChildInvocationMetrics> iceC_IceMX_ChildInvocationMetrics_init("::IceMX::ChildInvocationMetrics");
 }
 
-::Ice::ObjectFactoryPtr
+::Ice::ValueFactoryPtr
 IceMX::ChildInvocationMetrics::ice_factory()
 {
-    return ::IceInternal::factoryTable->getObjectFactory(::IceMX::ChildInvocationMetrics::ice_staticId());
+    return ::IceInternal::factoryTable->getValueFactory(::IceMX::ChildInvocationMetrics::ice_staticId());
 }
 
-void ICE_API 
-IceMX::__patch(ChildInvocationMetricsPtr& handle, const ::Ice::ObjectPtr& v)
+void
+IceMX::_icePatchObjectPtr(ChildInvocationMetricsPtr& handle, const ::Ice::ObjectPtr& v)
 {
     handle = ::IceMX::ChildInvocationMetricsPtr::dynamicCast(v);
     if(v && !handle)
@@ -1777,17 +1749,22 @@ IceMX::__patch(ChildInvocationMetricsPtr& handle, const ::Ice::ObjectPtr& v)
     }
 }
 
+IceMX::CollocatedMetrics::~CollocatedMetrics()
+{
+}
+
 ICE_API ::Ice::Object* IceMX::upCast(::IceMX::CollocatedMetrics* p) { return p; }
+
 ::Ice::ObjectPtr
 IceMX::CollocatedMetrics::ice_clone() const
 {
-    ::Ice::Object* __p = new CollocatedMetrics(*this);
-    return __p;
+    ::Ice::Object* p = new CollocatedMetrics(*this);
+    return p;
 }
 
 namespace
 {
-const ::std::string __IceMX__CollocatedMetrics_ids[4] =
+const ::std::string iceC_IceMX_CollocatedMetrics_ids[4] =
 {
     "::Ice::Object",
     "::IceMX::ChildInvocationMetrics",
@@ -1798,21 +1775,21 @@ const ::std::string __IceMX__CollocatedMetrics_ids[4] =
 }
 
 bool
-IceMX::CollocatedMetrics::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
+IceMX::CollocatedMetrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
 {
-    return ::std::binary_search(__IceMX__CollocatedMetrics_ids, __IceMX__CollocatedMetrics_ids + 4, _s);
+    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>(&__IceMX__CollocatedMetrics_ids[0], &__IceMX__CollocatedMetrics_ids[4]);
+    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 __IceMX__CollocatedMetrics_ids[2];
+    return ice_staticId();
 }
 
 const ::std::string&
@@ -1822,40 +1799,41 @@ IceMX::CollocatedMetrics::ice_staticId()
     static const ::std::string typeId = "::IceMX::CollocatedMetrics";
     return typeId;
 #else
-    return __IceMX__CollocatedMetrics_ids[2];
+    return iceC_IceMX_CollocatedMetrics_ids[2];
 #endif
 }
 
 void
-IceMX::CollocatedMetrics::__writeImpl(::IceInternal::BasicStream* __os) const
+IceMX::CollocatedMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
 {
-    __os->startWriteSlice(ice_staticId(), -1, false);
-    __os->endWriteSlice();
-    ::IceMX::ChildInvocationMetrics::__writeImpl(__os);
+    ostr->startSlice(ice_staticId(), -1, false);
+    Ice::StreamWriter< ::IceMX::CollocatedMetrics, ::Ice::OutputStream>::write(ostr, *this);
+    ostr->endSlice();
+    ::IceMX::ChildInvocationMetrics::_iceWriteImpl(ostr);
 }
 
 void
-IceMX::CollocatedMetrics::__readImpl(::IceInternal::BasicStream* __is)
+IceMX::CollocatedMetrics::_iceReadImpl(::Ice::InputStream* istr)
 {
-    __is->startReadSlice();
-    __is->endReadSlice();
-    ::IceMX::ChildInvocationMetrics::__readImpl(__is);
+    istr->startSlice();
+    Ice::StreamReader< ::IceMX::CollocatedMetrics, ::Ice::InputStream>::read(istr, *this);
+    istr->endSlice();
+    ::IceMX::ChildInvocationMetrics::_iceReadImpl(istr);
 }
 
 namespace
 {
-
-const ::IceInternal::DefaultObjectFactoryInit< ::IceMX::CollocatedMetrics> __IceMX__CollocatedMetrics_init("::IceMX::CollocatedMetrics");
+const ::IceInternal::DefaultValueFactoryInit< ::IceMX::CollocatedMetrics> iceC_IceMX_CollocatedMetrics_init("::IceMX::CollocatedMetrics");
 }
 
-::Ice::ObjectFactoryPtr
+::Ice::ValueFactoryPtr
 IceMX::CollocatedMetrics::ice_factory()
 {
-    return ::IceInternal::factoryTable->getObjectFactory(::IceMX::CollocatedMetrics::ice_staticId());
+    return ::IceInternal::factoryTable->getValueFactory(::IceMX::CollocatedMetrics::ice_staticId());
 }
 
-void ICE_API 
-IceMX::__patch(CollocatedMetricsPtr& handle, const ::Ice::ObjectPtr& v)
+void
+IceMX::_icePatchObjectPtr(CollocatedMetricsPtr& handle, const ::Ice::ObjectPtr& v)
 {
     handle = ::IceMX::CollocatedMetricsPtr::dynamicCast(v);
     if(v && !handle)
@@ -1864,17 +1842,22 @@ IceMX::__patch(CollocatedMetricsPtr& handle, const ::Ice::ObjectPtr& v)
     }
 }
 
+IceMX::RemoteMetrics::~RemoteMetrics()
+{
+}
+
 ICE_API ::Ice::Object* IceMX::upCast(::IceMX::RemoteMetrics* p) { return p; }
+
 ::Ice::ObjectPtr
 IceMX::RemoteMetrics::ice_clone() const
 {
-    ::Ice::Object* __p = new RemoteMetrics(*this);
-    return __p;
+    ::Ice::Object* p = new RemoteMetrics(*this);
+    return p;
 }
 
 namespace
 {
-const ::std::string __IceMX__RemoteMetrics_ids[4] =
+const ::std::string iceC_IceMX_RemoteMetrics_ids[4] =
 {
     "::Ice::Object",
     "::IceMX::ChildInvocationMetrics",
@@ -1885,21 +1868,21 @@ const ::std::string __IceMX__RemoteMetrics_ids[4] =
 }
 
 bool
-IceMX::RemoteMetrics::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
+IceMX::RemoteMetrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
 {
-    return ::std::binary_search(__IceMX__RemoteMetrics_ids, __IceMX__RemoteMetrics_ids + 4, _s);
+    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>(&__IceMX__RemoteMetrics_ids[0], &__IceMX__RemoteMetrics_ids[4]);
+    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 __IceMX__RemoteMetrics_ids[3];
+    return ice_staticId();
 }
 
 const ::std::string&
@@ -1909,40 +1892,41 @@ IceMX::RemoteMetrics::ice_staticId()
     static const ::std::string typeId = "::IceMX::RemoteMetrics";
     return typeId;
 #else
-    return __IceMX__RemoteMetrics_ids[3];
+    return iceC_IceMX_RemoteMetrics_ids[3];
 #endif
 }
 
 void
-IceMX::RemoteMetrics::__writeImpl(::IceInternal::BasicStream* __os) const
+IceMX::RemoteMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
 {
-    __os->startWriteSlice(ice_staticId(), -1, false);
-    __os->endWriteSlice();
-    ::IceMX::ChildInvocationMetrics::__writeImpl(__os);
+    ostr->startSlice(ice_staticId(), -1, false);
+    Ice::StreamWriter< ::IceMX::RemoteMetrics, ::Ice::OutputStream>::write(ostr, *this);
+    ostr->endSlice();
+    ::IceMX::ChildInvocationMetrics::_iceWriteImpl(ostr);
 }
 
 void
-IceMX::RemoteMetrics::__readImpl(::IceInternal::BasicStream* __is)
+IceMX::RemoteMetrics::_iceReadImpl(::Ice::InputStream* istr)
 {
-    __is->startReadSlice();
-    __is->endReadSlice();
-    ::IceMX::ChildInvocationMetrics::__readImpl(__is);
+    istr->startSlice();
+    Ice::StreamReader< ::IceMX::RemoteMetrics, ::Ice::InputStream>::read(istr, *this);
+    istr->endSlice();
+    ::IceMX::ChildInvocationMetrics::_iceReadImpl(istr);
 }
 
 namespace
 {
-
-const ::IceInternal::DefaultObjectFactoryInit< ::IceMX::RemoteMetrics> __IceMX__RemoteMetrics_init("::IceMX::RemoteMetrics");
+const ::IceInternal::DefaultValueFactoryInit< ::IceMX::RemoteMetrics> iceC_IceMX_RemoteMetrics_init("::IceMX::RemoteMetrics");
 }
 
-::Ice::ObjectFactoryPtr
+::Ice::ValueFactoryPtr
 IceMX::RemoteMetrics::ice_factory()
 {
-    return ::IceInternal::factoryTable->getObjectFactory(::IceMX::RemoteMetrics::ice_staticId());
+    return ::IceInternal::factoryTable->getValueFactory(::IceMX::RemoteMetrics::ice_staticId());
 }
 
-void ICE_API 
-IceMX::__patch(RemoteMetricsPtr& handle, const ::Ice::ObjectPtr& v)
+void
+IceMX::_icePatchObjectPtr(RemoteMetricsPtr& handle, const ::Ice::ObjectPtr& v)
 {
     handle = ::IceMX::RemoteMetricsPtr::dynamicCast(v);
     if(v && !handle)
@@ -1951,8 +1935,13 @@ IceMX::__patch(RemoteMetricsPtr& handle, const ::Ice::ObjectPtr& v)
     }
 }
 
+IceMX::InvocationMetrics::~InvocationMetrics()
+{
+}
+
 ICE_API ::Ice::Object* IceMX::upCast(::IceMX::InvocationMetrics* p) { return p; }
 
+
 #if defined(_MSC_VER) && (_MSC_VER >= 1900)
 #   pragma warning(push)
 #   pragma warning(disable:4589)
@@ -1960,8 +1949,8 @@ ICE_API ::Ice::Object* IceMX::upCast(::IceMX::InvocationMetrics* p) { return p;
 ::Ice::ObjectPtr
 IceMX::InvocationMetrics::ice_clone() const
 {
-    ::Ice::Object* __p = new InvocationMetrics(*this);
-    return __p;
+    ::Ice::Object* p = new InvocationMetrics(*this);
+    return p;
 }
 #if defined(_MSC_VER) && (_MSC_VER >= 1900)
 #   pragma warning(pop)
@@ -1969,7 +1958,7 @@ IceMX::InvocationMetrics::ice_clone() const
 
 namespace
 {
-const ::std::string __IceMX__InvocationMetrics_ids[3] =
+const ::std::string iceC_IceMX_InvocationMetrics_ids[3] =
 {
     "::Ice::Object",
     "::IceMX::InvocationMetrics",
@@ -1979,21 +1968,21 @@ const ::std::string __IceMX__InvocationMetrics_ids[3] =
 }
 
 bool
-IceMX::InvocationMetrics::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
+IceMX::InvocationMetrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
 {
-    return ::std::binary_search(__IceMX__InvocationMetrics_ids, __IceMX__InvocationMetrics_ids + 3, _s);
+    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>(&__IceMX__InvocationMetrics_ids[0], &__IceMX__InvocationMetrics_ids[3]);
+    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 __IceMX__InvocationMetrics_ids[1];
+    return ice_staticId();
 }
 
 const ::std::string&
@@ -2003,19 +1992,19 @@ IceMX::InvocationMetrics::ice_staticId()
     static const ::std::string typeId = "::IceMX::InvocationMetrics";
     return typeId;
 #else
-    return __IceMX__InvocationMetrics_ids[1];
+    return iceC_IceMX_InvocationMetrics_ids[1];
 #endif
 }
 
 void
-IceMX::InvocationMetrics::__gcVisitMembers(::IceInternal::GCVisitor& _v)
+IceMX::InvocationMetrics::_iceGcVisitMembers(::IceInternal::GCVisitor& v_)
 {
     {
         for(::IceMX::MetricsMap::iterator _i0 = remotes.begin(); _i0 != remotes.end(); ++_i0)
         {
             if((*_i0))
             {
-                if((::IceMX::upCast((*_i0).get())->__gcVisit(_v)))
+                if((::IceMX::upCast((*_i0).get())->_iceGcVisit(v_)))
                 {
                     (*_i0) = 0;
                 }
@@ -2027,7 +2016,7 @@ IceMX::InvocationMetrics::__gcVisitMembers(::IceInternal::GCVisitor& _v)
         {
             if((*_i0))
             {
-                if((::IceMX::upCast((*_i0).get())->__gcVisit(_v)))
+                if((::IceMX::upCast((*_i0).get())->_iceGcVisit(v_)))
                 {
                     (*_i0) = 0;
                 }
@@ -2037,43 +2026,36 @@ IceMX::InvocationMetrics::__gcVisitMembers(::IceInternal::GCVisitor& _v)
 }
 
 void
-IceMX::InvocationMetrics::__writeImpl(::IceInternal::BasicStream* __os) const
+IceMX::InvocationMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
 {
-    __os->startWriteSlice(ice_staticId(), -1, false);
-    __os->write(retry);
-    __os->write(userException);
-    __os->write(remotes);
-    __os->write(collocated);
-    __os->endWriteSlice();
-    ::IceMX::Metrics::__writeImpl(__os);
+    ostr->startSlice(ice_staticId(), -1, false);
+    Ice::StreamWriter< ::IceMX::InvocationMetrics, ::Ice::OutputStream>::write(ostr, *this);
+    ostr->endSlice();
+    ::IceMX::Metrics::_iceWriteImpl(ostr);
 }
 
 void
-IceMX::InvocationMetrics::__readImpl(::IceInternal::BasicStream* __is)
+IceMX::InvocationMetrics::_iceReadImpl(::Ice::InputStream* istr)
 {
-    __is->startReadSlice();
-    __is->read(retry);
-    __is->read(userException);
-    __is->read(remotes);
-    __is->read(collocated);
-    __is->endReadSlice();
-    ::IceMX::Metrics::__readImpl(__is);
+    istr->startSlice();
+    Ice::StreamReader< ::IceMX::InvocationMetrics, ::Ice::InputStream>::read(istr, *this);
+    istr->endSlice();
+    ::IceMX::Metrics::_iceReadImpl(istr);
 }
 
 namespace
 {
-
-const ::IceInternal::DefaultObjectFactoryInit< ::IceMX::InvocationMetrics> __IceMX__InvocationMetrics_init("::IceMX::InvocationMetrics");
+const ::IceInternal::DefaultValueFactoryInit< ::IceMX::InvocationMetrics> iceC_IceMX_InvocationMetrics_init("::IceMX::InvocationMetrics");
 }
 
-::Ice::ObjectFactoryPtr
+::Ice::ValueFactoryPtr
 IceMX::InvocationMetrics::ice_factory()
 {
-    return ::IceInternal::factoryTable->getObjectFactory(::IceMX::InvocationMetrics::ice_staticId());
+    return ::IceInternal::factoryTable->getValueFactory(::IceMX::InvocationMetrics::ice_staticId());
 }
 
-void ICE_API 
-IceMX::__patch(InvocationMetricsPtr& handle, const ::Ice::ObjectPtr& v)
+void
+IceMX::_icePatchObjectPtr(InvocationMetricsPtr& handle, const ::Ice::ObjectPtr& v)
 {
     handle = ::IceMX::InvocationMetricsPtr::dynamicCast(v);
     if(v && !handle)
@@ -2082,17 +2064,22 @@ IceMX::__patch(InvocationMetricsPtr& handle, const ::Ice::ObjectPtr& v)
     }
 }
 
+IceMX::ConnectionMetrics::~ConnectionMetrics()
+{
+}
+
 ICE_API ::Ice::Object* IceMX::upCast(::IceMX::ConnectionMetrics* p) { return p; }
+
 ::Ice::ObjectPtr
 IceMX::ConnectionMetrics::ice_clone() const
 {
-    ::Ice::Object* __p = new ConnectionMetrics(*this);
-    return __p;
+    ::Ice::Object* p = new ConnectionMetrics(*this);
+    return p;
 }
 
 namespace
 {
-const ::std::string __IceMX__ConnectionMetrics_ids[3] =
+const ::std::string iceC_IceMX_ConnectionMetrics_ids[3] =
 {
     "::Ice::Object",
     "::IceMX::ConnectionMetrics",
@@ -2102,21 +2089,21 @@ const ::std::string __IceMX__ConnectionMetrics_ids[3] =
 }
 
 bool
-IceMX::ConnectionMetrics::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
+IceMX::ConnectionMetrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
 {
-    return ::std::binary_search(__IceMX__ConnectionMetrics_ids, __IceMX__ConnectionMetrics_ids + 3, _s);
+    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>(&__IceMX__ConnectionMetrics_ids[0], &__IceMX__ConnectionMetrics_ids[3]);
+    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 __IceMX__ConnectionMetrics_ids[1];
+    return ice_staticId();
 }
 
 const ::std::string&
@@ -2126,44 +2113,41 @@ IceMX::ConnectionMetrics::ice_staticId()
     static const ::std::string typeId = "::IceMX::ConnectionMetrics";
     return typeId;
 #else
-    return __IceMX__ConnectionMetrics_ids[1];
+    return iceC_IceMX_ConnectionMetrics_ids[1];
 #endif
 }
 
 void
-IceMX::ConnectionMetrics::__writeImpl(::IceInternal::BasicStream* __os) const
+IceMX::ConnectionMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
 {
-    __os->startWriteSlice(ice_staticId(), -1, false);
-    __os->write(receivedBytes);
-    __os->write(sentBytes);
-    __os->endWriteSlice();
-    ::IceMX::Metrics::__writeImpl(__os);
+    ostr->startSlice(ice_staticId(), -1, false);
+    Ice::StreamWriter< ::IceMX::ConnectionMetrics, ::Ice::OutputStream>::write(ostr, *this);
+    ostr->endSlice();
+    ::IceMX::Metrics::_iceWriteImpl(ostr);
 }
 
 void
-IceMX::ConnectionMetrics::__readImpl(::IceInternal::BasicStream* __is)
+IceMX::ConnectionMetrics::_iceReadImpl(::Ice::InputStream* istr)
 {
-    __is->startReadSlice();
-    __is->read(receivedBytes);
-    __is->read(sentBytes);
-    __is->endReadSlice();
-    ::IceMX::Metrics::__readImpl(__is);
+    istr->startSlice();
+    Ice::StreamReader< ::IceMX::ConnectionMetrics, ::Ice::InputStream>::read(istr, *this);
+    istr->endSlice();
+    ::IceMX::Metrics::_iceReadImpl(istr);
 }
 
 namespace
 {
-
-const ::IceInternal::DefaultObjectFactoryInit< ::IceMX::ConnectionMetrics> __IceMX__ConnectionMetrics_init("::IceMX::ConnectionMetrics");
+const ::IceInternal::DefaultValueFactoryInit< ::IceMX::ConnectionMetrics> iceC_IceMX_ConnectionMetrics_init("::IceMX::ConnectionMetrics");
 }
 
-::Ice::ObjectFactoryPtr
+::Ice::ValueFactoryPtr
 IceMX::ConnectionMetrics::ice_factory()
 {
-    return ::IceInternal::factoryTable->getObjectFactory(::IceMX::ConnectionMetrics::ice_staticId());
+    return ::IceInternal::factoryTable->getValueFactory(::IceMX::ConnectionMetrics::ice_staticId());
 }
 
-void ICE_API 
-IceMX::__patch(ConnectionMetricsPtr& handle, const ::Ice::ObjectPtr& v)
+void
+IceMX::_icePatchObjectPtr(ConnectionMetricsPtr& handle, const ::Ice::ObjectPtr& v)
 {
     handle = ::IceMX::ConnectionMetricsPtr::dynamicCast(v);
     if(v && !handle)
@@ -2171,3 +2155,9 @@ IceMX::__patch(ConnectionMetricsPtr& handle, const ::Ice::ObjectPtr& v)
         IceInternal::Ex::throwUOE(::IceMX::ConnectionMetrics::ice_staticId(), v);
     }
 }
+
+namespace Ice
+{
+}
+
+#endif