zeroc-ice 3.6.5 → 3.7.4

data/lib/IceGrid/Descriptor.rb

@@ -1,14 +1,9 @@
 # encoding: utf-8
-# **********************************************************************
 #
-# Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+# Copyright (c) ZeroC, Inc. All rights reserved.
 #
-# This copy of Ice is licensed to you under the terms described in the
-# ICE_LICENSE file included in this distribution.
 #
-# **********************************************************************
-#
-# Ice version 3.6.5
+# Ice version 3.7.4
 #
 # <auto-generated>
 #
@@ -31,6 +26,7 @@ module ::IceGrid
 
     if not defined?(::IceGrid::PropertyDescriptor)
         class PropertyDescriptor
+            include ::Ice::Inspect_mixin
             def initialize(name='', value='')
                 @name = name
                 @value = value
@@ -54,10 +50,6 @@ module ::IceGrid
                 return other.class == self.class && other == self
             end
 
-            def inspect
-                ::Ice::__stringify(self, T_PropertyDescriptor)
-            end
-
             attr_accessor :name, :value
         end
 
@@ -73,6 +65,7 @@ module ::IceGrid
 
     if not defined?(::IceGrid::PropertySetDescriptor)
         class PropertySetDescriptor
+            include ::Ice::Inspect_mixin
             def initialize(references=nil, properties=nil)
                 @references = references
                 @properties = properties
@@ -96,10 +89,6 @@ module ::IceGrid
                 return other.class == self.class && other == self
             end
 
-            def inspect
-                ::Ice::__stringify(self, T_PropertySetDescriptor)
-            end
-
             attr_accessor :references, :properties
         end
 
@@ -115,6 +104,7 @@ module ::IceGrid
 
     if not defined?(::IceGrid::ObjectDescriptor)
         class ObjectDescriptor
+            include ::Ice::Inspect_mixin
             def initialize(id=::Ice::Identity.new, type='', proxyOptions='')
                 @id = id
                 @type = type
@@ -141,10 +131,6 @@ module ::IceGrid
                 return other.class == self.class && other == self
             end
 
-            def inspect
-                ::Ice::__stringify(self, T_ObjectDescriptor)
-            end
-
             attr_accessor :id, :type, :proxyOptions
         end
 
@@ -161,6 +147,7 @@ module ::IceGrid
 
     if not defined?(::IceGrid::AdapterDescriptor)
         class AdapterDescriptor
+            include ::Ice::Inspect_mixin
             def initialize(name='', description='', id='', replicaGroupId='', priority='', registerProcess=false, serverLifetime=false, objects=nil, allocatables=nil)
                 @name = name
                 @description = description
@@ -205,10 +192,6 @@ module ::IceGrid
                 return other.class == self.class && other == self
             end
 
-            def inspect
-                ::Ice::__stringify(self, T_AdapterDescriptor)
-            end
-
             attr_accessor :name, :description, :id, :replicaGroupId, :priority, :registerProcess, :serverLifetime, :objects, :allocatables
         end
 
@@ -231,6 +214,7 @@ module ::IceGrid
 
     if not defined?(::IceGrid::DbEnvDescriptor)
         class DbEnvDescriptor
+            include ::Ice::Inspect_mixin
             def initialize(name='', description='', dbHome='', properties=nil)
                 @name = name
                 @description = description
@@ -260,10 +244,6 @@ module ::IceGrid
                 return other.class == self.class && other == self
             end
 
-            def inspect
-                ::Ice::__stringify(self, T_DbEnvDescriptor)
-            end
-
             attr_accessor :name, :description, :dbHome, :properties
         end
 
@@ -279,30 +259,11 @@ module ::IceGrid
         T_DbEnvDescriptorSeq = ::Ice::__defineSequence('::IceGrid::DbEnvDescriptorSeq', ::IceGrid::T_DbEnvDescriptor)
     end
 
-    if not defined?(::IceGrid::CommunicatorDescriptor_mixin)
-        module CommunicatorDescriptor_mixin
-            include ::Ice::Object_mixin
-
-            def ice_ids(current=nil)
-                ['::Ice::Object', '::IceGrid::CommunicatorDescriptor']
-            end
+    if not defined?(::IceGrid::CommunicatorDescriptor_Mixin)
 
-            def ice_id(current=nil)
-                '::IceGrid::CommunicatorDescriptor'
-            end
-
-            def inspect
-                ::Ice::__stringify(self, T_CommunicatorDescriptor)
-            end
-
-            attr_accessor :adapters, :propertySet, :dbEnvs, :logs, :description
+        module ::IceGrid::CommunicatorDescriptor_Mixin
         end
-        class CommunicatorDescriptor
-            include CommunicatorDescriptor_mixin
-            
-            def CommunicatorDescriptor.ice_staticId()
-                '::IceGrid::CommunicatorDescriptor'
-            end
+        class CommunicatorDescriptor < ::Ice::Value
 
             def initialize(adapters=nil, propertySet=::IceGrid::PropertySetDescriptor.new, dbEnvs=nil, logs=nil, description='')
                 @adapters = adapters
@@ -311,44 +272,26 @@ module ::IceGrid
                 @logs = logs
                 @description = description
             end
-        end
-        module CommunicatorDescriptorPrx_mixin
-        end
-        class CommunicatorDescriptorPrx < ::Ice::ObjectPrx
-            include CommunicatorDescriptorPrx_mixin
-
-            def CommunicatorDescriptorPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
-                ice_checkedCast(proxy, '::IceGrid::CommunicatorDescriptor', facetOrCtx, _ctx)
-            end
 
-            def CommunicatorDescriptorPrx.uncheckedCast(proxy, facet=nil)
-                ice_uncheckedCast(proxy, facet)
-            end
-            def CommunicatorDescriptorPrx.ice_staticId()
-                '::IceGrid::CommunicatorDescriptor'
-            end
+            attr_accessor :adapters, :propertySet, :dbEnvs, :logs, :description
         end
 
         if not defined?(::IceGrid::T_CommunicatorDescriptor)
             T_CommunicatorDescriptor = ::Ice::__declareClass('::IceGrid::CommunicatorDescriptor')
-            T_CommunicatorDescriptorPrx = ::Ice::__declareProxy('::IceGrid::CommunicatorDescriptor')
         end
 
-        T_CommunicatorDescriptor.defineClass(CommunicatorDescriptor, -1, false, false, nil, [], [
+        T_CommunicatorDescriptor.defineClass(CommunicatorDescriptor, -1, false, false, nil, [
             ['adapters', ::IceGrid::T_AdapterDescriptorSeq, false, 0],
             ['propertySet', ::IceGrid::T_PropertySetDescriptor, false, 0],
             ['dbEnvs', ::IceGrid::T_DbEnvDescriptorSeq, false, 0],
             ['logs', ::Ice::T_StringSeq, false, 0],
             ['description', ::Ice::T_string, false, 0]
         ])
-        CommunicatorDescriptor_mixin::ICE_TYPE = T_CommunicatorDescriptor
-
-        T_CommunicatorDescriptorPrx.defineProxy(CommunicatorDescriptorPrx, T_CommunicatorDescriptor)
-        CommunicatorDescriptorPrx::ICE_TYPE = T_CommunicatorDescriptorPrx
     end
 
     if not defined?(::IceGrid::DistributionDescriptor)
         class DistributionDescriptor
+            include ::Ice::Inspect_mixin
             def initialize(icepatch='', directories=nil)
                 @icepatch = icepatch
                 @directories = directories
@@ -372,10 +315,6 @@ module ::IceGrid
                 return other.class == self.class && other == self
             end
 
-            def inspect
-                ::Ice::__stringify(self, T_DistributionDescriptor)
-            end
-
             attr_accessor :icepatch, :directories
         end
 
@@ -385,30 +324,11 @@ module ::IceGrid
         ])
     end
 
-    if not defined?(::IceGrid::ServerDescriptor_mixin)
-        module ServerDescriptor_mixin
-            include ::IceGrid::CommunicatorDescriptor_mixin
+    if not defined?(::IceGrid::ServerDescriptor_Mixin)
 
-            def ice_ids(current=nil)
-                ['::Ice::Object', '::IceGrid::CommunicatorDescriptor', '::IceGrid::ServerDescriptor']
-            end
-
-            def ice_id(current=nil)
-                '::IceGrid::ServerDescriptor'
-            end
-
-            def inspect
-                ::Ice::__stringify(self, T_ServerDescriptor)
-            end
-
-            attr_accessor :id, :exe, :iceVersion, :pwd, :options, :envs, :activation, :activationTimeout, :deactivationTimeout, :applicationDistrib, :distrib, :allocatable, :user
+        module ::IceGrid::ServerDescriptor_Mixin
         end
         class ServerDescriptor < ::IceGrid::CommunicatorDescriptor
-            include ServerDescriptor_mixin
-            
-            def ServerDescriptor.ice_staticId()
-                '::IceGrid::ServerDescriptor'
-            end
 
             def initialize(adapters=nil, propertySet=::IceGrid::PropertySetDescriptor.new, dbEnvs=nil, logs=nil, description='', id='', exe='', iceVersion='', pwd='', options=nil, envs=nil, activation='', activationTimeout='', deactivationTimeout='', applicationDistrib=false, distrib=::IceGrid::DistributionDescriptor.new, allocatable=false, user='')
                 super(adapters, propertySet, dbEnvs, logs, description)
@@ -426,31 +346,15 @@ module ::IceGrid
                 @allocatable = allocatable
                 @user = user
             end
-        end
-        module ServerDescriptorPrx_mixin
-            include ::IceGrid::CommunicatorDescriptorPrx_mixin
-        end
-        class ServerDescriptorPrx < ::Ice::ObjectPrx
-            include ServerDescriptorPrx_mixin
-
-            def ServerDescriptorPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
-                ice_checkedCast(proxy, '::IceGrid::ServerDescriptor', facetOrCtx, _ctx)
-            end
 
-            def ServerDescriptorPrx.uncheckedCast(proxy, facet=nil)
-                ice_uncheckedCast(proxy, facet)
-            end
-            def ServerDescriptorPrx.ice_staticId()
-                '::IceGrid::ServerDescriptor'
-            end
+            attr_accessor :id, :exe, :iceVersion, :pwd, :options, :envs, :activation, :activationTimeout, :deactivationTimeout, :applicationDistrib, :distrib, :allocatable, :user
         end
 
         if not defined?(::IceGrid::T_ServerDescriptor)
             T_ServerDescriptor = ::Ice::__declareClass('::IceGrid::ServerDescriptor')
-            T_ServerDescriptorPrx = ::Ice::__declareProxy('::IceGrid::ServerDescriptor')
         end
 
-        T_ServerDescriptor.defineClass(ServerDescriptor, -1, false, false, ::IceGrid::T_CommunicatorDescriptor, [], [
+        T_ServerDescriptor.defineClass(ServerDescriptor, -1, false, false, ::IceGrid::T_CommunicatorDescriptor, [
             ['id', ::Ice::T_string, false, 0],
             ['exe', ::Ice::T_string, false, 0],
             ['iceVersion', ::Ice::T_string, false, 0],
@@ -465,78 +369,35 @@ module ::IceGrid
             ['allocatable', ::Ice::T_bool, false, 0],
             ['user', ::Ice::T_string, false, 0]
         ])
-        ServerDescriptor_mixin::ICE_TYPE = T_ServerDescriptor
-
-        T_ServerDescriptorPrx.defineProxy(ServerDescriptorPrx, T_ServerDescriptor)
-        ServerDescriptorPrx::ICE_TYPE = T_ServerDescriptorPrx
     end
 
     if not defined?(::IceGrid::T_ServerDescriptorSeq)
         T_ServerDescriptorSeq = ::Ice::__defineSequence('::IceGrid::ServerDescriptorSeq', ::IceGrid::T_ServerDescriptor)
     end
 
-    if not defined?(::IceGrid::ServiceDescriptor_mixin)
-        module ServiceDescriptor_mixin
-            include ::IceGrid::CommunicatorDescriptor_mixin
-
-            def ice_ids(current=nil)
-                ['::Ice::Object', '::IceGrid::CommunicatorDescriptor', '::IceGrid::ServiceDescriptor']
-            end
-
-            def ice_id(current=nil)
-                '::IceGrid::ServiceDescriptor'
-            end
-
-            def inspect
-                ::Ice::__stringify(self, T_ServiceDescriptor)
-            end
+    if not defined?(::IceGrid::ServiceDescriptor_Mixin)
 
-            attr_accessor :name, :entry
+        module ::IceGrid::ServiceDescriptor_Mixin
         end
         class ServiceDescriptor < ::IceGrid::CommunicatorDescriptor
-            include ServiceDescriptor_mixin
-            
-            def ServiceDescriptor.ice_staticId()
-                '::IceGrid::ServiceDescriptor'
-            end
 
             def initialize(adapters=nil, propertySet=::IceGrid::PropertySetDescriptor.new, dbEnvs=nil, logs=nil, description='', name='', entry='')
                 super(adapters, propertySet, dbEnvs, logs, description)
                 @name = name
                 @entry = entry
             end
-        end
-        module ServiceDescriptorPrx_mixin
-            include ::IceGrid::CommunicatorDescriptorPrx_mixin
-        end
-        class ServiceDescriptorPrx < ::Ice::ObjectPrx
-            include ServiceDescriptorPrx_mixin
-
-            def ServiceDescriptorPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
-                ice_checkedCast(proxy, '::IceGrid::ServiceDescriptor', facetOrCtx, _ctx)
-            end
 
-            def ServiceDescriptorPrx.uncheckedCast(proxy, facet=nil)
-                ice_uncheckedCast(proxy, facet)
-            end
-            def ServiceDescriptorPrx.ice_staticId()
-                '::IceGrid::ServiceDescriptor'
-            end
+            attr_accessor :name, :entry
         end
 
         if not defined?(::IceGrid::T_ServiceDescriptor)
             T_ServiceDescriptor = ::Ice::__declareClass('::IceGrid::ServiceDescriptor')
-            T_ServiceDescriptorPrx = ::Ice::__declareProxy('::IceGrid::ServiceDescriptor')
         end
 
-        T_ServiceDescriptor.defineClass(ServiceDescriptor, -1, false, false, ::IceGrid::T_CommunicatorDescriptor, [], [
+        T_ServiceDescriptor.defineClass(ServiceDescriptor, -1, false, false, ::IceGrid::T_CommunicatorDescriptor, [
             ['name', ::Ice::T_string, false, 0],
             ['entry', ::Ice::T_string, false, 0]
         ])
-        ServiceDescriptor_mixin::ICE_TYPE = T_ServiceDescriptor
-
-        T_ServiceDescriptorPrx.defineProxy(ServiceDescriptorPrx, T_ServiceDescriptor)
-        ServiceDescriptorPrx::ICE_TYPE = T_ServiceDescriptorPrx
     end
 
     if not defined?(::IceGrid::T_ServiceDescriptorSeq)
@@ -545,6 +406,7 @@ module ::IceGrid
 
     if not defined?(::IceGrid::ServerInstanceDescriptor)
         class ServerInstanceDescriptor
+            include ::Ice::Inspect_mixin
             def initialize(template='', parameterValues=nil, propertySet=::IceGrid::PropertySetDescriptor.new, servicePropertySets=nil)
                 @template = template
                 @parameterValues = parameterValues
@@ -574,10 +436,6 @@ module ::IceGrid
                 return other.class == self.class && other == self
             end
 
-            def inspect
-                ::Ice::__stringify(self, T_ServerInstanceDescriptor)
-            end
-
             attr_accessor :template, :parameterValues, :propertySet, :servicePropertySets
         end
 
@@ -595,6 +453,7 @@ module ::IceGrid
 
     if not defined?(::IceGrid::TemplateDescriptor)
         class TemplateDescriptor
+            include ::Ice::Inspect_mixin
             def initialize(descriptor=nil, parameters=nil, parameterDefaults=nil)
                 @descriptor = descriptor
                 @parameters = parameters
@@ -621,10 +480,6 @@ module ::IceGrid
                 return other.class == self.class && other == self
             end
 
-            def inspect
-                ::Ice::__stringify(self, T_TemplateDescriptor)
-            end
-
             attr_accessor :descriptor, :parameters, :parameterDefaults
         end
 
@@ -641,6 +496,7 @@ module ::IceGrid
 
     if not defined?(::IceGrid::ServiceInstanceDescriptor)
         class ServiceInstanceDescriptor
+            include ::Ice::Inspect_mixin
             def initialize(template='', parameterValues=nil, descriptor=nil, propertySet=::IceGrid::PropertySetDescriptor.new)
                 @template = template
                 @parameterValues = parameterValues
@@ -670,10 +526,6 @@ module ::IceGrid
                 return other.class == self.class && other == self
             end
 
-            def inspect
-                ::Ice::__stringify(self, T_ServiceInstanceDescriptor)
-            end
-
             attr_accessor :template, :parameterValues, :descriptor, :propertySet
         end
 
@@ -689,68 +541,30 @@ module ::IceGrid
         T_ServiceInstanceDescriptorSeq = ::Ice::__defineSequence('::IceGrid::ServiceInstanceDescriptorSeq', ::IceGrid::T_ServiceInstanceDescriptor)
     end
 
-    if not defined?(::IceGrid::IceBoxDescriptor_mixin)
-        module IceBoxDescriptor_mixin
-            include ::IceGrid::ServerDescriptor_mixin
-
-            def ice_ids(current=nil)
-                ['::Ice::Object', '::IceGrid::CommunicatorDescriptor', '::IceGrid::IceBoxDescriptor', '::IceGrid::ServerDescriptor']
-            end
-
-            def ice_id(current=nil)
-                '::IceGrid::IceBoxDescriptor'
-            end
-
-            def inspect
-                ::Ice::__stringify(self, T_IceBoxDescriptor)
-            end
+    if not defined?(::IceGrid::IceBoxDescriptor_Mixin)
 
-            attr_accessor :services
+        module ::IceGrid::IceBoxDescriptor_Mixin
         end
         class IceBoxDescriptor < ::IceGrid::ServerDescriptor
-            include IceBoxDescriptor_mixin
-            
-            def IceBoxDescriptor.ice_staticId()
-                '::IceGrid::IceBoxDescriptor'
-            end
 
             def initialize(adapters=nil, propertySet=::IceGrid::PropertySetDescriptor.new, dbEnvs=nil, logs=nil, description='', id='', exe='', iceVersion='', pwd='', options=nil, envs=nil, activation='', activationTimeout='', deactivationTimeout='', applicationDistrib=false, distrib=::IceGrid::DistributionDescriptor.new, allocatable=false, user='', services=nil)
                 super(adapters, propertySet, dbEnvs, logs, description, id, exe, iceVersion, pwd, options, envs, activation, activationTimeout, deactivationTimeout, applicationDistrib, distrib, allocatable, user)
                 @services = services
             end
-        end
-        module IceBoxDescriptorPrx_mixin
-            include ::IceGrid::ServerDescriptorPrx_mixin
-        end
-        class IceBoxDescriptorPrx < ::Ice::ObjectPrx
-            include IceBoxDescriptorPrx_mixin
-
-            def IceBoxDescriptorPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
-                ice_checkedCast(proxy, '::IceGrid::IceBoxDescriptor', facetOrCtx, _ctx)
-            end
 
-            def IceBoxDescriptorPrx.uncheckedCast(proxy, facet=nil)
-                ice_uncheckedCast(proxy, facet)
-            end
-            def IceBoxDescriptorPrx.ice_staticId()
-                '::IceGrid::IceBoxDescriptor'
-            end
+            attr_accessor :services
         end
 
         if not defined?(::IceGrid::T_IceBoxDescriptor)
             T_IceBoxDescriptor = ::Ice::__declareClass('::IceGrid::IceBoxDescriptor')
-            T_IceBoxDescriptorPrx = ::Ice::__declareProxy('::IceGrid::IceBoxDescriptor')
         end
 
-        T_IceBoxDescriptor.defineClass(IceBoxDescriptor, -1, false, false, ::IceGrid::T_ServerDescriptor, [], [['services', ::IceGrid::T_ServiceInstanceDescriptorSeq, false, 0]])
-        IceBoxDescriptor_mixin::ICE_TYPE = T_IceBoxDescriptor
-
-        T_IceBoxDescriptorPrx.defineProxy(IceBoxDescriptorPrx, T_IceBoxDescriptor)
-        IceBoxDescriptorPrx::ICE_TYPE = T_IceBoxDescriptorPrx
+        T_IceBoxDescriptor.defineClass(IceBoxDescriptor, -1, false, false, ::IceGrid::T_ServerDescriptor, [['services', ::IceGrid::T_ServiceInstanceDescriptorSeq, false, 0]])
     end
 
     if not defined?(::IceGrid::NodeDescriptor)
         class NodeDescriptor
+            include ::Ice::Inspect_mixin
             def initialize(variables=nil, serverInstances=nil, servers=nil, loadFactor='', description='', propertySets=nil)
                 @variables = variables
                 @serverInstances = serverInstances
@@ -786,10 +600,6 @@ module ::IceGrid
                 return other.class == self.class && other == self
             end
 
-            def inspect
-                ::Ice::__stringify(self, T_NodeDescriptor)
-            end
-
             attr_accessor :variables, :serverInstances, :servers, :loadFactor, :description, :propertySets
         end
 
@@ -807,297 +617,104 @@ module ::IceGrid
         T_NodeDescriptorDict = ::Ice::__defineDictionary('::IceGrid::NodeDescriptorDict', ::Ice::T_string, ::IceGrid::T_NodeDescriptor)
     end
 
-    if not defined?(::IceGrid::LoadBalancingPolicy_mixin)
-        module LoadBalancingPolicy_mixin
-            include ::Ice::Object_mixin
+    if not defined?(::IceGrid::LoadBalancingPolicy_Mixin)
 
-            def ice_ids(current=nil)
-                ['::Ice::Object', '::IceGrid::LoadBalancingPolicy']
-            end
-
-            def ice_id(current=nil)
-                '::IceGrid::LoadBalancingPolicy'
-            end
-
-            def inspect
-                ::Ice::__stringify(self, T_LoadBalancingPolicy)
-            end
-
-            attr_accessor :nReplicas
+        module ::IceGrid::LoadBalancingPolicy_Mixin
         end
-        class LoadBalancingPolicy
-            include LoadBalancingPolicy_mixin
-            
-            def LoadBalancingPolicy.ice_staticId()
-                '::IceGrid::LoadBalancingPolicy'
-            end
+        class LoadBalancingPolicy < ::Ice::Value
 
             def initialize(nReplicas='')
                 @nReplicas = nReplicas
             end
-        end
-        module LoadBalancingPolicyPrx_mixin
-        end
-        class LoadBalancingPolicyPrx < ::Ice::ObjectPrx
-            include LoadBalancingPolicyPrx_mixin
-
-            def LoadBalancingPolicyPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
-                ice_checkedCast(proxy, '::IceGrid::LoadBalancingPolicy', facetOrCtx, _ctx)
-            end
 
-            def LoadBalancingPolicyPrx.uncheckedCast(proxy, facet=nil)
-                ice_uncheckedCast(proxy, facet)
-            end
-            def LoadBalancingPolicyPrx.ice_staticId()
-                '::IceGrid::LoadBalancingPolicy'
-            end
+            attr_accessor :nReplicas
         end
 
         if not defined?(::IceGrid::T_LoadBalancingPolicy)
             T_LoadBalancingPolicy = ::Ice::__declareClass('::IceGrid::LoadBalancingPolicy')
-            T_LoadBalancingPolicyPrx = ::Ice::__declareProxy('::IceGrid::LoadBalancingPolicy')
         end
 
-        T_LoadBalancingPolicy.defineClass(LoadBalancingPolicy, -1, false, false, nil, [], [['nReplicas', ::Ice::T_string, false, 0]])
-        LoadBalancingPolicy_mixin::ICE_TYPE = T_LoadBalancingPolicy
-
-        T_LoadBalancingPolicyPrx.defineProxy(LoadBalancingPolicyPrx, T_LoadBalancingPolicy)
-        LoadBalancingPolicyPrx::ICE_TYPE = T_LoadBalancingPolicyPrx
+        T_LoadBalancingPolicy.defineClass(LoadBalancingPolicy, -1, false, false, nil, [['nReplicas', ::Ice::T_string, false, 0]])
     end
 
-    if not defined?(::IceGrid::RandomLoadBalancingPolicy_mixin)
-        module RandomLoadBalancingPolicy_mixin
-            include ::IceGrid::LoadBalancingPolicy_mixin
-
-            def ice_ids(current=nil)
-                ['::Ice::Object', '::IceGrid::LoadBalancingPolicy', '::IceGrid::RandomLoadBalancingPolicy']
-            end
+    if not defined?(::IceGrid::RandomLoadBalancingPolicy_Mixin)
 
-            def ice_id(current=nil)
-                '::IceGrid::RandomLoadBalancingPolicy'
-            end
-
-            def inspect
-                ::Ice::__stringify(self, T_RandomLoadBalancingPolicy)
-            end
+        module ::IceGrid::RandomLoadBalancingPolicy_Mixin
         end
         class RandomLoadBalancingPolicy < ::IceGrid::LoadBalancingPolicy
-            include RandomLoadBalancingPolicy_mixin
-            
-            def RandomLoadBalancingPolicy.ice_staticId()
-                '::IceGrid::RandomLoadBalancingPolicy'
-            end
 
             def initialize(nReplicas='')
                 super(nReplicas)
             end
         end
-        module RandomLoadBalancingPolicyPrx_mixin
-            include ::IceGrid::LoadBalancingPolicyPrx_mixin
-        end
-        class RandomLoadBalancingPolicyPrx < ::Ice::ObjectPrx
-            include RandomLoadBalancingPolicyPrx_mixin
-
-            def RandomLoadBalancingPolicyPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
-                ice_checkedCast(proxy, '::IceGrid::RandomLoadBalancingPolicy', facetOrCtx, _ctx)
-            end
-
-            def RandomLoadBalancingPolicyPrx.uncheckedCast(proxy, facet=nil)
-                ice_uncheckedCast(proxy, facet)
-            end
-            def RandomLoadBalancingPolicyPrx.ice_staticId()
-                '::IceGrid::RandomLoadBalancingPolicy'
-            end
-        end
 
         if not defined?(::IceGrid::T_RandomLoadBalancingPolicy)
             T_RandomLoadBalancingPolicy = ::Ice::__declareClass('::IceGrid::RandomLoadBalancingPolicy')
-            T_RandomLoadBalancingPolicyPrx = ::Ice::__declareProxy('::IceGrid::RandomLoadBalancingPolicy')
         end
 
-        T_RandomLoadBalancingPolicy.defineClass(RandomLoadBalancingPolicy, -1, false, false, ::IceGrid::T_LoadBalancingPolicy, [], [])
-        RandomLoadBalancingPolicy_mixin::ICE_TYPE = T_RandomLoadBalancingPolicy
-
-        T_RandomLoadBalancingPolicyPrx.defineProxy(RandomLoadBalancingPolicyPrx, T_RandomLoadBalancingPolicy)
-        RandomLoadBalancingPolicyPrx::ICE_TYPE = T_RandomLoadBalancingPolicyPrx
+        T_RandomLoadBalancingPolicy.defineClass(RandomLoadBalancingPolicy, -1, false, false, ::IceGrid::T_LoadBalancingPolicy, [])
     end
 
-    if not defined?(::IceGrid::OrderedLoadBalancingPolicy_mixin)
-        module OrderedLoadBalancingPolicy_mixin
-            include ::IceGrid::LoadBalancingPolicy_mixin
-
-            def ice_ids(current=nil)
-                ['::Ice::Object', '::IceGrid::LoadBalancingPolicy', '::IceGrid::OrderedLoadBalancingPolicy']
-            end
-
-            def ice_id(current=nil)
-                '::IceGrid::OrderedLoadBalancingPolicy'
-            end
+    if not defined?(::IceGrid::OrderedLoadBalancingPolicy_Mixin)
 
-            def inspect
-                ::Ice::__stringify(self, T_OrderedLoadBalancingPolicy)
-            end
+        module ::IceGrid::OrderedLoadBalancingPolicy_Mixin
         end
         class OrderedLoadBalancingPolicy < ::IceGrid::LoadBalancingPolicy
-            include OrderedLoadBalancingPolicy_mixin
-            
-            def OrderedLoadBalancingPolicy.ice_staticId()
-                '::IceGrid::OrderedLoadBalancingPolicy'
-            end
 
             def initialize(nReplicas='')
                 super(nReplicas)
             end
         end
-        module OrderedLoadBalancingPolicyPrx_mixin
-            include ::IceGrid::LoadBalancingPolicyPrx_mixin
-        end
-        class OrderedLoadBalancingPolicyPrx < ::Ice::ObjectPrx
-            include OrderedLoadBalancingPolicyPrx_mixin
-
-            def OrderedLoadBalancingPolicyPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
-                ice_checkedCast(proxy, '::IceGrid::OrderedLoadBalancingPolicy', facetOrCtx, _ctx)
-            end
-
-            def OrderedLoadBalancingPolicyPrx.uncheckedCast(proxy, facet=nil)
-                ice_uncheckedCast(proxy, facet)
-            end
-            def OrderedLoadBalancingPolicyPrx.ice_staticId()
-                '::IceGrid::OrderedLoadBalancingPolicy'
-            end
-        end
 
         if not defined?(::IceGrid::T_OrderedLoadBalancingPolicy)
             T_OrderedLoadBalancingPolicy = ::Ice::__declareClass('::IceGrid::OrderedLoadBalancingPolicy')
-            T_OrderedLoadBalancingPolicyPrx = ::Ice::__declareProxy('::IceGrid::OrderedLoadBalancingPolicy')
         end
 
-        T_OrderedLoadBalancingPolicy.defineClass(OrderedLoadBalancingPolicy, -1, false, false, ::IceGrid::T_LoadBalancingPolicy, [], [])
-        OrderedLoadBalancingPolicy_mixin::ICE_TYPE = T_OrderedLoadBalancingPolicy
-
-        T_OrderedLoadBalancingPolicyPrx.defineProxy(OrderedLoadBalancingPolicyPrx, T_OrderedLoadBalancingPolicy)
-        OrderedLoadBalancingPolicyPrx::ICE_TYPE = T_OrderedLoadBalancingPolicyPrx
+        T_OrderedLoadBalancingPolicy.defineClass(OrderedLoadBalancingPolicy, -1, false, false, ::IceGrid::T_LoadBalancingPolicy, [])
     end
 
-    if not defined?(::IceGrid::RoundRobinLoadBalancingPolicy_mixin)
-        module RoundRobinLoadBalancingPolicy_mixin
-            include ::IceGrid::LoadBalancingPolicy_mixin
+    if not defined?(::IceGrid::RoundRobinLoadBalancingPolicy_Mixin)
 
-            def ice_ids(current=nil)
-                ['::Ice::Object', '::IceGrid::LoadBalancingPolicy', '::IceGrid::RoundRobinLoadBalancingPolicy']
-            end
-
-            def ice_id(current=nil)
-                '::IceGrid::RoundRobinLoadBalancingPolicy'
-            end
-
-            def inspect
-                ::Ice::__stringify(self, T_RoundRobinLoadBalancingPolicy)
-            end
+        module ::IceGrid::RoundRobinLoadBalancingPolicy_Mixin
         end
         class RoundRobinLoadBalancingPolicy < ::IceGrid::LoadBalancingPolicy
-            include RoundRobinLoadBalancingPolicy_mixin
-            
-            def RoundRobinLoadBalancingPolicy.ice_staticId()
-                '::IceGrid::RoundRobinLoadBalancingPolicy'
-            end
 
             def initialize(nReplicas='')
                 super(nReplicas)
             end
         end
-        module RoundRobinLoadBalancingPolicyPrx_mixin
-            include ::IceGrid::LoadBalancingPolicyPrx_mixin
-        end
-        class RoundRobinLoadBalancingPolicyPrx < ::Ice::ObjectPrx
-            include RoundRobinLoadBalancingPolicyPrx_mixin
-
-            def RoundRobinLoadBalancingPolicyPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
-                ice_checkedCast(proxy, '::IceGrid::RoundRobinLoadBalancingPolicy', facetOrCtx, _ctx)
-            end
-
-            def RoundRobinLoadBalancingPolicyPrx.uncheckedCast(proxy, facet=nil)
-                ice_uncheckedCast(proxy, facet)
-            end
-            def RoundRobinLoadBalancingPolicyPrx.ice_staticId()
-                '::IceGrid::RoundRobinLoadBalancingPolicy'
-            end
-        end
 
         if not defined?(::IceGrid::T_RoundRobinLoadBalancingPolicy)
             T_RoundRobinLoadBalancingPolicy = ::Ice::__declareClass('::IceGrid::RoundRobinLoadBalancingPolicy')
-            T_RoundRobinLoadBalancingPolicyPrx = ::Ice::__declareProxy('::IceGrid::RoundRobinLoadBalancingPolicy')
         end
 
-        T_RoundRobinLoadBalancingPolicy.defineClass(RoundRobinLoadBalancingPolicy, -1, false, false, ::IceGrid::T_LoadBalancingPolicy, [], [])
-        RoundRobinLoadBalancingPolicy_mixin::ICE_TYPE = T_RoundRobinLoadBalancingPolicy
-
-        T_RoundRobinLoadBalancingPolicyPrx.defineProxy(RoundRobinLoadBalancingPolicyPrx, T_RoundRobinLoadBalancingPolicy)
-        RoundRobinLoadBalancingPolicyPrx::ICE_TYPE = T_RoundRobinLoadBalancingPolicyPrx
+        T_RoundRobinLoadBalancingPolicy.defineClass(RoundRobinLoadBalancingPolicy, -1, false, false, ::IceGrid::T_LoadBalancingPolicy, [])
     end
 
-    if not defined?(::IceGrid::AdaptiveLoadBalancingPolicy_mixin)
-        module AdaptiveLoadBalancingPolicy_mixin
-            include ::IceGrid::LoadBalancingPolicy_mixin
-
-            def ice_ids(current=nil)
-                ['::Ice::Object', '::IceGrid::AdaptiveLoadBalancingPolicy', '::IceGrid::LoadBalancingPolicy']
-            end
-
-            def ice_id(current=nil)
-                '::IceGrid::AdaptiveLoadBalancingPolicy'
-            end
+    if not defined?(::IceGrid::AdaptiveLoadBalancingPolicy_Mixin)
 
-            def inspect
-                ::Ice::__stringify(self, T_AdaptiveLoadBalancingPolicy)
-            end
-
-            attr_accessor :loadSample
+        module ::IceGrid::AdaptiveLoadBalancingPolicy_Mixin
         end
         class AdaptiveLoadBalancingPolicy < ::IceGrid::LoadBalancingPolicy
-            include AdaptiveLoadBalancingPolicy_mixin
-            
-            def AdaptiveLoadBalancingPolicy.ice_staticId()
-                '::IceGrid::AdaptiveLoadBalancingPolicy'
-            end
 
             def initialize(nReplicas='', loadSample='')
                 super(nReplicas)
                 @loadSample = loadSample
             end
-        end
-        module AdaptiveLoadBalancingPolicyPrx_mixin
-            include ::IceGrid::LoadBalancingPolicyPrx_mixin
-        end
-        class AdaptiveLoadBalancingPolicyPrx < ::Ice::ObjectPrx
-            include AdaptiveLoadBalancingPolicyPrx_mixin
 
-            def AdaptiveLoadBalancingPolicyPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
-                ice_checkedCast(proxy, '::IceGrid::AdaptiveLoadBalancingPolicy', facetOrCtx, _ctx)
-            end
-
-            def AdaptiveLoadBalancingPolicyPrx.uncheckedCast(proxy, facet=nil)
-                ice_uncheckedCast(proxy, facet)
-            end
-            def AdaptiveLoadBalancingPolicyPrx.ice_staticId()
-                '::IceGrid::AdaptiveLoadBalancingPolicy'
-            end
+            attr_accessor :loadSample
         end
 
         if not defined?(::IceGrid::T_AdaptiveLoadBalancingPolicy)
             T_AdaptiveLoadBalancingPolicy = ::Ice::__declareClass('::IceGrid::AdaptiveLoadBalancingPolicy')
-            T_AdaptiveLoadBalancingPolicyPrx = ::Ice::__declareProxy('::IceGrid::AdaptiveLoadBalancingPolicy')
         end
 
-        T_AdaptiveLoadBalancingPolicy.defineClass(AdaptiveLoadBalancingPolicy, -1, false, false, ::IceGrid::T_LoadBalancingPolicy, [], [['loadSample', ::Ice::T_string, false, 0]])
-        AdaptiveLoadBalancingPolicy_mixin::ICE_TYPE = T_AdaptiveLoadBalancingPolicy
-
-        T_AdaptiveLoadBalancingPolicyPrx.defineProxy(AdaptiveLoadBalancingPolicyPrx, T_AdaptiveLoadBalancingPolicy)
-        AdaptiveLoadBalancingPolicyPrx::ICE_TYPE = T_AdaptiveLoadBalancingPolicyPrx
+        T_AdaptiveLoadBalancingPolicy.defineClass(AdaptiveLoadBalancingPolicy, -1, false, false, ::IceGrid::T_LoadBalancingPolicy, [['loadSample', ::Ice::T_string, false, 0]])
     end
 
     if not defined?(::IceGrid::ReplicaGroupDescriptor)
         class ReplicaGroupDescriptor
+            include ::Ice::Inspect_mixin
             def initialize(id='', loadBalancing=nil, proxyOptions='', objects=nil, description='', filter='')
                 @id = id
                 @loadBalancing = loadBalancing
@@ -1133,10 +750,6 @@ module ::IceGrid
                 return other.class == self.class && other == self
             end
 
-            def inspect
-                ::Ice::__stringify(self, T_ReplicaGroupDescriptor)
-            end
-
             attr_accessor :id, :loadBalancing, :proxyOptions, :objects, :description, :filter
         end
 
@@ -1156,6 +769,7 @@ module ::IceGrid
 
     if not defined?(::IceGrid::ApplicationDescriptor)
         class ApplicationDescriptor
+            include ::Ice::Inspect_mixin
             def initialize(name='', variables=nil, replicaGroups=nil, serverTemplates=nil, serviceTemplates=nil, nodes=nil, distrib=::IceGrid::DistributionDescriptor.new, description='', propertySets=nil)
                 @name = name
                 @variables = variables
@@ -1200,10 +814,6 @@ module ::IceGrid
                 return other.class == self.class && other == self
             end
 
-            def inspect
-                ::Ice::__stringify(self, T_ApplicationDescriptor)
-            end
-
             attr_accessor :name, :variables, :replicaGroups, :serverTemplates, :serviceTemplates, :nodes, :distrib, :description, :propertySets
         end
 
@@ -1224,66 +834,29 @@ module ::IceGrid
         T_ApplicationDescriptorSeq = ::Ice::__defineSequence('::IceGrid::ApplicationDescriptorSeq', ::IceGrid::T_ApplicationDescriptor)
     end
 
-    if not defined?(::IceGrid::BoxedString_mixin)
-        module BoxedString_mixin
-            include ::Ice::Object_mixin
+    if not defined?(::IceGrid::BoxedString_Mixin)
 
-            def ice_ids(current=nil)
-                ['::Ice::Object', '::IceGrid::BoxedString']
-            end
-
-            def ice_id(current=nil)
-                '::IceGrid::BoxedString'
-            end
-
-            def inspect
-                ::Ice::__stringify(self, T_BoxedString)
-            end
-
-            attr_accessor :value
+        module ::IceGrid::BoxedString_Mixin
         end
-        class BoxedString
-            include BoxedString_mixin
-            
-            def BoxedString.ice_staticId()
-                '::IceGrid::BoxedString'
-            end
+        class BoxedString < ::Ice::Value
 
             def initialize(value='')
                 @value = value
             end
-        end
-        module BoxedStringPrx_mixin
-        end
-        class BoxedStringPrx < ::Ice::ObjectPrx
-            include BoxedStringPrx_mixin
-
-            def BoxedStringPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
-                ice_checkedCast(proxy, '::IceGrid::BoxedString', facetOrCtx, _ctx)
-            end
 
-            def BoxedStringPrx.uncheckedCast(proxy, facet=nil)
-                ice_uncheckedCast(proxy, facet)
-            end
-            def BoxedStringPrx.ice_staticId()
-                '::IceGrid::BoxedString'
-            end
+            attr_accessor :value
         end
 
         if not defined?(::IceGrid::T_BoxedString)
             T_BoxedString = ::Ice::__declareClass('::IceGrid::BoxedString')
-            T_BoxedStringPrx = ::Ice::__declareProxy('::IceGrid::BoxedString')
         end
 
-        T_BoxedString.defineClass(BoxedString, -1, false, false, nil, [], [['value', ::Ice::T_string, false, 0]])
-        BoxedString_mixin::ICE_TYPE = T_BoxedString
-
-        T_BoxedStringPrx.defineProxy(BoxedStringPrx, T_BoxedString)
-        BoxedStringPrx::ICE_TYPE = T_BoxedStringPrx
+        T_BoxedString.defineClass(BoxedString, -1, false, false, nil, [['value', ::Ice::T_string, false, 0]])
     end
 
     if not defined?(::IceGrid::NodeUpdateDescriptor)
         class NodeUpdateDescriptor
+            include ::Ice::Inspect_mixin
             def initialize(name='', description=nil, variables=nil, removeVariables=nil, propertySets=nil, removePropertySets=nil, serverInstances=nil, servers=nil, removeServers=nil, loadFactor=nil)
                 @name = name
                 @description = description
@@ -1331,10 +904,6 @@ module ::IceGrid
                 return other.class == self.class && other == self
             end
 
-            def inspect
-                ::Ice::__stringify(self, T_NodeUpdateDescriptor)
-            end
-
             attr_accessor :name, :description, :variables, :removeVariables, :propertySets, :removePropertySets, :serverInstances, :servers, :removeServers, :loadFactor
         end
 
@@ -1356,66 +925,29 @@ module ::IceGrid
         T_NodeUpdateDescriptorSeq = ::Ice::__defineSequence('::IceGrid::NodeUpdateDescriptorSeq', ::IceGrid::T_NodeUpdateDescriptor)
     end
 
-    if not defined?(::IceGrid::BoxedDistributionDescriptor_mixin)
-        module BoxedDistributionDescriptor_mixin
-            include ::Ice::Object_mixin
-
-            def ice_ids(current=nil)
-                ['::Ice::Object', '::IceGrid::BoxedDistributionDescriptor']
-            end
-
-            def ice_id(current=nil)
-                '::IceGrid::BoxedDistributionDescriptor'
-            end
-
-            def inspect
-                ::Ice::__stringify(self, T_BoxedDistributionDescriptor)
-            end
+    if not defined?(::IceGrid::BoxedDistributionDescriptor_Mixin)
 
-            attr_accessor :value
+        module ::IceGrid::BoxedDistributionDescriptor_Mixin
         end
-        class BoxedDistributionDescriptor
-            include BoxedDistributionDescriptor_mixin
-            
-            def BoxedDistributionDescriptor.ice_staticId()
-                '::IceGrid::BoxedDistributionDescriptor'
-            end
+        class BoxedDistributionDescriptor < ::Ice::Value
 
             def initialize(value=::IceGrid::DistributionDescriptor.new)
                 @value = value
             end
-        end
-        module BoxedDistributionDescriptorPrx_mixin
-        end
-        class BoxedDistributionDescriptorPrx < ::Ice::ObjectPrx
-            include BoxedDistributionDescriptorPrx_mixin
-
-            def BoxedDistributionDescriptorPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
-                ice_checkedCast(proxy, '::IceGrid::BoxedDistributionDescriptor', facetOrCtx, _ctx)
-            end
 
-            def BoxedDistributionDescriptorPrx.uncheckedCast(proxy, facet=nil)
-                ice_uncheckedCast(proxy, facet)
-            end
-            def BoxedDistributionDescriptorPrx.ice_staticId()
-                '::IceGrid::BoxedDistributionDescriptor'
-            end
+            attr_accessor :value
         end
 
         if not defined?(::IceGrid::T_BoxedDistributionDescriptor)
             T_BoxedDistributionDescriptor = ::Ice::__declareClass('::IceGrid::BoxedDistributionDescriptor')
-            T_BoxedDistributionDescriptorPrx = ::Ice::__declareProxy('::IceGrid::BoxedDistributionDescriptor')
         end
 
-        T_BoxedDistributionDescriptor.defineClass(BoxedDistributionDescriptor, -1, false, false, nil, [], [['value', ::IceGrid::T_DistributionDescriptor, false, 0]])
-        BoxedDistributionDescriptor_mixin::ICE_TYPE = T_BoxedDistributionDescriptor
-
-        T_BoxedDistributionDescriptorPrx.defineProxy(BoxedDistributionDescriptorPrx, T_BoxedDistributionDescriptor)
-        BoxedDistributionDescriptorPrx::ICE_TYPE = T_BoxedDistributionDescriptorPrx
+        T_BoxedDistributionDescriptor.defineClass(BoxedDistributionDescriptor, -1, false, false, nil, [['value', ::IceGrid::T_DistributionDescriptor, false, 0]])
     end
 
     if not defined?(::IceGrid::ApplicationUpdateDescriptor)
         class ApplicationUpdateDescriptor
+            include ::Ice::Inspect_mixin
             def initialize(name='', description=nil, distrib=nil, variables=nil, removeVariables=nil, propertySets=nil, removePropertySets=nil, replicaGroups=nil, removeReplicaGroups=nil, serverTemplates=nil, removeServerTemplates=nil, serviceTemplates=nil, removeServiceTemplates=nil, nodes=nil, removeNodes=nil)
                 @name = name
                 @description = description
@@ -1478,10 +1010,6 @@ module ::IceGrid
                 return other.class == self.class && other == self
             end
 
-            def inspect
-                ::Ice::__stringify(self, T_ApplicationUpdateDescriptor)
-            end
-
             attr_accessor :name, :description, :distrib, :variables, :removeVariables, :propertySets, :removePropertySets, :replicaGroups, :removeReplicaGroups, :serverTemplates, :removeServerTemplates, :serviceTemplates, :removeServiceTemplates, :nodes, :removeNodes
         end