zeroc-ice 3.7.9.1 → 3.8.0

data/dist/lib/IceGrid/Descriptor.rb

@@ -0,0 +1,989 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2rb version 3.8.0
+# <auto-generated>Generated from Slice file 'Descriptor.ice'.</auto-generated>
+
+require 'Ice'
+require 'Ice/BuiltinSequences.rb'
+require 'Ice/Identity.rb'
+
+module ::IceGrid
+    if not defined?(::IceGrid::T_StringStringDict)
+        T_StringStringDict = Ice::__defineDictionary('::IceGrid::StringStringDict', Ice::T_string, Ice::T_string)
+    end
+
+    if not defined?(::IceGrid::PropertyDescriptor)
+        class PropertyDescriptor
+            include Ice::Inspect_mixin
+            def initialize(name='', value='')
+                @name = name
+                @value = value
+            end
+
+            def hash
+                _h = 0
+                _h = 5 * _h + @name.hash
+                _h = 5 * _h + @value.hash
+                _h % 0x7fffffff
+            end
+
+            def ==(other)
+                return false if !other.is_a? ::IceGrid::PropertyDescriptor or
+                    @name != other.name or
+                    @value != other.value
+                true
+            end
+
+            def eql?(other)
+                return other.class == self.class && other == self
+            end
+
+            attr_accessor :name, :value
+        end
+
+        T_PropertyDescriptor = Ice::__defineStruct('::IceGrid::PropertyDescriptor', PropertyDescriptor, [
+            ["name", Ice::T_string],
+            ["value", Ice::T_string]
+        ])
+    end
+
+    if not defined?(::IceGrid::T_PropertyDescriptorSeq)
+        T_PropertyDescriptorSeq = Ice::__defineSequence('::IceGrid::PropertyDescriptorSeq', ::IceGrid::T_PropertyDescriptor)
+    end
+
+    if not defined?(::IceGrid::PropertySetDescriptor)
+        class PropertySetDescriptor
+            include Ice::Inspect_mixin
+            def initialize(references=nil, properties=nil)
+                @references = references
+                @properties = properties
+            end
+
+            def hash
+                _h = 0
+                _h = 5 * _h + @references.hash
+                _h = 5 * _h + @properties.hash
+                _h % 0x7fffffff
+            end
+
+            def ==(other)
+                return false if !other.is_a? ::IceGrid::PropertySetDescriptor or
+                    @references != other.references or
+                    @properties != other.properties
+                true
+            end
+
+            def eql?(other)
+                return other.class == self.class && other == self
+            end
+
+            attr_accessor :references, :properties
+        end
+
+        T_PropertySetDescriptor = Ice::__defineStruct('::IceGrid::PropertySetDescriptor', PropertySetDescriptor, [
+            ["references", ::Ice::T_StringSeq],
+            ["properties", ::IceGrid::T_PropertyDescriptorSeq]
+        ])
+    end
+
+    if not defined?(::IceGrid::T_PropertySetDescriptorDict)
+        T_PropertySetDescriptorDict = Ice::__defineDictionary('::IceGrid::PropertySetDescriptorDict', Ice::T_string, ::IceGrid::T_PropertySetDescriptor)
+    end
+
+    if not defined?(::IceGrid::ObjectDescriptor)
+        class ObjectDescriptor
+            include Ice::Inspect_mixin
+            def initialize(id=::Ice::Identity.new, type='', proxyOptions='')
+                @id = id
+                @type = type
+                @proxyOptions = proxyOptions
+            end
+
+            def hash
+                _h = 0
+                _h = 5 * _h + @id.hash
+                _h = 5 * _h + @type.hash
+                _h = 5 * _h + @proxyOptions.hash
+                _h % 0x7fffffff
+            end
+
+            def ==(other)
+                return false if !other.is_a? ::IceGrid::ObjectDescriptor or
+                    @id != other.id or
+                    @type != other.type or
+                    @proxyOptions != other.proxyOptions
+                true
+            end
+
+            def eql?(other)
+                return other.class == self.class && other == self
+            end
+
+            attr_accessor :id, :type, :proxyOptions
+        end
+
+        T_ObjectDescriptor = Ice::__defineStruct('::IceGrid::ObjectDescriptor', ObjectDescriptor, [
+            ["id", ::Ice::T_Identity],
+            ["type", Ice::T_string],
+            ["proxyOptions", Ice::T_string]
+        ])
+    end
+
+    if not defined?(::IceGrid::T_ObjectDescriptorSeq)
+        T_ObjectDescriptorSeq = Ice::__defineSequence('::IceGrid::ObjectDescriptorSeq', ::IceGrid::T_ObjectDescriptor)
+    end
+
+    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
+                @id = id
+                @replicaGroupId = replicaGroupId
+                @priority = priority
+                @registerProcess = registerProcess
+                @serverLifetime = serverLifetime
+                @objects = objects
+                @allocatables = allocatables
+            end
+
+            def hash
+                _h = 0
+                _h = 5 * _h + @name.hash
+                _h = 5 * _h + @description.hash
+                _h = 5 * _h + @id.hash
+                _h = 5 * _h + @replicaGroupId.hash
+                _h = 5 * _h + @priority.hash
+                _h = 5 * _h + @registerProcess.hash
+                _h = 5 * _h + @serverLifetime.hash
+                _h = 5 * _h + @objects.hash
+                _h = 5 * _h + @allocatables.hash
+                _h % 0x7fffffff
+            end
+
+            def ==(other)
+                return false if !other.is_a? ::IceGrid::AdapterDescriptor or
+                    @name != other.name or
+                    @description != other.description or
+                    @id != other.id or
+                    @replicaGroupId != other.replicaGroupId or
+                    @priority != other.priority or
+                    @registerProcess != other.registerProcess or
+                    @serverLifetime != other.serverLifetime or
+                    @objects != other.objects or
+                    @allocatables != other.allocatables
+                true
+            end
+
+            def eql?(other)
+                return other.class == self.class && other == self
+            end
+
+            attr_accessor :name, :description, :id, :replicaGroupId, :priority, :registerProcess, :serverLifetime, :objects, :allocatables
+        end
+
+        T_AdapterDescriptor = Ice::__defineStruct('::IceGrid::AdapterDescriptor', AdapterDescriptor, [
+            ["name", Ice::T_string],
+            ["description", Ice::T_string],
+            ["id", Ice::T_string],
+            ["replicaGroupId", Ice::T_string],
+            ["priority", Ice::T_string],
+            ["registerProcess", Ice::T_bool],
+            ["serverLifetime", Ice::T_bool],
+            ["objects", ::IceGrid::T_ObjectDescriptorSeq],
+            ["allocatables", ::IceGrid::T_ObjectDescriptorSeq]
+        ])
+    end
+
+    if not defined?(::IceGrid::T_AdapterDescriptorSeq)
+        T_AdapterDescriptorSeq = Ice::__defineSequence('::IceGrid::AdapterDescriptorSeq', ::IceGrid::T_AdapterDescriptor)
+    end
+
+    if not defined?(::IceGrid::DbEnvDescriptor)
+        class DbEnvDescriptor
+            include Ice::Inspect_mixin
+            def initialize(name='', description='', dbHome='', properties=nil)
+                @name = name
+                @description = description
+                @dbHome = dbHome
+                @properties = properties
+            end
+
+            def hash
+                _h = 0
+                _h = 5 * _h + @name.hash
+                _h = 5 * _h + @description.hash
+                _h = 5 * _h + @dbHome.hash
+                _h = 5 * _h + @properties.hash
+                _h % 0x7fffffff
+            end
+
+            def ==(other)
+                return false if !other.is_a? ::IceGrid::DbEnvDescriptor or
+                    @name != other.name or
+                    @description != other.description or
+                    @dbHome != other.dbHome or
+                    @properties != other.properties
+                true
+            end
+
+            def eql?(other)
+                return other.class == self.class && other == self
+            end
+
+            attr_accessor :name, :description, :dbHome, :properties
+        end
+
+        T_DbEnvDescriptor = Ice::__defineStruct('::IceGrid::DbEnvDescriptor', DbEnvDescriptor, [
+            ["name", Ice::T_string],
+            ["description", Ice::T_string],
+            ["dbHome", Ice::T_string],
+            ["properties", ::IceGrid::T_PropertyDescriptorSeq]
+        ])
+    end
+
+    if not defined?(::IceGrid::T_DbEnvDescriptorSeq)
+        T_DbEnvDescriptorSeq = Ice::__defineSequence('::IceGrid::DbEnvDescriptorSeq', ::IceGrid::T_DbEnvDescriptor)
+    end
+
+    if not defined?(::IceGrid::T_CommunicatorDescriptor)
+        T_CommunicatorDescriptor = Ice::__declareClass('::IceGrid::CommunicatorDescriptor')
+    end
+
+    if not defined?(::IceGrid::CommunicatorDescriptor)
+        class CommunicatorDescriptor < Ice::Value
+
+            def initialize(adapters=nil, propertySet=::IceGrid::PropertySetDescriptor.new, dbEnvs=nil, logs=nil, description='')
+                @adapters = adapters
+                @propertySet = propertySet
+                @dbEnvs = dbEnvs
+                @logs = logs
+                @description = description
+            end
+
+            attr_accessor :adapters, :propertySet, :dbEnvs, :logs, :description
+        end
+
+        T_CommunicatorDescriptor.defineClass(CommunicatorDescriptor, -1, 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]
+        ])
+    end
+
+    if not defined?(::IceGrid::DistributionDescriptor)
+        class DistributionDescriptor
+            include Ice::Inspect_mixin
+            def initialize(icepatch='', directories=nil)
+                @icepatch = icepatch
+                @directories = directories
+            end
+
+            def hash
+                _h = 0
+                _h = 5 * _h + @icepatch.hash
+                _h = 5 * _h + @directories.hash
+                _h % 0x7fffffff
+            end
+
+            def ==(other)
+                return false if !other.is_a? ::IceGrid::DistributionDescriptor or
+                    @icepatch != other.icepatch or
+                    @directories != other.directories
+                true
+            end
+
+            def eql?(other)
+                return other.class == self.class && other == self
+            end
+
+            attr_accessor :icepatch, :directories
+        end
+
+        T_DistributionDescriptor = Ice::__defineStruct('::IceGrid::DistributionDescriptor', DistributionDescriptor, [
+            ["icepatch", Ice::T_string],
+            ["directories", ::Ice::T_StringSeq]
+        ])
+    end
+
+    if not defined?(::IceGrid::T_ServerDescriptor)
+        T_ServerDescriptor = Ice::__declareClass('::IceGrid::ServerDescriptor')
+    end
+
+    if not defined?(::IceGrid::ServerDescriptor)
+        class ServerDescriptor < ::IceGrid::CommunicatorDescriptor
+
+            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)
+                @id = id
+                @exe = exe
+                @iceVersion = iceVersion
+                @pwd = pwd
+                @options = options
+                @envs = envs
+                @activation = activation
+                @activationTimeout = activationTimeout
+                @deactivationTimeout = deactivationTimeout
+                @applicationDistrib = applicationDistrib
+                @distrib = distrib
+                @allocatable = allocatable
+                @user = user
+            end
+
+            attr_accessor :id, :exe, :iceVersion, :pwd, :options, :envs, :activation, :activationTimeout, :deactivationTimeout, :applicationDistrib, :distrib, :allocatable, :user
+        end
+
+        T_ServerDescriptor.defineClass(ServerDescriptor, -1, false, ::IceGrid::T_CommunicatorDescriptor, [
+            ['id', Ice::T_string, false, 0],
+            ['exe', Ice::T_string, false, 0],
+            ['iceVersion', Ice::T_string, false, 0],
+            ['pwd', Ice::T_string, false, 0],
+            ['options', ::Ice::T_StringSeq, false, 0],
+            ['envs', ::Ice::T_StringSeq, false, 0],
+            ['activation', Ice::T_string, false, 0],
+            ['activationTimeout', Ice::T_string, false, 0],
+            ['deactivationTimeout', Ice::T_string, false, 0],
+            ['applicationDistrib', Ice::T_bool, false, 0],
+            ['distrib', ::IceGrid::T_DistributionDescriptor, false, 0],
+            ['allocatable', Ice::T_bool, false, 0],
+            ['user', Ice::T_string, false, 0]
+        ])
+    end
+
+    if not defined?(::IceGrid::T_ServerDescriptorSeq)
+        T_ServerDescriptorSeq = Ice::__defineSequence('::IceGrid::ServerDescriptorSeq', ::IceGrid::T_ServerDescriptor)
+    end
+
+    if not defined?(::IceGrid::T_ServiceDescriptor)
+        T_ServiceDescriptor = Ice::__declareClass('::IceGrid::ServiceDescriptor')
+    end
+
+    if not defined?(::IceGrid::ServiceDescriptor)
+        class ServiceDescriptor < ::IceGrid::CommunicatorDescriptor
+
+            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
+
+            attr_accessor :name, :entry
+        end
+
+        T_ServiceDescriptor.defineClass(ServiceDescriptor, -1, false, ::IceGrid::T_CommunicatorDescriptor, [
+            ['name', Ice::T_string, false, 0],
+            ['entry', Ice::T_string, false, 0]
+        ])
+    end
+
+    if not defined?(::IceGrid::T_ServiceDescriptorSeq)
+        T_ServiceDescriptorSeq = Ice::__defineSequence('::IceGrid::ServiceDescriptorSeq', ::IceGrid::T_ServiceDescriptor)
+    end
+
+    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
+                @propertySet = propertySet
+                @servicePropertySets = servicePropertySets
+            end
+
+            def hash
+                _h = 0
+                _h = 5 * _h + @template.hash
+                _h = 5 * _h + @parameterValues.hash
+                _h = 5 * _h + @propertySet.hash
+                _h = 5 * _h + @servicePropertySets.hash
+                _h % 0x7fffffff
+            end
+
+            def ==(other)
+                return false if !other.is_a? ::IceGrid::ServerInstanceDescriptor or
+                    @template != other.template or
+                    @parameterValues != other.parameterValues or
+                    @propertySet != other.propertySet or
+                    @servicePropertySets != other.servicePropertySets
+                true
+            end
+
+            def eql?(other)
+                return other.class == self.class && other == self
+            end
+
+            attr_accessor :template, :parameterValues, :propertySet, :servicePropertySets
+        end
+
+        T_ServerInstanceDescriptor = Ice::__defineStruct('::IceGrid::ServerInstanceDescriptor', ServerInstanceDescriptor, [
+            ["template", Ice::T_string],
+            ["parameterValues", ::IceGrid::T_StringStringDict],
+            ["propertySet", ::IceGrid::T_PropertySetDescriptor],
+            ["servicePropertySets", ::IceGrid::T_PropertySetDescriptorDict]
+        ])
+    end
+
+    if not defined?(::IceGrid::T_ServerInstanceDescriptorSeq)
+        T_ServerInstanceDescriptorSeq = Ice::__defineSequence('::IceGrid::ServerInstanceDescriptorSeq', ::IceGrid::T_ServerInstanceDescriptor)
+    end
+
+    if not defined?(::IceGrid::TemplateDescriptor)
+        class TemplateDescriptor
+            include Ice::Inspect_mixin
+            def initialize(descriptor=nil, parameters=nil, parameterDefaults=nil)
+                @descriptor = descriptor
+                @parameters = parameters
+                @parameterDefaults = parameterDefaults
+            end
+
+            def hash
+                _h = 0
+                _h = 5 * _h + @descriptor.hash
+                _h = 5 * _h + @parameters.hash
+                _h = 5 * _h + @parameterDefaults.hash
+                _h % 0x7fffffff
+            end
+
+            def ==(other)
+                return false if !other.is_a? ::IceGrid::TemplateDescriptor or
+                    @descriptor != other.descriptor or
+                    @parameters != other.parameters or
+                    @parameterDefaults != other.parameterDefaults
+                true
+            end
+
+            def eql?(other)
+                return other.class == self.class && other == self
+            end
+
+            attr_accessor :descriptor, :parameters, :parameterDefaults
+        end
+
+        T_TemplateDescriptor = Ice::__defineStruct('::IceGrid::TemplateDescriptor', TemplateDescriptor, [
+            ["descriptor", ::IceGrid::T_CommunicatorDescriptor],
+            ["parameters", ::Ice::T_StringSeq],
+            ["parameterDefaults", ::IceGrid::T_StringStringDict]
+        ])
+    end
+
+    if not defined?(::IceGrid::T_TemplateDescriptorDict)
+        T_TemplateDescriptorDict = Ice::__defineDictionary('::IceGrid::TemplateDescriptorDict', Ice::T_string, ::IceGrid::T_TemplateDescriptor)
+    end
+
+    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
+                @descriptor = descriptor
+                @propertySet = propertySet
+            end
+
+            def hash
+                _h = 0
+                _h = 5 * _h + @template.hash
+                _h = 5 * _h + @parameterValues.hash
+                _h = 5 * _h + @descriptor.hash
+                _h = 5 * _h + @propertySet.hash
+                _h % 0x7fffffff
+            end
+
+            def ==(other)
+                return false if !other.is_a? ::IceGrid::ServiceInstanceDescriptor or
+                    @template != other.template or
+                    @parameterValues != other.parameterValues or
+                    @descriptor != other.descriptor or
+                    @propertySet != other.propertySet
+                true
+            end
+
+            def eql?(other)
+                return other.class == self.class && other == self
+            end
+
+            attr_accessor :template, :parameterValues, :descriptor, :propertySet
+        end
+
+        T_ServiceInstanceDescriptor = Ice::__defineStruct('::IceGrid::ServiceInstanceDescriptor', ServiceInstanceDescriptor, [
+            ["template", Ice::T_string],
+            ["parameterValues", ::IceGrid::T_StringStringDict],
+            ["descriptor", ::IceGrid::T_ServiceDescriptor],
+            ["propertySet", ::IceGrid::T_PropertySetDescriptor]
+        ])
+    end
+
+    if not defined?(::IceGrid::T_ServiceInstanceDescriptorSeq)
+        T_ServiceInstanceDescriptorSeq = Ice::__defineSequence('::IceGrid::ServiceInstanceDescriptorSeq', ::IceGrid::T_ServiceInstanceDescriptor)
+    end
+
+    if not defined?(::IceGrid::T_IceBoxDescriptor)
+        T_IceBoxDescriptor = Ice::__declareClass('::IceGrid::IceBoxDescriptor')
+    end
+
+    if not defined?(::IceGrid::IceBoxDescriptor)
+        class IceBoxDescriptor < ::IceGrid::ServerDescriptor
+
+            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
+
+            attr_accessor :services
+        end
+
+        T_IceBoxDescriptor.defineClass(IceBoxDescriptor, -1, 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
+                @servers = servers
+                @loadFactor = loadFactor
+                @description = description
+                @propertySets = propertySets
+            end
+
+            def hash
+                _h = 0
+                _h = 5 * _h + @variables.hash
+                _h = 5 * _h + @serverInstances.hash
+                _h = 5 * _h + @servers.hash
+                _h = 5 * _h + @loadFactor.hash
+                _h = 5 * _h + @description.hash
+                _h = 5 * _h + @propertySets.hash
+                _h % 0x7fffffff
+            end
+
+            def ==(other)
+                return false if !other.is_a? ::IceGrid::NodeDescriptor or
+                    @variables != other.variables or
+                    @serverInstances != other.serverInstances or
+                    @servers != other.servers or
+                    @loadFactor != other.loadFactor or
+                    @description != other.description or
+                    @propertySets != other.propertySets
+                true
+            end
+
+            def eql?(other)
+                return other.class == self.class && other == self
+            end
+
+            attr_accessor :variables, :serverInstances, :servers, :loadFactor, :description, :propertySets
+        end
+
+        T_NodeDescriptor = Ice::__defineStruct('::IceGrid::NodeDescriptor', NodeDescriptor, [
+            ["variables", ::IceGrid::T_StringStringDict],
+            ["serverInstances", ::IceGrid::T_ServerInstanceDescriptorSeq],
+            ["servers", ::IceGrid::T_ServerDescriptorSeq],
+            ["loadFactor", Ice::T_string],
+            ["description", Ice::T_string],
+            ["propertySets", ::IceGrid::T_PropertySetDescriptorDict]
+        ])
+    end
+
+    if not defined?(::IceGrid::T_NodeDescriptorDict)
+        T_NodeDescriptorDict = Ice::__defineDictionary('::IceGrid::NodeDescriptorDict', Ice::T_string, ::IceGrid::T_NodeDescriptor)
+    end
+
+    if not defined?(::IceGrid::T_LoadBalancingPolicy)
+        T_LoadBalancingPolicy = Ice::__declareClass('::IceGrid::LoadBalancingPolicy')
+    end
+
+    if not defined?(::IceGrid::LoadBalancingPolicy)
+        class LoadBalancingPolicy < Ice::Value
+
+            def initialize(nReplicas='')
+                @nReplicas = nReplicas
+            end
+
+            attr_accessor :nReplicas
+        end
+
+        T_LoadBalancingPolicy.defineClass(LoadBalancingPolicy, -1, false, nil, [['nReplicas', Ice::T_string, false, 0]])
+    end
+
+    if not defined?(::IceGrid::T_RandomLoadBalancingPolicy)
+        T_RandomLoadBalancingPolicy = Ice::__declareClass('::IceGrid::RandomLoadBalancingPolicy')
+    end
+
+    if not defined?(::IceGrid::RandomLoadBalancingPolicy)
+        class RandomLoadBalancingPolicy < ::IceGrid::LoadBalancingPolicy
+
+            def initialize(nReplicas='')
+                super(nReplicas)
+            end
+        end
+
+        T_RandomLoadBalancingPolicy.defineClass(RandomLoadBalancingPolicy, -1, false, ::IceGrid::T_LoadBalancingPolicy, [])
+    end
+
+    if not defined?(::IceGrid::T_OrderedLoadBalancingPolicy)
+        T_OrderedLoadBalancingPolicy = Ice::__declareClass('::IceGrid::OrderedLoadBalancingPolicy')
+    end
+
+    if not defined?(::IceGrid::OrderedLoadBalancingPolicy)
+        class OrderedLoadBalancingPolicy < ::IceGrid::LoadBalancingPolicy
+
+            def initialize(nReplicas='')
+                super(nReplicas)
+            end
+        end
+
+        T_OrderedLoadBalancingPolicy.defineClass(OrderedLoadBalancingPolicy, -1, false, ::IceGrid::T_LoadBalancingPolicy, [])
+    end
+
+    if not defined?(::IceGrid::T_RoundRobinLoadBalancingPolicy)
+        T_RoundRobinLoadBalancingPolicy = Ice::__declareClass('::IceGrid::RoundRobinLoadBalancingPolicy')
+    end
+
+    if not defined?(::IceGrid::RoundRobinLoadBalancingPolicy)
+        class RoundRobinLoadBalancingPolicy < ::IceGrid::LoadBalancingPolicy
+
+            def initialize(nReplicas='')
+                super(nReplicas)
+            end
+        end
+
+        T_RoundRobinLoadBalancingPolicy.defineClass(RoundRobinLoadBalancingPolicy, -1, false, ::IceGrid::T_LoadBalancingPolicy, [])
+    end
+
+    if not defined?(::IceGrid::T_AdaptiveLoadBalancingPolicy)
+        T_AdaptiveLoadBalancingPolicy = Ice::__declareClass('::IceGrid::AdaptiveLoadBalancingPolicy')
+    end
+
+    if not defined?(::IceGrid::AdaptiveLoadBalancingPolicy)
+        class AdaptiveLoadBalancingPolicy < ::IceGrid::LoadBalancingPolicy
+
+            def initialize(nReplicas='', loadSample='')
+                super(nReplicas)
+                @loadSample = loadSample
+            end
+
+            attr_accessor :loadSample
+        end
+
+        T_AdaptiveLoadBalancingPolicy.defineClass(AdaptiveLoadBalancingPolicy, -1, 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
+                @proxyOptions = proxyOptions
+                @objects = objects
+                @description = description
+                @filter = filter
+            end
+
+            def hash
+                _h = 0
+                _h = 5 * _h + @id.hash
+                _h = 5 * _h + @loadBalancing.hash
+                _h = 5 * _h + @proxyOptions.hash
+                _h = 5 * _h + @objects.hash
+                _h = 5 * _h + @description.hash
+                _h = 5 * _h + @filter.hash
+                _h % 0x7fffffff
+            end
+
+            def ==(other)
+                return false if !other.is_a? ::IceGrid::ReplicaGroupDescriptor or
+                    @id != other.id or
+                    @loadBalancing != other.loadBalancing or
+                    @proxyOptions != other.proxyOptions or
+                    @objects != other.objects or
+                    @description != other.description or
+                    @filter != other.filter
+                true
+            end
+
+            def eql?(other)
+                return other.class == self.class && other == self
+            end
+
+            attr_accessor :id, :loadBalancing, :proxyOptions, :objects, :description, :filter
+        end
+
+        T_ReplicaGroupDescriptor = Ice::__defineStruct('::IceGrid::ReplicaGroupDescriptor', ReplicaGroupDescriptor, [
+            ["id", Ice::T_string],
+            ["loadBalancing", ::IceGrid::T_LoadBalancingPolicy],
+            ["proxyOptions", Ice::T_string],
+            ["objects", ::IceGrid::T_ObjectDescriptorSeq],
+            ["description", Ice::T_string],
+            ["filter", Ice::T_string]
+        ])
+    end
+
+    if not defined?(::IceGrid::T_ReplicaGroupDescriptorSeq)
+        T_ReplicaGroupDescriptorSeq = Ice::__defineSequence('::IceGrid::ReplicaGroupDescriptorSeq', ::IceGrid::T_ReplicaGroupDescriptor)
+    end
+
+    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
+                @replicaGroups = replicaGroups
+                @serverTemplates = serverTemplates
+                @serviceTemplates = serviceTemplates
+                @nodes = nodes
+                @distrib = distrib
+                @description = description
+                @propertySets = propertySets
+            end
+
+            def hash
+                _h = 0
+                _h = 5 * _h + @name.hash
+                _h = 5 * _h + @variables.hash
+                _h = 5 * _h + @replicaGroups.hash
+                _h = 5 * _h + @serverTemplates.hash
+                _h = 5 * _h + @serviceTemplates.hash
+                _h = 5 * _h + @nodes.hash
+                _h = 5 * _h + @distrib.hash
+                _h = 5 * _h + @description.hash
+                _h = 5 * _h + @propertySets.hash
+                _h % 0x7fffffff
+            end
+
+            def ==(other)
+                return false if !other.is_a? ::IceGrid::ApplicationDescriptor or
+                    @name != other.name or
+                    @variables != other.variables or
+                    @replicaGroups != other.replicaGroups or
+                    @serverTemplates != other.serverTemplates or
+                    @serviceTemplates != other.serviceTemplates or
+                    @nodes != other.nodes or
+                    @distrib != other.distrib or
+                    @description != other.description or
+                    @propertySets != other.propertySets
+                true
+            end
+
+            def eql?(other)
+                return other.class == self.class && other == self
+            end
+
+            attr_accessor :name, :variables, :replicaGroups, :serverTemplates, :serviceTemplates, :nodes, :distrib, :description, :propertySets
+        end
+
+        T_ApplicationDescriptor = Ice::__defineStruct('::IceGrid::ApplicationDescriptor', ApplicationDescriptor, [
+            ["name", Ice::T_string],
+            ["variables", ::IceGrid::T_StringStringDict],
+            ["replicaGroups", ::IceGrid::T_ReplicaGroupDescriptorSeq],
+            ["serverTemplates", ::IceGrid::T_TemplateDescriptorDict],
+            ["serviceTemplates", ::IceGrid::T_TemplateDescriptorDict],
+            ["nodes", ::IceGrid::T_NodeDescriptorDict],
+            ["distrib", ::IceGrid::T_DistributionDescriptor],
+            ["description", Ice::T_string],
+            ["propertySets", ::IceGrid::T_PropertySetDescriptorDict]
+        ])
+    end
+
+    if not defined?(::IceGrid::T_ApplicationDescriptorSeq)
+        T_ApplicationDescriptorSeq = Ice::__defineSequence('::IceGrid::ApplicationDescriptorSeq', ::IceGrid::T_ApplicationDescriptor)
+    end
+
+    if not defined?(::IceGrid::T_BoxedString)
+        T_BoxedString = Ice::__declareClass('::IceGrid::BoxedString')
+    end
+
+    if not defined?(::IceGrid::BoxedString)
+        class BoxedString < Ice::Value
+
+            def initialize(value='')
+                @value = value
+            end
+
+            attr_accessor :value
+        end
+
+        T_BoxedString.defineClass(BoxedString, -1, 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
+                @variables = variables
+                @removeVariables = removeVariables
+                @propertySets = propertySets
+                @removePropertySets = removePropertySets
+                @serverInstances = serverInstances
+                @servers = servers
+                @removeServers = removeServers
+                @loadFactor = loadFactor
+            end
+
+            def hash
+                _h = 0
+                _h = 5 * _h + @name.hash
+                _h = 5 * _h + @description.hash
+                _h = 5 * _h + @variables.hash
+                _h = 5 * _h + @removeVariables.hash
+                _h = 5 * _h + @propertySets.hash
+                _h = 5 * _h + @removePropertySets.hash
+                _h = 5 * _h + @serverInstances.hash
+                _h = 5 * _h + @servers.hash
+                _h = 5 * _h + @removeServers.hash
+                _h = 5 * _h + @loadFactor.hash
+                _h % 0x7fffffff
+            end
+
+            def ==(other)
+                return false if !other.is_a? ::IceGrid::NodeUpdateDescriptor or
+                    @name != other.name or
+                    @description != other.description or
+                    @variables != other.variables or
+                    @removeVariables != other.removeVariables or
+                    @propertySets != other.propertySets or
+                    @removePropertySets != other.removePropertySets or
+                    @serverInstances != other.serverInstances or
+                    @servers != other.servers or
+                    @removeServers != other.removeServers or
+                    @loadFactor != other.loadFactor
+                true
+            end
+
+            def eql?(other)
+                return other.class == self.class && other == self
+            end
+
+            attr_accessor :name, :description, :variables, :removeVariables, :propertySets, :removePropertySets, :serverInstances, :servers, :removeServers, :loadFactor
+        end
+
+        T_NodeUpdateDescriptor = Ice::__defineStruct('::IceGrid::NodeUpdateDescriptor', NodeUpdateDescriptor, [
+            ["name", Ice::T_string],
+            ["description", ::IceGrid::T_BoxedString],
+            ["variables", ::IceGrid::T_StringStringDict],
+            ["removeVariables", ::Ice::T_StringSeq],
+            ["propertySets", ::IceGrid::T_PropertySetDescriptorDict],
+            ["removePropertySets", ::Ice::T_StringSeq],
+            ["serverInstances", ::IceGrid::T_ServerInstanceDescriptorSeq],
+            ["servers", ::IceGrid::T_ServerDescriptorSeq],
+            ["removeServers", ::Ice::T_StringSeq],
+            ["loadFactor", ::IceGrid::T_BoxedString]
+        ])
+    end
+
+    if not defined?(::IceGrid::T_NodeUpdateDescriptorSeq)
+        T_NodeUpdateDescriptorSeq = Ice::__defineSequence('::IceGrid::NodeUpdateDescriptorSeq', ::IceGrid::T_NodeUpdateDescriptor)
+    end
+
+    if not defined?(::IceGrid::T_BoxedDistributionDescriptor)
+        T_BoxedDistributionDescriptor = Ice::__declareClass('::IceGrid::BoxedDistributionDescriptor')
+    end
+
+    if not defined?(::IceGrid::BoxedDistributionDescriptor)
+        class BoxedDistributionDescriptor < Ice::Value
+
+            def initialize(value=::IceGrid::DistributionDescriptor.new)
+                @value = value
+            end
+
+            attr_accessor :value
+        end
+
+        T_BoxedDistributionDescriptor.defineClass(BoxedDistributionDescriptor, -1, 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
+                @distrib = distrib
+                @variables = variables
+                @removeVariables = removeVariables
+                @propertySets = propertySets
+                @removePropertySets = removePropertySets
+                @replicaGroups = replicaGroups
+                @removeReplicaGroups = removeReplicaGroups
+                @serverTemplates = serverTemplates
+                @removeServerTemplates = removeServerTemplates
+                @serviceTemplates = serviceTemplates
+                @removeServiceTemplates = removeServiceTemplates
+                @nodes = nodes
+                @removeNodes = removeNodes
+            end
+
+            def hash
+                _h = 0
+                _h = 5 * _h + @name.hash
+                _h = 5 * _h + @description.hash
+                _h = 5 * _h + @distrib.hash
+                _h = 5 * _h + @variables.hash
+                _h = 5 * _h + @removeVariables.hash
+                _h = 5 * _h + @propertySets.hash
+                _h = 5 * _h + @removePropertySets.hash
+                _h = 5 * _h + @replicaGroups.hash
+                _h = 5 * _h + @removeReplicaGroups.hash
+                _h = 5 * _h + @serverTemplates.hash
+                _h = 5 * _h + @removeServerTemplates.hash
+                _h = 5 * _h + @serviceTemplates.hash
+                _h = 5 * _h + @removeServiceTemplates.hash
+                _h = 5 * _h + @nodes.hash
+                _h = 5 * _h + @removeNodes.hash
+                _h % 0x7fffffff
+            end
+
+            def ==(other)
+                return false if !other.is_a? ::IceGrid::ApplicationUpdateDescriptor or
+                    @name != other.name or
+                    @description != other.description or
+                    @distrib != other.distrib or
+                    @variables != other.variables or
+                    @removeVariables != other.removeVariables or
+                    @propertySets != other.propertySets or
+                    @removePropertySets != other.removePropertySets or
+                    @replicaGroups != other.replicaGroups or
+                    @removeReplicaGroups != other.removeReplicaGroups or
+                    @serverTemplates != other.serverTemplates or
+                    @removeServerTemplates != other.removeServerTemplates or
+                    @serviceTemplates != other.serviceTemplates or
+                    @removeServiceTemplates != other.removeServiceTemplates or
+                    @nodes != other.nodes or
+                    @removeNodes != other.removeNodes
+                true
+            end
+
+            def eql?(other)
+                return other.class == self.class && other == self
+            end
+
+            attr_accessor :name, :description, :distrib, :variables, :removeVariables, :propertySets, :removePropertySets, :replicaGroups, :removeReplicaGroups, :serverTemplates, :removeServerTemplates, :serviceTemplates, :removeServiceTemplates, :nodes, :removeNodes
+        end
+
+        T_ApplicationUpdateDescriptor = Ice::__defineStruct('::IceGrid::ApplicationUpdateDescriptor', ApplicationUpdateDescriptor, [
+            ["name", Ice::T_string],
+            ["description", ::IceGrid::T_BoxedString],
+            ["distrib", ::IceGrid::T_BoxedDistributionDescriptor],
+            ["variables", ::IceGrid::T_StringStringDict],
+            ["removeVariables", ::Ice::T_StringSeq],
+            ["propertySets", ::IceGrid::T_PropertySetDescriptorDict],
+            ["removePropertySets", ::Ice::T_StringSeq],
+            ["replicaGroups", ::IceGrid::T_ReplicaGroupDescriptorSeq],
+            ["removeReplicaGroups", ::Ice::T_StringSeq],
+            ["serverTemplates", ::IceGrid::T_TemplateDescriptorDict],
+            ["removeServerTemplates", ::Ice::T_StringSeq],
+            ["serviceTemplates", ::IceGrid::T_TemplateDescriptorDict],
+            ["removeServiceTemplates", ::Ice::T_StringSeq],
+            ["nodes", ::IceGrid::T_NodeUpdateDescriptorSeq],
+            ["removeNodes", ::Ice::T_StringSeq]
+        ])
+    end
+end