# **********************************************************************
#
# Copyright (c) 2003-2015 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.0
#
# <auto-generated>
#
# Generated from file `Descriptor.ice'
#
# Warning: do not edit this file.
#
# </auto-generated>
#

import Ice, IcePy
import Ice_Identity_ice
import Ice_BuiltinSequences_ice

# Included module Ice
_M_Ice = Ice.openModule('Ice')

# Start of module IceGrid
_M_IceGrid = Ice.openModule('IceGrid')
__name__ = 'IceGrid'

if '_t_StringStringDict' not in _M_IceGrid.__dict__:
    _M_IceGrid._t_StringStringDict = IcePy.defineDictionary('::IceGrid::StringStringDict', (), IcePy._t_string, IcePy._t_string)

if 'PropertyDescriptor' not in _M_IceGrid.__dict__:
    _M_IceGrid.PropertyDescriptor = Ice.createTempClass()
    class PropertyDescriptor(object):
        '''Property descriptor.'''
        def __init__(self, name='', value=''):
            self.name = name
            self.value = value

        def __hash__(self):
            _h = 0
            _h = 5 * _h + Ice.getHash(self.name)
            _h = 5 * _h + Ice.getHash(self.value)
            return _h % 0x7fffffff

        def __compare(self, other):
            if other is None:
                return 1
            elif not isinstance(other, _M_IceGrid.PropertyDescriptor):
                return NotImplemented
            else:
                if self.name is None or other.name is None:
                    if self.name != other.name:
                        return (-1 if self.name is None else 1)
                else:
                    if self.name < other.name:
                        return -1
                    elif self.name > other.name:
                        return 1
                if self.value is None or other.value is None:
                    if self.value != other.value:
                        return (-1 if self.value is None else 1)
                else:
                    if self.value < other.value:
                        return -1
                    elif self.value > other.value:
                        return 1
                return 0

        def __lt__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r < 0

        def __le__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r <= 0

        def __gt__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r > 0

        def __ge__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r >= 0

        def __eq__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r == 0

        def __ne__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r != 0

        def __str__(self):
            return IcePy.stringify(self, _M_IceGrid._t_PropertyDescriptor)

        __repr__ = __str__

    _M_IceGrid._t_PropertyDescriptor = IcePy.defineStruct('::IceGrid::PropertyDescriptor', PropertyDescriptor, (), (
        ('name', (), IcePy._t_string),
        ('value', (), IcePy._t_string)
    ))

    _M_IceGrid.PropertyDescriptor = PropertyDescriptor
    del PropertyDescriptor

if '_t_PropertyDescriptorSeq' not in _M_IceGrid.__dict__:
    _M_IceGrid._t_PropertyDescriptorSeq = IcePy.defineSequence('::IceGrid::PropertyDescriptorSeq', (), _M_IceGrid._t_PropertyDescriptor)

if 'PropertySetDescriptor' not in _M_IceGrid.__dict__:
    _M_IceGrid.PropertySetDescriptor = Ice.createTempClass()
    class PropertySetDescriptor(object):
        '''A property set descriptor.'''
        def __init__(self, references=None, properties=None):
            self.references = references
            self.properties = properties

        def __hash__(self):
            _h = 0
            if self.references:
                for _i0 in self.references:
                    _h = 5 * _h + Ice.getHash(_i0)
            if self.properties:
                for _i1 in self.properties:
                    _h = 5 * _h + Ice.getHash(_i1)
            return _h % 0x7fffffff

        def __compare(self, other):
            if other is None:
                return 1
            elif not isinstance(other, _M_IceGrid.PropertySetDescriptor):
                return NotImplemented
            else:
                if self.references is None or other.references is None:
                    if self.references != other.references:
                        return (-1 if self.references is None else 1)
                else:
                    if self.references < other.references:
                        return -1
                    elif self.references > other.references:
                        return 1
                if self.properties is None or other.properties is None:
                    if self.properties != other.properties:
                        return (-1 if self.properties is None else 1)
                else:
                    if self.properties < other.properties:
                        return -1
                    elif self.properties > other.properties:
                        return 1
                return 0

        def __lt__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r < 0

        def __le__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r <= 0

        def __gt__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r > 0

        def __ge__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r >= 0

        def __eq__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r == 0

        def __ne__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r != 0

        def __str__(self):
            return IcePy.stringify(self, _M_IceGrid._t_PropertySetDescriptor)

        __repr__ = __str__

    _M_IceGrid._t_PropertySetDescriptor = IcePy.defineStruct('::IceGrid::PropertySetDescriptor', PropertySetDescriptor, (), (
        ('references', (), _M_Ice._t_StringSeq),
        ('properties', (), _M_IceGrid._t_PropertyDescriptorSeq)
    ))

    _M_IceGrid.PropertySetDescriptor = PropertySetDescriptor
    del PropertySetDescriptor

if '_t_PropertySetDescriptorDict' not in _M_IceGrid.__dict__:
    _M_IceGrid._t_PropertySetDescriptorDict = IcePy.defineDictionary('::IceGrid::PropertySetDescriptorDict', (), IcePy._t_string, _M_IceGrid._t_PropertySetDescriptor)

if 'ObjectDescriptor' not in _M_IceGrid.__dict__:
    _M_IceGrid.ObjectDescriptor = Ice.createTempClass()
    class ObjectDescriptor(object):
        '''An Ice object descriptor.'''
        def __init__(self, id=Ice._struct_marker, type='', proxyOptions=''):
            if id is Ice._struct_marker:
                self.id = _M_Ice.Identity()
            else:
                self.id = id
            self.type = type
            self.proxyOptions = proxyOptions

        def __hash__(self):
            _h = 0
            _h = 5 * _h + Ice.getHash(self.id)
            _h = 5 * _h + Ice.getHash(self.type)
            _h = 5 * _h + Ice.getHash(self.proxyOptions)
            return _h % 0x7fffffff

        def __compare(self, other):
            if other is None:
                return 1
            elif not isinstance(other, _M_IceGrid.ObjectDescriptor):
                return NotImplemented
            else:
                if self.id is None or other.id is None:
                    if self.id != other.id:
                        return (-1 if self.id is None else 1)
                else:
                    if self.id < other.id:
                        return -1
                    elif self.id > other.id:
                        return 1
                if self.type is None or other.type is None:
                    if self.type != other.type:
                        return (-1 if self.type is None else 1)
                else:
                    if self.type < other.type:
                        return -1
                    elif self.type > other.type:
                        return 1
                if self.proxyOptions is None or other.proxyOptions is None:
                    if self.proxyOptions != other.proxyOptions:
                        return (-1 if self.proxyOptions is None else 1)
                else:
                    if self.proxyOptions < other.proxyOptions:
                        return -1
                    elif self.proxyOptions > other.proxyOptions:
                        return 1
                return 0

        def __lt__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r < 0

        def __le__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r <= 0

        def __gt__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r > 0

        def __ge__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r >= 0

        def __eq__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r == 0

        def __ne__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r != 0

        def __str__(self):
            return IcePy.stringify(self, _M_IceGrid._t_ObjectDescriptor)

        __repr__ = __str__

    _M_IceGrid._t_ObjectDescriptor = IcePy.defineStruct('::IceGrid::ObjectDescriptor', ObjectDescriptor, (), (
        ('id', (), _M_Ice._t_Identity),
        ('type', (), IcePy._t_string),
        ('proxyOptions', (), IcePy._t_string)
    ))

    _M_IceGrid.ObjectDescriptor = ObjectDescriptor
    del ObjectDescriptor

if '_t_ObjectDescriptorSeq' not in _M_IceGrid.__dict__:
    _M_IceGrid._t_ObjectDescriptorSeq = IcePy.defineSequence('::IceGrid::ObjectDescriptorSeq', (), _M_IceGrid._t_ObjectDescriptor)

if 'AdapterDescriptor' not in _M_IceGrid.__dict__:
    _M_IceGrid.AdapterDescriptor = Ice.createTempClass()
    class AdapterDescriptor(object):
        '''An Ice object adapter descriptor.'''
        def __init__(self, name='', description='', id='', replicaGroupId='', priority='', registerProcess=False, serverLifetime=False, objects=None, allocatables=None):
            self.name = name
            self.description = description
            self.id = id
            self.replicaGroupId = replicaGroupId
            self.priority = priority
            self.registerProcess = registerProcess
            self.serverLifetime = serverLifetime
            self.objects = objects
            self.allocatables = allocatables

        def __hash__(self):
            _h = 0
            _h = 5 * _h + Ice.getHash(self.name)
            _h = 5 * _h + Ice.getHash(self.description)
            _h = 5 * _h + Ice.getHash(self.id)
            _h = 5 * _h + Ice.getHash(self.replicaGroupId)
            _h = 5 * _h + Ice.getHash(self.priority)
            _h = 5 * _h + Ice.getHash(self.registerProcess)
            _h = 5 * _h + Ice.getHash(self.serverLifetime)
            if self.objects:
                for _i0 in self.objects:
                    _h = 5 * _h + Ice.getHash(_i0)
            if self.allocatables:
                for _i1 in self.allocatables:
                    _h = 5 * _h + Ice.getHash(_i1)
            return _h % 0x7fffffff

        def __compare(self, other):
            if other is None:
                return 1
            elif not isinstance(other, _M_IceGrid.AdapterDescriptor):
                return NotImplemented
            else:
                if self.name is None or other.name is None:
                    if self.name != other.name:
                        return (-1 if self.name is None else 1)
                else:
                    if self.name < other.name:
                        return -1
                    elif self.name > other.name:
                        return 1
                if self.description is None or other.description is None:
                    if self.description != other.description:
                        return (-1 if self.description is None else 1)
                else:
                    if self.description < other.description:
                        return -1
                    elif self.description > other.description:
                        return 1
                if self.id is None or other.id is None:
                    if self.id != other.id:
                        return (-1 if self.id is None else 1)
                else:
                    if self.id < other.id:
                        return -1
                    elif self.id > other.id:
                        return 1
                if self.replicaGroupId is None or other.replicaGroupId is None:
                    if self.replicaGroupId != other.replicaGroupId:
                        return (-1 if self.replicaGroupId is None else 1)
                else:
                    if self.replicaGroupId < other.replicaGroupId:
                        return -1
                    elif self.replicaGroupId > other.replicaGroupId:
                        return 1
                if self.priority is None or other.priority is None:
                    if self.priority != other.priority:
                        return (-1 if self.priority is None else 1)
                else:
                    if self.priority < other.priority:
                        return -1
                    elif self.priority > other.priority:
                        return 1
                if self.registerProcess is None or other.registerProcess is None:
                    if self.registerProcess != other.registerProcess:
                        return (-1 if self.registerProcess is None else 1)
                else:
                    if self.registerProcess < other.registerProcess:
                        return -1
                    elif self.registerProcess > other.registerProcess:
                        return 1
                if self.serverLifetime is None or other.serverLifetime is None:
                    if self.serverLifetime != other.serverLifetime:
                        return (-1 if self.serverLifetime is None else 1)
                else:
                    if self.serverLifetime < other.serverLifetime:
                        return -1
                    elif self.serverLifetime > other.serverLifetime:
                        return 1
                if self.objects is None or other.objects is None:
                    if self.objects != other.objects:
                        return (-1 if self.objects is None else 1)
                else:
                    if self.objects < other.objects:
                        return -1
                    elif self.objects > other.objects:
                        return 1
                if self.allocatables is None or other.allocatables is None:
                    if self.allocatables != other.allocatables:
                        return (-1 if self.allocatables is None else 1)
                else:
                    if self.allocatables < other.allocatables:
                        return -1
                    elif self.allocatables > other.allocatables:
                        return 1
                return 0

        def __lt__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r < 0

        def __le__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r <= 0

        def __gt__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r > 0

        def __ge__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r >= 0

        def __eq__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r == 0

        def __ne__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r != 0

        def __str__(self):
            return IcePy.stringify(self, _M_IceGrid._t_AdapterDescriptor)

        __repr__ = __str__

    _M_IceGrid._t_AdapterDescriptor = IcePy.defineStruct('::IceGrid::AdapterDescriptor', AdapterDescriptor, (), (
        ('name', (), IcePy._t_string),
        ('description', (), IcePy._t_string),
        ('id', (), IcePy._t_string),
        ('replicaGroupId', (), IcePy._t_string),
        ('priority', (), IcePy._t_string),
        ('registerProcess', (), IcePy._t_bool),
        ('serverLifetime', (), IcePy._t_bool),
        ('objects', (), _M_IceGrid._t_ObjectDescriptorSeq),
        ('allocatables', (), _M_IceGrid._t_ObjectDescriptorSeq)
    ))

    _M_IceGrid.AdapterDescriptor = AdapterDescriptor
    del AdapterDescriptor

if '_t_AdapterDescriptorSeq' not in _M_IceGrid.__dict__:
    _M_IceGrid._t_AdapterDescriptorSeq = IcePy.defineSequence('::IceGrid::AdapterDescriptorSeq', (), _M_IceGrid._t_AdapterDescriptor)

if 'DbEnvDescriptor' not in _M_IceGrid.__dict__:
    _M_IceGrid.DbEnvDescriptor = Ice.createTempClass()
    class DbEnvDescriptor(object):
        '''A Freeze database environment descriptor.'''
        def __init__(self, name='', description='', dbHome='', properties=None):
            self.name = name
            self.description = description
            self.dbHome = dbHome
            self.properties = properties

        def __hash__(self):
            _h = 0
            _h = 5 * _h + Ice.getHash(self.name)
            _h = 5 * _h + Ice.getHash(self.description)
            _h = 5 * _h + Ice.getHash(self.dbHome)
            if self.properties:
                for _i0 in self.properties:
                    _h = 5 * _h + Ice.getHash(_i0)
            return _h % 0x7fffffff

        def __compare(self, other):
            if other is None:
                return 1
            elif not isinstance(other, _M_IceGrid.DbEnvDescriptor):
                return NotImplemented
            else:
                if self.name is None or other.name is None:
                    if self.name != other.name:
                        return (-1 if self.name is None else 1)
                else:
                    if self.name < other.name:
                        return -1
                    elif self.name > other.name:
                        return 1
                if self.description is None or other.description is None:
                    if self.description != other.description:
                        return (-1 if self.description is None else 1)
                else:
                    if self.description < other.description:
                        return -1
                    elif self.description > other.description:
                        return 1
                if self.dbHome is None or other.dbHome is None:
                    if self.dbHome != other.dbHome:
                        return (-1 if self.dbHome is None else 1)
                else:
                    if self.dbHome < other.dbHome:
                        return -1
                    elif self.dbHome > other.dbHome:
                        return 1
                if self.properties is None or other.properties is None:
                    if self.properties != other.properties:
                        return (-1 if self.properties is None else 1)
                else:
                    if self.properties < other.properties:
                        return -1
                    elif self.properties > other.properties:
                        return 1
                return 0

        def __lt__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r < 0

        def __le__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r <= 0

        def __gt__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r > 0

        def __ge__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r >= 0

        def __eq__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r == 0

        def __ne__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r != 0

        def __str__(self):
            return IcePy.stringify(self, _M_IceGrid._t_DbEnvDescriptor)

        __repr__ = __str__

    _M_IceGrid._t_DbEnvDescriptor = IcePy.defineStruct('::IceGrid::DbEnvDescriptor', DbEnvDescriptor, (), (
        ('name', (), IcePy._t_string),
        ('description', (), IcePy._t_string),
        ('dbHome', (), IcePy._t_string),
        ('properties', (), _M_IceGrid._t_PropertyDescriptorSeq)
    ))

    _M_IceGrid.DbEnvDescriptor = DbEnvDescriptor
    del DbEnvDescriptor

if '_t_DbEnvDescriptorSeq' not in _M_IceGrid.__dict__:
    _M_IceGrid._t_DbEnvDescriptorSeq = IcePy.defineSequence('::IceGrid::DbEnvDescriptorSeq', (), _M_IceGrid._t_DbEnvDescriptor)

if 'CommunicatorDescriptor' not in _M_IceGrid.__dict__:
    _M_IceGrid.CommunicatorDescriptor = Ice.createTempClass()
    class CommunicatorDescriptor(Ice.Object):
        '''A communicator descriptor.'''
        def __init__(self, adapters=None, propertySet=Ice._struct_marker, dbEnvs=None, logs=None, description=''):
            self.adapters = adapters
            if propertySet is Ice._struct_marker:
                self.propertySet = _M_IceGrid.PropertySetDescriptor()
            else:
                self.propertySet = propertySet
            self.dbEnvs = dbEnvs
            self.logs = logs
            self.description = description

        def ice_ids(self, current=None):
            return ('::Ice::Object', '::IceGrid::CommunicatorDescriptor')

        def ice_id(self, current=None):
            return '::IceGrid::CommunicatorDescriptor'

        def ice_staticId():
            return '::IceGrid::CommunicatorDescriptor'
        ice_staticId = staticmethod(ice_staticId)

        def __str__(self):
            return IcePy.stringify(self, _M_IceGrid._t_CommunicatorDescriptor)

        __repr__ = __str__

    _M_IceGrid.CommunicatorDescriptorPrx = Ice.createTempClass()
    class CommunicatorDescriptorPrx(Ice.ObjectPrx):

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_IceGrid.CommunicatorDescriptorPrx.ice_checkedCast(proxy, '::IceGrid::CommunicatorDescriptor', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_IceGrid.CommunicatorDescriptorPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

        def ice_staticId():
            return '::IceGrid::CommunicatorDescriptor'
        ice_staticId = staticmethod(ice_staticId)

    _M_IceGrid._t_CommunicatorDescriptorPrx = IcePy.defineProxy('::IceGrid::CommunicatorDescriptor', CommunicatorDescriptorPrx)

    _M_IceGrid._t_CommunicatorDescriptor = IcePy.defineClass('::IceGrid::CommunicatorDescriptor', CommunicatorDescriptor, -1, (), False, False, None, (), (
        ('adapters', (), _M_IceGrid._t_AdapterDescriptorSeq, False, 0),
        ('propertySet', (), _M_IceGrid._t_PropertySetDescriptor, False, 0),
        ('dbEnvs', (), _M_IceGrid._t_DbEnvDescriptorSeq, False, 0),
        ('logs', (), _M_Ice._t_StringSeq, False, 0),
        ('description', (), IcePy._t_string, False, 0)
    ))
    CommunicatorDescriptor._ice_type = _M_IceGrid._t_CommunicatorDescriptor

    _M_IceGrid.CommunicatorDescriptor = CommunicatorDescriptor
    del CommunicatorDescriptor

    _M_IceGrid.CommunicatorDescriptorPrx = CommunicatorDescriptorPrx
    del CommunicatorDescriptorPrx

if 'DistributionDescriptor' not in _M_IceGrid.__dict__:
    _M_IceGrid.DistributionDescriptor = Ice.createTempClass()
    class DistributionDescriptor(object):
        '''A distribution descriptor defines an IcePatch2 server and the
directories to retrieve from the patch server.'''
        def __init__(self, icepatch='', directories=None):
            self.icepatch = icepatch
            self.directories = directories

        def __hash__(self):
            _h = 0
            _h = 5 * _h + Ice.getHash(self.icepatch)
            if self.directories:
                for _i0 in self.directories:
                    _h = 5 * _h + Ice.getHash(_i0)
            return _h % 0x7fffffff

        def __compare(self, other):
            if other is None:
                return 1
            elif not isinstance(other, _M_IceGrid.DistributionDescriptor):
                return NotImplemented
            else:
                if self.icepatch is None or other.icepatch is None:
                    if self.icepatch != other.icepatch:
                        return (-1 if self.icepatch is None else 1)
                else:
                    if self.icepatch < other.icepatch:
                        return -1
                    elif self.icepatch > other.icepatch:
                        return 1
                if self.directories is None or other.directories is None:
                    if self.directories != other.directories:
                        return (-1 if self.directories is None else 1)
                else:
                    if self.directories < other.directories:
                        return -1
                    elif self.directories > other.directories:
                        return 1
                return 0

        def __lt__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r < 0

        def __le__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r <= 0

        def __gt__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r > 0

        def __ge__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r >= 0

        def __eq__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r == 0

        def __ne__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r != 0

        def __str__(self):
            return IcePy.stringify(self, _M_IceGrid._t_DistributionDescriptor)

        __repr__ = __str__

    _M_IceGrid._t_DistributionDescriptor = IcePy.defineStruct('::IceGrid::DistributionDescriptor', DistributionDescriptor, (), (
        ('icepatch', (), IcePy._t_string),
        ('directories', (), _M_Ice._t_StringSeq)
    ))

    _M_IceGrid.DistributionDescriptor = DistributionDescriptor
    del DistributionDescriptor

if 'ServerDescriptor' not in _M_IceGrid.__dict__:
    _M_IceGrid.ServerDescriptor = Ice.createTempClass()
    class ServerDescriptor(_M_IceGrid.CommunicatorDescriptor):
        '''An Ice server descriptor.'''
        def __init__(self, adapters=None, propertySet=Ice._struct_marker, dbEnvs=None, logs=None, description='', id='', exe='', iceVersion='', pwd='', options=None, envs=None, activation='', activationTimeout='', deactivationTimeout='', applicationDistrib=False, distrib=Ice._struct_marker, allocatable=False, user=''):
            _M_IceGrid.CommunicatorDescriptor.__init__(self, adapters, propertySet, dbEnvs, logs, description)
            self.id = id
            self.exe = exe
            self.iceVersion = iceVersion
            self.pwd = pwd
            self.options = options
            self.envs = envs
            self.activation = activation
            self.activationTimeout = activationTimeout
            self.deactivationTimeout = deactivationTimeout
            self.applicationDistrib = applicationDistrib
            if distrib is Ice._struct_marker:
                self.distrib = _M_IceGrid.DistributionDescriptor()
            else:
                self.distrib = distrib
            self.allocatable = allocatable
            self.user = user

        def ice_ids(self, current=None):
            return ('::Ice::Object', '::IceGrid::CommunicatorDescriptor', '::IceGrid::ServerDescriptor')

        def ice_id(self, current=None):
            return '::IceGrid::ServerDescriptor'

        def ice_staticId():
            return '::IceGrid::ServerDescriptor'
        ice_staticId = staticmethod(ice_staticId)

        def __str__(self):
            return IcePy.stringify(self, _M_IceGrid._t_ServerDescriptor)

        __repr__ = __str__

    _M_IceGrid.ServerDescriptorPrx = Ice.createTempClass()
    class ServerDescriptorPrx(_M_IceGrid.CommunicatorDescriptorPrx):

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_IceGrid.ServerDescriptorPrx.ice_checkedCast(proxy, '::IceGrid::ServerDescriptor', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_IceGrid.ServerDescriptorPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

        def ice_staticId():
            return '::IceGrid::ServerDescriptor'
        ice_staticId = staticmethod(ice_staticId)

    _M_IceGrid._t_ServerDescriptorPrx = IcePy.defineProxy('::IceGrid::ServerDescriptor', ServerDescriptorPrx)

    _M_IceGrid._t_ServerDescriptor = IcePy.defineClass('::IceGrid::ServerDescriptor', ServerDescriptor, -1, (), False, False, _M_IceGrid._t_CommunicatorDescriptor, (), (
        ('id', (), IcePy._t_string, False, 0),
        ('exe', (), IcePy._t_string, False, 0),
        ('iceVersion', (), IcePy._t_string, False, 0),
        ('pwd', (), IcePy._t_string, False, 0),
        ('options', (), _M_Ice._t_StringSeq, False, 0),
        ('envs', (), _M_Ice._t_StringSeq, False, 0),
        ('activation', (), IcePy._t_string, False, 0),
        ('activationTimeout', (), IcePy._t_string, False, 0),
        ('deactivationTimeout', (), IcePy._t_string, False, 0),
        ('applicationDistrib', (), IcePy._t_bool, False, 0),
        ('distrib', (), _M_IceGrid._t_DistributionDescriptor, False, 0),
        ('allocatable', (), IcePy._t_bool, False, 0),
        ('user', (), IcePy._t_string, False, 0)
    ))
    ServerDescriptor._ice_type = _M_IceGrid._t_ServerDescriptor

    _M_IceGrid.ServerDescriptor = ServerDescriptor
    del ServerDescriptor

    _M_IceGrid.ServerDescriptorPrx = ServerDescriptorPrx
    del ServerDescriptorPrx

if '_t_ServerDescriptorSeq' not in _M_IceGrid.__dict__:
    _M_IceGrid._t_ServerDescriptorSeq = IcePy.defineSequence('::IceGrid::ServerDescriptorSeq', (), _M_IceGrid._t_ServerDescriptor)

if 'ServiceDescriptor' not in _M_IceGrid.__dict__:
    _M_IceGrid.ServiceDescriptor = Ice.createTempClass()
    class ServiceDescriptor(_M_IceGrid.CommunicatorDescriptor):
        '''An IceBox service descriptor.'''
        def __init__(self, adapters=None, propertySet=Ice._struct_marker, dbEnvs=None, logs=None, description='', name='', entry=''):
            _M_IceGrid.CommunicatorDescriptor.__init__(self, adapters, propertySet, dbEnvs, logs, description)
            self.name = name
            self.entry = entry

        def ice_ids(self, current=None):
            return ('::Ice::Object', '::IceGrid::CommunicatorDescriptor', '::IceGrid::ServiceDescriptor')

        def ice_id(self, current=None):
            return '::IceGrid::ServiceDescriptor'

        def ice_staticId():
            return '::IceGrid::ServiceDescriptor'
        ice_staticId = staticmethod(ice_staticId)

        def __str__(self):
            return IcePy.stringify(self, _M_IceGrid._t_ServiceDescriptor)

        __repr__ = __str__

    _M_IceGrid.ServiceDescriptorPrx = Ice.createTempClass()
    class ServiceDescriptorPrx(_M_IceGrid.CommunicatorDescriptorPrx):

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_IceGrid.ServiceDescriptorPrx.ice_checkedCast(proxy, '::IceGrid::ServiceDescriptor', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_IceGrid.ServiceDescriptorPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

        def ice_staticId():
            return '::IceGrid::ServiceDescriptor'
        ice_staticId = staticmethod(ice_staticId)

    _M_IceGrid._t_ServiceDescriptorPrx = IcePy.defineProxy('::IceGrid::ServiceDescriptor', ServiceDescriptorPrx)

    _M_IceGrid._t_ServiceDescriptor = IcePy.defineClass('::IceGrid::ServiceDescriptor', ServiceDescriptor, -1, (), False, False, _M_IceGrid._t_CommunicatorDescriptor, (), (
        ('name', (), IcePy._t_string, False, 0),
        ('entry', (), IcePy._t_string, False, 0)
    ))
    ServiceDescriptor._ice_type = _M_IceGrid._t_ServiceDescriptor

    _M_IceGrid.ServiceDescriptor = ServiceDescriptor
    del ServiceDescriptor

    _M_IceGrid.ServiceDescriptorPrx = ServiceDescriptorPrx
    del ServiceDescriptorPrx

if '_t_ServiceDescriptorSeq' not in _M_IceGrid.__dict__:
    _M_IceGrid._t_ServiceDescriptorSeq = IcePy.defineSequence('::IceGrid::ServiceDescriptorSeq', (), _M_IceGrid._t_ServiceDescriptor)

if 'ServerInstanceDescriptor' not in _M_IceGrid.__dict__:
    _M_IceGrid.ServerInstanceDescriptor = Ice.createTempClass()
    class ServerInstanceDescriptor(object):
        '''A server template instance descriptor.'''
        def __init__(self, template='', parameterValues=None, propertySet=Ice._struct_marker, servicePropertySets=None):
            self.template = template
            self.parameterValues = parameterValues
            if propertySet is Ice._struct_marker:
                self.propertySet = _M_IceGrid.PropertySetDescriptor()
            else:
                self.propertySet = propertySet
            self.servicePropertySets = servicePropertySets

        def __eq__(self, other):
            if other is None:
                return False
            elif not isinstance(other, _M_IceGrid.ServerInstanceDescriptor):
                return NotImplemented
            else:
                if self.template != other.template:
                    return False
                if self.parameterValues != other.parameterValues:
                    return False
                if self.propertySet != other.propertySet:
                    return False
                if self.servicePropertySets != other.servicePropertySets:
                    return False
                return True

        def __ne__(self, other):
            return not self.__eq__(other)

        def __str__(self):
            return IcePy.stringify(self, _M_IceGrid._t_ServerInstanceDescriptor)

        __repr__ = __str__

    _M_IceGrid._t_ServerInstanceDescriptor = IcePy.defineStruct('::IceGrid::ServerInstanceDescriptor', ServerInstanceDescriptor, (), (
        ('template', (), IcePy._t_string),
        ('parameterValues', (), _M_IceGrid._t_StringStringDict),
        ('propertySet', (), _M_IceGrid._t_PropertySetDescriptor),
        ('servicePropertySets', (), _M_IceGrid._t_PropertySetDescriptorDict)
    ))

    _M_IceGrid.ServerInstanceDescriptor = ServerInstanceDescriptor
    del ServerInstanceDescriptor

if '_t_ServerInstanceDescriptorSeq' not in _M_IceGrid.__dict__:
    _M_IceGrid._t_ServerInstanceDescriptorSeq = IcePy.defineSequence('::IceGrid::ServerInstanceDescriptorSeq', (), _M_IceGrid._t_ServerInstanceDescriptor)

if 'TemplateDescriptor' not in _M_IceGrid.__dict__:
    _M_IceGrid.TemplateDescriptor = Ice.createTempClass()
    class TemplateDescriptor(object):
        '''A template descriptor for server or service templates.'''
        def __init__(self, descriptor=None, parameters=None, parameterDefaults=None):
            self.descriptor = descriptor
            self.parameters = parameters
            self.parameterDefaults = parameterDefaults

        def __eq__(self, other):
            if other is None:
                return False
            elif not isinstance(other, _M_IceGrid.TemplateDescriptor):
                return NotImplemented
            else:
                if self.descriptor != other.descriptor:
                    return False
                if self.parameters != other.parameters:
                    return False
                if self.parameterDefaults != other.parameterDefaults:
                    return False
                return True

        def __ne__(self, other):
            return not self.__eq__(other)

        def __str__(self):
            return IcePy.stringify(self, _M_IceGrid._t_TemplateDescriptor)

        __repr__ = __str__

    _M_IceGrid._t_TemplateDescriptor = IcePy.defineStruct('::IceGrid::TemplateDescriptor', TemplateDescriptor, (), (
        ('descriptor', (), _M_IceGrid._t_CommunicatorDescriptor),
        ('parameters', (), _M_Ice._t_StringSeq),
        ('parameterDefaults', (), _M_IceGrid._t_StringStringDict)
    ))

    _M_IceGrid.TemplateDescriptor = TemplateDescriptor
    del TemplateDescriptor

if '_t_TemplateDescriptorDict' not in _M_IceGrid.__dict__:
    _M_IceGrid._t_TemplateDescriptorDict = IcePy.defineDictionary('::IceGrid::TemplateDescriptorDict', (), IcePy._t_string, _M_IceGrid._t_TemplateDescriptor)

if 'ServiceInstanceDescriptor' not in _M_IceGrid.__dict__:
    _M_IceGrid.ServiceInstanceDescriptor = Ice.createTempClass()
    class ServiceInstanceDescriptor(object):
        '''A service template instance descriptor.'''
        def __init__(self, template='', parameterValues=None, descriptor=None, propertySet=Ice._struct_marker):
            self.template = template
            self.parameterValues = parameterValues
            self.descriptor = descriptor
            if propertySet is Ice._struct_marker:
                self.propertySet = _M_IceGrid.PropertySetDescriptor()
            else:
                self.propertySet = propertySet

        def __eq__(self, other):
            if other is None:
                return False
            elif not isinstance(other, _M_IceGrid.ServiceInstanceDescriptor):
                return NotImplemented
            else:
                if self.template != other.template:
                    return False
                if self.parameterValues != other.parameterValues:
                    return False
                if self.descriptor != other.descriptor:
                    return False
                if self.propertySet != other.propertySet:
                    return False
                return True

        def __ne__(self, other):
            return not self.__eq__(other)

        def __str__(self):
            return IcePy.stringify(self, _M_IceGrid._t_ServiceInstanceDescriptor)

        __repr__ = __str__

    _M_IceGrid._t_ServiceInstanceDescriptor = IcePy.defineStruct('::IceGrid::ServiceInstanceDescriptor', ServiceInstanceDescriptor, (), (
        ('template', (), IcePy._t_string),
        ('parameterValues', (), _M_IceGrid._t_StringStringDict),
        ('descriptor', (), _M_IceGrid._t_ServiceDescriptor),
        ('propertySet', (), _M_IceGrid._t_PropertySetDescriptor)
    ))

    _M_IceGrid.ServiceInstanceDescriptor = ServiceInstanceDescriptor
    del ServiceInstanceDescriptor

if '_t_ServiceInstanceDescriptorSeq' not in _M_IceGrid.__dict__:
    _M_IceGrid._t_ServiceInstanceDescriptorSeq = IcePy.defineSequence('::IceGrid::ServiceInstanceDescriptorSeq', (), _M_IceGrid._t_ServiceInstanceDescriptor)

if 'IceBoxDescriptor' not in _M_IceGrid.__dict__:
    _M_IceGrid.IceBoxDescriptor = Ice.createTempClass()
    class IceBoxDescriptor(_M_IceGrid.ServerDescriptor):
        '''An IceBox server descriptor.'''
        def __init__(self, adapters=None, propertySet=Ice._struct_marker, dbEnvs=None, logs=None, description='', id='', exe='', iceVersion='', pwd='', options=None, envs=None, activation='', activationTimeout='', deactivationTimeout='', applicationDistrib=False, distrib=Ice._struct_marker, allocatable=False, user='', services=None):
            _M_IceGrid.ServerDescriptor.__init__(self, adapters, propertySet, dbEnvs, logs, description, id, exe, iceVersion, pwd, options, envs, activation, activationTimeout, deactivationTimeout, applicationDistrib, distrib, allocatable, user)
            self.services = services

        def ice_ids(self, current=None):
            return ('::Ice::Object', '::IceGrid::CommunicatorDescriptor', '::IceGrid::IceBoxDescriptor', '::IceGrid::ServerDescriptor')

        def ice_id(self, current=None):
            return '::IceGrid::IceBoxDescriptor'

        def ice_staticId():
            return '::IceGrid::IceBoxDescriptor'
        ice_staticId = staticmethod(ice_staticId)

        def __str__(self):
            return IcePy.stringify(self, _M_IceGrid._t_IceBoxDescriptor)

        __repr__ = __str__

    _M_IceGrid.IceBoxDescriptorPrx = Ice.createTempClass()
    class IceBoxDescriptorPrx(_M_IceGrid.ServerDescriptorPrx):

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_IceGrid.IceBoxDescriptorPrx.ice_checkedCast(proxy, '::IceGrid::IceBoxDescriptor', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_IceGrid.IceBoxDescriptorPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

        def ice_staticId():
            return '::IceGrid::IceBoxDescriptor'
        ice_staticId = staticmethod(ice_staticId)

    _M_IceGrid._t_IceBoxDescriptorPrx = IcePy.defineProxy('::IceGrid::IceBoxDescriptor', IceBoxDescriptorPrx)

    _M_IceGrid._t_IceBoxDescriptor = IcePy.declareClass('::IceGrid::IceBoxDescriptor')

    _M_IceGrid._t_IceBoxDescriptor = IcePy.defineClass('::IceGrid::IceBoxDescriptor', IceBoxDescriptor, -1, (), False, False, _M_IceGrid._t_ServerDescriptor, (), (('services', (), _M_IceGrid._t_ServiceInstanceDescriptorSeq, False, 0),))
    IceBoxDescriptor._ice_type = _M_IceGrid._t_IceBoxDescriptor

    _M_IceGrid.IceBoxDescriptor = IceBoxDescriptor
    del IceBoxDescriptor

    _M_IceGrid.IceBoxDescriptorPrx = IceBoxDescriptorPrx
    del IceBoxDescriptorPrx

if 'NodeDescriptor' not in _M_IceGrid.__dict__:
    _M_IceGrid.NodeDescriptor = Ice.createTempClass()
    class NodeDescriptor(object):
        '''A node descriptor.'''
        def __init__(self, variables=None, serverInstances=None, servers=None, loadFactor='', description='', propertySets=None):
            self.variables = variables
            self.serverInstances = serverInstances
            self.servers = servers
            self.loadFactor = loadFactor
            self.description = description
            self.propertySets = propertySets

        def __eq__(self, other):
            if other is None:
                return False
            elif not isinstance(other, _M_IceGrid.NodeDescriptor):
                return NotImplemented
            else:
                if self.variables != other.variables:
                    return False
                if self.serverInstances != other.serverInstances:
                    return False
                if self.servers != other.servers:
                    return False
                if self.loadFactor != other.loadFactor:
                    return False
                if self.description != other.description:
                    return False
                if self.propertySets != other.propertySets:
                    return False
                return True

        def __ne__(self, other):
            return not self.__eq__(other)

        def __str__(self):
            return IcePy.stringify(self, _M_IceGrid._t_NodeDescriptor)

        __repr__ = __str__

    _M_IceGrid._t_NodeDescriptor = IcePy.defineStruct('::IceGrid::NodeDescriptor', NodeDescriptor, (), (
        ('variables', (), _M_IceGrid._t_StringStringDict),
        ('serverInstances', (), _M_IceGrid._t_ServerInstanceDescriptorSeq),
        ('servers', (), _M_IceGrid._t_ServerDescriptorSeq),
        ('loadFactor', (), IcePy._t_string),
        ('description', (), IcePy._t_string),
        ('propertySets', (), _M_IceGrid._t_PropertySetDescriptorDict)
    ))

    _M_IceGrid.NodeDescriptor = NodeDescriptor
    del NodeDescriptor

if '_t_NodeDescriptorDict' not in _M_IceGrid.__dict__:
    _M_IceGrid._t_NodeDescriptorDict = IcePy.defineDictionary('::IceGrid::NodeDescriptorDict', (), IcePy._t_string, _M_IceGrid._t_NodeDescriptor)

if 'LoadBalancingPolicy' not in _M_IceGrid.__dict__:
    _M_IceGrid.LoadBalancingPolicy = Ice.createTempClass()
    class LoadBalancingPolicy(Ice.Object):
        '''A base class for load balancing policies.'''
        def __init__(self, nReplicas=''):
            self.nReplicas = nReplicas

        def ice_ids(self, current=None):
            return ('::Ice::Object', '::IceGrid::LoadBalancingPolicy')

        def ice_id(self, current=None):
            return '::IceGrid::LoadBalancingPolicy'

        def ice_staticId():
            return '::IceGrid::LoadBalancingPolicy'
        ice_staticId = staticmethod(ice_staticId)

        def __str__(self):
            return IcePy.stringify(self, _M_IceGrid._t_LoadBalancingPolicy)

        __repr__ = __str__

    _M_IceGrid.LoadBalancingPolicyPrx = Ice.createTempClass()
    class LoadBalancingPolicyPrx(Ice.ObjectPrx):

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_IceGrid.LoadBalancingPolicyPrx.ice_checkedCast(proxy, '::IceGrid::LoadBalancingPolicy', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_IceGrid.LoadBalancingPolicyPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

        def ice_staticId():
            return '::IceGrid::LoadBalancingPolicy'
        ice_staticId = staticmethod(ice_staticId)

    _M_IceGrid._t_LoadBalancingPolicyPrx = IcePy.defineProxy('::IceGrid::LoadBalancingPolicy', LoadBalancingPolicyPrx)

    _M_IceGrid._t_LoadBalancingPolicy = IcePy.defineClass('::IceGrid::LoadBalancingPolicy', LoadBalancingPolicy, -1, (), False, False, None, (), (('nReplicas', (), IcePy._t_string, False, 0),))
    LoadBalancingPolicy._ice_type = _M_IceGrid._t_LoadBalancingPolicy

    _M_IceGrid.LoadBalancingPolicy = LoadBalancingPolicy
    del LoadBalancingPolicy

    _M_IceGrid.LoadBalancingPolicyPrx = LoadBalancingPolicyPrx
    del LoadBalancingPolicyPrx

if 'RandomLoadBalancingPolicy' not in _M_IceGrid.__dict__:
    _M_IceGrid.RandomLoadBalancingPolicy = Ice.createTempClass()
    class RandomLoadBalancingPolicy(_M_IceGrid.LoadBalancingPolicy):
        '''Random load balancing policy.'''
        def __init__(self, nReplicas=''):
            _M_IceGrid.LoadBalancingPolicy.__init__(self, nReplicas)

        def ice_ids(self, current=None):
            return ('::Ice::Object', '::IceGrid::LoadBalancingPolicy', '::IceGrid::RandomLoadBalancingPolicy')

        def ice_id(self, current=None):
            return '::IceGrid::RandomLoadBalancingPolicy'

        def ice_staticId():
            return '::IceGrid::RandomLoadBalancingPolicy'
        ice_staticId = staticmethod(ice_staticId)

        def __str__(self):
            return IcePy.stringify(self, _M_IceGrid._t_RandomLoadBalancingPolicy)

        __repr__ = __str__

    _M_IceGrid.RandomLoadBalancingPolicyPrx = Ice.createTempClass()
    class RandomLoadBalancingPolicyPrx(_M_IceGrid.LoadBalancingPolicyPrx):

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_IceGrid.RandomLoadBalancingPolicyPrx.ice_checkedCast(proxy, '::IceGrid::RandomLoadBalancingPolicy', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_IceGrid.RandomLoadBalancingPolicyPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

        def ice_staticId():
            return '::IceGrid::RandomLoadBalancingPolicy'
        ice_staticId = staticmethod(ice_staticId)

    _M_IceGrid._t_RandomLoadBalancingPolicyPrx = IcePy.defineProxy('::IceGrid::RandomLoadBalancingPolicy', RandomLoadBalancingPolicyPrx)

    _M_IceGrid._t_RandomLoadBalancingPolicy = IcePy.defineClass('::IceGrid::RandomLoadBalancingPolicy', RandomLoadBalancingPolicy, -1, (), False, False, _M_IceGrid._t_LoadBalancingPolicy, (), ())
    RandomLoadBalancingPolicy._ice_type = _M_IceGrid._t_RandomLoadBalancingPolicy

    _M_IceGrid.RandomLoadBalancingPolicy = RandomLoadBalancingPolicy
    del RandomLoadBalancingPolicy

    _M_IceGrid.RandomLoadBalancingPolicyPrx = RandomLoadBalancingPolicyPrx
    del RandomLoadBalancingPolicyPrx

if 'OrderedLoadBalancingPolicy' not in _M_IceGrid.__dict__:
    _M_IceGrid.OrderedLoadBalancingPolicy = Ice.createTempClass()
    class OrderedLoadBalancingPolicy(_M_IceGrid.LoadBalancingPolicy):
        '''Ordered load balancing policy.'''
        def __init__(self, nReplicas=''):
            _M_IceGrid.LoadBalancingPolicy.__init__(self, nReplicas)

        def ice_ids(self, current=None):
            return ('::Ice::Object', '::IceGrid::LoadBalancingPolicy', '::IceGrid::OrderedLoadBalancingPolicy')

        def ice_id(self, current=None):
            return '::IceGrid::OrderedLoadBalancingPolicy'

        def ice_staticId():
            return '::IceGrid::OrderedLoadBalancingPolicy'
        ice_staticId = staticmethod(ice_staticId)

        def __str__(self):
            return IcePy.stringify(self, _M_IceGrid._t_OrderedLoadBalancingPolicy)

        __repr__ = __str__

    _M_IceGrid.OrderedLoadBalancingPolicyPrx = Ice.createTempClass()
    class OrderedLoadBalancingPolicyPrx(_M_IceGrid.LoadBalancingPolicyPrx):

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_IceGrid.OrderedLoadBalancingPolicyPrx.ice_checkedCast(proxy, '::IceGrid::OrderedLoadBalancingPolicy', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_IceGrid.OrderedLoadBalancingPolicyPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

        def ice_staticId():
            return '::IceGrid::OrderedLoadBalancingPolicy'
        ice_staticId = staticmethod(ice_staticId)

    _M_IceGrid._t_OrderedLoadBalancingPolicyPrx = IcePy.defineProxy('::IceGrid::OrderedLoadBalancingPolicy', OrderedLoadBalancingPolicyPrx)

    _M_IceGrid._t_OrderedLoadBalancingPolicy = IcePy.defineClass('::IceGrid::OrderedLoadBalancingPolicy', OrderedLoadBalancingPolicy, -1, (), False, False, _M_IceGrid._t_LoadBalancingPolicy, (), ())
    OrderedLoadBalancingPolicy._ice_type = _M_IceGrid._t_OrderedLoadBalancingPolicy

    _M_IceGrid.OrderedLoadBalancingPolicy = OrderedLoadBalancingPolicy
    del OrderedLoadBalancingPolicy

    _M_IceGrid.OrderedLoadBalancingPolicyPrx = OrderedLoadBalancingPolicyPrx
    del OrderedLoadBalancingPolicyPrx

if 'RoundRobinLoadBalancingPolicy' not in _M_IceGrid.__dict__:
    _M_IceGrid.RoundRobinLoadBalancingPolicy = Ice.createTempClass()
    class RoundRobinLoadBalancingPolicy(_M_IceGrid.LoadBalancingPolicy):
        '''Round robin load balancing policy.'''
        def __init__(self, nReplicas=''):
            _M_IceGrid.LoadBalancingPolicy.__init__(self, nReplicas)

        def ice_ids(self, current=None):
            return ('::Ice::Object', '::IceGrid::LoadBalancingPolicy', '::IceGrid::RoundRobinLoadBalancingPolicy')

        def ice_id(self, current=None):
            return '::IceGrid::RoundRobinLoadBalancingPolicy'

        def ice_staticId():
            return '::IceGrid::RoundRobinLoadBalancingPolicy'
        ice_staticId = staticmethod(ice_staticId)

        def __str__(self):
            return IcePy.stringify(self, _M_IceGrid._t_RoundRobinLoadBalancingPolicy)

        __repr__ = __str__

    _M_IceGrid.RoundRobinLoadBalancingPolicyPrx = Ice.createTempClass()
    class RoundRobinLoadBalancingPolicyPrx(_M_IceGrid.LoadBalancingPolicyPrx):

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_IceGrid.RoundRobinLoadBalancingPolicyPrx.ice_checkedCast(proxy, '::IceGrid::RoundRobinLoadBalancingPolicy', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_IceGrid.RoundRobinLoadBalancingPolicyPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

        def ice_staticId():
            return '::IceGrid::RoundRobinLoadBalancingPolicy'
        ice_staticId = staticmethod(ice_staticId)

    _M_IceGrid._t_RoundRobinLoadBalancingPolicyPrx = IcePy.defineProxy('::IceGrid::RoundRobinLoadBalancingPolicy', RoundRobinLoadBalancingPolicyPrx)

    _M_IceGrid._t_RoundRobinLoadBalancingPolicy = IcePy.defineClass('::IceGrid::RoundRobinLoadBalancingPolicy', RoundRobinLoadBalancingPolicy, -1, (), False, False, _M_IceGrid._t_LoadBalancingPolicy, (), ())
    RoundRobinLoadBalancingPolicy._ice_type = _M_IceGrid._t_RoundRobinLoadBalancingPolicy

    _M_IceGrid.RoundRobinLoadBalancingPolicy = RoundRobinLoadBalancingPolicy
    del RoundRobinLoadBalancingPolicy

    _M_IceGrid.RoundRobinLoadBalancingPolicyPrx = RoundRobinLoadBalancingPolicyPrx
    del RoundRobinLoadBalancingPolicyPrx

if 'AdaptiveLoadBalancingPolicy' not in _M_IceGrid.__dict__:
    _M_IceGrid.AdaptiveLoadBalancingPolicy = Ice.createTempClass()
    class AdaptiveLoadBalancingPolicy(_M_IceGrid.LoadBalancingPolicy):
        '''Adaptive load balancing policy.'''
        def __init__(self, nReplicas='', loadSample=''):
            _M_IceGrid.LoadBalancingPolicy.__init__(self, nReplicas)
            self.loadSample = loadSample

        def ice_ids(self, current=None):
            return ('::Ice::Object', '::IceGrid::AdaptiveLoadBalancingPolicy', '::IceGrid::LoadBalancingPolicy')

        def ice_id(self, current=None):
            return '::IceGrid::AdaptiveLoadBalancingPolicy'

        def ice_staticId():
            return '::IceGrid::AdaptiveLoadBalancingPolicy'
        ice_staticId = staticmethod(ice_staticId)

        def __str__(self):
            return IcePy.stringify(self, _M_IceGrid._t_AdaptiveLoadBalancingPolicy)

        __repr__ = __str__

    _M_IceGrid.AdaptiveLoadBalancingPolicyPrx = Ice.createTempClass()
    class AdaptiveLoadBalancingPolicyPrx(_M_IceGrid.LoadBalancingPolicyPrx):

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_IceGrid.AdaptiveLoadBalancingPolicyPrx.ice_checkedCast(proxy, '::IceGrid::AdaptiveLoadBalancingPolicy', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_IceGrid.AdaptiveLoadBalancingPolicyPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

        def ice_staticId():
            return '::IceGrid::AdaptiveLoadBalancingPolicy'
        ice_staticId = staticmethod(ice_staticId)

    _M_IceGrid._t_AdaptiveLoadBalancingPolicyPrx = IcePy.defineProxy('::IceGrid::AdaptiveLoadBalancingPolicy', AdaptiveLoadBalancingPolicyPrx)

    _M_IceGrid._t_AdaptiveLoadBalancingPolicy = IcePy.defineClass('::IceGrid::AdaptiveLoadBalancingPolicy', AdaptiveLoadBalancingPolicy, -1, (), False, False, _M_IceGrid._t_LoadBalancingPolicy, (), (('loadSample', (), IcePy._t_string, False, 0),))
    AdaptiveLoadBalancingPolicy._ice_type = _M_IceGrid._t_AdaptiveLoadBalancingPolicy

    _M_IceGrid.AdaptiveLoadBalancingPolicy = AdaptiveLoadBalancingPolicy
    del AdaptiveLoadBalancingPolicy

    _M_IceGrid.AdaptiveLoadBalancingPolicyPrx = AdaptiveLoadBalancingPolicyPrx
    del AdaptiveLoadBalancingPolicyPrx

if 'ReplicaGroupDescriptor' not in _M_IceGrid.__dict__:
    _M_IceGrid.ReplicaGroupDescriptor = Ice.createTempClass()
    class ReplicaGroupDescriptor(object):
        '''A replica group descriptor.'''
        def __init__(self, id='', loadBalancing=None, proxyOptions='', objects=None, description='', filter=''):
            self.id = id
            self.loadBalancing = loadBalancing
            self.proxyOptions = proxyOptions
            self.objects = objects
            self.description = description
            self.filter = filter

        def __eq__(self, other):
            if other is None:
                return False
            elif not isinstance(other, _M_IceGrid.ReplicaGroupDescriptor):
                return NotImplemented
            else:
                if self.id != other.id:
                    return False
                if self.loadBalancing != other.loadBalancing:
                    return False
                if self.proxyOptions != other.proxyOptions:
                    return False
                if self.objects != other.objects:
                    return False
                if self.description != other.description:
                    return False
                if self.filter != other.filter:
                    return False
                return True

        def __ne__(self, other):
            return not self.__eq__(other)

        def __str__(self):
            return IcePy.stringify(self, _M_IceGrid._t_ReplicaGroupDescriptor)

        __repr__ = __str__

    _M_IceGrid._t_ReplicaGroupDescriptor = IcePy.defineStruct('::IceGrid::ReplicaGroupDescriptor', ReplicaGroupDescriptor, (), (
        ('id', (), IcePy._t_string),
        ('loadBalancing', (), _M_IceGrid._t_LoadBalancingPolicy),
        ('proxyOptions', (), IcePy._t_string),
        ('objects', (), _M_IceGrid._t_ObjectDescriptorSeq),
        ('description', (), IcePy._t_string),
        ('filter', (), IcePy._t_string)
    ))

    _M_IceGrid.ReplicaGroupDescriptor = ReplicaGroupDescriptor
    del ReplicaGroupDescriptor

if '_t_ReplicaGroupDescriptorSeq' not in _M_IceGrid.__dict__:
    _M_IceGrid._t_ReplicaGroupDescriptorSeq = IcePy.defineSequence('::IceGrid::ReplicaGroupDescriptorSeq', (), _M_IceGrid._t_ReplicaGroupDescriptor)

if 'ApplicationDescriptor' not in _M_IceGrid.__dict__:
    _M_IceGrid.ApplicationDescriptor = Ice.createTempClass()
    class ApplicationDescriptor(object):
        '''An application descriptor.'''
        def __init__(self, name='', variables=None, replicaGroups=None, serverTemplates=None, serviceTemplates=None, nodes=None, distrib=Ice._struct_marker, description='', propertySets=None):
            self.name = name
            self.variables = variables
            self.replicaGroups = replicaGroups
            self.serverTemplates = serverTemplates
            self.serviceTemplates = serviceTemplates
            self.nodes = nodes
            if distrib is Ice._struct_marker:
                self.distrib = _M_IceGrid.DistributionDescriptor()
            else:
                self.distrib = distrib
            self.description = description
            self.propertySets = propertySets

        def __eq__(self, other):
            if other is None:
                return False
            elif not isinstance(other, _M_IceGrid.ApplicationDescriptor):
                return NotImplemented
            else:
                if self.name != other.name:
                    return False
                if self.variables != other.variables:
                    return False
                if self.replicaGroups != other.replicaGroups:
                    return False
                if self.serverTemplates != other.serverTemplates:
                    return False
                if self.serviceTemplates != other.serviceTemplates:
                    return False
                if self.nodes != other.nodes:
                    return False
                if self.distrib != other.distrib:
                    return False
                if self.description != other.description:
                    return False
                if self.propertySets != other.propertySets:
                    return False
                return True

        def __ne__(self, other):
            return not self.__eq__(other)

        def __str__(self):
            return IcePy.stringify(self, _M_IceGrid._t_ApplicationDescriptor)

        __repr__ = __str__

    _M_IceGrid._t_ApplicationDescriptor = IcePy.defineStruct('::IceGrid::ApplicationDescriptor', ApplicationDescriptor, (), (
        ('name', (), IcePy._t_string),
        ('variables', (), _M_IceGrid._t_StringStringDict),
        ('replicaGroups', (), _M_IceGrid._t_ReplicaGroupDescriptorSeq),
        ('serverTemplates', (), _M_IceGrid._t_TemplateDescriptorDict),
        ('serviceTemplates', (), _M_IceGrid._t_TemplateDescriptorDict),
        ('nodes', (), _M_IceGrid._t_NodeDescriptorDict),
        ('distrib', (), _M_IceGrid._t_DistributionDescriptor),
        ('description', (), IcePy._t_string),
        ('propertySets', (), _M_IceGrid._t_PropertySetDescriptorDict)
    ))

    _M_IceGrid.ApplicationDescriptor = ApplicationDescriptor
    del ApplicationDescriptor

if '_t_ApplicationDescriptorSeq' not in _M_IceGrid.__dict__:
    _M_IceGrid._t_ApplicationDescriptorSeq = IcePy.defineSequence('::IceGrid::ApplicationDescriptorSeq', (), _M_IceGrid._t_ApplicationDescriptor)

if 'BoxedString' not in _M_IceGrid.__dict__:
    _M_IceGrid.BoxedString = Ice.createTempClass()
    class BoxedString(Ice.Object):
        '''A "boxed" string.'''
        def __init__(self, value=''):
            self.value = value

        def ice_ids(self, current=None):
            return ('::Ice::Object', '::IceGrid::BoxedString')

        def ice_id(self, current=None):
            return '::IceGrid::BoxedString'

        def ice_staticId():
            return '::IceGrid::BoxedString'
        ice_staticId = staticmethod(ice_staticId)

        def __str__(self):
            return IcePy.stringify(self, _M_IceGrid._t_BoxedString)

        __repr__ = __str__

    _M_IceGrid.BoxedStringPrx = Ice.createTempClass()
    class BoxedStringPrx(Ice.ObjectPrx):

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_IceGrid.BoxedStringPrx.ice_checkedCast(proxy, '::IceGrid::BoxedString', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_IceGrid.BoxedStringPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

        def ice_staticId():
            return '::IceGrid::BoxedString'
        ice_staticId = staticmethod(ice_staticId)

    _M_IceGrid._t_BoxedStringPrx = IcePy.defineProxy('::IceGrid::BoxedString', BoxedStringPrx)

    _M_IceGrid._t_BoxedString = IcePy.defineClass('::IceGrid::BoxedString', BoxedString, -1, (), False, False, None, (), (('value', (), IcePy._t_string, False, 0),))
    BoxedString._ice_type = _M_IceGrid._t_BoxedString

    _M_IceGrid.BoxedString = BoxedString
    del BoxedString

    _M_IceGrid.BoxedStringPrx = BoxedStringPrx
    del BoxedStringPrx

if 'NodeUpdateDescriptor' not in _M_IceGrid.__dict__:
    _M_IceGrid.NodeUpdateDescriptor = Ice.createTempClass()
    class NodeUpdateDescriptor(object):
        '''A node update descriptor to describe the updates to apply to a
node of a deployed application.'''
        def __init__(self, name='', description=None, variables=None, removeVariables=None, propertySets=None, removePropertySets=None, serverInstances=None, servers=None, removeServers=None, loadFactor=None):
            self.name = name
            self.description = description
            self.variables = variables
            self.removeVariables = removeVariables
            self.propertySets = propertySets
            self.removePropertySets = removePropertySets
            self.serverInstances = serverInstances
            self.servers = servers
            self.removeServers = removeServers
            self.loadFactor = loadFactor

        def __eq__(self, other):
            if other is None:
                return False
            elif not isinstance(other, _M_IceGrid.NodeUpdateDescriptor):
                return NotImplemented
            else:
                if self.name != other.name:
                    return False
                if self.description != other.description:
                    return False
                if self.variables != other.variables:
                    return False
                if self.removeVariables != other.removeVariables:
                    return False
                if self.propertySets != other.propertySets:
                    return False
                if self.removePropertySets != other.removePropertySets:
                    return False
                if self.serverInstances != other.serverInstances:
                    return False
                if self.servers != other.servers:
                    return False
                if self.removeServers != other.removeServers:
                    return False
                if self.loadFactor != other.loadFactor:
                    return False
                return True

        def __ne__(self, other):
            return not self.__eq__(other)

        def __str__(self):
            return IcePy.stringify(self, _M_IceGrid._t_NodeUpdateDescriptor)

        __repr__ = __str__

    _M_IceGrid._t_NodeUpdateDescriptor = IcePy.defineStruct('::IceGrid::NodeUpdateDescriptor', NodeUpdateDescriptor, (), (
        ('name', (), IcePy._t_string),
        ('description', (), _M_IceGrid._t_BoxedString),
        ('variables', (), _M_IceGrid._t_StringStringDict),
        ('removeVariables', (), _M_Ice._t_StringSeq),
        ('propertySets', (), _M_IceGrid._t_PropertySetDescriptorDict),
        ('removePropertySets', (), _M_Ice._t_StringSeq),
        ('serverInstances', (), _M_IceGrid._t_ServerInstanceDescriptorSeq),
        ('servers', (), _M_IceGrid._t_ServerDescriptorSeq),
        ('removeServers', (), _M_Ice._t_StringSeq),
        ('loadFactor', (), _M_IceGrid._t_BoxedString)
    ))

    _M_IceGrid.NodeUpdateDescriptor = NodeUpdateDescriptor
    del NodeUpdateDescriptor

if '_t_NodeUpdateDescriptorSeq' not in _M_IceGrid.__dict__:
    _M_IceGrid._t_NodeUpdateDescriptorSeq = IcePy.defineSequence('::IceGrid::NodeUpdateDescriptorSeq', (), _M_IceGrid._t_NodeUpdateDescriptor)

if 'BoxedDistributionDescriptor' not in _M_IceGrid.__dict__:
    _M_IceGrid.BoxedDistributionDescriptor = Ice.createTempClass()
    class BoxedDistributionDescriptor(Ice.Object):
        '''A "boxed" distribution descriptor.'''
        def __init__(self, value=Ice._struct_marker):
            if value is Ice._struct_marker:
                self.value = _M_IceGrid.DistributionDescriptor()
            else:
                self.value = value

        def ice_ids(self, current=None):
            return ('::Ice::Object', '::IceGrid::BoxedDistributionDescriptor')

        def ice_id(self, current=None):
            return '::IceGrid::BoxedDistributionDescriptor'

        def ice_staticId():
            return '::IceGrid::BoxedDistributionDescriptor'
        ice_staticId = staticmethod(ice_staticId)

        def __str__(self):
            return IcePy.stringify(self, _M_IceGrid._t_BoxedDistributionDescriptor)

        __repr__ = __str__

    _M_IceGrid.BoxedDistributionDescriptorPrx = Ice.createTempClass()
    class BoxedDistributionDescriptorPrx(Ice.ObjectPrx):

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_IceGrid.BoxedDistributionDescriptorPrx.ice_checkedCast(proxy, '::IceGrid::BoxedDistributionDescriptor', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_IceGrid.BoxedDistributionDescriptorPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

        def ice_staticId():
            return '::IceGrid::BoxedDistributionDescriptor'
        ice_staticId = staticmethod(ice_staticId)

    _M_IceGrid._t_BoxedDistributionDescriptorPrx = IcePy.defineProxy('::IceGrid::BoxedDistributionDescriptor', BoxedDistributionDescriptorPrx)

    _M_IceGrid._t_BoxedDistributionDescriptor = IcePy.defineClass('::IceGrid::BoxedDistributionDescriptor', BoxedDistributionDescriptor, -1, (), False, False, None, (), (('value', (), _M_IceGrid._t_DistributionDescriptor, False, 0),))
    BoxedDistributionDescriptor._ice_type = _M_IceGrid._t_BoxedDistributionDescriptor

    _M_IceGrid.BoxedDistributionDescriptor = BoxedDistributionDescriptor
    del BoxedDistributionDescriptor

    _M_IceGrid.BoxedDistributionDescriptorPrx = BoxedDistributionDescriptorPrx
    del BoxedDistributionDescriptorPrx

if 'ApplicationUpdateDescriptor' not in _M_IceGrid.__dict__:
    _M_IceGrid.ApplicationUpdateDescriptor = Ice.createTempClass()
    class ApplicationUpdateDescriptor(object):
        '''An application update descriptor to describe the updates to apply
to a deployed application.'''
        def __init__(self, name='', description=None, distrib=None, variables=None, removeVariables=None, propertySets=None, removePropertySets=None, replicaGroups=None, removeReplicaGroups=None, serverTemplates=None, removeServerTemplates=None, serviceTemplates=None, removeServiceTemplates=None, nodes=None, removeNodes=None):
            self.name = name
            self.description = description
            self.distrib = distrib
            self.variables = variables
            self.removeVariables = removeVariables
            self.propertySets = propertySets
            self.removePropertySets = removePropertySets
            self.replicaGroups = replicaGroups
            self.removeReplicaGroups = removeReplicaGroups
            self.serverTemplates = serverTemplates
            self.removeServerTemplates = removeServerTemplates
            self.serviceTemplates = serviceTemplates
            self.removeServiceTemplates = removeServiceTemplates
            self.nodes = nodes
            self.removeNodes = removeNodes

        def __eq__(self, other):
            if other is None:
                return False
            elif not isinstance(other, _M_IceGrid.ApplicationUpdateDescriptor):
                return NotImplemented
            else:
                if self.name != other.name:
                    return False
                if self.description != other.description:
                    return False
                if self.distrib != other.distrib:
                    return False
                if self.variables != other.variables:
                    return False
                if self.removeVariables != other.removeVariables:
                    return False
                if self.propertySets != other.propertySets:
                    return False
                if self.removePropertySets != other.removePropertySets:
                    return False
                if self.replicaGroups != other.replicaGroups:
                    return False
                if self.removeReplicaGroups != other.removeReplicaGroups:
                    return False
                if self.serverTemplates != other.serverTemplates:
                    return False
                if self.removeServerTemplates != other.removeServerTemplates:
                    return False
                if self.serviceTemplates != other.serviceTemplates:
                    return False
                if self.removeServiceTemplates != other.removeServiceTemplates:
                    return False
                if self.nodes != other.nodes:
                    return False
                if self.removeNodes != other.removeNodes:
                    return False
                return True

        def __ne__(self, other):
            return not self.__eq__(other)

        def __str__(self):
            return IcePy.stringify(self, _M_IceGrid._t_ApplicationUpdateDescriptor)

        __repr__ = __str__

    _M_IceGrid._t_ApplicationUpdateDescriptor = IcePy.defineStruct('::IceGrid::ApplicationUpdateDescriptor', ApplicationUpdateDescriptor, (), (
        ('name', (), IcePy._t_string),
        ('description', (), _M_IceGrid._t_BoxedString),
        ('distrib', (), _M_IceGrid._t_BoxedDistributionDescriptor),
        ('variables', (), _M_IceGrid._t_StringStringDict),
        ('removeVariables', (), _M_Ice._t_StringSeq),
        ('propertySets', (), _M_IceGrid._t_PropertySetDescriptorDict),
        ('removePropertySets', (), _M_Ice._t_StringSeq),
        ('replicaGroups', (), _M_IceGrid._t_ReplicaGroupDescriptorSeq),
        ('removeReplicaGroups', (), _M_Ice._t_StringSeq),
        ('serverTemplates', (), _M_IceGrid._t_TemplateDescriptorDict),
        ('removeServerTemplates', (), _M_Ice._t_StringSeq),
        ('serviceTemplates', (), _M_IceGrid._t_TemplateDescriptorDict),
        ('removeServiceTemplates', (), _M_Ice._t_StringSeq),
        ('nodes', (), _M_IceGrid._t_NodeUpdateDescriptorSeq),
        ('removeNodes', (), _M_Ice._t_StringSeq)
    ))

    _M_IceGrid.ApplicationUpdateDescriptor = ApplicationUpdateDescriptor
    del ApplicationUpdateDescriptor

# End of module IceGrid

Ice.sliceChecksums["::IceGrid::AdapterDescriptor"] = "4ae12581eab9d8ecba56534d28960f0"
Ice.sliceChecksums["::IceGrid::AdapterDescriptorSeq"] = "61bb9118038552b5e80bf14cf41719c"
Ice.sliceChecksums["::IceGrid::AdaptiveLoadBalancingPolicy"] = "eae551a45bf88ecdfdcbd169e3502816"
Ice.sliceChecksums["::IceGrid::ApplicationDescriptor"] = "fc17fb9c4c7fc8f17ad10bc5da634a0"
Ice.sliceChecksums["::IceGrid::ApplicationDescriptorSeq"] = "b56d6d3091e8c0199e924bbdc074"
Ice.sliceChecksums["::IceGrid::ApplicationUpdateDescriptor"] = "9aef62072a0ecc3ee4be33bc46e0da"
Ice.sliceChecksums["::IceGrid::BoxedDistributionDescriptor"] = "bab8796f5dc33ebe6955d4bb3219c5e9"
Ice.sliceChecksums["::IceGrid::BoxedString"] = "f6bfc069c5150c34e14331c921218d7"
Ice.sliceChecksums["::IceGrid::CommunicatorDescriptor"] = "b7cdae49f8df0d1d93afb857875ec15"
Ice.sliceChecksums["::IceGrid::DbEnvDescriptor"] = "19c130dac4bf7fa2f82375a85e5f421"
Ice.sliceChecksums["::IceGrid::DbEnvDescriptorSeq"] = "d0e45f67b942541727ae69d6cda2fdd8"
Ice.sliceChecksums["::IceGrid::DistributionDescriptor"] = "109eee8e2dc57e518243806796d756"
Ice.sliceChecksums["::IceGrid::IceBoxDescriptor"] = "814eec3d42ab727f75f7b183e1b02c38"
Ice.sliceChecksums["::IceGrid::LoadBalancingPolicy"] = "dfbd5166bbdcac620f2d7f5de185afe"
Ice.sliceChecksums["::IceGrid::NodeDescriptor"] = "be38d2d0b946fea6266f7a97d493d4"
Ice.sliceChecksums["::IceGrid::NodeDescriptorDict"] = "600e78031867992f2fbd18719cb494"
Ice.sliceChecksums["::IceGrid::NodeUpdateDescriptor"] = "d1c0a29ce34753b44e54285c49c9780"
Ice.sliceChecksums["::IceGrid::NodeUpdateDescriptorSeq"] = "3416e1746e2acedfb8192d9d83d9dc3"
Ice.sliceChecksums["::IceGrid::ObjectDescriptor"] = "913039a22b7b5fc0fd156ce764a4237d"
Ice.sliceChecksums["::IceGrid::ObjectDescriptorSeq"] = "57236a6ef224f825849907a344412bb"
Ice.sliceChecksums["::IceGrid::OrderedLoadBalancingPolicy"] = "bef5dacddeeae0e0b58945adaea2121"
Ice.sliceChecksums["::IceGrid::PropertyDescriptor"] = "8b2145a8b1c5c8ffc9eac6a13e731798"
Ice.sliceChecksums["::IceGrid::PropertyDescriptorSeq"] = "5f4143ef7e2c87b63136a3177b7a2830"
Ice.sliceChecksums["::IceGrid::PropertySetDescriptor"] = "d07a6de61ed833b349d869bacb7d857"
Ice.sliceChecksums["::IceGrid::PropertySetDescriptorDict"] = "30fc60d722ab4ba7affa70387730322f"
Ice.sliceChecksums["::IceGrid::RandomLoadBalancingPolicy"] = "b52a26591c76fe2d6d134d954568c1a"
Ice.sliceChecksums["::IceGrid::ReplicaGroupDescriptor"] = "dadc1d584d51fe9a16ea846b2796717"
Ice.sliceChecksums["::IceGrid::ReplicaGroupDescriptorSeq"] = "5a3d3e7b4dc5f21b74f7adb5a6b24ccc"
Ice.sliceChecksums["::IceGrid::RoundRobinLoadBalancingPolicy"] = "d9c7e987c732d89b7aa79621a788fcb4"
Ice.sliceChecksums["::IceGrid::ServerDescriptor"] = "45903227dd1968cedd1811b9d71bc374"
Ice.sliceChecksums["::IceGrid::ServerDescriptorSeq"] = "1bf128cadf1974b22258f66617a1ed"
Ice.sliceChecksums["::IceGrid::ServerInstanceDescriptor"] = "56938d38e0189cdbd57d16e5a6bbc0fb"
Ice.sliceChecksums["::IceGrid::ServerInstanceDescriptorSeq"] = "2a8ae55ccef7917d96691c0a84778dd"
Ice.sliceChecksums["::IceGrid::ServiceDescriptor"] = "7c2496565248aa7d9732565ee5fe7c"
Ice.sliceChecksums["::IceGrid::ServiceDescriptorSeq"] = "cc519ed2b7f626b896cdc062823166"
Ice.sliceChecksums["::IceGrid::ServiceInstanceDescriptor"] = "8581f0afc39ae7daab937244b28c1394"
Ice.sliceChecksums["::IceGrid::ServiceInstanceDescriptorSeq"] = "eb22cd2a50e79f648d803c4b54755"
Ice.sliceChecksums["::IceGrid::StringStringDict"] = "87cdc9524ba3964efc9091e5b3346f29"
Ice.sliceChecksums["::IceGrid::TemplateDescriptor"] = "d1229192d114f32db747493becd5765"
Ice.sliceChecksums["::IceGrid::TemplateDescriptorDict"] = "7b9427f03e8ce3b67decd2cc35baa1"
