# -*- coding: utf-8 -*-
#
# Copyright (c) ZeroC, Inc. All rights reserved.
#
#
# Ice version 3.7.6
#
# <auto-generated>
#
# Generated from file `Descriptor.ice'
#
# Warning: do not edit this file.
#
# </auto-generated>
#

from sys import version_info as _version_info_
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.
        Members:
        name -- The name of the property.
        value -- The value of the property.
        """
        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.
        Members:
        references -- References to named property sets.
        properties -- The property set properties.
        """
        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.
        Members:
        id -- The identity of the object.
        type -- The object type.
        proxyOptions -- Proxy options to use with the proxy created for this Ice object. If empty,
        the proxy will be created with the proxy options specified on the object
        adapter or replica group.
        """
        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.
        Members:
        name -- The object adapter name.
        description -- The description of this object adapter.
        id -- The object adapter id.
        replicaGroupId -- The replica id of this adapter.
        priority -- The adapter priority. This is eventually used when the adapter
        is member of a replica group to sort the adapter endpoints by
        priority.
        registerProcess -- Flag to specify if the object adapter will register a process object.
        serverLifetime -- If true the lifetime of this object adapter is the same of the
        server lifetime. This information is used by the IceGrid node
        to figure out the server state: the server is active only if
        all its "server lifetime" adapters are active.
        objects -- The well-known object descriptors associated with this object adapter.
        allocatables -- The allocatable object descriptors associated with this object adapter.
        """
        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.
        Members:
        name -- The name of the database environment.
        description -- The description of this database environment.
        dbHome -- The home of the database environment (i.e., the directory where
        the database files will be stored). If empty, the node will
        provide a default database directory, otherwise the directory
        must exist.
        properties -- The configuration properties of the database environment.
        """
        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.Value):
        """
        A communicator descriptor.
        Members:
        adapters -- The object adapters.
        propertySet -- The property set.
        dbEnvs -- The database environments.
        logs -- The path of each log file.
        description -- A description of this 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_id(self):
            return '::IceGrid::CommunicatorDescriptor'

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

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

        __repr__ = __str__

    _M_IceGrid._t_CommunicatorDescriptor = IcePy.defineValue('::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

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.
        Members:
        icepatch -- The proxy of the IcePatch2 server.
        directories -- The source directories.
        """
        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.
        Members:
        id -- The server id.
        exe -- The path of the server executable.
        iceVersion -- The Ice version used by this server. This is only required if
        backward compatibility with servers using old Ice versions is
        needed (otherwise the registry will assume the server is using
        the same Ice version).
        For example "3.1.1", "3.2", "3.3.0".
        pwd -- The path to the server working directory.
        options -- The command line options to pass to the server executable.
        envs -- The server environment variables.
        activation -- The server activation mode (possible values are "on-demand" or
        "manual").
        activationTimeout -- The activation timeout (an integer value representing the
        number of seconds to wait for activation).
        deactivationTimeout -- The deactivation timeout (an integer value representing the
        number of seconds to wait for deactivation).
        applicationDistrib -- Specifies if the server depends on the application
        distribution.
        distrib -- The distribution descriptor.
        allocatable -- Specifies if the server is allocatable.
        user -- The user account used to run the server.
        """
        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_id(self):
            return '::IceGrid::ServerDescriptor'

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

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

        __repr__ = __str__

    _M_IceGrid._t_ServerDescriptor = IcePy.defineValue('::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

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.
        Members:
        name -- The service name.
        entry -- The entry point of the IceBox service.
        """
        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_id(self):
            return '::IceGrid::ServiceDescriptor'

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

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

        __repr__ = __str__

    _M_IceGrid._t_ServiceDescriptor = IcePy.defineValue('::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

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.
        Members:
        template -- The template used by this instance.
        parameterValues -- The template parameter values.
        propertySet -- The property set.
        servicePropertySets -- The services property sets. It's only valid to set these
        property sets if the template is an IceBox server template.
        """
        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.
        Members:
        descriptor -- The template.
        parameters -- The parameters required to instantiate the template.
        parameterDefaults -- The parameters default values.
        """
        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.
        Members:
        template -- The template used by this instance.
        parameterValues -- The template parameter values.
        descriptor -- The service definition if the instance isn't a template
        instance (i.e.: if the template attribute is empty).
        propertySet -- The property set.
        """
        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.
        Members:
        services -- The service instances.
        """
        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_id(self):
            return '::IceGrid::IceBoxDescriptor'

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

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

        __repr__ = __str__

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

    _M_IceGrid._t_IceBoxDescriptor = IcePy.defineValue('::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

if 'NodeDescriptor' not in _M_IceGrid.__dict__:
    _M_IceGrid.NodeDescriptor = Ice.createTempClass()
    class NodeDescriptor(object):
        """
        A node descriptor.
        Members:
        variables -- The variables defined for the node.
        serverInstances -- The server instances.
        servers -- Servers (which are not template instances).
        loadFactor -- Load factor of the node.
        description -- The description of this node.
        propertySets -- Property set descriptors.
        """
        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.Value):
        """
        A base class for load balancing policies.
        Members:
        nReplicas -- The number of replicas that will be used to gather the
        endpoints of a replica group.
        """
        def __init__(self, nReplicas=''):
            self.nReplicas = nReplicas

        def ice_id(self):
            return '::IceGrid::LoadBalancingPolicy'

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

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

        __repr__ = __str__

    _M_IceGrid._t_LoadBalancingPolicy = IcePy.defineValue('::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

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_id(self):
            return '::IceGrid::RandomLoadBalancingPolicy'

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

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

        __repr__ = __str__

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

    _M_IceGrid.RandomLoadBalancingPolicy = RandomLoadBalancingPolicy
    del RandomLoadBalancingPolicy

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_id(self):
            return '::IceGrid::OrderedLoadBalancingPolicy'

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

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

        __repr__ = __str__

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

    _M_IceGrid.OrderedLoadBalancingPolicy = OrderedLoadBalancingPolicy
    del OrderedLoadBalancingPolicy

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_id(self):
            return '::IceGrid::RoundRobinLoadBalancingPolicy'

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

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

        __repr__ = __str__

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

    _M_IceGrid.RoundRobinLoadBalancingPolicy = RoundRobinLoadBalancingPolicy
    del RoundRobinLoadBalancingPolicy

if 'AdaptiveLoadBalancingPolicy' not in _M_IceGrid.__dict__:
    _M_IceGrid.AdaptiveLoadBalancingPolicy = Ice.createTempClass()
    class AdaptiveLoadBalancingPolicy(_M_IceGrid.LoadBalancingPolicy):
        """
        Adaptive load balancing policy.
        Members:
        loadSample -- The load sample to use for the load balancing. The allowed
        values for this attribute are "1", "5" and "15", representing
        respectively the load average over the past minute, the past 5
        minutes and the past 15 minutes.
        """
        def __init__(self, nReplicas='', loadSample=''):
            _M_IceGrid.LoadBalancingPolicy.__init__(self, nReplicas)
            self.loadSample = loadSample

        def ice_id(self):
            return '::IceGrid::AdaptiveLoadBalancingPolicy'

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

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

        __repr__ = __str__

    _M_IceGrid._t_AdaptiveLoadBalancingPolicy = IcePy.defineValue('::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

if 'ReplicaGroupDescriptor' not in _M_IceGrid.__dict__:
    _M_IceGrid.ReplicaGroupDescriptor = Ice.createTempClass()
    class ReplicaGroupDescriptor(object):
        """
        A replica group descriptor.
        Members:
        id -- The id of the replica group.
        loadBalancing -- The load balancing policy.
        proxyOptions -- Default options for proxies created for the replica group.
        objects -- The object descriptors associated with this object adapter.
        description -- The description of this replica group.
        filter -- The filter to use for this replica group.
        """
        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.
        Members:
        name -- The application name.
        variables -- The variables defined in the application descriptor.
        replicaGroups -- The replica groups.
        serverTemplates -- The server templates.
        serviceTemplates -- The service templates.
        nodes -- The application nodes.
        distrib -- The application distribution.
        description -- The description of this application.
        propertySets -- Property set descriptors.
        """
        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.Value):
        """
        A "boxed" string.
        Members:
        value -- The value of the boxed string.
        """
        def __init__(self, value=''):
            self.value = value

        def ice_id(self):
            return '::IceGrid::BoxedString'

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

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

        __repr__ = __str__

    _M_IceGrid._t_BoxedString = IcePy.defineValue('::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

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.
        Members:
        name -- The name of the node to update.
        description -- The updated description (or null if the description wasn't
        updated.)
        variables -- The variables to update.
        removeVariables -- The variables to remove.
        propertySets -- The property sets to update.
        removePropertySets -- The property sets to remove.
        serverInstances -- The server instances to update.
        servers -- The servers which are not template instances to update.
        removeServers -- The ids of the servers to remove.
        loadFactor -- The updated load factor of the node (or null if the load factor
        was not updated).
        """
        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.Value):
        """
        A "boxed" distribution descriptor.
        Members:
        value -- The value of the 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_id(self):
            return '::IceGrid::BoxedDistributionDescriptor'

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

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

        __repr__ = __str__

    _M_IceGrid._t_BoxedDistributionDescriptor = IcePy.defineValue('::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

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.
        Members:
        name -- The name of the application to update.
        description -- The updated description (or null if the description wasn't
        updated.)
        distrib -- The updated distribution application descriptor.
        variables -- The variables to update.
        removeVariables -- The variables to remove.
        propertySets -- The property sets to update.
        removePropertySets -- The property sets to remove.
        replicaGroups -- The replica groups to update.
        removeReplicaGroups -- The replica groups to remove.
        serverTemplates -- The server templates to update.
        removeServerTemplates -- The ids of the server template to remove.
        serviceTemplates -- The service templates to update.
        removeServiceTemplates -- The ids of the service template to remove.
        nodes -- The application nodes to update.
        removeNodes -- The nodes to remove.
        """
        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"
