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

import Ice, IcePy, __builtin__
import Ice_Identity_ice
import Ice_BuiltinSequences_ice

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

# Start of module Ice
__name__ = 'Ice'

if not _M_Ice.__dict__.has_key('InitializationException'):
    _M_Ice.InitializationException = Ice.createTempClass()
    class InitializationException(Ice.LocalException):
        '''This exception is raised when a failure occurs during initialization.'''
        def __init__(self, reason=''):
            self.reason = reason

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::InitializationException'

    _M_Ice._t_InitializationException = IcePy.defineException('::Ice::InitializationException', InitializationException, (), None, (('reason', (), IcePy._t_string),))
    InitializationException._ice_type = _M_Ice._t_InitializationException

    _M_Ice.InitializationException = InitializationException
    del InitializationException

if not _M_Ice.__dict__.has_key('PluginInitializationException'):
    _M_Ice.PluginInitializationException = Ice.createTempClass()
    class PluginInitializationException(Ice.LocalException):
        '''This exception indicates that a failure occurred while initializing
a plug-in.'''
        def __init__(self, reason=''):
            self.reason = reason

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::PluginInitializationException'

    _M_Ice._t_PluginInitializationException = IcePy.defineException('::Ice::PluginInitializationException', PluginInitializationException, (), None, (('reason', (), IcePy._t_string),))
    PluginInitializationException._ice_type = _M_Ice._t_PluginInitializationException

    _M_Ice.PluginInitializationException = PluginInitializationException
    del PluginInitializationException

if not _M_Ice.__dict__.has_key('CollocationOptimizationException'):
    _M_Ice.CollocationOptimizationException = Ice.createTempClass()
    class CollocationOptimizationException(Ice.LocalException):
        '''This exception is raised if a feature is requested that is not
supported with collocation optimization.'''
        def __init__(self):
            pass

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::CollocationOptimizationException'

    _M_Ice._t_CollocationOptimizationException = IcePy.defineException('::Ice::CollocationOptimizationException', CollocationOptimizationException, (), None, ())
    CollocationOptimizationException._ice_type = _M_Ice._t_CollocationOptimizationException

    _M_Ice.CollocationOptimizationException = CollocationOptimizationException
    del CollocationOptimizationException

if not _M_Ice.__dict__.has_key('AlreadyRegisteredException'):
    _M_Ice.AlreadyRegisteredException = Ice.createTempClass()
    class AlreadyRegisteredException(Ice.LocalException):
        '''An attempt was made to register something more than once with
the Ice run time.

This exception is raised if an attempt is made to register a
servant, servant locator, facet, object factory, plug-in, object
adapter, object, or user exception factory more than once for the
same ID.'''
        def __init__(self, kindOfObject='', id=''):
            self.kindOfObject = kindOfObject
            self.id = id

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::AlreadyRegisteredException'

    _M_Ice._t_AlreadyRegisteredException = IcePy.defineException('::Ice::AlreadyRegisteredException', AlreadyRegisteredException, (), None, (
        ('kindOfObject', (), IcePy._t_string),
        ('id', (), IcePy._t_string)
    ))
    AlreadyRegisteredException._ice_type = _M_Ice._t_AlreadyRegisteredException

    _M_Ice.AlreadyRegisteredException = AlreadyRegisteredException
    del AlreadyRegisteredException

if not _M_Ice.__dict__.has_key('NotRegisteredException'):
    _M_Ice.NotRegisteredException = Ice.createTempClass()
    class NotRegisteredException(Ice.LocalException):
        '''An attempt was made to find or deregister something that is not
registered with the Ice run time or Ice locator.

This exception is raised if an attempt is made to remove a servant,
servant locator, facet, object factory, plug-in, object adapter, 
object, or user exception factory that is not currently registered.

It's also raised if the Ice locator can't find an object or object
adapter when resolving an indirect proxy or when an object adapter
is activated.'''
        def __init__(self, kindOfObject='', id=''):
            self.kindOfObject = kindOfObject
            self.id = id

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::NotRegisteredException'

    _M_Ice._t_NotRegisteredException = IcePy.defineException('::Ice::NotRegisteredException', NotRegisteredException, (), None, (
        ('kindOfObject', (), IcePy._t_string),
        ('id', (), IcePy._t_string)
    ))
    NotRegisteredException._ice_type = _M_Ice._t_NotRegisteredException

    _M_Ice.NotRegisteredException = NotRegisteredException
    del NotRegisteredException

if not _M_Ice.__dict__.has_key('TwowayOnlyException'):
    _M_Ice.TwowayOnlyException = Ice.createTempClass()
    class TwowayOnlyException(Ice.LocalException):
        '''The operation can only be invoked with a twoway request.

This exception is raised if an attempt is made to invoke an
operation with ice_oneway, ice_batchOneway, ice_datagram,
or ice_batchDatagram and the operation has a return value,
out-parameters, or an exception specification.'''
        def __init__(self, operation=''):
            self.operation = operation

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::TwowayOnlyException'

    _M_Ice._t_TwowayOnlyException = IcePy.defineException('::Ice::TwowayOnlyException', TwowayOnlyException, (), None, (('operation', (), IcePy._t_string),))
    TwowayOnlyException._ice_type = _M_Ice._t_TwowayOnlyException

    _M_Ice.TwowayOnlyException = TwowayOnlyException
    del TwowayOnlyException

if not _M_Ice.__dict__.has_key('CloneNotImplementedException'):
    _M_Ice.CloneNotImplementedException = Ice.createTempClass()
    class CloneNotImplementedException(Ice.LocalException):
        '''An attempt was made to clone a class that does not support
cloning.

This exception is raised if ice_clone is called on
a class that is derived from an abstract Slice class (that is,
a class containing operations), and the derived class does not
provide an implementation of the ice_clone operation (C++ only).'''
        def __init__(self):
            pass

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::CloneNotImplementedException'

    _M_Ice._t_CloneNotImplementedException = IcePy.defineException('::Ice::CloneNotImplementedException', CloneNotImplementedException, (), None, ())
    CloneNotImplementedException._ice_type = _M_Ice._t_CloneNotImplementedException

    _M_Ice.CloneNotImplementedException = CloneNotImplementedException
    del CloneNotImplementedException

if not _M_Ice.__dict__.has_key('UnknownException'):
    _M_Ice.UnknownException = Ice.createTempClass()
    class UnknownException(Ice.LocalException):
        '''This exception is raised if an operation call on a server raises an
unknown exception. For example, for C++, this exception is raised
if the server throws a C++ exception that is not directly or
indirectly derived from Ice::LocalException or
Ice::UserException.'''
        def __init__(self, unknown=''):
            self.unknown = unknown

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::UnknownException'

    _M_Ice._t_UnknownException = IcePy.defineException('::Ice::UnknownException', UnknownException, (), None, (('unknown', (), IcePy._t_string),))
    UnknownException._ice_type = _M_Ice._t_UnknownException

    _M_Ice.UnknownException = UnknownException
    del UnknownException

if not _M_Ice.__dict__.has_key('UnknownLocalException'):
    _M_Ice.UnknownLocalException = Ice.createTempClass()
    class UnknownLocalException(_M_Ice.UnknownException):
        '''This exception is raised if an operation call on a server raises a
local exception. Because local exceptions are not transmitted by
the Ice protocol, the client receives all local exceptions raised
by the server as UnknownLocalException. The only exception to this
rule are all exceptions derived from RequestFailedException,
which are transmitted by the Ice protocol even though they are
declared local.'''
        def __init__(self, unknown=''):
            _M_Ice.UnknownException.__init__(self, unknown)

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::UnknownLocalException'

    _M_Ice._t_UnknownLocalException = IcePy.defineException('::Ice::UnknownLocalException', UnknownLocalException, (), _M_Ice._t_UnknownException, ())
    UnknownLocalException._ice_type = _M_Ice._t_UnknownLocalException

    _M_Ice.UnknownLocalException = UnknownLocalException
    del UnknownLocalException

if not _M_Ice.__dict__.has_key('UnknownUserException'):
    _M_Ice.UnknownUserException = Ice.createTempClass()
    class UnknownUserException(_M_Ice.UnknownException):
        '''An operation raised an incorrect user exception.

This exception is raised if an operation raises a
user exception that is not declared in the exception's
throws clause. Such undeclared exceptions are
not transmitted from the server to the client by the Ice
protocol, but instead the client just gets an
UnknownUserException. This is necessary in order to not violate
the contract established by an operation's signature: Only local
exceptions and user exceptions declared in the
throws clause can be raised.'''
        def __init__(self, unknown=''):
            _M_Ice.UnknownException.__init__(self, unknown)

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::UnknownUserException'

    _M_Ice._t_UnknownUserException = IcePy.defineException('::Ice::UnknownUserException', UnknownUserException, (), _M_Ice._t_UnknownException, ())
    UnknownUserException._ice_type = _M_Ice._t_UnknownUserException

    _M_Ice.UnknownUserException = UnknownUserException
    del UnknownUserException

if not _M_Ice.__dict__.has_key('VersionMismatchException'):
    _M_Ice.VersionMismatchException = Ice.createTempClass()
    class VersionMismatchException(Ice.LocalException):
        '''This exception is raised if the Ice library version does not match
the version in the Ice header files.'''
        def __init__(self):
            pass

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::VersionMismatchException'

    _M_Ice._t_VersionMismatchException = IcePy.defineException('::Ice::VersionMismatchException', VersionMismatchException, (), None, ())
    VersionMismatchException._ice_type = _M_Ice._t_VersionMismatchException

    _M_Ice.VersionMismatchException = VersionMismatchException
    del VersionMismatchException

if not _M_Ice.__dict__.has_key('CommunicatorDestroyedException'):
    _M_Ice.CommunicatorDestroyedException = Ice.createTempClass()
    class CommunicatorDestroyedException(Ice.LocalException):
        '''This exception is raised if the Communicator has been destroyed.'''
        def __init__(self):
            pass

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::CommunicatorDestroyedException'

    _M_Ice._t_CommunicatorDestroyedException = IcePy.defineException('::Ice::CommunicatorDestroyedException', CommunicatorDestroyedException, (), None, ())
    CommunicatorDestroyedException._ice_type = _M_Ice._t_CommunicatorDestroyedException

    _M_Ice.CommunicatorDestroyedException = CommunicatorDestroyedException
    del CommunicatorDestroyedException

if not _M_Ice.__dict__.has_key('ObjectAdapterDeactivatedException'):
    _M_Ice.ObjectAdapterDeactivatedException = Ice.createTempClass()
    class ObjectAdapterDeactivatedException(Ice.LocalException):
        '''This exception is raised if an attempt is made to use a deactivated
ObjectAdapter.'''
        def __init__(self, name=''):
            self.name = name

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::ObjectAdapterDeactivatedException'

    _M_Ice._t_ObjectAdapterDeactivatedException = IcePy.defineException('::Ice::ObjectAdapterDeactivatedException', ObjectAdapterDeactivatedException, (), None, (('name', (), IcePy._t_string),))
    ObjectAdapterDeactivatedException._ice_type = _M_Ice._t_ObjectAdapterDeactivatedException

    _M_Ice.ObjectAdapterDeactivatedException = ObjectAdapterDeactivatedException
    del ObjectAdapterDeactivatedException

if not _M_Ice.__dict__.has_key('ObjectAdapterIdInUseException'):
    _M_Ice.ObjectAdapterIdInUseException = Ice.createTempClass()
    class ObjectAdapterIdInUseException(Ice.LocalException):
        '''This exception is raised if an ObjectAdapter cannot be activated.

This happens if the Locator detects another active ObjectAdapter with
the same adapter id.'''
        def __init__(self, id=''):
            self.id = id

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::ObjectAdapterIdInUseException'

    _M_Ice._t_ObjectAdapterIdInUseException = IcePy.defineException('::Ice::ObjectAdapterIdInUseException', ObjectAdapterIdInUseException, (), None, (('id', (), IcePy._t_string),))
    ObjectAdapterIdInUseException._ice_type = _M_Ice._t_ObjectAdapterIdInUseException

    _M_Ice.ObjectAdapterIdInUseException = ObjectAdapterIdInUseException
    del ObjectAdapterIdInUseException

if not _M_Ice.__dict__.has_key('NoEndpointException'):
    _M_Ice.NoEndpointException = Ice.createTempClass()
    class NoEndpointException(Ice.LocalException):
        '''This exception is raised if no suitable endpoint is available.'''
        def __init__(self, proxy=''):
            self.proxy = proxy

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::NoEndpointException'

    _M_Ice._t_NoEndpointException = IcePy.defineException('::Ice::NoEndpointException', NoEndpointException, (), None, (('proxy', (), IcePy._t_string),))
    NoEndpointException._ice_type = _M_Ice._t_NoEndpointException

    _M_Ice.NoEndpointException = NoEndpointException
    del NoEndpointException

if not _M_Ice.__dict__.has_key('EndpointParseException'):
    _M_Ice.EndpointParseException = Ice.createTempClass()
    class EndpointParseException(Ice.LocalException):
        '''This exception is raised if there was an error while parsing an
endpoint.'''
        def __init__(self, str=''):
            self.str = str

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::EndpointParseException'

    _M_Ice._t_EndpointParseException = IcePy.defineException('::Ice::EndpointParseException', EndpointParseException, (), None, (('str', (), IcePy._t_string),))
    EndpointParseException._ice_type = _M_Ice._t_EndpointParseException

    _M_Ice.EndpointParseException = EndpointParseException
    del EndpointParseException

if not _M_Ice.__dict__.has_key('EndpointSelectionTypeParseException'):
    _M_Ice.EndpointSelectionTypeParseException = Ice.createTempClass()
    class EndpointSelectionTypeParseException(Ice.LocalException):
        '''This exception is raised if there was an error while parsing an
endpoint selection type.'''
        def __init__(self, str=''):
            self.str = str

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::EndpointSelectionTypeParseException'

    _M_Ice._t_EndpointSelectionTypeParseException = IcePy.defineException('::Ice::EndpointSelectionTypeParseException', EndpointSelectionTypeParseException, (), None, (('str', (), IcePy._t_string),))
    EndpointSelectionTypeParseException._ice_type = _M_Ice._t_EndpointSelectionTypeParseException

    _M_Ice.EndpointSelectionTypeParseException = EndpointSelectionTypeParseException
    del EndpointSelectionTypeParseException

if not _M_Ice.__dict__.has_key('IdentityParseException'):
    _M_Ice.IdentityParseException = Ice.createTempClass()
    class IdentityParseException(Ice.LocalException):
        '''This exception is raised if there was an error while parsing a
stringified identity.'''
        def __init__(self, str=''):
            self.str = str

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::IdentityParseException'

    _M_Ice._t_IdentityParseException = IcePy.defineException('::Ice::IdentityParseException', IdentityParseException, (), None, (('str', (), IcePy._t_string),))
    IdentityParseException._ice_type = _M_Ice._t_IdentityParseException

    _M_Ice.IdentityParseException = IdentityParseException
    del IdentityParseException

if not _M_Ice.__dict__.has_key('ProxyParseException'):
    _M_Ice.ProxyParseException = Ice.createTempClass()
    class ProxyParseException(Ice.LocalException):
        '''This exception is raised if there was an error while parsing a
stringified proxy.'''
        def __init__(self, str=''):
            self.str = str

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::ProxyParseException'

    _M_Ice._t_ProxyParseException = IcePy.defineException('::Ice::ProxyParseException', ProxyParseException, (), None, (('str', (), IcePy._t_string),))
    ProxyParseException._ice_type = _M_Ice._t_ProxyParseException

    _M_Ice.ProxyParseException = ProxyParseException
    del ProxyParseException

if not _M_Ice.__dict__.has_key('IllegalIdentityException'):
    _M_Ice.IllegalIdentityException = Ice.createTempClass()
    class IllegalIdentityException(Ice.LocalException):
        '''This exception is raised if an illegal identity is encountered.'''
        def __init__(self, id=Ice._struct_marker):
            if id is Ice._struct_marker:
                self.id = _M_Ice.Identity()
            else:
                self.id = id

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::IllegalIdentityException'

    _M_Ice._t_IllegalIdentityException = IcePy.defineException('::Ice::IllegalIdentityException', IllegalIdentityException, (), None, (('id', (), _M_Ice._t_Identity),))
    IllegalIdentityException._ice_type = _M_Ice._t_IllegalIdentityException

    _M_Ice.IllegalIdentityException = IllegalIdentityException
    del IllegalIdentityException

if not _M_Ice.__dict__.has_key('RequestFailedException'):
    _M_Ice.RequestFailedException = Ice.createTempClass()
    class RequestFailedException(Ice.LocalException):
        '''This exception is raised if a request failed. This exception, and
all exceptions derived from RequestFailedException, are
transmitted by the Ice protocol, even though they are declared
local.'''
        def __init__(self, id=Ice._struct_marker, facet='', operation=''):
            if id is Ice._struct_marker:
                self.id = _M_Ice.Identity()
            else:
                self.id = id
            self.facet = facet
            self.operation = operation

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::RequestFailedException'

    _M_Ice._t_RequestFailedException = IcePy.defineException('::Ice::RequestFailedException', RequestFailedException, (), None, (
        ('id', (), _M_Ice._t_Identity),
        ('facet', (), IcePy._t_string),
        ('operation', (), IcePy._t_string)
    ))
    RequestFailedException._ice_type = _M_Ice._t_RequestFailedException

    _M_Ice.RequestFailedException = RequestFailedException
    del RequestFailedException

if not _M_Ice.__dict__.has_key('ObjectNotExistException'):
    _M_Ice.ObjectNotExistException = Ice.createTempClass()
    class ObjectNotExistException(_M_Ice.RequestFailedException):
        '''This exception is raised if an object does not exist on the server,
that is, if no facets with the given identity exist.'''
        def __init__(self, id=Ice._struct_marker, facet='', operation=''):
            _M_Ice.RequestFailedException.__init__(self, id, facet, operation)

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::ObjectNotExistException'

    _M_Ice._t_ObjectNotExistException = IcePy.defineException('::Ice::ObjectNotExistException', ObjectNotExistException, (), _M_Ice._t_RequestFailedException, ())
    ObjectNotExistException._ice_type = _M_Ice._t_ObjectNotExistException

    _M_Ice.ObjectNotExistException = ObjectNotExistException
    del ObjectNotExistException

if not _M_Ice.__dict__.has_key('FacetNotExistException'):
    _M_Ice.FacetNotExistException = Ice.createTempClass()
    class FacetNotExistException(_M_Ice.RequestFailedException):
        '''This exception is raised if no facet with the given name exists,
but at least one facet with the given identity exists.'''
        def __init__(self, id=Ice._struct_marker, facet='', operation=''):
            _M_Ice.RequestFailedException.__init__(self, id, facet, operation)

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::FacetNotExistException'

    _M_Ice._t_FacetNotExistException = IcePy.defineException('::Ice::FacetNotExistException', FacetNotExistException, (), _M_Ice._t_RequestFailedException, ())
    FacetNotExistException._ice_type = _M_Ice._t_FacetNotExistException

    _M_Ice.FacetNotExistException = FacetNotExistException
    del FacetNotExistException

if not _M_Ice.__dict__.has_key('OperationNotExistException'):
    _M_Ice.OperationNotExistException = Ice.createTempClass()
    class OperationNotExistException(_M_Ice.RequestFailedException):
        '''This exception is raised if an operation for a given object does
not exist on the server. Typically this is caused by either the
client or the server using an outdated Slice specification.'''
        def __init__(self, id=Ice._struct_marker, facet='', operation=''):
            _M_Ice.RequestFailedException.__init__(self, id, facet, operation)

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::OperationNotExistException'

    _M_Ice._t_OperationNotExistException = IcePy.defineException('::Ice::OperationNotExistException', OperationNotExistException, (), _M_Ice._t_RequestFailedException, ())
    OperationNotExistException._ice_type = _M_Ice._t_OperationNotExistException

    _M_Ice.OperationNotExistException = OperationNotExistException
    del OperationNotExistException

if not _M_Ice.__dict__.has_key('SyscallException'):
    _M_Ice.SyscallException = Ice.createTempClass()
    class SyscallException(Ice.LocalException):
        '''This exception is raised if a system error occurred in the server
or client process. There are many possible causes for such a system
exception. For details on the cause, SyscallException#error
should be inspected.'''
        def __init__(self, error=0):
            self.error = error

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::SyscallException'

    _M_Ice._t_SyscallException = IcePy.defineException('::Ice::SyscallException', SyscallException, (), None, (('error', (), IcePy._t_int),))
    SyscallException._ice_type = _M_Ice._t_SyscallException

    _M_Ice.SyscallException = SyscallException
    del SyscallException

if not _M_Ice.__dict__.has_key('SocketException'):
    _M_Ice.SocketException = Ice.createTempClass()
    class SocketException(_M_Ice.SyscallException):
        '''This exception indicates socket errors.'''
        def __init__(self, error=0):
            _M_Ice.SyscallException.__init__(self, error)

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::SocketException'

    _M_Ice._t_SocketException = IcePy.defineException('::Ice::SocketException', SocketException, (), _M_Ice._t_SyscallException, ())
    SocketException._ice_type = _M_Ice._t_SocketException

    _M_Ice.SocketException = SocketException
    del SocketException

if not _M_Ice.__dict__.has_key('FileException'):
    _M_Ice.FileException = Ice.createTempClass()
    class FileException(_M_Ice.SyscallException):
        '''This exception indicates file errors.'''
        def __init__(self, error=0, path=''):
            _M_Ice.SyscallException.__init__(self, error)
            self.path = path

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::FileException'

    _M_Ice._t_FileException = IcePy.defineException('::Ice::FileException', FileException, (), _M_Ice._t_SyscallException, (('path', (), IcePy._t_string),))
    FileException._ice_type = _M_Ice._t_FileException

    _M_Ice.FileException = FileException
    del FileException

if not _M_Ice.__dict__.has_key('ConnectFailedException'):
    _M_Ice.ConnectFailedException = Ice.createTempClass()
    class ConnectFailedException(_M_Ice.SocketException):
        '''This exception indicates connection failures.'''
        def __init__(self, error=0):
            _M_Ice.SocketException.__init__(self, error)

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::ConnectFailedException'

    _M_Ice._t_ConnectFailedException = IcePy.defineException('::Ice::ConnectFailedException', ConnectFailedException, (), _M_Ice._t_SocketException, ())
    ConnectFailedException._ice_type = _M_Ice._t_ConnectFailedException

    _M_Ice.ConnectFailedException = ConnectFailedException
    del ConnectFailedException

if not _M_Ice.__dict__.has_key('ConnectionRefusedException'):
    _M_Ice.ConnectionRefusedException = Ice.createTempClass()
    class ConnectionRefusedException(_M_Ice.ConnectFailedException):
        '''This exception indicates a connection failure for which
the server host actively refuses a connection.'''
        def __init__(self, error=0):
            _M_Ice.ConnectFailedException.__init__(self, error)

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::ConnectionRefusedException'

    _M_Ice._t_ConnectionRefusedException = IcePy.defineException('::Ice::ConnectionRefusedException', ConnectionRefusedException, (), _M_Ice._t_ConnectFailedException, ())
    ConnectionRefusedException._ice_type = _M_Ice._t_ConnectionRefusedException

    _M_Ice.ConnectionRefusedException = ConnectionRefusedException
    del ConnectionRefusedException

if not _M_Ice.__dict__.has_key('ConnectionLostException'):
    _M_Ice.ConnectionLostException = Ice.createTempClass()
    class ConnectionLostException(_M_Ice.SocketException):
        '''This exception indicates a lost connection.'''
        def __init__(self, error=0):
            _M_Ice.SocketException.__init__(self, error)

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::ConnectionLostException'

    _M_Ice._t_ConnectionLostException = IcePy.defineException('::Ice::ConnectionLostException', ConnectionLostException, (), _M_Ice._t_SocketException, ())
    ConnectionLostException._ice_type = _M_Ice._t_ConnectionLostException

    _M_Ice.ConnectionLostException = ConnectionLostException
    del ConnectionLostException

if not _M_Ice.__dict__.has_key('DNSException'):
    _M_Ice.DNSException = Ice.createTempClass()
    class DNSException(Ice.LocalException):
        '''This exception indicates a DNS problem. For details on the cause,
DNSException#error should be inspected.'''
        def __init__(self, error=0, host=''):
            self.error = error
            self.host = host

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::DNSException'

    _M_Ice._t_DNSException = IcePy.defineException('::Ice::DNSException', DNSException, (), None, (
        ('error', (), IcePy._t_int),
        ('host', (), IcePy._t_string)
    ))
    DNSException._ice_type = _M_Ice._t_DNSException

    _M_Ice.DNSException = DNSException
    del DNSException

if not _M_Ice.__dict__.has_key('TimeoutException'):
    _M_Ice.TimeoutException = Ice.createTempClass()
    class TimeoutException(Ice.LocalException):
        '''This exception indicates a timeout condition.'''
        def __init__(self):
            pass

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::TimeoutException'

    _M_Ice._t_TimeoutException = IcePy.defineException('::Ice::TimeoutException', TimeoutException, (), None, ())
    TimeoutException._ice_type = _M_Ice._t_TimeoutException

    _M_Ice.TimeoutException = TimeoutException
    del TimeoutException

if not _M_Ice.__dict__.has_key('ConnectTimeoutException'):
    _M_Ice.ConnectTimeoutException = Ice.createTempClass()
    class ConnectTimeoutException(_M_Ice.TimeoutException):
        '''This exception indicates a connection establishment timeout condition.'''
        def __init__(self):
            _M_Ice.TimeoutException.__init__(self)

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::ConnectTimeoutException'

    _M_Ice._t_ConnectTimeoutException = IcePy.defineException('::Ice::ConnectTimeoutException', ConnectTimeoutException, (), _M_Ice._t_TimeoutException, ())
    ConnectTimeoutException._ice_type = _M_Ice._t_ConnectTimeoutException

    _M_Ice.ConnectTimeoutException = ConnectTimeoutException
    del ConnectTimeoutException

if not _M_Ice.__dict__.has_key('CloseTimeoutException'):
    _M_Ice.CloseTimeoutException = Ice.createTempClass()
    class CloseTimeoutException(_M_Ice.TimeoutException):
        '''This exception indicates a connection closure timeout condition.'''
        def __init__(self):
            _M_Ice.TimeoutException.__init__(self)

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::CloseTimeoutException'

    _M_Ice._t_CloseTimeoutException = IcePy.defineException('::Ice::CloseTimeoutException', CloseTimeoutException, (), _M_Ice._t_TimeoutException, ())
    CloseTimeoutException._ice_type = _M_Ice._t_CloseTimeoutException

    _M_Ice.CloseTimeoutException = CloseTimeoutException
    del CloseTimeoutException

if not _M_Ice.__dict__.has_key('ConnectionTimeoutException'):
    _M_Ice.ConnectionTimeoutException = Ice.createTempClass()
    class ConnectionTimeoutException(_M_Ice.TimeoutException):
        '''This exception indicates that a connection has been shut down because it has been
idle for some time.'''
        def __init__(self):
            _M_Ice.TimeoutException.__init__(self)

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::ConnectionTimeoutException'

    _M_Ice._t_ConnectionTimeoutException = IcePy.defineException('::Ice::ConnectionTimeoutException', ConnectionTimeoutException, (), _M_Ice._t_TimeoutException, ())
    ConnectionTimeoutException._ice_type = _M_Ice._t_ConnectionTimeoutException

    _M_Ice.ConnectionTimeoutException = ConnectionTimeoutException
    del ConnectionTimeoutException

if not _M_Ice.__dict__.has_key('ProtocolException'):
    _M_Ice.ProtocolException = Ice.createTempClass()
    class ProtocolException(Ice.LocalException):
        '''A generic exception base for all kinds of protocol error
conditions.'''
        def __init__(self, reason=''):
            self.reason = reason

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::ProtocolException'

    _M_Ice._t_ProtocolException = IcePy.defineException('::Ice::ProtocolException', ProtocolException, (), None, (('reason', (), IcePy._t_string),))
    ProtocolException._ice_type = _M_Ice._t_ProtocolException

    _M_Ice.ProtocolException = ProtocolException
    del ProtocolException

if not _M_Ice.__dict__.has_key('BadMagicException'):
    _M_Ice.BadMagicException = Ice.createTempClass()
    class BadMagicException(_M_Ice.ProtocolException):
        '''This exception indicates that a message did not start with the expected
magic number ('I', 'c', 'e', 'P').'''
        def __init__(self, reason='', badMagic=None):
            _M_Ice.ProtocolException.__init__(self, reason)
            self.badMagic = badMagic

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::BadMagicException'

    _M_Ice._t_BadMagicException = IcePy.defineException('::Ice::BadMagicException', BadMagicException, (), _M_Ice._t_ProtocolException, (('badMagic', (), _M_Ice._t_ByteSeq),))
    BadMagicException._ice_type = _M_Ice._t_BadMagicException

    _M_Ice.BadMagicException = BadMagicException
    del BadMagicException

if not _M_Ice.__dict__.has_key('UnsupportedProtocolException'):
    _M_Ice.UnsupportedProtocolException = Ice.createTempClass()
    class UnsupportedProtocolException(_M_Ice.ProtocolException):
        '''This exception indicates an unsupported protocol version.'''
        def __init__(self, reason='', badMajor=0, badMinor=0, major=0, minor=0):
            _M_Ice.ProtocolException.__init__(self, reason)
            self.badMajor = badMajor
            self.badMinor = badMinor
            self.major = major
            self.minor = minor

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::UnsupportedProtocolException'

    _M_Ice._t_UnsupportedProtocolException = IcePy.defineException('::Ice::UnsupportedProtocolException', UnsupportedProtocolException, (), _M_Ice._t_ProtocolException, (
        ('badMajor', (), IcePy._t_int),
        ('badMinor', (), IcePy._t_int),
        ('major', (), IcePy._t_int),
        ('minor', (), IcePy._t_int)
    ))
    UnsupportedProtocolException._ice_type = _M_Ice._t_UnsupportedProtocolException

    _M_Ice.UnsupportedProtocolException = UnsupportedProtocolException
    del UnsupportedProtocolException

if not _M_Ice.__dict__.has_key('UnsupportedEncodingException'):
    _M_Ice.UnsupportedEncodingException = Ice.createTempClass()
    class UnsupportedEncodingException(_M_Ice.ProtocolException):
        '''This exception indicates an unsupported data encoding version.'''
        def __init__(self, reason='', badMajor=0, badMinor=0, major=0, minor=0):
            _M_Ice.ProtocolException.__init__(self, reason)
            self.badMajor = badMajor
            self.badMinor = badMinor
            self.major = major
            self.minor = minor

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::UnsupportedEncodingException'

    _M_Ice._t_UnsupportedEncodingException = IcePy.defineException('::Ice::UnsupportedEncodingException', UnsupportedEncodingException, (), _M_Ice._t_ProtocolException, (
        ('badMajor', (), IcePy._t_int),
        ('badMinor', (), IcePy._t_int),
        ('major', (), IcePy._t_int),
        ('minor', (), IcePy._t_int)
    ))
    UnsupportedEncodingException._ice_type = _M_Ice._t_UnsupportedEncodingException

    _M_Ice.UnsupportedEncodingException = UnsupportedEncodingException
    del UnsupportedEncodingException

if not _M_Ice.__dict__.has_key('UnknownMessageException'):
    _M_Ice.UnknownMessageException = Ice.createTempClass()
    class UnknownMessageException(_M_Ice.ProtocolException):
        '''This exception indicates that an unknown protocol message has been received.'''
        def __init__(self, reason=''):
            _M_Ice.ProtocolException.__init__(self, reason)

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::UnknownMessageException'

    _M_Ice._t_UnknownMessageException = IcePy.defineException('::Ice::UnknownMessageException', UnknownMessageException, (), _M_Ice._t_ProtocolException, ())
    UnknownMessageException._ice_type = _M_Ice._t_UnknownMessageException

    _M_Ice.UnknownMessageException = UnknownMessageException
    del UnknownMessageException

if not _M_Ice.__dict__.has_key('ConnectionNotValidatedException'):
    _M_Ice.ConnectionNotValidatedException = Ice.createTempClass()
    class ConnectionNotValidatedException(_M_Ice.ProtocolException):
        '''This exception is raised if a message is received over a connection
that is not yet validated.'''
        def __init__(self, reason=''):
            _M_Ice.ProtocolException.__init__(self, reason)

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::ConnectionNotValidatedException'

    _M_Ice._t_ConnectionNotValidatedException = IcePy.defineException('::Ice::ConnectionNotValidatedException', ConnectionNotValidatedException, (), _M_Ice._t_ProtocolException, ())
    ConnectionNotValidatedException._ice_type = _M_Ice._t_ConnectionNotValidatedException

    _M_Ice.ConnectionNotValidatedException = ConnectionNotValidatedException
    del ConnectionNotValidatedException

if not _M_Ice.__dict__.has_key('UnknownRequestIdException'):
    _M_Ice.UnknownRequestIdException = Ice.createTempClass()
    class UnknownRequestIdException(_M_Ice.ProtocolException):
        '''This exception indicates that a response for an unknown request ID has been
received.'''
        def __init__(self, reason=''):
            _M_Ice.ProtocolException.__init__(self, reason)

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::UnknownRequestIdException'

    _M_Ice._t_UnknownRequestIdException = IcePy.defineException('::Ice::UnknownRequestIdException', UnknownRequestIdException, (), _M_Ice._t_ProtocolException, ())
    UnknownRequestIdException._ice_type = _M_Ice._t_UnknownRequestIdException

    _M_Ice.UnknownRequestIdException = UnknownRequestIdException
    del UnknownRequestIdException

if not _M_Ice.__dict__.has_key('UnknownReplyStatusException'):
    _M_Ice.UnknownReplyStatusException = Ice.createTempClass()
    class UnknownReplyStatusException(_M_Ice.ProtocolException):
        '''This exception indicates that an unknown reply status has been received.'''
        def __init__(self, reason=''):
            _M_Ice.ProtocolException.__init__(self, reason)

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::UnknownReplyStatusException'

    _M_Ice._t_UnknownReplyStatusException = IcePy.defineException('::Ice::UnknownReplyStatusException', UnknownReplyStatusException, (), _M_Ice._t_ProtocolException, ())
    UnknownReplyStatusException._ice_type = _M_Ice._t_UnknownReplyStatusException

    _M_Ice.UnknownReplyStatusException = UnknownReplyStatusException
    del UnknownReplyStatusException

if not _M_Ice.__dict__.has_key('CloseConnectionException'):
    _M_Ice.CloseConnectionException = Ice.createTempClass()
    class CloseConnectionException(_M_Ice.ProtocolException):
        '''This exception indicates that the connection has been gracefully shut down by the
server. The operation call that caused this exception has not been
executed by the server. In most cases you will not get this
exception, because the client will automatically retry the
operation call in case the server shut down the connection. However,
if upon retry the server shuts down the connection again, and the
retry limit has been reached, then this exception is propagated to
the application code.'''
        def __init__(self, reason=''):
            _M_Ice.ProtocolException.__init__(self, reason)

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::CloseConnectionException'

    _M_Ice._t_CloseConnectionException = IcePy.defineException('::Ice::CloseConnectionException', CloseConnectionException, (), _M_Ice._t_ProtocolException, ())
    CloseConnectionException._ice_type = _M_Ice._t_CloseConnectionException

    _M_Ice.CloseConnectionException = CloseConnectionException
    del CloseConnectionException

if not _M_Ice.__dict__.has_key('ForcedCloseConnectionException'):
    _M_Ice.ForcedCloseConnectionException = Ice.createTempClass()
    class ForcedCloseConnectionException(_M_Ice.ProtocolException):
        '''This exception is raised by an operation call if the application
forcefully closes the connection Connection#close.'''
        def __init__(self, reason=''):
            _M_Ice.ProtocolException.__init__(self, reason)

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::ForcedCloseConnectionException'

    _M_Ice._t_ForcedCloseConnectionException = IcePy.defineException('::Ice::ForcedCloseConnectionException', ForcedCloseConnectionException, (), _M_Ice._t_ProtocolException, ())
    ForcedCloseConnectionException._ice_type = _M_Ice._t_ForcedCloseConnectionException

    _M_Ice.ForcedCloseConnectionException = ForcedCloseConnectionException
    del ForcedCloseConnectionException

if not _M_Ice.__dict__.has_key('IllegalMessageSizeException'):
    _M_Ice.IllegalMessageSizeException = Ice.createTempClass()
    class IllegalMessageSizeException(_M_Ice.ProtocolException):
        '''This exception indicates that a message size is less
than the minimum required size.'''
        def __init__(self, reason=''):
            _M_Ice.ProtocolException.__init__(self, reason)

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::IllegalMessageSizeException'

    _M_Ice._t_IllegalMessageSizeException = IcePy.defineException('::Ice::IllegalMessageSizeException', IllegalMessageSizeException, (), _M_Ice._t_ProtocolException, ())
    IllegalMessageSizeException._ice_type = _M_Ice._t_IllegalMessageSizeException

    _M_Ice.IllegalMessageSizeException = IllegalMessageSizeException
    del IllegalMessageSizeException

if not _M_Ice.__dict__.has_key('CompressionException'):
    _M_Ice.CompressionException = Ice.createTempClass()
    class CompressionException(_M_Ice.ProtocolException):
        '''This exception indicates a problem with compressing or uncompressing data.'''
        def __init__(self, reason=''):
            _M_Ice.ProtocolException.__init__(self, reason)

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::CompressionException'

    _M_Ice._t_CompressionException = IcePy.defineException('::Ice::CompressionException', CompressionException, (), _M_Ice._t_ProtocolException, ())
    CompressionException._ice_type = _M_Ice._t_CompressionException

    _M_Ice.CompressionException = CompressionException
    del CompressionException

if not _M_Ice.__dict__.has_key('DatagramLimitException'):
    _M_Ice.DatagramLimitException = Ice.createTempClass()
    class DatagramLimitException(_M_Ice.ProtocolException):
        '''A datagram exceeds the configured size.

This exception is raised if a datagram exceeds the configured send or receive buffer
size, or exceeds the maximum payload size of a UDP packet (65507 bytes).'''
        def __init__(self, reason=''):
            _M_Ice.ProtocolException.__init__(self, reason)

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::DatagramLimitException'

    _M_Ice._t_DatagramLimitException = IcePy.defineException('::Ice::DatagramLimitException', DatagramLimitException, (), _M_Ice._t_ProtocolException, ())
    DatagramLimitException._ice_type = _M_Ice._t_DatagramLimitException

    _M_Ice.DatagramLimitException = DatagramLimitException
    del DatagramLimitException

if not _M_Ice.__dict__.has_key('MarshalException'):
    _M_Ice.MarshalException = Ice.createTempClass()
    class MarshalException(_M_Ice.ProtocolException):
        '''This exception is raised for errors during marshaling or unmarshaling data.'''
        def __init__(self, reason=''):
            _M_Ice.ProtocolException.__init__(self, reason)

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::MarshalException'

    _M_Ice._t_MarshalException = IcePy.defineException('::Ice::MarshalException', MarshalException, (), _M_Ice._t_ProtocolException, ())
    MarshalException._ice_type = _M_Ice._t_MarshalException

    _M_Ice.MarshalException = MarshalException
    del MarshalException

if not _M_Ice.__dict__.has_key('ProxyUnmarshalException'):
    _M_Ice.ProxyUnmarshalException = Ice.createTempClass()
    class ProxyUnmarshalException(_M_Ice.MarshalException):
        '''This exception is raised if inconsistent data is received while unmarshaling a proxy.'''
        def __init__(self, reason=''):
            _M_Ice.MarshalException.__init__(self, reason)

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::ProxyUnmarshalException'

    _M_Ice._t_ProxyUnmarshalException = IcePy.defineException('::Ice::ProxyUnmarshalException', ProxyUnmarshalException, (), _M_Ice._t_MarshalException, ())
    ProxyUnmarshalException._ice_type = _M_Ice._t_ProxyUnmarshalException

    _M_Ice.ProxyUnmarshalException = ProxyUnmarshalException
    del ProxyUnmarshalException

if not _M_Ice.__dict__.has_key('UnmarshalOutOfBoundsException'):
    _M_Ice.UnmarshalOutOfBoundsException = Ice.createTempClass()
    class UnmarshalOutOfBoundsException(_M_Ice.MarshalException):
        '''This exception is raised if an out-of-bounds condition occurs during unmarshaling.'''
        def __init__(self, reason=''):
            _M_Ice.MarshalException.__init__(self, reason)

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::UnmarshalOutOfBoundsException'

    _M_Ice._t_UnmarshalOutOfBoundsException = IcePy.defineException('::Ice::UnmarshalOutOfBoundsException', UnmarshalOutOfBoundsException, (), _M_Ice._t_MarshalException, ())
    UnmarshalOutOfBoundsException._ice_type = _M_Ice._t_UnmarshalOutOfBoundsException

    _M_Ice.UnmarshalOutOfBoundsException = UnmarshalOutOfBoundsException
    del UnmarshalOutOfBoundsException

if not _M_Ice.__dict__.has_key('NoObjectFactoryException'):
    _M_Ice.NoObjectFactoryException = Ice.createTempClass()
    class NoObjectFactoryException(_M_Ice.MarshalException):
        '''This exception is raised if no suitable object factory was found during
unmarshaling of a Slice class instance.'''
        def __init__(self, reason='', type=''):
            _M_Ice.MarshalException.__init__(self, reason)
            self.type = type

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::NoObjectFactoryException'

    _M_Ice._t_NoObjectFactoryException = IcePy.defineException('::Ice::NoObjectFactoryException', NoObjectFactoryException, (), _M_Ice._t_MarshalException, (('type', (), IcePy._t_string),))
    NoObjectFactoryException._ice_type = _M_Ice._t_NoObjectFactoryException

    _M_Ice.NoObjectFactoryException = NoObjectFactoryException
    del NoObjectFactoryException

if not _M_Ice.__dict__.has_key('UnexpectedObjectException'):
    _M_Ice.UnexpectedObjectException = Ice.createTempClass()
    class UnexpectedObjectException(_M_Ice.MarshalException):
        '''This exception is raised if the type of an unmarshaled Slice class instance does
not match its expected type.
This can happen if client and server are compiled with mismatched Slice
definitions or if a class of the wrong type is passed as a parameter
or return value using dynamic invocation. This exception can also be
raised if IceStorm is used to send Slice class instances and
an operation is subscribed to the wrong topic.'''
        def __init__(self, reason='', type='', expectedType=''):
            _M_Ice.MarshalException.__init__(self, reason)
            self.type = type
            self.expectedType = expectedType

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::UnexpectedObjectException'

    _M_Ice._t_UnexpectedObjectException = IcePy.defineException('::Ice::UnexpectedObjectException', UnexpectedObjectException, (), _M_Ice._t_MarshalException, (
        ('type', (), IcePy._t_string),
        ('expectedType', (), IcePy._t_string)
    ))
    UnexpectedObjectException._ice_type = _M_Ice._t_UnexpectedObjectException

    _M_Ice.UnexpectedObjectException = UnexpectedObjectException
    del UnexpectedObjectException

if not _M_Ice.__dict__.has_key('MemoryLimitException'):
    _M_Ice.MemoryLimitException = Ice.createTempClass()
    class MemoryLimitException(_M_Ice.MarshalException):
        '''This exception is raised if a request size exceeds the limit specified by the Ice.MessageSizeMax property.'''
        def __init__(self, reason=''):
            _M_Ice.MarshalException.__init__(self, reason)

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::MemoryLimitException'

    _M_Ice._t_MemoryLimitException = IcePy.defineException('::Ice::MemoryLimitException', MemoryLimitException, (), _M_Ice._t_MarshalException, ())
    MemoryLimitException._ice_type = _M_Ice._t_MemoryLimitException

    _M_Ice.MemoryLimitException = MemoryLimitException
    del MemoryLimitException

if not _M_Ice.__dict__.has_key('StringConversionException'):
    _M_Ice.StringConversionException = Ice.createTempClass()
    class StringConversionException(_M_Ice.MarshalException):
        '''This exception is
raised when a string conversion to or from UTF-8 fails during 
marshaling or unmarshaling.'''
        def __init__(self, reason=''):
            _M_Ice.MarshalException.__init__(self, reason)

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::StringConversionException'

    _M_Ice._t_StringConversionException = IcePy.defineException('::Ice::StringConversionException', StringConversionException, (), _M_Ice._t_MarshalException, ())
    StringConversionException._ice_type = _M_Ice._t_StringConversionException

    _M_Ice.StringConversionException = StringConversionException
    del StringConversionException

if not _M_Ice.__dict__.has_key('EncapsulationException'):
    _M_Ice.EncapsulationException = Ice.createTempClass()
    class EncapsulationException(_M_Ice.MarshalException):
        '''This exception indicates a malformed data encapsulation.'''
        def __init__(self, reason=''):
            _M_Ice.MarshalException.__init__(self, reason)

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::EncapsulationException'

    _M_Ice._t_EncapsulationException = IcePy.defineException('::Ice::EncapsulationException', EncapsulationException, (), _M_Ice._t_MarshalException, ())
    EncapsulationException._ice_type = _M_Ice._t_EncapsulationException

    _M_Ice.EncapsulationException = EncapsulationException
    del EncapsulationException

if not _M_Ice.__dict__.has_key('FeatureNotSupportedException'):
    _M_Ice.FeatureNotSupportedException = Ice.createTempClass()
    class FeatureNotSupportedException(Ice.LocalException):
        '''This exception is raised if an unsupported feature is used. The
unsupported feature string contains the name of the unsupported
feature'''
        def __init__(self, unsupportedFeature=''):
            self.unsupportedFeature = unsupportedFeature

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::FeatureNotSupportedException'

    _M_Ice._t_FeatureNotSupportedException = IcePy.defineException('::Ice::FeatureNotSupportedException', FeatureNotSupportedException, (), None, (('unsupportedFeature', (), IcePy._t_string),))
    FeatureNotSupportedException._ice_type = _M_Ice._t_FeatureNotSupportedException

    _M_Ice.FeatureNotSupportedException = FeatureNotSupportedException
    del FeatureNotSupportedException

if not _M_Ice.__dict__.has_key('SecurityException'):
    _M_Ice.SecurityException = Ice.createTempClass()
    class SecurityException(Ice.LocalException):
        '''This exception indicates a failure in a security subsystem,
such as the IceSSL plug-in.'''
        def __init__(self, reason=''):
            self.reason = reason

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::SecurityException'

    _M_Ice._t_SecurityException = IcePy.defineException('::Ice::SecurityException', SecurityException, (), None, (('reason', (), IcePy._t_string),))
    SecurityException._ice_type = _M_Ice._t_SecurityException

    _M_Ice.SecurityException = SecurityException
    del SecurityException

if not _M_Ice.__dict__.has_key('FixedProxyException'):
    _M_Ice.FixedProxyException = Ice.createTempClass()
    class FixedProxyException(Ice.LocalException):
        '''This exception indicates that an attempt has been made to
change the connection properties of a fixed proxy.'''
        def __init__(self):
            pass

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::FixedProxyException'

    _M_Ice._t_FixedProxyException = IcePy.defineException('::Ice::FixedProxyException', FixedProxyException, (), None, ())
    FixedProxyException._ice_type = _M_Ice._t_FixedProxyException

    _M_Ice.FixedProxyException = FixedProxyException
    del FixedProxyException

if not _M_Ice.__dict__.has_key('ResponseSentException'):
    _M_Ice.ResponseSentException = Ice.createTempClass()
    class ResponseSentException(Ice.LocalException):
        '''Indicates that the response to a request has already been sent;
re-dispatching such a request is not possible.'''
        def __init__(self):
            pass

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Ice::ResponseSentException'

    _M_Ice._t_ResponseSentException = IcePy.defineException('::Ice::ResponseSentException', ResponseSentException, (), None, ())
    ResponseSentException._ice_type = _M_Ice._t_ResponseSentException

    _M_Ice.ResponseSentException = ResponseSentException
    del ResponseSentException

# End of module Ice
