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)