class SessionNotExistException(Ice.UserException):
'''This exception is raised if a client tries to destroy a session
with a router, but no session exists for the client.'''
def __init__(self):
pass
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'Glacier2::SessionNotExistException'
_M_Glacier2._t_SessionNotExistException = IcePy.defineException(
'::Glacier2::SessionNotExistException', SessionNotExistException, (),
False, None, ())
SessionNotExistException._ice_type = _M_Glacier2._t_SessionNotExistException
_M_Glacier2.SessionNotExistException = SessionNotExistException
del SessionNotExistException
if 'Router' not in _M_Glacier2.__dict__:
_M_Glacier2.Router = Ice.createTempClass()
class Router(_M_Ice.Router):
'''The Glacier2 specialization of the Ice.Router
interface.'''
def __init__(self):
if Ice.getType(self) == _M_Glacier2.Router:
raise RuntimeError('Glacier2.Router is an abstract class')
if not _M_IceGrid.__dict__.has_key('ParseException'):
_M_IceGrid.ParseException = Ice.createTempClass()
class ParseException(Ice.UserException):
'''This exception is raised if an error occurs during parsing.'''
def __init__(self, reason=''):
self.reason = reason
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'IceGrid::ParseException'
_M_IceGrid._t_ParseException = IcePy.defineException('::IceGrid::ParseException', ParseException, (), None, (('reason', (), IcePy._t_string),))
ParseException._ice_type = _M_IceGrid._t_ParseException
_M_IceGrid.ParseException = ParseException
del ParseException
if not _M_IceGrid.__dict__.has_key('FileParser'):
_M_IceGrid.FileParser = Ice.createTempClass()
class FileParser(Ice.Object):
'''icegridadmin provides a FileParser
object to transform XML files into ApplicationDescriptor
objects.'''
def __init__(self):
if __builtin__.type(self) == _M_IceGrid.FileParser:
raise RuntimeError('IceGrid.FileParser is an abstract class')
_M_IceGrid.ParseException = Ice.createTempClass()
class ParseException(Ice.UserException):
'''This exception is raised if an error occurs during parsing.'''
def __init__(self, reason=''):
self.reason = reason
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'IceGrid::ParseException'
_M_IceGrid._t_ParseException = IcePy.defineException(
'::IceGrid::ParseException', ParseException, (), None,
(('reason', (), IcePy._t_string), ))
ParseException._ice_type = _M_IceGrid._t_ParseException
_M_IceGrid.ParseException = ParseException
del ParseException
if not _M_IceGrid.__dict__.has_key('FileParser'):
_M_IceGrid.FileParser = Ice.createTempClass()
class FileParser(Ice.Object):
'''icegridadmin provides a FileParser
object to transform XML files into ApplicationDescriptor
objects.'''
def __init__(self):
if __builtin__.type(self) == _M_IceGrid.FileParser:
if not _M_IcePatch2.__dict__.has_key('PartitionOutOfRangeException'):
_M_IcePatch2.PartitionOutOfRangeException = Ice.createTempClass()
class PartitionOutOfRangeException(Ice.UserException):
'''The partition argument for
FileServer#getFileInfoSeq was not in the range 0-255.'''
def __init__(self):
pass
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'IcePatch2::PartitionOutOfRangeException'
_M_IcePatch2._t_PartitionOutOfRangeException = IcePy.defineException('::IcePatch2::PartitionOutOfRangeException', PartitionOutOfRangeException, (), None, ())
PartitionOutOfRangeException._ice_type = _M_IcePatch2._t_PartitionOutOfRangeException
_M_IcePatch2.PartitionOutOfRangeException = PartitionOutOfRangeException
del PartitionOutOfRangeException
if not _M_IcePatch2.__dict__.has_key('FileAccessException'):
_M_IcePatch2.FileAccessException = Ice.createTempClass()
class FileAccessException(Ice.UserException):
'''This exception is raised if FileServer#getFileCompressed cannot read the
contents of a file.'''
def __init__(self, reason=''):
self.reason = reason
def __str__(self):
return IcePy.stringifyException(self)
__name__ = 'geocloud'
if not _M_geocloud.__dict__.has_key('AlreadyExists'):
_M_geocloud.AlreadyExists = Ice.createTempClass()
class AlreadyExists(Ice.UserException):
def __init__(self, key=''):
self.key = key
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'geocloud::AlreadyExists'
_M_geocloud._t_AlreadyExists = IcePy.defineException('::geocloud::AlreadyExists', AlreadyExists, (), None, (('key', (), IcePy._t_string),))
AlreadyExists._ice_type = _M_geocloud._t_AlreadyExists
_M_geocloud.AlreadyExists = AlreadyExists
del AlreadyExists
if not _M_geocloud.__dict__.has_key('NoSuchKey'):
_M_geocloud.NoSuchKey = Ice.createTempClass()
class NoSuchKey(Ice.UserException):
def __init__(self, key=''):
self.key = key
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
This exception is raised if an application does not exist.
Members:
name -- The name of the application.
"""
def __init__(self, name=''):
self.name = name
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_id = '::IceGrid::ApplicationNotExistException'
_M_IceGrid._t_ApplicationNotExistException = IcePy.defineException(
'::IceGrid::ApplicationNotExistException',
ApplicationNotExistException, (), False, None,
(('name', (), IcePy._t_string, False, 0), ))
ApplicationNotExistException._ice_type = _M_IceGrid._t_ApplicationNotExistException
_M_IceGrid.ApplicationNotExistException = ApplicationNotExistException
del ApplicationNotExistException
if 'ServerNotExistException' not in _M_IceGrid.__dict__:
_M_IceGrid.ServerNotExistException = Ice.createTempClass()
class ServerNotExistException(Ice.UserException):
"""
This exception is raised if a server does not exist.
Members:
id -- The identifier of the server.
"""
__name__ = 'Bank'
if 'IncorrectData' not in _M_Bank.__dict__:
_M_Bank.IncorrectData = Ice.createTempClass()
class IncorrectData(Ice.UserException):
def __init__(self, reason=''):
self.reason = reason
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'Bank::IncorrectData'
_M_Bank._t_IncorrectData = IcePy.defineException('::Bank::IncorrectData', IncorrectData, (), False, None, (('reason', (), IcePy._t_string, False, 0),))
IncorrectData._ice_type = _M_Bank._t_IncorrectData
_M_Bank.IncorrectData = IncorrectData
del IncorrectData
if 'RequestRejected' not in _M_Bank.__dict__:
_M_Bank.RequestRejected = Ice.createTempClass()
class RequestRejected(Ice.UserException):
def __init__(self, reason=''):
self.reason = reason
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
if 'UnsupportedCurrency' not in _M_Bank.__dict__:
_M_Bank.UnsupportedCurrency = Ice.createTempClass()
class UnsupportedCurrency(Ice.UserException):
def __init__(self):
pass
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_id = '::Bank::UnsupportedCurrency'
_M_Bank._t_UnsupportedCurrency = IcePy.defineException(
'::Bank::UnsupportedCurrency', UnsupportedCurrency, (), False, None,
())
UnsupportedCurrency._ice_type = _M_Bank._t_UnsupportedCurrency
_M_Bank.UnsupportedCurrency = UnsupportedCurrency
del UnsupportedCurrency
if 'InsufficientAccount' not in _M_Bank.__dict__:
_M_Bank.InsufficientAccount = Ice.createTempClass()
class InsufficientAccount(Ice.UserException):
def __init__(self):
pass
def __str__(self):
return IcePy.stringifyException(self)
if not _M_IceGrid.__dict__.has_key('UserAccountNotFoundException'):
_M_IceGrid.UserAccountNotFoundException = Ice.createTempClass()
class UserAccountNotFoundException(Ice.UserException):
'''This exception is raised if a user account for a given session
identifier can't be found.'''
def __init__(self):
pass
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'IceGrid::UserAccountNotFoundException'
_M_IceGrid._t_UserAccountNotFoundException = IcePy.defineException('::IceGrid::UserAccountNotFoundException', UserAccountNotFoundException, (), None, ())
UserAccountNotFoundException._ice_type = _M_IceGrid._t_UserAccountNotFoundException
_M_IceGrid.UserAccountNotFoundException = UserAccountNotFoundException
del UserAccountNotFoundException
if not _M_IceGrid.__dict__.has_key('UserAccountMapper'):
_M_IceGrid.UserAccountMapper = Ice.createTempClass()
class UserAccountMapper(Ice.Object):
'''A user account mapper object is used by IceGrid nodes to map
session identifiers to user accounts.'''
def __init__(self):
if __builtin__.type(self) == _M_IceGrid.UserAccountMapper:
raise RuntimeError('IceGrid.UserAccountMapper is an abstract class')
def ice_ids(self, current=None):
if not _M_Glacier2.__dict__.has_key('CannotCreateSessionException'):
_M_Glacier2.CannotCreateSessionException = Ice.createTempClass()
class CannotCreateSessionException(Ice.UserException):
'''This exception is raised if an attempt to create a new session
failed.'''
def __init__(self, reason=''):
self.reason = reason
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'Glacier2::CannotCreateSessionException'
_M_Glacier2._t_CannotCreateSessionException = IcePy.defineException('::Glacier2::CannotCreateSessionException', CannotCreateSessionException, (), None, (('reason', (), IcePy._t_string),))
CannotCreateSessionException._ice_type = _M_Glacier2._t_CannotCreateSessionException
_M_Glacier2.CannotCreateSessionException = CannotCreateSessionException
del CannotCreateSessionException
if not _M_Glacier2.__dict__.has_key('Session'):
_M_Glacier2.Session = Ice.createTempClass()
class Session(Ice.Object):
'''A client-visible session object, which is tied to the lifecycle of
a Router.'''
def __init__(self):
if __builtin__.type(self) == _M_Glacier2.Session:
raise RuntimeError('Glacier2.Session is an abstract class')
def ice_ids(self, current=None):
class ServerError(Ice.UserException):
def __init__(self, serverStackTrace='', serverExceptionClass='', message=''):
self.serverStackTrace = serverStackTrace
self.serverExceptionClass = serverExceptionClass
self.message = message
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'omero::ServerError'
_M_omero._t_ServerError = IcePy.defineException('::omero::ServerError', ServerError, (), None, (
('serverStackTrace', (), IcePy._t_string),
('serverExceptionClass', (), IcePy._t_string),
('message', (), IcePy._t_string)
))
ServerError._ice_type = _M_omero._t_ServerError
_M_omero.ServerError = ServerError
del ServerError
if not _M_omero.__dict__.has_key('SessionException'):
_M_omero.SessionException = Ice.createTempClass()
class SessionException(_M_omero.ServerError):
'''Base session exception, though in the OMERO.blitz
implementation, all exceptions thrown by the Glacier2
must subclass CannotCreateSessionException. See below.'''
def __init__(self, serverStackTrace='', serverExceptionClass='', message=''):
_M_omero.ServerError.__init__(self, serverStackTrace, serverExceptionClass, message)
if "IncorrectData" not in _M_Bank.__dict__:
_M_Bank.IncorrectData = Ice.createTempClass()
class IncorrectData(Ice.UserException):
def __init__(self, reason=""):
self.reason = reason
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = "Bank::IncorrectData"
_M_Bank._t_IncorrectData = IcePy.defineException(
"::Bank::IncorrectData", IncorrectData, (), False, None, (("reason", (), IcePy._t_string, False, 0),)
)
IncorrectData._ice_type = _M_Bank._t_IncorrectData
_M_Bank.IncorrectData = IncorrectData
del IncorrectData
if "RequestRejected" not in _M_Bank.__dict__:
_M_Bank.RequestRejected = Ice.createTempClass()
class RequestRejected(Ice.UserException):
def __init__(self, reason=""):
self.reason = reason
def __str__(self):
return IcePy.stringifyException(self)
__name__ = 'Arithmetic'
if 'GenericError' not in _M_Arithmetic.__dict__:
_M_Arithmetic.GenericError = Ice.createTempClass()
class GenericError(Ice.UserException):
def __init__(self, reason=''):
self.reason = reason
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'Arithmetic::GenericError'
_M_Arithmetic._t_GenericError = IcePy.defineException('::Arithmetic::GenericError', GenericError, (), False, None, (('reason', (), IcePy._t_string, False, 0),))
GenericError._ice_type = _M_Arithmetic._t_GenericError
_M_Arithmetic.GenericError = GenericError
del GenericError
if 'Natural' not in _M_Arithmetic.__dict__:
_M_Arithmetic.Natural = Ice.createTempClass()
class Natural(Ice.Object):
def __init__(self):
if Ice.getType(self) == _M_Arithmetic.Natural:
raise RuntimeError('Arithmetic.Natural is an abstract class')
def ice_ids(self, current=None):
return ('::Arithmetic::Natural', '::Ice::Object')
if not _M_IceStorm.__dict__.has_key('LinkExists'):
_M_IceStorm.LinkExists = Ice.createTempClass()
class LinkExists(Ice.UserException):
'''This exception indicates that an attempt was made to create a link
that already exists.'''
def __init__(self, name=''):
self.name = name
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'IceStorm::LinkExists'
_M_IceStorm._t_LinkExists = IcePy.defineException('::IceStorm::LinkExists', LinkExists, (), None, (('name', (), IcePy._t_string),))
LinkExists._ice_type = _M_IceStorm._t_LinkExists
_M_IceStorm.LinkExists = LinkExists
del LinkExists
if not _M_IceStorm.__dict__.has_key('NoSuchLink'):
_M_IceStorm.NoSuchLink = Ice.createTempClass()
class NoSuchLink(Ice.UserException):
'''This exception indicates that an attempt was made to remove a
link that does not exist.'''
def __init__(self, name=''):
self.name = name
def __str__(self):
return IcePy.stringifyException(self)
del Currency
if 'UserNotLoggedException' not in _M_assignment2.__dict__:
_M_assignment2.UserNotLoggedException = Ice.createTempClass()
class UserNotLoggedException(Ice.UserException):
def __init__(self):
pass
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'assignment2::UserNotLoggedException'
_M_assignment2._t_UserNotLoggedException = IcePy.defineException('::assignment2::UserNotLoggedException', UserNotLoggedException, (), False, None, ())
UserNotLoggedException._ice_type = _M_assignment2._t_UserNotLoggedException
_M_assignment2.UserNotLoggedException = UserNotLoggedException
del UserNotLoggedException
if 'Loan' not in _M_assignment2.__dict__:
_M_assignment2.Loan = Ice.createTempClass()
class Loan(object):
def __init__(self, interest='', paid='', toPay='', monthsLeft=0):
self.interest = interest
self.paid = paid
self.toPay = toPay
self.monthsLeft = monthsLeft
def __hash__(self):
class FailureException(Ice.LocalException):
'''This exception is a general failure notification. It is thrown
for errors such as a service encountering an error during
initialization, or the service manager being unable
to load a service executable.'''
def __init__(self, reason=''):
self.reason = reason
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'IceBox::FailureException'
_M_IceBox._t_FailureException = IcePy.defineException('::IceBox::FailureException', FailureException, (), None, (('reason', (), IcePy._t_string),))
FailureException._ice_type = _M_IceBox._t_FailureException
_M_IceBox.FailureException = FailureException
del FailureException
if not _M_IceBox.__dict__.has_key('AlreadyStartedException'):
_M_IceBox.AlreadyStartedException = Ice.createTempClass()
class AlreadyStartedException(Ice.UserException):
'''This exception is thrown if an attempt is made to start an
already-started service.'''
def __init__(self):
pass
def __str__(self):
return IcePy.stringifyException(self)
_M_Vistek.Core.GenericError = Ice.createTempClass()
class GenericError(Ice.UserException):
def __init__(self, errorCode=0, errorMessage=''):
self.errorCode = errorCode
self.errorMessage = errorMessage
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'Vistek::Core::GenericError'
_M_Vistek.Core._t_GenericError = IcePy.defineException(
'::Vistek::Core::GenericError', GenericError, (), False, None,
(('errorCode', (), IcePy._t_int, False, 0),
('errorMessage', (), IcePy._t_string, False, 0)))
GenericError._ice_type = _M_Vistek.Core._t_GenericError
_M_Vistek.Core.GenericError = GenericError
del GenericError
if 'ServiceException' not in _M_Vistek.Core.__dict__:
_M_Vistek.Core.ServiceException = Ice.createTempClass()
class ServiceException(_M_Vistek.Core.GenericError):
def __init__(self, errorCode=0, errorMessage=''):
_M_Vistek.Core.GenericError.__init__(self, errorCode, errorMessage)
def __str__(self):
return IcePy.stringifyException(self)
if 'UnknownMetricsView' not in _M_IceMX.__dict__:
_M_IceMX.UnknownMetricsView = Ice.createTempClass()
class UnknownMetricsView(Ice.UserException):
'''Raised if a metrics view cannot be found.'''
def __init__(self):
pass
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'IceMX::UnknownMetricsView'
_M_IceMX._t_UnknownMetricsView = IcePy.defineException(
'::IceMX::UnknownMetricsView', UnknownMetricsView, (), False, None, ())
UnknownMetricsView._ice_type = _M_IceMX._t_UnknownMetricsView
_M_IceMX.UnknownMetricsView = UnknownMetricsView
del UnknownMetricsView
if 'MetricsAdmin' not in _M_IceMX.__dict__:
_M_IceMX.MetricsAdmin = Ice.createTempClass()
class MetricsAdmin(Ice.Object):
'''The metrics administrative facet interface. This interface allows
remote administrative clients to access metrics of an application
that enabled the Ice administrative facility and configured some
metrics views.'''
def __init__(self):
if Ice.getType(self) == _M_IceMX.MetricsAdmin:
__name__ = 'RoboCompJointMotor'
if 'HardwareFailedException' not in _M_RoboCompJointMotor.__dict__:
_M_RoboCompJointMotor.HardwareFailedException = Ice.createTempClass()
class HardwareFailedException(Ice.UserException):
def __init__(self, what=''):
self.what = what
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'RoboCompJointMotor::HardwareFailedException'
_M_RoboCompJointMotor._t_HardwareFailedException = IcePy.defineException('::RoboCompJointMotor::HardwareFailedException', HardwareFailedException, (), False, None, (('what', (), IcePy._t_string, False, 0),))
HardwareFailedException._ice_type = _M_RoboCompJointMotor._t_HardwareFailedException
_M_RoboCompJointMotor.HardwareFailedException = HardwareFailedException
del HardwareFailedException
if 'OutOfRangeException' not in _M_RoboCompJointMotor.__dict__:
_M_RoboCompJointMotor.OutOfRangeException = Ice.createTempClass()
class OutOfRangeException(Ice.UserException):
def __init__(self, what=''):
self.what = what
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
del EnumNone
if not _M_FS.__dict__.has_key('myexcep'):
_M_FS.myexcep = Ice.createTempClass()
class myexcep(Ice.UserException):
def __init__(self, _lambda=0):
self._lambda = _lambda
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'FS::myexcep'
_M_FS._t_myexcep = IcePy.defineException('::FS::myexcep', myexcep, (), None, (('_lambda', (), IcePy._t_int),))
myexcep._ice_type = _M_FS._t_myexcep
_M_FS.myexcep = myexcep
del myexcep
if not _M_FS.__dict__.has_key('_t_File'):
_M_FS._t_File = IcePy.defineSequence('::FS::File', (), IcePy._t_byte)
if not _M_FS.__dict__.has_key('Api'):
_M_FS.Api = Ice.createTempClass()
class Api(Ice.Object):
def __init__(self):
if __builtin__.type(self) == _M_FS.Api:
raise RuntimeError('FS.Api is an abstract class')
if 'NotPermittedError' not in _M_Bank.__dict__:
_M_Bank.NotPermittedError = Ice.createTempClass()
class NotPermittedError(Ice.UserException):
def __init__(self, message=''):
self.message = message
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_id = '::Bank::NotPermittedError'
_M_Bank._t_NotPermittedError = IcePy.defineException(
'::Bank::NotPermittedError', NotPermittedError, (), False, None,
(('message', (), IcePy._t_string, False, 0), ))
NotPermittedError._ice_type = _M_Bank._t_NotPermittedError
_M_Bank.NotPermittedError = NotPermittedError
del NotPermittedError
if 'NoSuchAccountError' not in _M_Bank.__dict__:
_M_Bank.NoSuchAccountError = Ice.createTempClass()
class NoSuchAccountError(Ice.UserException):
def __init__(self):
pass
def __str__(self):
return IcePy.stringifyException(self)
def __init__(self, timeOfError=Ice._struct_marker, reason=''):
if timeOfError is Ice._struct_marker:
self.timeOfError = _M_SmartHouse.Time()
else:
self.timeOfError = timeOfError
self.reason = reason
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_id = '::SmartHouse::DeviceError'
_M_SmartHouse._t_DeviceError = IcePy.defineException(
'::SmartHouse::DeviceError', DeviceError, (), False, None,
(('timeOfError', (), _M_SmartHouse._t_Time, False, 0),
('reason', (), IcePy._t_string, False, 0)))
DeviceError._ice_type = _M_SmartHouse._t_DeviceError
_M_SmartHouse.DeviceError = DeviceError
del DeviceError
if 'OutOfRangeExc' not in _M_SmartHouse.__dict__:
_M_SmartHouse.OutOfRangeExc = Ice.createTempClass()
class OutOfRangeExc(_M_SmartHouse.DeviceError):
def __init__(self, timeOfError=Ice._struct_marker, reason=''):
_M_SmartHouse.DeviceError.__init__(self, timeOfError, reason)
def __str__(self):
return IcePy.stringifyException(self)
del PlayerPrx
if 'GameInProgress' not in _M_drobots.__dict__:
_M_drobots.GameInProgress = Ice.createTempClass()
class GameInProgress(Ice.UserException):
def __init__(self):
pass
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'drobots::GameInProgress'
_M_drobots._t_GameInProgress = IcePy.defineException('::drobots::GameInProgress', GameInProgress, (), False, None, ())
GameInProgress._ice_type = _M_drobots._t_GameInProgress
_M_drobots.GameInProgress = GameInProgress
del GameInProgress
if 'Game' not in _M_drobots.__dict__:
_M_drobots.Game = Ice.createTempClass()
class Game(Ice.Object):
def __init__(self):
if Ice.getType(self) == _M_drobots.Game:
raise RuntimeError('drobots.Game is an abstract class')
def ice_ids(self, current=None):
return ('::Ice::Object', '::drobots::Game')
__name__ = 'Bank'
if not _M_Bank.__dict__.has_key('UserAlreadyLoggedInException'):
_M_Bank.UserAlreadyLoggedInException = Ice.createTempClass()
class UserAlreadyLoggedInException(Ice.UserException):
def __init__(self, description=''):
self.description = description
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'Bank::UserAlreadyLoggedInException'
_M_Bank._t_UserAlreadyLoggedInException = IcePy.defineException('::Bank::UserAlreadyLoggedInException', UserAlreadyLoggedInException, (), None, (('description', (), IcePy._t_string),))
UserAlreadyLoggedInException._ice_type = _M_Bank._t_UserAlreadyLoggedInException
_M_Bank.UserAlreadyLoggedInException = UserAlreadyLoggedInException
del UserAlreadyLoggedInException
if not _M_Bank.__dict__.has_key('UserNotExistException'):
_M_Bank.UserNotExistException = Ice.createTempClass()
class UserNotExistException(Ice.UserException):
def __init__(self, description=''):
self.description = description
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
class CannotCreateSessionException(Ice.UserException):
'''This exception is raised if an attempt to create a new session
failed.'''
def __init__(self, reason=''):
self.reason = reason
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'Glacier2::CannotCreateSessionException'
_M_Glacier2._t_CannotCreateSessionException = IcePy.defineException(
'::Glacier2::CannotCreateSessionException',
CannotCreateSessionException, (), None,
(('reason', (), IcePy._t_string), ))
CannotCreateSessionException._ice_type = _M_Glacier2._t_CannotCreateSessionException
_M_Glacier2.CannotCreateSessionException = CannotCreateSessionException
del CannotCreateSessionException
if not _M_Glacier2.__dict__.has_key('Session'):
_M_Glacier2.Session = Ice.createTempClass()
class Session(Ice.Object):
'''A client-visible session object, which is tied to the lifecycle of
a Router.'''
def __init__(self):
if __builtin__.type(self) == _M_Glacier2.Session:
raise RuntimeError('Glacier2.Session is an abstract class')
class LinkExists(Ice.UserException):
'''This exception indicates that an attempt was made to create a link
that already exists.'''
def __init__(self, name=''):
self.name = name
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'IceStorm::LinkExists'
_M_IceStorm._t_LinkExists = IcePy.defineException(
'::IceStorm::LinkExists', LinkExists, (), None,
(('name', (), IcePy._t_string), ))
LinkExists._ice_type = _M_IceStorm._t_LinkExists
_M_IceStorm.LinkExists = LinkExists
del LinkExists
if not _M_IceStorm.__dict__.has_key('NoSuchLink'):
_M_IceStorm.NoSuchLink = Ice.createTempClass()
class NoSuchLink(Ice.UserException):
'''This exception indicates that an attempt was made to remove a
link that does not exist.'''
def __init__(self, name=''):
self.name = name
if 'BaseException' not in _M_IotController.__dict__:
_M_IotController.BaseException = Ice.createTempClass()
class BaseException(Ice.UserException):
def __init__(self, message=''):
self.message = message
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_id = '::IotController::BaseException'
_M_IotController._t_BaseException = IcePy.defineException(
'::IotController::BaseException', BaseException, (), False, None,
(('message', (), IcePy._t_string, False, 0), ))
BaseException._ice_type = _M_IotController._t_BaseException
_M_IotController.BaseException = BaseException
del BaseException
if 'ArgumentException' not in _M_IotController.__dict__:
_M_IotController.ArgumentException = Ice.createTempClass()
class ArgumentException(_M_IotController.BaseException):
def __init__(self, message=''):
_M_IotController.BaseException.__init__(self, message)
def __str__(self):
return IcePy.stringifyException(self)
if 'ImproperValue' not in _M_Domotics.__dict__:
_M_Domotics.ImproperValue = Ice.createTempClass()
class ImproperValue(Ice.UserException):
def __init__(self, message=''):
self.message = message
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_id = '::Domotics::ImproperValue'
_M_Domotics._t_ImproperValue = IcePy.defineException(
'::Domotics::ImproperValue', ImproperValue, (), False, None,
(('message', (), IcePy._t_string, False, 0), ))
ImproperValue._ice_type = _M_Domotics._t_ImproperValue
_M_Domotics.ImproperValue = ImproperValue
del ImproperValue
_M_Domotics._t_Heater = IcePy.defineValue('::Domotics::Heater', Ice.Value, -1,
(), False, True, None, ())
if 'HeaterPrx' not in _M_Domotics.__dict__:
_M_Domotics.HeaterPrx = Ice.createTempClass()
class HeaterPrx(Ice.ObjectPrx):
def getTemperature(self, context=None):
return _M_Domotics.Heater._op_getTemperature.invoke(
if 'AlreadyControlledException' not in _M_Demo.__dict__:
_M_Demo.AlreadyControlledException = Ice.createTempClass()
class AlreadyControlledException(Ice.UserException):
def __init__(self, byWho=''):
self.byWho = byWho
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'Demo::AlreadyControlledException'
_M_Demo._t_AlreadyControlledException = IcePy.defineException(
'::Demo::AlreadyControlledException', AlreadyControlledException, (),
False, None, (('byWho', (), IcePy._t_string, False, 0), ))
AlreadyControlledException._ice_type = _M_Demo._t_AlreadyControlledException
_M_Demo.AlreadyControlledException = AlreadyControlledException
del AlreadyControlledException
if 'NotKnownDeviceException' not in _M_Demo.__dict__:
_M_Demo.NotKnownDeviceException = Ice.createTempClass()
class NotKnownDeviceException(Ice.UserException):
def __init__(self, explanation=''):
self.explanation = explanation
def __str__(self):
return IcePy.stringifyException(self)
if 'BankException' not in _M_Bank.__dict__:
_M_Bank.BankException = Ice.createTempClass()
class BankException(Ice.UserException):
def __init__(self, msg=''):
self.msg = msg
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_id = '::Bank::BankException'
_M_Bank._t_BankException = IcePy.defineException(
'::Bank::BankException', BankException, (), False, None,
(('msg', (), IcePy._t_string, False, 0), ))
BankException._ice_type = _M_Bank._t_BankException
_M_Bank.BankException = BankException
del BankException
if 'AccountException' not in _M_Bank.__dict__:
_M_Bank.AccountException = Ice.createTempClass()
class AccountException(_M_Bank.BankException):
def __init__(self,
msg='',
errorType=_M_Bank.AccountError.AMOUNTNEGATIVE):
_M_Bank.BankException.__init__(self, msg)
self.errorType = errorType
if not _M_Ice.__dict__.has_key('AdapterNotFoundException'):
_M_Ice.AdapterNotFoundException = Ice.createTempClass()
class AdapterNotFoundException(Ice.UserException):
'''This exception is raised if an adapter cannot be found.'''
def __init__(self):
pass
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'Ice::AdapterNotFoundException'
_M_Ice._t_AdapterNotFoundException = IcePy.defineException('::Ice::AdapterNotFoundException', AdapterNotFoundException, (), None, ())
AdapterNotFoundException._ice_type = _M_Ice._t_AdapterNotFoundException
_M_Ice.AdapterNotFoundException = AdapterNotFoundException
del AdapterNotFoundException
if not _M_Ice.__dict__.has_key('InvalidReplicaGroupIdException'):
_M_Ice.InvalidReplicaGroupIdException = Ice.createTempClass()
class InvalidReplicaGroupIdException(Ice.UserException):
'''This exception is raised if the replica group provided by the
server is invalid.'''
def __init__(self):
pass
def __str__(self):
return IcePy.stringifyException(self)
if 'ErrorBase' not in _M_Utils.__dict__:
_M_Utils.ErrorBase = Ice.createTempClass()
class ErrorBase(Ice.UserException):
def __init__(self, description='', debug=''):
self.description = description
self.debug = debug
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'Utils::ErrorBase'
_M_Utils._t_ErrorBase = IcePy.defineException('::Utils::ErrorBase', ErrorBase, (), False, None, (
('description', (), IcePy._t_string, False, 0),
('debug', (), IcePy._t_string, False, 0)
))
ErrorBase._ice_type = _M_Utils._t_ErrorBase
_M_Utils.ErrorBase = ErrorBase
del ErrorBase
if 'SystemError' not in _M_Utils.__dict__:
_M_Utils.SystemError = Ice.createTempClass()
class SystemError(_M_Utils.ErrorBase):
"""
系统调用失败错误
"""
def __init__(self, description='', debug='', rawCode=0):
_M_Utils.ErrorBase.__init__(self, description, debug)
self.rawCode = rawCode
if not _M_MyUtil.__dict__.has_key('MceException'):
_M_MyUtil.MceException = Ice.createTempClass()
class MceException(Ice.UserException):
def __init__(self, message=''):
self.message = message
def ice_name(self):
return 'MyUtil::MceException'
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_M_MyUtil._t_MceException = IcePy.defineException('::MyUtil::MceException', MceException, (), None, (('message', (), IcePy._t_string),))
MceException.ice_type = _M_MyUtil._t_MceException
_M_MyUtil.MceException = MceException
del MceException
if not _M_MyUtil.__dict__.has_key('NoSuchObjectException'):
_M_MyUtil.NoSuchObjectException = Ice.createTempClass()
class NoSuchObjectException(_M_MyUtil.MceException):
def __init__(self, message=''):
_M_MyUtil.MceException.__init__(self, message)
def ice_name(self):
return 'MyUtil::NoSuchObjectException'
def __str__(self):
This exception is raised if a client is denied the ability to create
a session with the router.
Members:
reason -- The reason why permission was denied.
"""
def __init__(self, reason=''):
self.reason = reason
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_id = '::Glacier2::PermissionDeniedException'
_M_Glacier2._t_PermissionDeniedException = IcePy.defineException('::Glacier2::PermissionDeniedException', PermissionDeniedException, (), True, None, (('reason', (), IcePy._t_string, False, 0),))
PermissionDeniedException._ice_type = _M_Glacier2._t_PermissionDeniedException
_M_Glacier2.PermissionDeniedException = PermissionDeniedException
del PermissionDeniedException
_M_Glacier2._t_PermissionsVerifier = IcePy.defineValue('::Glacier2::PermissionsVerifier', Ice.Value, -1, (), False, True, None, ())
if 'PermissionsVerifierPrx' not in _M_Glacier2.__dict__:
_M_Glacier2.PermissionsVerifierPrx = Ice.createTempClass()
class PermissionsVerifierPrx(Ice.ObjectPrx):
"""
Check whether a user has permission to access the router.
Arguments:
userId -- The user id for which to check permission.
del AccountInfo
if 'AccountException' not in _M_Bank.__dict__:
_M_Bank.AccountException = Ice.createTempClass()
class AccountException(Ice.UserException):
def __init__(self, message=''):
self.message = message
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_id = '::Bank::AccountException'
_M_Bank._t_AccountException = IcePy.defineException('::Bank::AccountException', AccountException, (), False, None, (('message', (), IcePy._t_string, False, 0),))
AccountException._ice_type = _M_Bank._t_AccountException
_M_Bank.AccountException = AccountException
del AccountException
if 'LoginException' not in _M_Bank.__dict__:
_M_Bank.LoginException = Ice.createTempClass()
class LoginException(Ice.UserException):
def __init__(self, message=''):
self.message = message
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
def __init__(self, errorTime=Ice._struct_marker, reason=''):
if errorTime is Ice._struct_marker:
self.errorTime = _M_SmartHouse.TimeOfDay()
else:
self.errorTime = errorTime
self.reason = reason
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_id = '::SmartHouse::Error'
_M_SmartHouse._t_Error = IcePy.defineException(
'::SmartHouse::Error', Error, (), False, None,
(('errorTime', (), _M_SmartHouse._t_TimeOfDay, False, 0),
('reason', (), IcePy._t_string, False, 0)))
Error._ice_type = _M_SmartHouse._t_Error
_M_SmartHouse.Error = Error
del Error
if 'OutOfRangeError' not in _M_SmartHouse.__dict__:
_M_SmartHouse.OutOfRangeError = Ice.createTempClass()
class OutOfRangeError(_M_SmartHouse.Error):
def __init__(self, errorTime=Ice._struct_marker, reason=''):
_M_SmartHouse.Error.__init__(self, errorTime, reason)
def __str__(self):
return IcePy.stringifyException(self)
class PartitionOutOfRangeException(Ice.UserException):
'''The partition argument for
FileServer#getFileInfoSeq was not in the range 0-255.'''
def __init__(self):
pass
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'IcePatch2::PartitionOutOfRangeException'
_M_IcePatch2._t_PartitionOutOfRangeException = IcePy.defineException(
'::IcePatch2::PartitionOutOfRangeException',
PartitionOutOfRangeException, (), False, None, ())
PartitionOutOfRangeException._ice_type = _M_IcePatch2._t_PartitionOutOfRangeException
_M_IcePatch2.PartitionOutOfRangeException = PartitionOutOfRangeException
del PartitionOutOfRangeException
if 'FileAccessException' not in _M_IcePatch2.__dict__:
_M_IcePatch2.FileAccessException = Ice.createTempClass()
class FileAccessException(Ice.UserException):
'''This exception is raised if FileServer#getFileCompressed cannot read the
contents of a file.'''
def __init__(self, reason=''):
self.reason = reason
del ProcessPrx
if not _M_guitarlib.__dict__.has_key('InvalidConfiguration'):
_M_guitarlib.InvalidConfiguration = Ice.createTempClass()
class InvalidConfiguration(Ice.UserException):
def __init__(self, reason=''):
self.reason = reason
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'guitarlib::InvalidConfiguration'
_M_guitarlib._t_InvalidConfiguration = IcePy.defineException('::guitarlib::InvalidConfiguration', InvalidConfiguration, (), None, (('reason', (), IcePy._t_string),))
InvalidConfiguration._ice_type = _M_guitarlib._t_InvalidConfiguration
_M_guitarlib.InvalidConfiguration = InvalidConfiguration
del InvalidConfiguration
if not _M_guitarlib.__dict__.has_key('_t_Configuration'):
_M_guitarlib._t_Configuration = IcePy.defineDictionary('::guitarlib::Configuration', (), IcePy._t_string, IcePy._t_string)
if not _M_guitarlib.__dict__.has_key('Application'):
_M_guitarlib.Application = Ice.createTempClass()
class Application(Ice.Object):
def __init__(self):
if __builtin__.type(self) == _M_guitarlib.Application:
raise RuntimeError('guitarlib.Application is an abstract class')
'''This exception is a general failure notification. It is thrown
for errors such as a service encountering an error during
initialization, or the service manager being unable
to load a service executable.'''
def __init__(self, reason=''):
self.reason = reason
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'IceBox::FailureException'
_M_IceBox._t_FailureException = IcePy.defineException(
'::IceBox::FailureException', FailureException, (), False, None,
(('reason', (), IcePy._t_string, False, 0), ))
FailureException._ice_type = _M_IceBox._t_FailureException
_M_IceBox.FailureException = FailureException
del FailureException
if 'AlreadyStartedException' not in _M_IceBox.__dict__:
_M_IceBox.AlreadyStartedException = Ice.createTempClass()
class AlreadyStartedException(Ice.UserException):
'''This exception is thrown if an attempt is made to start an
already-started service.'''
def __init__(self):
pass
class UserAccountNotFoundException(Ice.UserException):
'''This exception is raised if a user account for a given session
identifier can't be found.'''
def __init__(self):
pass
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'IceGrid::UserAccountNotFoundException'
_M_IceGrid._t_UserAccountNotFoundException = IcePy.defineException(
'::IceGrid::UserAccountNotFoundException',
UserAccountNotFoundException, (), None, ())
UserAccountNotFoundException._ice_type = _M_IceGrid._t_UserAccountNotFoundException
_M_IceGrid.UserAccountNotFoundException = UserAccountNotFoundException
del UserAccountNotFoundException
if not _M_IceGrid.__dict__.has_key('UserAccountMapper'):
_M_IceGrid.UserAccountMapper = Ice.createTempClass()
class UserAccountMapper(Ice.Object):
'''A user account mapper object is used by IceGrid nodes to map
session identifiers to user accounts.'''
def __init__(self):
if __builtin__.type(self) == _M_IceGrid.UserAccountMapper:
raise RuntimeError(
if 'LoanNotAllowed' not in _M_Bank.__dict__:
_M_Bank.LoanNotAllowed = Ice.createTempClass()
class LoanNotAllowed(Ice.UserException):
def __init__(self):
pass
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_id = '::Bank::LoanNotAllowed'
_M_Bank._t_LoanNotAllowed = IcePy.defineException('::Bank::LoanNotAllowed',
LoanNotAllowed, (),
False, None, ())
LoanNotAllowed._ice_type = _M_Bank._t_LoanNotAllowed
_M_Bank.LoanNotAllowed = LoanNotAllowed
del LoanNotAllowed
if 'CurrencyNoctSupported' not in _M_Bank.__dict__:
_M_Bank.CurrencyNoctSupported = Ice.createTempClass()
class CurrencyNoctSupported(Ice.UserException):
def __init__(self):
pass
def __str__(self):
return IcePy.stringifyException(self)
if 'InvalidCredentials' not in _M_Bank.__dict__:
_M_Bank.InvalidCredentials = Ice.createTempClass()
class InvalidCredentials(Ice.UserException):
def __init__(self):
pass
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_id = '::Bank::InvalidCredentials'
_M_Bank._t_InvalidCredentials = IcePy.defineException(
'::Bank::InvalidCredentials', InvalidCredentials, (), False, None, ())
InvalidCredentials._ice_type = _M_Bank._t_InvalidCredentials
_M_Bank.InvalidCredentials = InvalidCredentials
del InvalidCredentials
if 'LoanRejectionError' not in _M_Bank.__dict__:
_M_Bank.LoanRejectionError = Ice.createTempClass()
class LoanRejectionError(Ice.UserException):
def __init__(self, reason=''):
self.reason = reason
def __str__(self):
return IcePy.stringifyException(self)
class RemoteLoggerAlreadyAttachedException(Ice.UserException):
'''An exception thrown by LoggerAdmin#attachRemoteLogger to report
that the provided RemoteLogger was previously attached to this
LoggerAdmin.'''
def __init__(self):
pass
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'Ice::RemoteLoggerAlreadyAttachedException'
_M_Ice._t_RemoteLoggerAlreadyAttachedException = IcePy.defineException(
'::Ice::RemoteLoggerAlreadyAttachedException',
RemoteLoggerAlreadyAttachedException, (), False, None, ())
RemoteLoggerAlreadyAttachedException._ice_type = _M_Ice._t_RemoteLoggerAlreadyAttachedException
_M_Ice.RemoteLoggerAlreadyAttachedException = RemoteLoggerAlreadyAttachedException
del RemoteLoggerAlreadyAttachedException
if 'LoggerAdmin' not in _M_Ice.__dict__:
_M_Ice.LoggerAdmin = Ice.createTempClass()
class LoggerAdmin(Ice.Object):
'''The interface of the admin object that allows an Ice application the attach its
RemoteLogger to the Logger of this admin object's Ice communicator.'''
def __init__(self):
if Ice.getType(self) == _M_Ice.LoggerAdmin:
raise RuntimeError('Ice.LoggerAdmin is an abstract class')
if 'JderobotException' not in _M_jderobot.__dict__:
_M_jderobot.JderobotException = Ice.createTempClass()
class JderobotException(Ice.UserException):
def __init__(self, what=''):
self.what = what
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'jderobot::JderobotException'
_M_jderobot._t_JderobotException = IcePy.defineException(
'::jderobot::JderobotException', JderobotException, (), False, None,
(('what', (), IcePy._t_string, False, 0), ))
JderobotException._ice_type = _M_jderobot._t_JderobotException
_M_jderobot.JderobotException = JderobotException
del JderobotException
if 'ConfigurationNotExistException' not in _M_jderobot.__dict__:
_M_jderobot.ConfigurationNotExistException = Ice.createTempClass()
class ConfigurationNotExistException(_M_jderobot.JderobotException):
def __init__(self, what=''):
_M_jderobot.JderobotException.__init__(self, what)
def __str__(self):
return IcePy.stringifyException(self)
if not _M_IceGrid.__dict__.has_key('ApplicationNotExistException'):
_M_IceGrid.ApplicationNotExistException = Ice.createTempClass()
class ApplicationNotExistException(Ice.UserException):
'''This exception is raised if an application does not exist.'''
def __init__(self, name=''):
self.name = name
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'IceGrid::ApplicationNotExistException'
_M_IceGrid._t_ApplicationNotExistException = IcePy.defineException('::IceGrid::ApplicationNotExistException', ApplicationNotExistException, (), None, (('name', (), IcePy._t_string),))
ApplicationNotExistException._ice_type = _M_IceGrid._t_ApplicationNotExistException
_M_IceGrid.ApplicationNotExistException = ApplicationNotExistException
del ApplicationNotExistException
if not _M_IceGrid.__dict__.has_key('ServerNotExistException'):
_M_IceGrid.ServerNotExistException = Ice.createTempClass()
class ServerNotExistException(Ice.UserException):
'''This exception is raised if a server does not exist.'''
def __init__(self, id=''):
self.id = id
def __str__(self):
return IcePy.stringifyException(self)
if not _M_FS.__dict__.has_key('myexcep'):
_M_FS.myexcep = Ice.createTempClass()
class myexcep(Ice.UserException):
def __init__(self, _lambda=0):
self._lambda = _lambda
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'FS::myexcep'
_M_FS._t_myexcep = IcePy.defineException('::FS::myexcep', myexcep, (),
None,
(('_lambda', (), IcePy._t_int), ))
myexcep._ice_type = _M_FS._t_myexcep
_M_FS.myexcep = myexcep
del myexcep
if not _M_FS.__dict__.has_key('_t_File'):
_M_FS._t_File = IcePy.defineSequence('::FS::File', (), IcePy._t_byte)
if not _M_FS.__dict__.has_key('Api'):
_M_FS.Api = Ice.createTempClass()
class Api(Ice.Object):
def __init__(self):
if __builtin__.type(self) == _M_FS.Api:
if 'InvalidOperationException' not in _M_Home.__dict__:
_M_Home.InvalidOperationException = Ice.createTempClass()
class InvalidOperationException(Ice.UserException):
def __init__(self):
pass
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_id = '::Home::InvalidOperationException'
_M_Home._t_InvalidOperationException = IcePy.defineException(
'::Home::InvalidOperationException', InvalidOperationException, (),
False, None, ())
InvalidOperationException._ice_type = _M_Home._t_InvalidOperationException
_M_Home.InvalidOperationException = InvalidOperationException
del InvalidOperationException
if 'AlreadyOnException' not in _M_Home.__dict__:
_M_Home.AlreadyOnException = Ice.createTempClass()
class AlreadyOnException(_M_Home.InvalidOperationException):
def __init__(self):
_M_Home.InvalidOperationException.__init__(self)
def __str__(self):
return IcePy.stringifyException(self)
if 'InvalidTokenException' not in _M_device_repo_ice.__dict__:
_M_device_repo_ice.InvalidTokenException = Ice.createTempClass()
class InvalidTokenException(Ice.UserException):
def __init__(self):
pass
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_id = '::device_repo_ice::InvalidTokenException'
_M_device_repo_ice._t_InvalidTokenException = IcePy.defineException(
'::device_repo_ice::InvalidTokenException', InvalidTokenException, (),
False, None, ())
InvalidTokenException._ice_type = _M_device_repo_ice._t_InvalidTokenException
_M_device_repo_ice.InvalidTokenException = InvalidTokenException
del InvalidTokenException
if 'DeviceOccupiedException' not in _M_device_repo_ice.__dict__:
_M_device_repo_ice.DeviceOccupiedException = Ice.createTempClass()
class DeviceOccupiedException(Ice.UserException):
def __init__(self):
pass
def __str__(self):
return IcePy.stringifyException(self)
if not _M_Glacier2.__dict__.has_key('PermissionDeniedException'):
_M_Glacier2.PermissionDeniedException = Ice.createTempClass()
class PermissionDeniedException(Ice.UserException):
'''This exception is raised if a client is denied the ability to create
a session with the router.'''
def __init__(self, reason=''):
self.reason = reason
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'Glacier2::PermissionDeniedException'
_M_Glacier2._t_PermissionDeniedException = IcePy.defineException('::Glacier2::PermissionDeniedException', PermissionDeniedException, (), None, (('reason', (), IcePy._t_string),))
PermissionDeniedException._ice_type = _M_Glacier2._t_PermissionDeniedException
_M_Glacier2.PermissionDeniedException = PermissionDeniedException
del PermissionDeniedException
if not _M_Glacier2.__dict__.has_key('SessionNotExistException'):
_M_Glacier2.SessionNotExistException = Ice.createTempClass()
class SessionNotExistException(Ice.UserException):
'''This exception is raised if a client tries to destroy a session
with a router, but no session exists for the client.'''
def __init__(self):
pass
def __str__(self):
return IcePy.stringifyException(self)
