zeroc-ice 3.6.5 → 3.7.0

data/lib/Ice/Metrics.rb

@@ -1,14 +1,14 @@
 # encoding: utf-8
 # **********************************************************************
 #
-# 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>
 #
@@ -22,36 +22,17 @@
 require 'Ice'
 require 'Ice/BuiltinSequences.rb'
 
-module ::IceMX
+module IceMX
 
     if not defined?(::IceMX::T_StringIntDict)
         T_StringIntDict = ::Ice::__defineDictionary('::IceMX::StringIntDict', ::Ice::T_string, ::Ice::T_int)
     end
 
-    if not defined?(::IceMX::Metrics_mixin)
-        module Metrics_mixin
-            include ::Ice::Object_mixin
+    if not defined?(::IceMX::Metrics_Mixin)
 
-            def ice_ids(current=nil)
-                ['::Ice::Object', '::IceMX::Metrics']
-            end
-
-            def ice_id(current=nil)
-                '::IceMX::Metrics'
-            end
-
-            def inspect
-                ::Ice::__stringify(self, T_Metrics)
-            end
-
-            attr_accessor :id, :total, :current, :totalLifetime, :failures
+        module ::IceMX::Metrics_Mixin
         end
-        class Metrics
-            include Metrics_mixin
-            
-            def Metrics.ice_staticId()
-                '::IceMX::Metrics'
-            end
+        class Metrics < ::Ice::Value
 
             def initialize(id='', total=0, current=0, totalLifetime=0, failures=0)
                 @id = id
@@ -60,44 +41,26 @@ module ::IceMX
                 @totalLifetime = totalLifetime
                 @failures = failures
             end
-        end
-        module MetricsPrx_mixin
-        end
-        class MetricsPrx < ::Ice::ObjectPrx
-            include MetricsPrx_mixin
-
-            def MetricsPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
-                ice_checkedCast(proxy, '::IceMX::Metrics', facetOrCtx, _ctx)
-            end
 
-            def MetricsPrx.uncheckedCast(proxy, facet=nil)
-                ice_uncheckedCast(proxy, facet)
-            end
-            def MetricsPrx.ice_staticId()
-                '::IceMX::Metrics'
-            end
+            attr_accessor :id, :total, :current, :totalLifetime, :failures
         end
 
         if not defined?(::IceMX::T_Metrics)
             T_Metrics = ::Ice::__declareClass('::IceMX::Metrics')
-            T_MetricsPrx = ::Ice::__declareProxy('::IceMX::Metrics')
         end
 
-        T_Metrics.defineClass(Metrics, -1, false, false, nil, [], [
+        T_Metrics.defineClass(Metrics, -1, false, false, nil, [
             ['id', ::Ice::T_string, false, 0],
             ['total', ::Ice::T_long, false, 0],
             ['current', ::Ice::T_int, false, 0],
             ['totalLifetime', ::Ice::T_long, false, 0],
             ['failures', ::Ice::T_int, false, 0]
         ])
-        Metrics_mixin::ICE_TYPE = T_Metrics
-
-        T_MetricsPrx.defineProxy(MetricsPrx, T_Metrics)
-        MetricsPrx::ICE_TYPE = T_MetricsPrx
     end
 
     if not defined?(::IceMX::MetricsFailures)
         class MetricsFailures
+            include ::Ice::Inspect_mixin
             def initialize(id='', failures=nil)
                 @id = id
                 @failures = failures
@@ -121,10 +84,6 @@ module ::IceMX
                 return other.class == self.class && other == self
             end
 
-            def inspect
-                ::Ice::__stringify(self, T_MetricsFailures)
-            end
-
             attr_accessor :id, :failures
         end
 
@@ -152,131 +111,71 @@ module ::IceMX
             end
 
             def to_s
-                'IceMX::UnknownMetricsView'
+                '::IceMX::UnknownMetricsView'
             end
         end
 
         T_UnknownMetricsView = ::Ice::__defineException('::IceMX::UnknownMetricsView', UnknownMetricsView, false, nil, [])
-        UnknownMetricsView::ICE_TYPE = T_UnknownMetricsView
     end
 
-    if not defined?(::IceMX::MetricsAdmin_mixin)
-        module MetricsAdmin_mixin
-            include ::Ice::Object_mixin
+    if not defined?(::IceMX::MetricsAdmin_Mixin)
 
-            def ice_ids(current=nil)
-                ['::Ice::Object', '::IceMX::MetricsAdmin']
-            end
-
-            def ice_id(current=nil)
-                '::IceMX::MetricsAdmin'
-            end
-
-            #
-            # Operation signatures.
-            #
-            # def getMetricsViewNames(current=nil)
-            # def enableMetricsView(name, current=nil)
-            # def disableMetricsView(name, current=nil)
-            # def getMetricsView(view, current=nil)
-            # def getMapMetricsFailures(view, map, current=nil)
-            # def getMetricsFailures(view, map, id, current=nil)
-
-            def inspect
-                ::Ice::__stringify(self, T_MetricsAdmin)
-            end
-        end
-        class MetricsAdmin
-            include MetricsAdmin_mixin
-            
-            def MetricsAdmin.ice_staticId()
-                '::IceMX::MetricsAdmin'
-            end
+        module ::IceMX::MetricsAdmin_Mixin
         end
         module MetricsAdminPrx_mixin
 
-            def getMetricsViewNames(_ctx=nil)
-                MetricsAdmin_mixin::OP_getMetricsViewNames.invoke(self, [], _ctx)
+            def getMetricsViewNames(context=nil)
+                MetricsAdminPrx_mixin::OP_getMetricsViewNames.invoke(self, [], context)
             end
 
-            def enableMetricsView(name, _ctx=nil)
-                MetricsAdmin_mixin::OP_enableMetricsView.invoke(self, [name], _ctx)
+            def enableMetricsView(name, context=nil)
+                MetricsAdminPrx_mixin::OP_enableMetricsView.invoke(self, [name], context)
             end
 
-            def disableMetricsView(name, _ctx=nil)
-                MetricsAdmin_mixin::OP_disableMetricsView.invoke(self, [name], _ctx)
+            def disableMetricsView(name, context=nil)
+                MetricsAdminPrx_mixin::OP_disableMetricsView.invoke(self, [name], context)
             end
 
-            def getMetricsView(view, _ctx=nil)
-                MetricsAdmin_mixin::OP_getMetricsView.invoke(self, [view], _ctx)
+            def getMetricsView(view, context=nil)
+                MetricsAdminPrx_mixin::OP_getMetricsView.invoke(self, [view], context)
             end
 
-            def getMapMetricsFailures(view, map, _ctx=nil)
-                MetricsAdmin_mixin::OP_getMapMetricsFailures.invoke(self, [view, map], _ctx)
+            def getMapMetricsFailures(view, map, context=nil)
+                MetricsAdminPrx_mixin::OP_getMapMetricsFailures.invoke(self, [view, map], context)
             end
 
-            def getMetricsFailures(view, map, id, _ctx=nil)
-                MetricsAdmin_mixin::OP_getMetricsFailures.invoke(self, [view, map, id], _ctx)
+            def getMetricsFailures(view, map, id, context=nil)
+                MetricsAdminPrx_mixin::OP_getMetricsFailures.invoke(self, [view, map, id], context)
             end
         end
+
         class MetricsAdminPrx < ::Ice::ObjectPrx
+            include ::Ice::Proxy_mixin
             include MetricsAdminPrx_mixin
-
-            def MetricsAdminPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
-                ice_checkedCast(proxy, '::IceMX::MetricsAdmin', facetOrCtx, _ctx)
-            end
-
-            def MetricsAdminPrx.uncheckedCast(proxy, facet=nil)
-                ice_uncheckedCast(proxy, facet)
-            end
-            def MetricsAdminPrx.ice_staticId()
-                '::IceMX::MetricsAdmin'
-            end
         end
 
-        if not defined?(::IceMX::T_MetricsAdmin)
+        if not defined?(::IceMX::T_MetricsAdminPrx)
             T_MetricsAdmin = ::Ice::__declareClass('::IceMX::MetricsAdmin')
             T_MetricsAdminPrx = ::Ice::__declareProxy('::IceMX::MetricsAdmin')
         end
 
-        T_MetricsAdmin.defineClass(MetricsAdmin, -1, true, false, nil, [], [])
-        MetricsAdmin_mixin::ICE_TYPE = T_MetricsAdmin
+        T_MetricsAdmin.defineClass(::Ice::Value, -1, false, true, nil, [])
 
-        T_MetricsAdminPrx.defineProxy(MetricsAdminPrx, T_MetricsAdmin)
-        MetricsAdminPrx::ICE_TYPE = T_MetricsAdminPrx
+        T_MetricsAdminPrx.defineProxy(MetricsAdminPrx, nil, [])
 
-        MetricsAdmin_mixin::OP_getMetricsViewNames = ::Ice::__defineOperation('getMetricsViewNames', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, ::Ice::FormatType::SlicedFormat, [], [[::Ice::T_StringSeq, false, 0]], [::Ice::T_StringSeq, false, 0], [])
-        MetricsAdmin_mixin::OP_enableMetricsView = ::Ice::__defineOperation('enableMetricsView', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, ::Ice::FormatType::SlicedFormat, [[::Ice::T_string, false, 0]], [], nil, [::IceMX::T_UnknownMetricsView])
-        MetricsAdmin_mixin::OP_disableMetricsView = ::Ice::__defineOperation('disableMetricsView', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, ::Ice::FormatType::SlicedFormat, [[::Ice::T_string, false, 0]], [], nil, [::IceMX::T_UnknownMetricsView])
-        MetricsAdmin_mixin::OP_getMetricsView = ::Ice::__defineOperation('getMetricsView', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, ::Ice::FormatType::SlicedFormat, [[::Ice::T_string, false, 0]], [[::Ice::T_long, false, 0]], [::IceMX::T_MetricsView, false, 0], [::IceMX::T_UnknownMetricsView])
-        MetricsAdmin_mixin::OP_getMapMetricsFailures = ::Ice::__defineOperation('getMapMetricsFailures', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, ::Ice::FormatType::SlicedFormat, [[::Ice::T_string, false, 0], [::Ice::T_string, false, 0]], [], [::IceMX::T_MetricsFailuresSeq, false, 0], [::IceMX::T_UnknownMetricsView])
-        MetricsAdmin_mixin::OP_getMetricsFailures = ::Ice::__defineOperation('getMetricsFailures', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, ::Ice::FormatType::SlicedFormat, [[::Ice::T_string, false, 0], [::Ice::T_string, false, 0], [::Ice::T_string, false, 0]], [], [::IceMX::T_MetricsFailures, false, 0], [::IceMX::T_UnknownMetricsView])
+        MetricsAdminPrx_mixin::OP_getMetricsViewNames = ::Ice::__defineOperation('getMetricsViewNames', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, ::Ice::FormatType::SlicedFormat, [], [[::Ice::T_StringSeq, false, 0]], [::Ice::T_StringSeq, false, 0], [])
+        MetricsAdminPrx_mixin::OP_enableMetricsView = ::Ice::__defineOperation('enableMetricsView', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, ::Ice::FormatType::SlicedFormat, [[::Ice::T_string, false, 0]], [], nil, [::IceMX::T_UnknownMetricsView])
+        MetricsAdminPrx_mixin::OP_disableMetricsView = ::Ice::__defineOperation('disableMetricsView', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, ::Ice::FormatType::SlicedFormat, [[::Ice::T_string, false, 0]], [], nil, [::IceMX::T_UnknownMetricsView])
+        MetricsAdminPrx_mixin::OP_getMetricsView = ::Ice::__defineOperation('getMetricsView', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, ::Ice::FormatType::SlicedFormat, [[::Ice::T_string, false, 0]], [[::Ice::T_long, false, 0]], [::IceMX::T_MetricsView, false, 0], [::IceMX::T_UnknownMetricsView])
+        MetricsAdminPrx_mixin::OP_getMapMetricsFailures = ::Ice::__defineOperation('getMapMetricsFailures', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, ::Ice::FormatType::SlicedFormat, [[::Ice::T_string, false, 0], [::Ice::T_string, false, 0]], [], [::IceMX::T_MetricsFailuresSeq, false, 0], [::IceMX::T_UnknownMetricsView])
+        MetricsAdminPrx_mixin::OP_getMetricsFailures = ::Ice::__defineOperation('getMetricsFailures', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, ::Ice::FormatType::SlicedFormat, [[::Ice::T_string, false, 0], [::Ice::T_string, false, 0], [::Ice::T_string, false, 0]], [], [::IceMX::T_MetricsFailures, false, 0], [::IceMX::T_UnknownMetricsView])
     end
 
-    if not defined?(::IceMX::ThreadMetrics_mixin)
-        module ThreadMetrics_mixin
-            include ::IceMX::Metrics_mixin
-
-            def ice_ids(current=nil)
-                ['::Ice::Object', '::IceMX::Metrics', '::IceMX::ThreadMetrics']
-            end
-
-            def ice_id(current=nil)
-                '::IceMX::ThreadMetrics'
-            end
-
-            def inspect
-                ::Ice::__stringify(self, T_ThreadMetrics)
-            end
+    if not defined?(::IceMX::ThreadMetrics_Mixin)
 
-            attr_accessor :inUseForIO, :inUseForUser, :inUseForOther
+        module ::IceMX::ThreadMetrics_Mixin
         end
         class ThreadMetrics < ::IceMX::Metrics
-            include ThreadMetrics_mixin
-            
-            def ThreadMetrics.ice_staticId()
-                '::IceMX::ThreadMetrics'
-            end
 
             def initialize(id='', total=0, current=0, totalLifetime=0, failures=0, inUseForIO=0, inUseForUser=0, inUseForOther=0)
                 super(id, total, current, totalLifetime, failures)
@@ -284,65 +183,26 @@ module ::IceMX
                 @inUseForUser = inUseForUser
                 @inUseForOther = inUseForOther
             end
-        end
-        module ThreadMetricsPrx_mixin
-            include ::IceMX::MetricsPrx_mixin
-        end
-        class ThreadMetricsPrx < ::Ice::ObjectPrx
-            include ThreadMetricsPrx_mixin
-
-            def ThreadMetricsPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
-                ice_checkedCast(proxy, '::IceMX::ThreadMetrics', facetOrCtx, _ctx)
-            end
 
-            def ThreadMetricsPrx.uncheckedCast(proxy, facet=nil)
-                ice_uncheckedCast(proxy, facet)
-            end
-            def ThreadMetricsPrx.ice_staticId()
-                '::IceMX::ThreadMetrics'
-            end
+            attr_accessor :inUseForIO, :inUseForUser, :inUseForOther
         end
 
         if not defined?(::IceMX::T_ThreadMetrics)
             T_ThreadMetrics = ::Ice::__declareClass('::IceMX::ThreadMetrics')
-            T_ThreadMetricsPrx = ::Ice::__declareProxy('::IceMX::ThreadMetrics')
         end
 
-        T_ThreadMetrics.defineClass(ThreadMetrics, -1, false, false, ::IceMX::T_Metrics, [], [
+        T_ThreadMetrics.defineClass(ThreadMetrics, -1, false, false, ::IceMX::T_Metrics, [
             ['inUseForIO', ::Ice::T_int, false, 0],
             ['inUseForUser', ::Ice::T_int, false, 0],
             ['inUseForOther', ::Ice::T_int, false, 0]
         ])
-        ThreadMetrics_mixin::ICE_TYPE = T_ThreadMetrics
-
-        T_ThreadMetricsPrx.defineProxy(ThreadMetricsPrx, T_ThreadMetrics)
-        ThreadMetricsPrx::ICE_TYPE = T_ThreadMetricsPrx
     end
 
-    if not defined?(::IceMX::DispatchMetrics_mixin)
-        module DispatchMetrics_mixin
-            include ::IceMX::Metrics_mixin
-
-            def ice_ids(current=nil)
-                ['::Ice::Object', '::IceMX::DispatchMetrics', '::IceMX::Metrics']
-            end
-
-            def ice_id(current=nil)
-                '::IceMX::DispatchMetrics'
-            end
-
-            def inspect
-                ::Ice::__stringify(self, T_DispatchMetrics)
-            end
+    if not defined?(::IceMX::DispatchMetrics_Mixin)
 
-            attr_accessor :userException, :size, :replySize
+        module ::IceMX::DispatchMetrics_Mixin
         end
         class DispatchMetrics < ::IceMX::Metrics
-            include DispatchMetrics_mixin
-            
-            def DispatchMetrics.ice_staticId()
-                '::IceMX::DispatchMetrics'
-            end
 
             def initialize(id='', total=0, current=0, totalLifetime=0, failures=0, userException=0, size=0, replySize=0)
                 super(id, total, current, totalLifetime, failures)
@@ -350,243 +210,87 @@ module ::IceMX
                 @size = size
                 @replySize = replySize
             end
-        end
-        module DispatchMetricsPrx_mixin
-            include ::IceMX::MetricsPrx_mixin
-        end
-        class DispatchMetricsPrx < ::Ice::ObjectPrx
-            include DispatchMetricsPrx_mixin
 
-            def DispatchMetricsPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
-                ice_checkedCast(proxy, '::IceMX::DispatchMetrics', facetOrCtx, _ctx)
-            end
-
-            def DispatchMetricsPrx.uncheckedCast(proxy, facet=nil)
-                ice_uncheckedCast(proxy, facet)
-            end
-            def DispatchMetricsPrx.ice_staticId()
-                '::IceMX::DispatchMetrics'
-            end
+            attr_accessor :userException, :size, :replySize
         end
 
         if not defined?(::IceMX::T_DispatchMetrics)
             T_DispatchMetrics = ::Ice::__declareClass('::IceMX::DispatchMetrics')
-            T_DispatchMetricsPrx = ::Ice::__declareProxy('::IceMX::DispatchMetrics')
         end
 
-        T_DispatchMetrics.defineClass(DispatchMetrics, -1, false, false, ::IceMX::T_Metrics, [], [
+        T_DispatchMetrics.defineClass(DispatchMetrics, -1, false, false, ::IceMX::T_Metrics, [
             ['userException', ::Ice::T_int, false, 0],
             ['size', ::Ice::T_long, false, 0],
             ['replySize', ::Ice::T_long, false, 0]
         ])
-        DispatchMetrics_mixin::ICE_TYPE = T_DispatchMetrics
-
-        T_DispatchMetricsPrx.defineProxy(DispatchMetricsPrx, T_DispatchMetrics)
-        DispatchMetricsPrx::ICE_TYPE = T_DispatchMetricsPrx
     end
 
-    if not defined?(::IceMX::ChildInvocationMetrics_mixin)
-        module ChildInvocationMetrics_mixin
-            include ::IceMX::Metrics_mixin
-
-            def ice_ids(current=nil)
-                ['::Ice::Object', '::IceMX::ChildInvocationMetrics', '::IceMX::Metrics']
-            end
-
-            def ice_id(current=nil)
-                '::IceMX::ChildInvocationMetrics'
-            end
-
-            def inspect
-                ::Ice::__stringify(self, T_ChildInvocationMetrics)
-            end
+    if not defined?(::IceMX::ChildInvocationMetrics_Mixin)
 
-            attr_accessor :size, :replySize
+        module ::IceMX::ChildInvocationMetrics_Mixin
         end
         class ChildInvocationMetrics < ::IceMX::Metrics
-            include ChildInvocationMetrics_mixin
-            
-            def ChildInvocationMetrics.ice_staticId()
-                '::IceMX::ChildInvocationMetrics'
-            end
 
             def initialize(id='', total=0, current=0, totalLifetime=0, failures=0, size=0, replySize=0)
                 super(id, total, current, totalLifetime, failures)
                 @size = size
                 @replySize = replySize
             end
-        end
-        module ChildInvocationMetricsPrx_mixin
-            include ::IceMX::MetricsPrx_mixin
-        end
-        class ChildInvocationMetricsPrx < ::Ice::ObjectPrx
-            include ChildInvocationMetricsPrx_mixin
-
-            def ChildInvocationMetricsPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
-                ice_checkedCast(proxy, '::IceMX::ChildInvocationMetrics', facetOrCtx, _ctx)
-            end
 
-            def ChildInvocationMetricsPrx.uncheckedCast(proxy, facet=nil)
-                ice_uncheckedCast(proxy, facet)
-            end
-            def ChildInvocationMetricsPrx.ice_staticId()
-                '::IceMX::ChildInvocationMetrics'
-            end
+            attr_accessor :size, :replySize
         end
 
         if not defined?(::IceMX::T_ChildInvocationMetrics)
             T_ChildInvocationMetrics = ::Ice::__declareClass('::IceMX::ChildInvocationMetrics')
-            T_ChildInvocationMetricsPrx = ::Ice::__declareProxy('::IceMX::ChildInvocationMetrics')
         end
 
-        T_ChildInvocationMetrics.defineClass(ChildInvocationMetrics, -1, false, false, ::IceMX::T_Metrics, [], [
+        T_ChildInvocationMetrics.defineClass(ChildInvocationMetrics, -1, false, false, ::IceMX::T_Metrics, [
             ['size', ::Ice::T_long, false, 0],
             ['replySize', ::Ice::T_long, false, 0]
         ])
-        ChildInvocationMetrics_mixin::ICE_TYPE = T_ChildInvocationMetrics
-
-        T_ChildInvocationMetricsPrx.defineProxy(ChildInvocationMetricsPrx, T_ChildInvocationMetrics)
-        ChildInvocationMetricsPrx::ICE_TYPE = T_ChildInvocationMetricsPrx
     end
 
-    if not defined?(::IceMX::CollocatedMetrics_mixin)
-        module CollocatedMetrics_mixin
-            include ::IceMX::ChildInvocationMetrics_mixin
+    if not defined?(::IceMX::CollocatedMetrics_Mixin)
 
-            def ice_ids(current=nil)
-                ['::Ice::Object', '::IceMX::ChildInvocationMetrics', '::IceMX::CollocatedMetrics', '::IceMX::Metrics']
-            end
-
-            def ice_id(current=nil)
-                '::IceMX::CollocatedMetrics'
-            end
-
-            def inspect
-                ::Ice::__stringify(self, T_CollocatedMetrics)
-            end
+        module ::IceMX::CollocatedMetrics_Mixin
         end
         class CollocatedMetrics < ::IceMX::ChildInvocationMetrics
-            include CollocatedMetrics_mixin
-            
-            def CollocatedMetrics.ice_staticId()
-                '::IceMX::CollocatedMetrics'
-            end
 
             def initialize(id='', total=0, current=0, totalLifetime=0, failures=0, size=0, replySize=0)
                 super(id, total, current, totalLifetime, failures, size, replySize)
             end
         end
-        module CollocatedMetricsPrx_mixin
-            include ::IceMX::ChildInvocationMetricsPrx_mixin
-        end
-        class CollocatedMetricsPrx < ::Ice::ObjectPrx
-            include CollocatedMetricsPrx_mixin
-
-            def CollocatedMetricsPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
-                ice_checkedCast(proxy, '::IceMX::CollocatedMetrics', facetOrCtx, _ctx)
-            end
-
-            def CollocatedMetricsPrx.uncheckedCast(proxy, facet=nil)
-                ice_uncheckedCast(proxy, facet)
-            end
-            def CollocatedMetricsPrx.ice_staticId()
-                '::IceMX::CollocatedMetrics'
-            end
-        end
 
         if not defined?(::IceMX::T_CollocatedMetrics)
             T_CollocatedMetrics = ::Ice::__declareClass('::IceMX::CollocatedMetrics')
-            T_CollocatedMetricsPrx = ::Ice::__declareProxy('::IceMX::CollocatedMetrics')
         end
 
-        T_CollocatedMetrics.defineClass(CollocatedMetrics, -1, false, false, ::IceMX::T_ChildInvocationMetrics, [], [])
-        CollocatedMetrics_mixin::ICE_TYPE = T_CollocatedMetrics
-
-        T_CollocatedMetricsPrx.defineProxy(CollocatedMetricsPrx, T_CollocatedMetrics)
-        CollocatedMetricsPrx::ICE_TYPE = T_CollocatedMetricsPrx
+        T_CollocatedMetrics.defineClass(CollocatedMetrics, -1, false, false, ::IceMX::T_ChildInvocationMetrics, [])
     end
 
-    if not defined?(::IceMX::RemoteMetrics_mixin)
-        module RemoteMetrics_mixin
-            include ::IceMX::ChildInvocationMetrics_mixin
-
-            def ice_ids(current=nil)
-                ['::Ice::Object', '::IceMX::ChildInvocationMetrics', '::IceMX::Metrics', '::IceMX::RemoteMetrics']
-            end
-
-            def ice_id(current=nil)
-                '::IceMX::RemoteMetrics'
-            end
+    if not defined?(::IceMX::RemoteMetrics_Mixin)
 
-            def inspect
-                ::Ice::__stringify(self, T_RemoteMetrics)
-            end
+        module ::IceMX::RemoteMetrics_Mixin
         end
         class RemoteMetrics < ::IceMX::ChildInvocationMetrics
-            include RemoteMetrics_mixin
-            
-            def RemoteMetrics.ice_staticId()
-                '::IceMX::RemoteMetrics'
-            end
 
             def initialize(id='', total=0, current=0, totalLifetime=0, failures=0, size=0, replySize=0)
                 super(id, total, current, totalLifetime, failures, size, replySize)
             end
         end
-        module RemoteMetricsPrx_mixin
-            include ::IceMX::ChildInvocationMetricsPrx_mixin
-        end
-        class RemoteMetricsPrx < ::Ice::ObjectPrx
-            include RemoteMetricsPrx_mixin
-
-            def RemoteMetricsPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
-                ice_checkedCast(proxy, '::IceMX::RemoteMetrics', facetOrCtx, _ctx)
-            end
-
-            def RemoteMetricsPrx.uncheckedCast(proxy, facet=nil)
-                ice_uncheckedCast(proxy, facet)
-            end
-            def RemoteMetricsPrx.ice_staticId()
-                '::IceMX::RemoteMetrics'
-            end
-        end
 
         if not defined?(::IceMX::T_RemoteMetrics)
             T_RemoteMetrics = ::Ice::__declareClass('::IceMX::RemoteMetrics')
-            T_RemoteMetricsPrx = ::Ice::__declareProxy('::IceMX::RemoteMetrics')
         end
 
-        T_RemoteMetrics.defineClass(RemoteMetrics, -1, false, false, ::IceMX::T_ChildInvocationMetrics, [], [])
-        RemoteMetrics_mixin::ICE_TYPE = T_RemoteMetrics
-
-        T_RemoteMetricsPrx.defineProxy(RemoteMetricsPrx, T_RemoteMetrics)
-        RemoteMetricsPrx::ICE_TYPE = T_RemoteMetricsPrx
+        T_RemoteMetrics.defineClass(RemoteMetrics, -1, false, false, ::IceMX::T_ChildInvocationMetrics, [])
     end
 
-    if not defined?(::IceMX::InvocationMetrics_mixin)
-        module InvocationMetrics_mixin
-            include ::IceMX::Metrics_mixin
+    if not defined?(::IceMX::InvocationMetrics_Mixin)
 
-            def ice_ids(current=nil)
-                ['::Ice::Object', '::IceMX::InvocationMetrics', '::IceMX::Metrics']
-            end
-
-            def ice_id(current=nil)
-                '::IceMX::InvocationMetrics'
-            end
-
-            def inspect
-                ::Ice::__stringify(self, T_InvocationMetrics)
-            end
-
-            attr_accessor :_retry, :userException, :remotes, :collocated
+        module ::IceMX::InvocationMetrics_Mixin
         end
         class InvocationMetrics < ::IceMX::Metrics
-            include InvocationMetrics_mixin
-            
-            def InvocationMetrics.ice_staticId()
-                '::IceMX::InvocationMetrics'
-            end
 
             def initialize(id='', total=0, current=0, totalLifetime=0, failures=0, _retry=0, userException=0, remotes=nil, collocated=nil)
                 super(id, total, current, totalLifetime, failures)
@@ -595,103 +299,44 @@ module ::IceMX
                 @remotes = remotes
                 @collocated = collocated
             end
-        end
-        module InvocationMetricsPrx_mixin
-            include ::IceMX::MetricsPrx_mixin
-        end
-        class InvocationMetricsPrx < ::Ice::ObjectPrx
-            include InvocationMetricsPrx_mixin
-
-            def InvocationMetricsPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
-                ice_checkedCast(proxy, '::IceMX::InvocationMetrics', facetOrCtx, _ctx)
-            end
 
-            def InvocationMetricsPrx.uncheckedCast(proxy, facet=nil)
-                ice_uncheckedCast(proxy, facet)
-            end
-            def InvocationMetricsPrx.ice_staticId()
-                '::IceMX::InvocationMetrics'
-            end
+            attr_accessor :_retry, :userException, :remotes, :collocated
         end
 
         if not defined?(::IceMX::T_InvocationMetrics)
             T_InvocationMetrics = ::Ice::__declareClass('::IceMX::InvocationMetrics')
-            T_InvocationMetricsPrx = ::Ice::__declareProxy('::IceMX::InvocationMetrics')
         end
 
-        T_InvocationMetrics.defineClass(InvocationMetrics, -1, false, false, ::IceMX::T_Metrics, [], [
+        T_InvocationMetrics.defineClass(InvocationMetrics, -1, false, false, ::IceMX::T_Metrics, [
             ['_retry', ::Ice::T_int, false, 0],
             ['userException', ::Ice::T_int, false, 0],
             ['remotes', ::IceMX::T_MetricsMap, false, 0],
             ['collocated', ::IceMX::T_MetricsMap, false, 0]
         ])
-        InvocationMetrics_mixin::ICE_TYPE = T_InvocationMetrics
-
-        T_InvocationMetricsPrx.defineProxy(InvocationMetricsPrx, T_InvocationMetrics)
-        InvocationMetricsPrx::ICE_TYPE = T_InvocationMetricsPrx
     end
 
-    if not defined?(::IceMX::ConnectionMetrics_mixin)
-        module ConnectionMetrics_mixin
-            include ::IceMX::Metrics_mixin
-
-            def ice_ids(current=nil)
-                ['::Ice::Object', '::IceMX::ConnectionMetrics', '::IceMX::Metrics']
-            end
-
-            def ice_id(current=nil)
-                '::IceMX::ConnectionMetrics'
-            end
+    if not defined?(::IceMX::ConnectionMetrics_Mixin)
 
-            def inspect
-                ::Ice::__stringify(self, T_ConnectionMetrics)
-            end
-
-            attr_accessor :receivedBytes, :sentBytes
+        module ::IceMX::ConnectionMetrics_Mixin
         end
         class ConnectionMetrics < ::IceMX::Metrics
-            include ConnectionMetrics_mixin
-            
-            def ConnectionMetrics.ice_staticId()
-                '::IceMX::ConnectionMetrics'
-            end
 
             def initialize(id='', total=0, current=0, totalLifetime=0, failures=0, receivedBytes=0, sentBytes=0)
                 super(id, total, current, totalLifetime, failures)
                 @receivedBytes = receivedBytes
                 @sentBytes = sentBytes
             end
-        end
-        module ConnectionMetricsPrx_mixin
-            include ::IceMX::MetricsPrx_mixin
-        end
-        class ConnectionMetricsPrx < ::Ice::ObjectPrx
-            include ConnectionMetricsPrx_mixin
-
-            def ConnectionMetricsPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
-                ice_checkedCast(proxy, '::IceMX::ConnectionMetrics', facetOrCtx, _ctx)
-            end
 
-            def ConnectionMetricsPrx.uncheckedCast(proxy, facet=nil)
-                ice_uncheckedCast(proxy, facet)
-            end
-            def ConnectionMetricsPrx.ice_staticId()
-                '::IceMX::ConnectionMetrics'
-            end
+            attr_accessor :receivedBytes, :sentBytes
         end
 
         if not defined?(::IceMX::T_ConnectionMetrics)
             T_ConnectionMetrics = ::Ice::__declareClass('::IceMX::ConnectionMetrics')
-            T_ConnectionMetricsPrx = ::Ice::__declareProxy('::IceMX::ConnectionMetrics')
         end
 
-        T_ConnectionMetrics.defineClass(ConnectionMetrics, -1, false, false, ::IceMX::T_Metrics, [], [
+        T_ConnectionMetrics.defineClass(ConnectionMetrics, -1, false, false, ::IceMX::T_Metrics, [
             ['receivedBytes', ::Ice::T_long, false, 0],
             ['sentBytes', ::Ice::T_long, false, 0]
         ])
-        ConnectionMetrics_mixin::ICE_TYPE = T_ConnectionMetrics
-
-        T_ConnectionMetricsPrx.defineProxy(ConnectionMetricsPrx, T_ConnectionMetrics)
-        ConnectionMetricsPrx::ICE_TYPE = T_ConnectionMetricsPrx
     end
 end