# Generated from file `bidirectional.ice' # # Warning: do not edit this file. # # </auto-generated> # from sys import version_info as _version_info_ import Ice, IcePy # Start of module Demo _M_Demo = Ice.openModule('Demo') __name__ = 'Demo' _M_Demo._t_PrinterPython = IcePy.defineValue('::Demo::PrinterPython', Ice.Value, -1, (), False, True, None, ()) if 'PrinterPythonPrx' not in _M_Demo.__dict__: _M_Demo.PrinterPythonPrx = Ice.createTempClass() class PrinterPythonPrx(Ice.ObjectPrx): def PrintString(self, s, context=None): return _M_Demo.PrinterPython._op_PrintString.invoke( self, ((s, ), context)) def PrintStringAsync(self, s, context=None): return _M_Demo.PrinterPython._op_PrintString.invokeAsync( self, ((s, ), context)) def begin_PrintString(self,
return IcePy.stringifyException(self) __repr__ = __str__ _ice_id = '::SmartHouse::LackOfIngredientExc' _M_SmartHouse._t_LackOfIngredientExc = IcePy.defineException( '::SmartHouse::LackOfIngredientExc', LackOfIngredientExc, (), False, _M_SmartHouse._t_DeviceError, ()) LackOfIngredientExc._ice_type = _M_SmartHouse._t_LackOfIngredientExc _M_SmartHouse.LackOfIngredientExc = LackOfIngredientExc del LackOfIngredientExc _M_SmartHouse._t_ISmartDevice = IcePy.defineValue('::SmartHouse::ISmartDevice', Ice.Value, -1, (), False, True, None, ()) if 'ISmartDevicePrx' not in _M_SmartHouse.__dict__: _M_SmartHouse.ISmartDevicePrx = Ice.createTempClass() class ISmartDevicePrx(Ice.ObjectPrx): def getPowerMode(self, context=None): return _M_SmartHouse.ISmartDevice._op_getPowerMode.invoke( self, ((), context)) def getPowerModeAsync(self, context=None): return _M_SmartHouse.ISmartDevice._op_getPowerMode.invokeAsync( self, ((), context)) def begin_getPowerMode(self,
('s6', (), IcePy._t_string), ('s7', (), IcePy._t_string), ('s8', (), IcePy._t_string), ('d3', (), IcePy._t_double), ('d4', (), IcePy._t_double), ('d5', (), IcePy._t_double), ('b3', (), IcePy._t_bool), ('b4', (), IcePy._t_bool), ('b5', (), IcePy._t_bool), ('iSeq2', (), _M_Tester._t_SeqInt), ('sSeq2', (), _M_Tester._t_SeqString), ('dSeq1', (), _M_Tester._t_SeqDouble), ('dSeq2', (), _M_Tester._t_SeqDouble))) _M_Tester.BigData = BigData del BigData _M_Tester._t_TesterIface = IcePy.defineValue('::Tester::TesterIface', Ice.Value, -1, (), False, True, None, ()) if 'TesterIfacePrx' not in _M_Tester.__dict__: _M_Tester.TesterIfacePrx = Ice.createTempClass() class TesterIfacePrx(Ice.ObjectPrx): def processSmall(self, smallData, context=None): return _M_Tester.TesterIface._op_processSmall.invoke( self, ((smallData, ), context)) def processSmallAsync(self, smallData, context=None): return _M_Tester.TesterIface._op_processSmall.invokeAsync( self, ((smallData, ), context)) def begin_processSmall(self,
Perform any necessary initialization steps. """ raise NotImplementedError("method 'initialize' not implemented") def destroy(self): """ Called when the communicator is being destroyed. """ raise NotImplementedError("method 'destroy' not implemented") def __str__(self): return IcePy.stringify(self, _M_Ice._t_Plugin) __repr__ = __str__ _M_Ice._t_Plugin = IcePy.defineValue('::Ice::Plugin', Plugin, -1, (), False, True, None, ()) Plugin._ice_type = _M_Ice._t_Plugin _M_Ice.Plugin = Plugin del Plugin if 'PluginManager' not in _M_Ice.__dict__: _M_Ice.PluginManager = Ice.createTempClass() class PluginManager(object): """ Each communicator has a plug-in manager to administer the set of plug-ins. """ def __init__(self): if Ice.getType(self) == _M_Ice.PluginManager: raise RuntimeError('Ice.PluginManager is an abstract class')
Arguments: curr -- Information about the current operation call for which a servant was located by locate. servant -- The servant that was returned by locate. cookie -- The cookie that was returned by locate. Throws: UserException -- The implementation can raise a UserException and the run time will marshal it as the result of the invocation. """ raise NotImplementedError("method 'finished' not implemented") def deactivate(self, category): """ Called when the object adapter in which this servant locator is installed is destroyed. Arguments: category -- Indicates for which category the servant locator is being deactivated. """ raise NotImplementedError("method 'deactivate' not implemented") def __str__(self): return IcePy.stringify(self, _M_Ice._t_ServantLocator) __repr__ = __str__ _M_Ice._t_ServantLocator = IcePy.defineValue('::Ice::ServantLocator', ServantLocator, -1, (), False, True, None, ()) ServantLocator._ice_type = _M_Ice._t_ServantLocator _M_Ice.ServantLocator = ServantLocator del ServantLocator # End of module Ice
# from sys import version_info as _version_info_ import Ice, IcePy import Ice.BuiltinSequences_ice # Included module Ice _M_Ice = Ice.openModule('Ice') # Start of module Ice __name__ = 'Ice' if '_t_PropertyDict' not in _M_Ice.__dict__: _M_Ice._t_PropertyDict = IcePy.defineDictionary('::Ice::PropertyDict', (), IcePy._t_string, IcePy._t_string) _M_Ice._t_PropertiesAdmin = IcePy.defineValue('::Ice::PropertiesAdmin', Ice.Value, -1, (), False, True, None, ()) if 'PropertiesAdminPrx' not in _M_Ice.__dict__: _M_Ice.PropertiesAdminPrx = Ice.createTempClass() class PropertiesAdminPrx(Ice.ObjectPrx): """ Get a property by key. If the property is not set, an empty string is returned. Arguments: key -- The property key. context -- The request context for the invocation. Returns: The property value. """ def getProperty(self, key, context=None): return _M_Ice.PropertiesAdmin._op_getProperty.invoke(self, ((key, ), context))
""" raise NotImplementedError("method 'parseIceCommandLineOptions' not implemented") def load(self, file): """ Load properties from a file. Arguments: file -- The property file. """ raise NotImplementedError("method 'load' not implemented") def clone(self): """ Create a copy of this property set. Returns: A copy of this property set. """ raise NotImplementedError("method 'clone' not implemented") def __str__(self): return IcePy.stringify(self, _M_Ice._t_Properties) __repr__ = __str__ _M_Ice._t_Properties = IcePy.defineValue('::Ice::Properties', Properties, -1, (), False, True, None, ()) Properties._ice_type = _M_Ice._t_Properties _M_Ice.Properties = Properties del Properties # End of module Ice
return IcePy.stringifyException(self) __repr__ = __str__ _ice_id = '::SmartHouse::IsOffError' _M_SmartHouse._t_IsOffError = IcePy.defineException( '::SmartHouse::IsOffError', IsOffError, (), False, _M_SmartHouse._t_Error, ()) IsOffError._ice_type = _M_SmartHouse._t_IsOffError _M_SmartHouse.IsOffError = IsOffError del IsOffError _M_SmartHouse._t_IDevice = IcePy.defineValue('::SmartHouse::IDevice', Ice.Value, -1, (), False, True, None, ()) if 'IDevicePrx' not in _M_SmartHouse.__dict__: _M_SmartHouse.IDevicePrx = Ice.createTempClass() class IDevicePrx(Ice.ObjectPrx): def getPowerState(self, context=None): return _M_SmartHouse.IDevice._op_getPowerState.invoke( self, ((), context)) def getPowerStateAsync(self, context=None): return _M_SmartHouse.IDevice._op_getPowerState.invokeAsync( self, ((), context)) def begin_getPowerState(self,
# Warning: do not edit this file. # # </auto-generated> # from sys import version_info as _version_info_ import Ice, IcePy from . import device_repo_ice # Included module device_repo_ice _M_device_repo_ice = Ice.openModule('device_repo.device_repo_ice') # Start of module device_repo_ice __name__ = 'device_repo.device_repo_ice' _M_device_repo_ice._t_Digitizer = IcePy.defineValue( '::device_repo_ice::Digitizer', Ice.Value, -1, (), False, True, None, ()) if 'DigitizerPrx' not in _M_device_repo_ice.__dict__: _M_device_repo_ice.DigitizerPrx = Ice.createTempClass() class DigitizerPrx(_M_device_repo_ice.DevicePrx): def set_sample_number(self, number_of_samples, context=None): return _M_device_repo_ice.Digitizer._op_set_sample_number.invoke( self, ((number_of_samples, ), context)) def set_sample_numberAsync(self, number_of_samples, context=None): return _M_device_repo_ice.Digitizer._op_set_sample_number.invokeAsync( self, ((number_of_samples, ), context)) def begin_set_sample_number(self, number_of_samples,
('humedad', (), IcePy._t_string), ('viento', (), IcePy._t_string), ('vientoDireccion', (), IcePy._t_string))) _M_Meteorologia.MedicionHora = MedicionHora del MedicionHora if '_t_Mediciones' not in _M_Meteorologia.__dict__: _M_Meteorologia._t_Mediciones = IcePy.defineSequence( '::Meteorologia::Mediciones', (), _M_Meteorologia._t_MedicionDia) if '_t_MedicionesHora' not in _M_Meteorologia.__dict__: _M_Meteorologia._t_MedicionesHora = IcePy.defineSequence( '::Meteorologia::MedicionesHora', (), _M_Meteorologia._t_MedicionHora) _M_Meteorologia._t_Conexion = IcePy.defineValue('::Meteorologia::Conexion', Ice.Value, -1, (), False, True, None, ()) if 'ConexionPrx' not in _M_Meteorologia.__dict__: _M_Meteorologia.ConexionPrx = Ice.createTempClass() class ConexionPrx(Ice.ObjectPrx): def reporteSemanal(self, ciudad, context=None): return _M_Meteorologia.Conexion._op_reporteSemanal.invoke( self, ((ciudad, ), context)) def reporteSemanalAsync(self, ciudad, context=None): return _M_Meteorologia.Conexion._op_reporteSemanal.invokeAsync( self, ((ciudad, ), context)) def begin_reporteSemanal(self,
def __str__(self): return IcePy.stringifyException(self) __repr__ = __str__ _ice_id = '::Bank::AlreadyCreated' _M_Bank._t_AlreadyCreated = IcePy.defineException('::Bank::AlreadyCreated', AlreadyCreated, (), False, None, ()) AlreadyCreated._ice_type = _M_Bank._t_AlreadyCreated _M_Bank.AlreadyCreated = AlreadyCreated del AlreadyCreated _M_Bank._t_Account = IcePy.defineValue('::Bank::Account', Ice.Value, -1, (), False, True, None, ()) if 'AccountPrx' not in _M_Bank.__dict__: _M_Bank.AccountPrx = Ice.createTempClass() class AccountPrx(Ice.ObjectPrx): def getCreditCost(self, amount, finishDate, context=None): return _M_Bank.Account._op_getCreditCost.invoke( self, ((amount, finishDate), context)) def getCreditCostAsync(self, amount, finishDate, context=None): return _M_Bank.Account._op_getCreditCost.invokeAsync( self, ((amount, finishDate), context)) def begin_getCreditCost(self, amount,
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. password -- The user's password. context -- The request context for the invocation. Returns a tuple containing the following: _retval -- True if access is granted, or false otherwise. reason -- The reason why access was denied. Throws:
# Warning: do not edit this file. # # </auto-generated> # from sys import version_info as _version_info_ import Ice, IcePy from . import device_repo_ice # Included module device_repo_ice _M_device_repo_ice = Ice.openModule('device_repo.device_repo_ice') # Start of module device_repo_ice __name__ = 'device_repo.device_repo_ice' _M_device_repo_ice._t_DummyDevice = IcePy.defineValue( '::device_repo_ice::DummyDevice', Ice.Value, -1, (), False, True, None, ()) if 'DummyDevicePrx' not in _M_device_repo_ice.__dict__: _M_device_repo_ice.DummyDevicePrx = Ice.createTempClass() class DummyDevicePrx(_M_device_repo_ice.DevicePrx): def get_data(self, context=None): return _M_device_repo_ice.DummyDevice._op_get_data.invoke( self, ((), context)) def get_dataAsync(self, context=None): return _M_device_repo_ice.DummyDevice._op_get_data.invokeAsync( self, ((), context)) def begin_get_data(self, _response=None,
def failed(self, exceptionName): """ Notification of a failure. Arguments: exceptionName -- The name of the exception. """ raise NotImplementedError("method 'failed' not implemented") def __str__(self): return IcePy.stringify(self, _M_Ice.Instrumentation._t_Observer) __repr__ = __str__ _M_Ice.Instrumentation._t_Observer = IcePy.defineValue( '::Ice::Instrumentation::Observer', Observer, -1, (), False, True, None, ()) Observer._ice_type = _M_Ice.Instrumentation._t_Observer _M_Ice.Instrumentation.Observer = Observer del Observer if 'ThreadState' not in _M_Ice.Instrumentation.__dict__: _M_Ice.Instrumentation.ThreadState = Ice.createTempClass() class ThreadState(Ice.EnumBase): """ The thread state enumeration keeps track of the different possible states of Ice threads. Enumerators: ThreadStateIdle -- The thread is idle.
__repr__ = __str__ _M_mp3App._t_Song = IcePy.defineStruct( '::mp3App::Song', Song, (), (('name', (), IcePy._t_string), ('artist', (), IcePy._t_string), ('genre', (), IcePy._t_string), ('length', (), IcePy._t_string), ('path', (), IcePy._t_string))) _M_mp3App.Song = Song del Song if '_t_playList' not in _M_mp3App.__dict__: _M_mp3App._t_playList = IcePy.defineSequence('::mp3App::playList', (), IcePy._t_string) _M_mp3App._t_Function = IcePy.defineValue('::mp3App::Function', Ice.Value, -1, (), False, True, None, ()) if 'FunctionPrx' not in _M_mp3App.__dict__: _M_mp3App.FunctionPrx = Ice.createTempClass() class FunctionPrx(Ice.ObjectPrx): def sendPlayList(self, seq, context=None): return _M_mp3App.Function._op_sendPlayList.invoke( self, ((seq, ), context)) def sendPlayListAsync(self, seq, context=None): return _M_mp3App.Function._op_sendPlayList.invokeAsync( self, ((seq, ), context)) def begin_sendPlayList(self, seq,
unnamed top-level Slice module. For example, the absolute Slice type id for an interface Bar in the module Foo is "::Foo::Bar". Note that the leading "::" is required. Arguments: type -- The value type. Returns: The value created for the given type, or nil if the factory is unable to create the value. """ raise NotImplementedError("method 'create' not implemented") def __str__(self): return IcePy.stringify(self, _M_Ice._t_ValueFactory) __repr__ = __str__ _M_Ice._t_ValueFactory = IcePy.defineValue('::Ice::ValueFactory', ValueFactory, -1, (), False, True, None, ()) ValueFactory._ice_type = _M_Ice._t_ValueFactory _M_Ice.ValueFactory = ValueFactory del ValueFactory if 'ValueFactoryManager' not in _M_Ice.__dict__: _M_Ice.ValueFactoryManager = Ice.createTempClass() class ValueFactoryManager(object): """ A value factory manager maintains a collection of value factories. An application can supply a custom implementation during communicator initialization, otherwise Ice provides a default implementation. """ def __init__(self): if Ice.getType(self) == _M_Ice.ValueFactoryManager:
__repr__ = __str__ _M_server._t_Musique = IcePy.defineStruct('::server::Musique', Musique, (), (('id', (), IcePy._t_int), ('name', (), IcePy._t_string), ('artist', (), IcePy._t_string))) _M_server.Musique = Musique del Musique if '_t_bdd' not in _M_server.__dict__: _M_server._t_bdd = IcePy.defineSequence('::server::bdd', (), _M_server._t_Musique) _M_server._t_ServeurIce = IcePy.defineValue('::server::ServeurIce', Ice.Value, -1, (), False, True, None, ()) if 'ServeurIcePrx' not in _M_server.__dict__: _M_server.ServeurIcePrx = Ice.createTempClass() class ServeurIcePrx(Ice.ObjectPrx): def ajouterMusique(self, name, context=None): return _M_server.ServeurIce._op_ajouterMusique.invoke( self, ((name, ), context)) def ajouterMusiqueAsync(self, name, context=None): return _M_server.ServeurIce._op_ajouterMusique.invokeAsync( self, ((name, ), context)) def begin_ajouterMusique(self, name,
_M_Notification._t_caseResult = IcePy.defineStruct( '::Notification::caseResult', caseResult, (), (('registrationTimeStamp', (), _M_Notification._t_timeStamp), ('expectedResolutionTime', (), IcePy._t_int), ('resultMessage', (), IcePy._t_string))) _M_Notification.caseResult = caseResult del caseResult if '_t_batchedResults' not in _M_Notification.__dict__: _M_Notification._t_batchedResults = IcePy.defineSequence( '::Notification::batchedResults', (), _M_Notification._t_caseResult) _M_Notification._t_Notifier = IcePy.defineValue('::Notification::Notifier', Ice.Value, -1, (), False, True, None, ()) if 'NotifierPrx' not in _M_Notification.__dict__: _M_Notification.NotifierPrx = Ice.createTempClass() class NotifierPrx(Ice.ObjectPrx): def singleNotify(self, result, context=None): return _M_Notification.Notifier._op_singleNotify.invoke( self, ((result, ), context)) def singleNotifyAsync(self, result, context=None): return _M_Notification.Notifier._op_singleNotify.invokeAsync( self, ((result, ), context)) def begin_singleNotify(self,
else: return r != 0 def __str__(self): return IcePy.stringify(self, _M_Bank._t_UserCredentials) __repr__ = __str__ _M_Bank._t_UserCredentials = IcePy.defineStruct( '::Bank::UserCredentials', UserCredentials, (), (('pesel', (), IcePy._t_string), ('password', (), IcePy._t_string))) _M_Bank.UserCredentials = UserCredentials del UserCredentials _M_Bank._t_Account = IcePy.defineValue('::Bank::Account', Ice.Value, -1, (), False, True, None, ()) if 'AccountPrx' not in _M_Bank.__dict__: _M_Bank.AccountPrx = Ice.createTempClass() class AccountPrx(Ice.ObjectPrx): def getCurrentState(self, credentials, context=None): return _M_Bank.Account._op_getCurrentState.invoke( self, ((credentials, ), context)) def getCurrentStateAsync(self, credentials, context=None): return _M_Bank.Account._op_getCurrentState.invokeAsync( self, ((credentials, ), context)) def begin_getCurrentState(self, credentials,
self.forwarded = forwarded def ice_id(self): return '::IceMX::TopicMetrics' @staticmethod def ice_staticId(): return '::IceMX::TopicMetrics' def __str__(self): return IcePy.stringify(self, _M_IceMX._t_TopicMetrics) __repr__ = __str__ _M_IceMX._t_TopicMetrics = IcePy.defineValue( '::IceMX::TopicMetrics', TopicMetrics, -1, (), False, False, _M_IceMX._t_Metrics, (('published', (), IcePy._t_long, False, 0), ('forwarded', (), IcePy._t_long, False, 0))) TopicMetrics._ice_type = _M_IceMX._t_TopicMetrics _M_IceMX.TopicMetrics = TopicMetrics del TopicMetrics if 'SubscriberMetrics' not in _M_IceMX.__dict__: _M_IceMX.SubscriberMetrics = Ice.createTempClass() class SubscriberMetrics(_M_IceMX.Metrics): """ Provides information on IceStorm subscribers. Members: queued -- Number of queued events. outstanding -- Number of outstanding events.
__repr__ = __str__ _M_MetaServer._t_Song = IcePy.defineStruct( '::MetaServer::Song', Song, (), (('name', (), IcePy._t_string), ('author', (), IcePy._t_string), ('album', (), IcePy._t_string), ('path', (), IcePy._t_string))) _M_MetaServer.Song = Song del Song if '_t_SongSeq' not in _M_MetaServer.__dict__: _M_MetaServer._t_SongSeq = IcePy.defineSequence('::MetaServer::SongSeq', (), _M_MetaServer._t_Song) _M_MetaServer._t_IMetaServer = IcePy.defineValue('::MetaServer::IMetaServer', Ice.Value, -1, (), False, True, None, ()) if 'IMetaServerPrx' not in _M_MetaServer.__dict__: _M_MetaServer.IMetaServerPrx = Ice.createTempClass() class IMetaServerPrx(Ice.ObjectPrx): def searchMusic(self, name, author, album, context=None): return _M_MetaServer.IMetaServer._op_searchMusic.invoke( self, ((name, author, album), context)) def searchMusicAsync(self, name, author, album, context=None): return _M_MetaServer.IMetaServer._op_searchMusic.invokeAsync( self, ((name, author, album), context)) def begin_searchMusic(self,
return IcePy.stringify(self, _M_filecenter._t_FileInfo) __repr__ = __str__ _M_filecenter._t_FileInfo = IcePy.defineStruct( '::filecenter::FileInfo', FileInfo, (), (('creattime', (), IcePy._t_long), ('updatetime', (), IcePy._t_long), ('filesize', (), IcePy._t_int), ('filescore', (), IcePy._t_byte), ('filename', (), IcePy._t_string), ('filetype', (), IcePy._t_string), ('filepath', (), IcePy._t_string))) _M_filecenter.FileInfo = FileInfo del FileInfo _M_filecenter._t_FileReader = IcePy.defineValue('::filecenter::FileReader', Ice.Value, -1, (), False, True, None, ()) if 'FileReaderPrx' not in _M_filecenter.__dict__: _M_filecenter.FileReaderPrx = Ice.createTempClass() class FileReaderPrx(Ice.ObjectPrx): def ReadFileInfo(self, fileid, context=None): return _M_filecenter.FileReader._op_ReadFileInfo.invoke( self, ((fileid, ), context)) def ReadFileInfoAsync(self, fileid, context=None): return _M_filecenter.FileReader._op_ReadFileInfo.invokeAsync( self, ((fileid, ), context)) def begin_ReadFileInfo(self,
# Generated from file `PetFood.ice' # # Warning: do not edit this file. # # </auto-generated> # from sys import version_info as _version_info_ import Ice, IcePy # Start of module PetFoodSensors _M_PetFoodSensors = Ice.openModule('PetFoodSensors') __name__ = 'PetFoodSensors' _M_PetFoodSensors._t_SensorControl = IcePy.defineValue( '::PetFoodSensors::SensorControl', Ice.Value, -1, (), False, True, None, ()) if 'SensorControlPrx' not in _M_PetFoodSensors.__dict__: _M_PetFoodSensors.SensorControlPrx = Ice.createTempClass() class SensorControlPrx(Ice.ObjectPrx): def motorTime(self, time, context=None): return _M_PetFoodSensors.SensorControl._op_motorTime.invoke( self, ((time, ), context)) def motorTimeAsync(self, time, context=None): return _M_PetFoodSensors.SensorControl._op_motorTime.invokeAsync( self, ((time, ), context)) def begin_motorTime(self,
# from sys import version_info as _version_info_ import Ice, IcePy # Start of module xidianRadar _M_xidianRadar = Ice.openModule('xidianRadar') __name__ = 'xidianRadar' if '_t_IntList' not in _M_xidianRadar.__dict__: _M_xidianRadar._t_IntList = IcePy.defineSequence('::xidianRadar::IntList', (), IcePy._t_int) if '_t_IntIntList' not in _M_xidianRadar.__dict__: _M_xidianRadar._t_IntIntList = IcePy.defineSequence('::xidianRadar::IntIntList', (), _M_xidianRadar._t_IntList) _M_xidianRadar._t_RadarUtil = IcePy.defineValue('::xidianRadar::RadarUtil', Ice.Value, -1, (), False, True, None, ()) if 'RadarUtilPrx' not in _M_xidianRadar.__dict__: _M_xidianRadar.RadarUtilPrx = Ice.createTempClass() class RadarUtilPrx(Ice.ObjectPrx): def recognitionRadar(self, r, context=None): return _M_xidianRadar.RadarUtil._op_recognitionRadar.invoke(self, ((r, ), context)) def recognitionRadarAsync(self, r, context=None): return _M_xidianRadar.RadarUtil._op_recognitionRadar.invokeAsync(self, ((r, ), context)) def begin_recognitionRadar(self, r, _response=None, _ex=None, _sent=None, context=None): return _M_xidianRadar.RadarUtil._op_recognitionRadar.begin(self, ((r, ), _response, _ex, _sent, context)) def end_recognitionRadar(self, _r):
""" Returns true if this endpoint is a secure endpoint. Returns: True for a secure endpoint. """ raise NotImplementedError("method 'secure' not implemented") def __str__(self): return IcePy.stringify(self, _M_Ice._t_EndpointInfo) __repr__ = __str__ _M_Ice._t_EndpointInfo = IcePy.declareValue('::Ice::EndpointInfo') _M_Ice._t_EndpointInfo = IcePy.defineValue('::Ice::EndpointInfo', EndpointInfo, -1, (), False, False, None, ( ('underlying', (), _M_Ice._t_EndpointInfo, False, 0), ('timeout', (), IcePy._t_int, False, 0), ('compress', (), IcePy._t_bool, False, 0) )) EndpointInfo._ice_type = _M_Ice._t_EndpointInfo _M_Ice.EndpointInfo = EndpointInfo del EndpointInfo if 'Endpoint' not in _M_Ice.__dict__: _M_Ice.Endpoint = Ice.createTempClass() class Endpoint(object): """ The user-level interface to an endpoint. """ def __init__(self): if Ice.getType(self) == _M_Ice.Endpoint:
# Warning: do not edit this file. # # </auto-generated> # from sys import version_info as _version_info_ import Ice, IcePy from . import device_repo_ice # Included module device_repo_ice _M_device_repo_ice = Ice.openModule('device_repo.device_repo_ice') # Start of module device_repo_ice __name__ = 'device_repo.device_repo_ice' _M_device_repo_ice._t_VNA = IcePy.defineValue('::device_repo_ice::VNA', Ice.Value, -1, (), False, True, None, ()) if 'VNAPrx' not in _M_device_repo_ice.__dict__: _M_device_repo_ice.VNAPrx = Ice.createTempClass() class VNAPrx(_M_device_repo_ice.DevicePrx): def set_power(self, power_in_db, context=None): return _M_device_repo_ice.VNA._op_set_power.invoke(self, ((power_in_db, ), context)) def set_powerAsync(self, power_in_db, context=None): return _M_device_repo_ice.VNA._op_set_power.invokeAsync(self, ((power_in_db, ), context)) def begin_set_power(self, power_in_db, _response=None, _ex=None, _sent=None, context=None): return _M_device_repo_ice.VNA._op_set_power.begin(self, ((power_in_db, ), _response, _ex, _sent, context)) def end_set_power(self, _r):
import Glacier2.Session_ice import IceGrid.Exception_ice # Included module Ice _M_Ice = Ice.openModule('Ice') # Included module Glacier2 _M_Glacier2 = Ice.openModule('Glacier2') # Included module IceGrid _M_IceGrid = Ice.openModule('IceGrid') # Start of module IceGrid __name__ = 'IceGrid' _M_IceGrid._t_Session = IcePy.defineValue('::IceGrid::Session', Ice.Value, -1, (), False, True, None, ()) if 'SessionPrx' not in _M_IceGrid.__dict__: _M_IceGrid.SessionPrx = Ice.createTempClass() class SessionPrx(_M_Glacier2.SessionPrx): """ Keep the session alive. Clients should call this operation regularly to prevent the server from reaping the session. Arguments: context -- The request context for the invocation. """ def keepAlive(self, context=None): return _M_IceGrid.Session._op_keepAlive.invoke(self, ((), context)) """
__repr__ = __str__ _M_Server._t_Song = IcePy.defineStruct('::Server::Song', Song, (), ( ('name', (), IcePy._t_string), ('author', (), IcePy._t_string), ('album', (), IcePy._t_string), ('path', (), IcePy._t_string) )) _M_Server.Song = Song del Song if '_t_SongSeq' not in _M_Server.__dict__: _M_Server._t_SongSeq = IcePy.defineSequence('::Server::SongSeq', (), _M_Server._t_Song) _M_Server._t_IServer = IcePy.defineValue('::Server::IServer', Ice.Value, -1, (), False, True, None, ()) if 'IServerPrx' not in _M_Server.__dict__: _M_Server.IServerPrx = Ice.createTempClass() class IServerPrx(Ice.ObjectPrx): def searchMusic(self, name, author, album, context=None): return _M_Server.IServer._op_searchMusic.invoke(self, ((name, author, album), context)) def searchMusicAsync(self, name, author, album, context=None): return _M_Server.IServer._op_searchMusic.invokeAsync(self, ((name, author, album), context)) def begin_searchMusic(self, name, author, album, _response=None, _ex=None, _sent=None, context=None): return _M_Server.IServer._op_searchMusic.begin(self, ((name, author, album), _response, _ex, _sent, context)) def end_searchMusic(self, _r):
def __str__(self): return IcePy.stringify(self, _M_device_repo_ice._t_DeviceEntry) __repr__ = __str__ _M_device_repo_ice._t_DeviceEntry = IcePy.defineStruct( '::device_repo_ice::DeviceEntry', DeviceEntry, (), (('id', (), IcePy._t_string), ('type', (), _M_device_repo_ice._t_DeviceType))) _M_device_repo_ice.DeviceEntry = DeviceEntry del DeviceEntry _M_device_repo_ice._t_Device = IcePy.defineValue('::device_repo_ice::Device', Ice.Value, -1, (), False, True, None, ()) if 'DevicePrx' not in _M_device_repo_ice.__dict__: _M_device_repo_ice.DevicePrx = Ice.createTempClass() class DevicePrx(Ice.ObjectPrx): def get_type(self, context=None): return _M_device_repo_ice.Device._op_get_type.invoke( self, ((), context)) def get_typeAsync(self, context=None): return _M_device_repo_ice.Device._op_get_type.invokeAsync( self, ((), context)) def begin_get_type(self,
def ice_id(self): return '::StreamingServer::Track' @staticmethod def ice_staticId(): return '::StreamingServer::Track' def __str__(self): return IcePy.stringify(self, _M_StreamingServer._t_Track) __repr__ = __str__ _M_StreamingServer._t_Track = IcePy.defineValue( '::StreamingServer::Track', Track, -1, (), False, False, None, (('title', (), IcePy._t_string, False, 0), ('album', (), IcePy._t_string, False, 0), ('artist', (), IcePy._t_string, False, 0), ('path', (), IcePy._t_string, False, 0))) Track._ice_type = _M_StreamingServer._t_Track _M_StreamingServer.Track = Track del Track if '_t_trackSequence' not in _M_StreamingServer.__dict__: _M_StreamingServer._t_trackSequence = IcePy.defineSequence( '::StreamingServer::trackSequence', (), _M_StreamingServer._t_Track) if 'Status' not in _M_StreamingServer.__dict__: _M_StreamingServer.Status = Ice.createTempClass() class Status(Ice.Value):