return False if self.b != other.b: return False return True def __ne__(self, other): return not self.__eq__(other) def __str__(self): return IcePy.stringify(self, _M_jderobot._t_Color) __repr__ = __str__ _M_jderobot._t_Color = IcePy.defineStruct('::jderobot::Color', Color, (), ( ('r', (), IcePy._t_float), ('g', (), IcePy._t_float), ('b', (), IcePy._t_float) )) _M_jderobot.Color = Color del Color if 'RGBSegment' not in _M_jderobot.__dict__: _M_jderobot.RGBSegment = Ice.createTempClass() class RGBSegment(object): def __init__(self, seg=Ice._struct_marker, c=Ice._struct_marker): if seg is Ice._struct_marker: self.seg = _M_jderobot.Segment() else: self.seg = seg if c is Ice._struct_marker:
def __ne__(self, other): r = self.__compare(other) if r is NotImplemented: return r else: return r != 0 def __str__(self): return IcePy.stringify(self, _M_SmartHouse._t_Time) __repr__ = __str__ _M_SmartHouse._t_Time = IcePy.defineStruct('::SmartHouse::Time', Time, (), (('hour', (), IcePy._t_short), ('minute', (), IcePy._t_short), ('second', (), IcePy._t_short))) _M_SmartHouse.Time = Time del Time if 'DeviceError' not in _M_SmartHouse.__dict__: _M_SmartHouse.DeviceError = Ice.createTempClass() class DeviceError(Ice.UserException): def __init__(self, timeOfError=Ice._struct_marker, reason=''): if timeOfError is Ice._struct_marker: self.timeOfError = _M_SmartHouse.Time() else: self.timeOfError = timeOfError
def __ne__(self, other): r = self.__compare(other) if r is NotImplemented: return r else: return r != 0 def __str__(self): return IcePy.stringify(self, _M_device_repo_ice._t_DataSet) __repr__ = __str__ _M_device_repo_ice._t_DataSet = IcePy.defineStruct( '::device_repo_ice::DataSet', DataSet, (), (('shape', (), _M_device_repo_ice._t_ints), ('type', (), _M_device_repo_ice._t_DataType), ('packed_data', (), _M_device_repo_ice._t_bytes))) _M_device_repo_ice.DataSet = DataSet del DataSet if 'DoubleDataSet' not in _M_device_repo_ice.__dict__: _M_device_repo_ice.DoubleDataSet = Ice.createTempClass() class DoubleDataSet(object): def __init__(self, shape=None, array=None): self.shape = shape self.array = array def __eq__(self, other):
return False return NotImplemented def __ge__(self, other): if isinstance(other, _M_Glacier2.SSLInfo): return self.remoteHost >= other.remoteHost or self.remotePort >= other.remotePort or self.localHost >= other.localHost or self.localPort >= other.localPort or self.cipher >= other.cipher or self.certs >= other.certs elif other == None: return False return NotImplemented def __str__(self): return IcePy.stringify(self, _M_Glacier2._t_SSLInfo) __repr__ = __str__ _M_Glacier2._t_SSLInfo = IcePy.defineStruct('::Glacier2::SSLInfo', SSLInfo, (), ( ('remoteHost', (), IcePy._t_string), ('remotePort', (), IcePy._t_int), ('localHost', (), IcePy._t_string), ('localPort', (), IcePy._t_int), ('cipher', (), IcePy._t_string), ('certs', (), _M_Ice._t_StringSeq) )) _M_Glacier2.SSLInfo = SSLInfo del SSLInfo # End of module Glacier2 Ice.sliceChecksums["::Glacier2::SSLInfo"] = "ca63bc6d361a48471c4d16ea29818e5"
return r == 0 def __ne__(self, other): r = self.__compare(other) if r is NotImplemented: return r else: return r != 0 def __str__(self): return IcePy.stringify(self, _M_MetaServer._t_Song) __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()
if self.id != other.id: return False if self.failures != other.failures: return False return True def __ne__(self, other): return not self.__eq__(other) def __str__(self): return IcePy.stringify(self, _M_IceMX._t_MetricsFailures) __repr__ = __str__ _M_IceMX._t_MetricsFailures = IcePy.defineStruct( '::IceMX::MetricsFailures', MetricsFailures, (), (('id', (), IcePy._t_string), ('failures', (), _M_IceMX._t_StringIntDict))) _M_IceMX.MetricsFailures = MetricsFailures del MetricsFailures if '_t_MetricsFailuresSeq' not in _M_IceMX.__dict__: _M_IceMX._t_MetricsFailuresSeq = IcePy.defineSequence( '::IceMX::MetricsFailuresSeq', (), _M_IceMX._t_MetricsFailures) if '_t_MetricsMap' not in _M_IceMX.__dict__: _M_IceMX._t_MetricsMap = IcePy.defineSequence('::IceMX::MetricsMap', (), _M_IceMX._t_Metrics) if '_t_MetricsView' not in _M_IceMX.__dict__: _M_IceMX._t_MetricsView = IcePy.defineDictionary('::IceMX::MetricsView',
return False return NotImplemented def __ge__(self, other): if isinstance(other, _M_Ice.Identity): return self.name >= other.name or self.category >= other.category elif other == None: return False return NotImplemented def __str__(self): return IcePy.stringify(self, _M_Ice._t_Identity) __repr__ = __str__ _M_Ice._t_Identity = IcePy.defineStruct('::Ice::Identity', Identity, (), ( ('name', (), IcePy._t_string), ('category', (), IcePy._t_string) )) _M_Ice.Identity = Identity del Identity if not _M_Ice.__dict__.has_key('_t_ObjectDict'): _M_Ice._t_ObjectDict = IcePy.defineDictionary('::Ice::ObjectDict', (), _M_Ice._t_Identity, IcePy._t_Object) if not _M_Ice.__dict__.has_key('_t_IdentitySeq'): _M_Ice._t_IdentitySeq = IcePy.defineSequence('::Ice::IdentitySeq', (), _M_Ice._t_Identity) # End of module Ice
elif self.errNo > other.errNo: return 1 if self.msg < other.msg: return -1 elif self.msg > other.msg: return 1 return 0 def __str__(self): return IcePy.stringify(self, _M_rd._t_CallResultT) __repr__ = __str__ _M_rd._t_CallResultT = IcePy.defineStruct('::rd::CallResultT', CallResultT, (), ( ('succ', (), IcePy._t_bool), ('errNo', (), IcePy._t_int), ('msg', (), IcePy._t_string) )) _M_rd.CallResultT = CallResultT del CallResultT if not _M_rd.__dict__.has_key('IService'): _M_rd.IService = Ice.createTempClass() class IService(Ice.Object): def __init__(self): if __builtin__.type(self) == _M_rd.IService: raise RuntimeError('rd.IService is an abstract class') def ice_ids(self, current=None): return ('::Ice::Object', '::rd::IService')
def __ge__(self, other): if isinstance(other, _M_IcePatch2.FileInfo): return self.path >= other.path or self.checksum >= other.checksum or self.size >= other.size or self.executable >= other.executable elif other == None: return False return NotImplemented def __str__(self): return IcePy.stringify(self, _M_IcePatch2._t_FileInfo) __repr__ = __str__ _M_IcePatch2._t_FileInfo = IcePy.defineStruct('::IcePatch2::FileInfo', FileInfo, (), ( ('path', (), IcePy._t_string), ('checksum', (), _M_Ice._t_ByteSeq), ('size', (), IcePy._t_int), ('executable', (), IcePy._t_bool) )) _M_IcePatch2.FileInfo = FileInfo del FileInfo if not _M_IcePatch2.__dict__.has_key('_t_FileInfoSeq'): _M_IcePatch2._t_FileInfoSeq = IcePy.defineSequence('::IcePatch2::FileInfoSeq', (), _M_IcePatch2._t_FileInfo) # End of module IcePatch2 Ice.sliceChecksums["::IcePatch2::FileInfo"] = "4c71622889c19c7d3b5ef8210245" Ice.sliceChecksums["::IcePatch2::FileInfoSeq"] = "892945a7a7bfb532f6148c4be9889bd"
elif self.right > other.right: return 1 if self.bottom < other.bottom: return -1 elif self.bottom > other.bottom: return 1 return 0 def __str__(self): return IcePy.stringify(self, _M_FriendDetector._t_FacePosition) __repr__ = __str__ _M_FriendDetector._t_FacePosition = IcePy.defineStruct('::FriendDetector::FacePosition', FacePosition, (), ( ('left', (), IcePy._t_int), ('top', (), IcePy._t_int), ('right', (), IcePy._t_int), ('bottom', (), IcePy._t_int) )) _M_FriendDetector.FacePosition = FacePosition del FacePosition if not _M_FriendDetector.__dict__.has_key('_t_FacePositions'): _M_FriendDetector._t_FacePositions = IcePy.defineSequence('::FriendDetector::FacePositions', (), _M_FriendDetector._t_FacePosition) if not _M_FriendDetector.__dict__.has_key('Face'): _M_FriendDetector.Face = Ice.createTempClass() class Face(object): def __init__(self, position=Ice._struct_marker, name=''): if position is Ice._struct_marker: self.position = _M_FriendDetector.FacePosition()
if self.re != other.re: return False if self.im != other.im: return False return True def __ne__(self, other): return not self.__eq__(other) def __str__(self): return IcePy.stringify(self, _M_gnuradio.ctrlport.GNURadio._t_complex) __repr__ = __str__ _M_gnuradio.ctrlport.GNURadio._t_complex = IcePy.defineStruct('::GNURadio::complex', complex, (), ( ('re', (), IcePy._t_float), ('im', (), IcePy._t_float) )) _M_gnuradio.ctrlport.GNURadio.complex = complex del complex if 'Knob' not in _M_gnuradio.ctrlport.GNURadio.__dict__: _M_gnuradio.ctrlport.GNURadio.Knob = Ice.createTempClass() class Knob(Ice.Object): def __init__(self): pass def ice_ids(self, current=None): return ('::GNURadio::Knob', '::Ice::Object') def ice_id(self, current=None):
def __ge__(self, other): if isinstance(other, _M_icemodule.castcontrol.CastAgent.CastMessage): return self.time >= other.time or self.msgtype >= other.msgtype or self.message >= other.message elif other == None: return False return NotImplemented def __str__(self): return IcePy.stringify(self, _M_icemodule.castcontrol.CastAgent._t_CastMessage) __repr__ = __str__ _M_icemodule.castcontrol.CastAgent._t_CastMessage = IcePy.defineStruct('::castcontrol::CastAgent::CastMessage', CastMessage, (), ( ('time', (), IcePy._t_double), ('msgtype', (), IcePy._t_int), ('message', (), IcePy._t_string) )) _M_icemodule.castcontrol.CastAgent.CastMessage = CastMessage del CastMessage if not _M_icemodule.castcontrol.CastAgent.__dict__.has_key('_t_CastMessageList'): _M_icemodule.castcontrol.CastAgent._t_CastMessageList = IcePy.defineSequence('::castcontrol::CastAgent::CastMessageList', (), _M_icemodule.castcontrol.CastAgent._t_CastMessage) if not _M_icemodule.castcontrol.CastAgent.__dict__.has_key('ProcessInfo'): _M_icemodule.castcontrol.CastAgent.ProcessInfo = Ice.createTempClass() class ProcessInfo(object): def __init__(self, name='', status=0, error=0): self.name = name self.status = status
def __ge__(self, other): if isinstance(other, _M_omero.api.delete.DeleteCommand): return self.type >= other.type or self.id >= other.id or self.options >= other.options elif other == None: return False return NotImplemented def __str__(self): return IcePy.stringify(self, _M_omero.api.delete._t_DeleteCommand) __repr__ = __str__ _M_omero.api.delete._t_DeleteCommand = IcePy.defineStruct('::omero::api::delete::DeleteCommand', DeleteCommand, (), ( ('type', (), IcePy._t_string), ('id', (), IcePy._t_long), ('options', (), _M_omero.api._t_StringStringMap) )) _M_omero.api.delete.DeleteCommand = DeleteCommand del DeleteCommand if not _M_omero.api.delete.__dict__.has_key('_t_DeleteCommands'): _M_omero.api.delete._t_DeleteCommands = IcePy.defineSequence('::omero::api::delete::DeleteCommands', (), _M_omero.api.delete._t_DeleteCommand) if not _M_omero.api.delete.__dict__.has_key('DeleteReport'): _M_omero.api.delete.DeleteReport = Ice.createTempClass() class DeleteReport(Ice.Object): '''Status object which is returned for each [DeleteCommand] passed to [IDelete::queueCommand].''' def __init__(self, command=Ice._struct_marker, error='', warning='', undeletedFiles=None, steps=0, scheduledDeletes=0, actualDeletes=0, start=0, stepStarts=None, stepStops=None, stop=0):
r = self.__compare(other) if r is NotImplemented: return r else: return r != 0 def __str__(self): return IcePy.stringify(self, _M_Bank._t_PersonalData) __repr__ = __str__ _M_Bank._t_PersonalData = IcePy.defineStruct( "::Bank::PersonalData", PersonalData, (), ( ("firstName", (), IcePy._t_string), ("lastName", (), IcePy._t_string), ("NationalIDNumber", (), IcePy._t_string), ), ) _M_Bank.PersonalData = PersonalData del PersonalData if "BankManager" not in _M_Bank.__dict__: _M_Bank.BankManager = Ice.createTempClass() class BankManager(Ice.Object): def __init__(self): if Ice.getType(self) == _M_Bank.BankManager: raise RuntimeError("Bank.BankManager is an abstract class")
def __ne__(self, other): r = self.__compare(other) if r is NotImplemented: return r else: return r != 0 def __str__(self): return IcePy.stringify(self, _M_Meteorologia._t_MedicionDia) __repr__ = __str__ _M_Meteorologia._t_MedicionDia = IcePy.defineStruct( '::Meteorologia::MedicionDia', MedicionDia, (), (('dia', (), IcePy._t_string), ('text', (), IcePy._t_string), ('tempMin', (), IcePy._t_string), ('tempMax', (), IcePy._t_string), ('humedad', (), IcePy._t_string), ('viento', (), IcePy._t_string), ('vientoDireccion', (), IcePy._t_string))) _M_Meteorologia.MedicionDia = MedicionDia del MedicionDia if 'MedicionHora' not in _M_Meteorologia.__dict__: _M_Meteorologia.MedicionHora = Ice.createTempClass() class MedicionHora(object): def __init__(self, dia='', hora='', temp='', text='',
elif self.name > other.name: return 1 if self.eventType < other.eventType: return -1 elif self.eventType > other.eventType: return 1 return 0 def __str__(self): return IcePy.stringify(self, _M_RemoteAi._t_StateEvent) __repr__ = __str__ _M_RemoteAi._t_StateEvent = IcePy.defineStruct('::RemoteAi::StateEvent', StateEvent, (), ( ('timeStamp', (), IcePy._t_long), ('type', (), IcePy._t_string), ('name', (), IcePy._t_string), ('eventType', (), IcePy._t_string) )) _M_RemoteAi.StateEvent = StateEvent del StateEvent if not _M_RemoteAi.__dict__.has_key('_t_StateList'): _M_RemoteAi._t_StateList = IcePy.defineSequence('::RemoteAi::StateList', (), _M_RemoteAi._t_StateEvent) if not _M_RemoteAi.__dict__.has_key('AiInformation'): _M_RemoteAi.AiInformation = Ice.createTempClass() class AiInformation(Ice.Object): def __init__(self): if __builtin__.type(self) == _M_RemoteAi.AiInformation: raise RuntimeError('RemoteAi.AiInformation is an abstract class')
def __ge__(self, other): if isinstance(other, _M_Demo.TimeOfDay): return self.hour >= other.hour or self.minute >= other.minute or self.second >= other.second elif other == None: return False return NotImplemented def __str__(self): return IcePy.stringify(self, _M_Demo._t_TimeOfDay) __repr__ = __str__ _M_Demo._t_TimeOfDay = IcePy.defineStruct('::Demo::TimeOfDay', TimeOfDay, (), ( ('hour', (), IcePy._t_short), ('minute', (), IcePy._t_short), ('second', (), IcePy._t_short) )) _M_Demo.TimeOfDay = TimeOfDay del TimeOfDay if not _M_Demo.__dict__.has_key('Hello'): _M_Demo.Hello = Ice.createTempClass() class Hello(Ice.Object): def __init__(self): if __builtin__.type(self) == _M_Demo.Hello: raise RuntimeError('Demo.Hello is an abstract class') def ice_ids(self, current=None): return ('::Demo::Hello', '::Ice::Object')
return True def __ne__(self, other): return not self.__eq__(other) def __str__(self): return IcePy.stringify(self, _M_ARIAPI._t_stamp) __repr__ = __str__ _M_ARIAPI._t_stamp = IcePy.defineStruct('::ARIAPI::stamp', stamp, (), ( ('name', (), IcePy._t_string), ('timdate', (), IcePy._t_string), ('aznow', (), IcePy._t_float), ('elnow', (), IcePy._t_float), ('temperature', (), IcePy._t_float), ('freq0', (), IcePy._t_float), ('av', (), IcePy._t_int), ('avc', (), IcePy._t_int), ('nfreq', (), IcePy._t_int), ('freqsep', (), IcePy._t_float) )) _M_ARIAPI.stamp = stamp del stamp if 'specs' not in _M_ARIAPI.__dict__: _M_ARIAPI.specs = Ice.createTempClass() class specs(object): def __init__(self, sampleStamp=Ice._struct_marker, spec=None, avspec=None, avspecc=None, specd=None): if sampleStamp is Ice._struct_marker: self.sampleStamp = _M_ARIAPI.stamp()
return r == 0 def __ne__(self, other): r = self.__compare(other) if r is NotImplemented: return r else: return r != 0 def __str__(self): return IcePy.stringify(self, _M_svc._t_RelatedPerson) __repr__ = __str__ _M_svc._t_RelatedPerson = IcePy.defineStruct( '::svc::RelatedPerson', RelatedPerson, (), (('name', (), IcePy._t_string), ('title', (), IcePy._t_string))) _M_svc.RelatedPerson = RelatedPerson del RelatedPerson if 'Partner' not in _M_svc.__dict__: _M_svc.Partner = Ice.createTempClass() class Partner(object): def __init__(self, name='', rate='', scc=''): self.name = name self.rate = rate self.scc = scc def __hash__(self):
def __ne__(self, other): r = self.__compare(other) if r is NotImplemented: return r else: return r != 0 def __str__(self): return IcePy.stringify(self, _M_Bank._t_PersonalData) __repr__ = __str__ _M_Bank._t_PersonalData = IcePy.defineStruct('::Bank::PersonalData', PersonalData, (), ( ('firstName', (), IcePy._t_string), ('lastName', (), IcePy._t_string), ('nationality', (), IcePy._t_string), ('nationalIDNumber', (), IcePy._t_string) )) _M_Bank.PersonalData = PersonalData del PersonalData if 'BankManager' not in _M_Bank.__dict__: _M_Bank.BankManager = Ice.createTempClass() class BankManager(Ice.Object): def __init__(self): if Ice.getType(self) == _M_Bank.BankManager: raise RuntimeError('Bank.BankManager is an abstract class') def ice_ids(self, current=None): return ('::Bank::BankManager', '::Ice::Object')
def __ne__(self, other): r = self.__compare(other) if r is NotImplemented: return r else: return r != 0 def __str__(self): return IcePy.stringify(self, _M_server._t_Musique) __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()
def __ne__(self, other): r = self.__compare(other) if r is NotImplemented: return r else: return r != 0 def __str__(self): return IcePy.stringify(self, _M_assignment2._t_Loan) __repr__ = __str__ _M_assignment2._t_Loan = IcePy.defineStruct('::assignment2::Loan', Loan, (), ( ('interest', (), IcePy._t_string), ('paid', (), IcePy._t_string), ('toPay', (), IcePy._t_string), ('monthsLeft', (), IcePy._t_int) )) _M_assignment2.Loan = Loan del Loan if 'Investment' not in _M_assignment2.__dict__: _M_assignment2.Investment = Ice.createTempClass() class Investment(object): def __init__(self, interest='', moneyProvided='', moneyEarned='', monthsLeft=0): self.interest = interest self.moneyProvided = moneyProvided self.moneyEarned = moneyEarned self.monthsLeft = monthsLeft
return -1 elif self.timestamp > other.timestamp: return 1 if self.digest < other.digest: return -1 elif self.digest > other.digest: return 1 return 0 def __str__(self): return IcePy.stringify(self, _M_games._t_FileEntryT) __repr__ = __str__ _M_games._t_FileEntryT = IcePy.defineStruct( '::games::FileEntryT', FileEntryT, (), (('filename', (), IcePy._t_string), ('size', (), IcePy._t_int), ('timestamp', (), IcePy._t_int), ('digest', (), IcePy._t_string))) _M_games.FileEntryT = FileEntryT del FileEntryT if not _M_games.__dict__.has_key('_t_FileEntryListT'): _M_games._t_FileEntryListT = IcePy.defineSequence( '::games::FileEntryListT', (), _M_games._t_FileEntryT) if not _M_games.__dict__.has_key('ISyncEndpoint'): _M_games.ISyncEndpoint = Ice.createTempClass() class ISyncEndpoint(_M_games.IService): def __init__(self): if __builtin__.type(self) == _M_games.ISyncEndpoint:
return NotImplemented def __ge__(self, other): if isinstance(other, _M_Trade.Identity): return self.strName >= other.strName or self.strAccessToken >= other.strAccessToken or self.ptsdid >= other.ptsdid or self.ptaccount >= other.ptaccount or self.characterid >= other.characterid or self.charactername >= other.charactername or self.matrixid >= other.matrixid or self.clientIP >= other.clientIP or self.group >= other.group elif other == None: return False return NotImplemented def __str__(self): return IcePy.stringify(self, _M_Trade._t_Identity) __repr__ = __str__ _M_Trade._t_Identity = IcePy.defineStruct('::Trade::Identity', Identity, (), ( ('strName', (), IcePy._t_string), ('strAccessToken', (), IcePy._t_string), ('ptsdid', (), IcePy._t_string), ('ptaccount', (), IcePy._t_string), ('characterid', (), IcePy._t_string), ('charactername', (), IcePy._t_string), ('matrixid', (), IcePy._t_string), ('clientIP', (), IcePy._t_string), ('group', (), IcePy._t_string) )) _M_Trade.Identity = Identity del Identity # End of module Trade
if self.g != other.g: return False if self.b != other.b: return False return True def __ne__(self, other): return not self.__eq__(other) def __str__(self): return IcePy.stringify(self, _M_jderobot._t_Color) __repr__ = __str__ _M_jderobot._t_Color = IcePy.defineStruct('::jderobot::Color', Color, (), (('r', (), IcePy._t_float), ('g', (), IcePy._t_float), ('b', (), IcePy._t_float))) _M_jderobot.Color = Color del Color if 'RGBSegment' not in _M_jderobot.__dict__: _M_jderobot.RGBSegment = Ice.createTempClass() class RGBSegment(object): def __init__(self, seg=Ice._struct_marker, c=Ice._struct_marker): if seg is Ice._struct_marker: self.seg = _M_jderobot.Segment() else: self.seg = seg if c is Ice._struct_marker:
def __hash__(self): _h = 0 _h = 5 * _h + __builtin__.hash(self.policySyncTime) return _h % 0x7fffffff def __eq__(self, other): if not self.policySyncTime == other.policySyncTime: return False return True def __str__(self): return IcePy.stringify(self, _M_MPMS._t_fpcControlInfo) __repr__ = __str__ _M_MPMS._t_fpcControlInfo = IcePy.defineStruct('::MPMS::fpcControlInfo', fpcControlInfo, (("policySyncTime", IcePy._t_int),)) _M_MPMS.fpcControlInfo = fpcControlInfo del fpcControlInfo if not _M_MPMS.__dict__.has_key('MediaControlInfo'): _M_MPMS.MediaControlInfo = Ice.createTempClass() class MediaControlInfo(object): def __init__(self, id='', name='', url='', player='', width=0, height=0): self.id = id self.name = name self.url = url self.player = player self.width = width self.height = height
if isinstance(other, _M_FS.mystruct): return self.mytype >= other.mytype or self.bo >= other.bo or self.by >= other.by or self.sh >= other.sh or self.i >= other.i or self.l >= other.l or self.f >= other.f or self.d >= other.d or self.str >= other.str or self.ss >= other.ss or self.sd >= other.sd or self.s >= other.s or self.prx >= other.prx elif other == None: return False return NotImplemented def __str__(self): return IcePy.stringify(self, _M_FS._t_mystruct) __repr__ = __str__ _M_FS._t_mystruct = IcePy.defineStruct( '::FS::mystruct', mystruct, (), (('mytype', (), IcePy._t_int), ('bo', (), IcePy._t_bool), ('by', (), IcePy._t_byte), ('sh', (), IcePy._t_short), ('i', (), IcePy._t_int), ('l', (), IcePy._t_long), ('f', (), IcePy._t_float), ('d', (), IcePy._t_double), ('str', (), IcePy._t_string), ('ss', (), _M_FS._t_StringSeq), ('sd', (), _M_FS._t_StringDict), ('s', (), _M_FS._t_Example), ('prx', (), IcePy._t_ObjectPrx))) _M_FS.mystruct = mystruct del mystruct if not _M_FS.__dict__.has_key('EnumNone'): _M_FS.EnumNone = Ice.createTempClass() class EnumNone(object): def __init__(self, val): assert (val >= 0 and val < 1) self.value = val
return r == 0 def __ne__(self, other): r = self.__compare(other) if r is NotImplemented: return r else: return r != 0 def __str__(self): return IcePy.stringify(self, _M_drobots._t_Point) __repr__ = __str__ _M_drobots._t_Point = IcePy.defineStruct('::drobots::Point', Point, (), ( ('x', (), IcePy._t_int), ('y', (), IcePy._t_int) )) _M_drobots.Point = Point del Point if 'Robot' not in _M_drobots.__dict__: _M_drobots.Robot = Ice.createTempClass() class Robot(Ice.Object): def __init__(self): if Ice.getType(self) == _M_drobots.Robot: raise RuntimeError('drobots.Robot is an abstract class') def ice_ids(self, current=None): return ('::Ice::Object', '::drobots::Robot')
elif self.timestamp > other.timestamp: return 1 if self.digest < other.digest: return -1 elif self.digest > other.digest: return 1 return 0 def __str__(self): return IcePy.stringify(self, _M_games._t_FileEntryT) __repr__ = __str__ _M_games._t_FileEntryT = IcePy.defineStruct('::games::FileEntryT', FileEntryT, (), ( ('filename', (), IcePy._t_string), ('size', (), IcePy._t_int), ('timestamp', (), IcePy._t_int), ('digest', (), IcePy._t_string) )) _M_games.FileEntryT = FileEntryT del FileEntryT if not _M_games.__dict__.has_key('_t_FileEntryListT'): _M_games._t_FileEntryListT = IcePy.defineSequence('::games::FileEntryListT', (), _M_games._t_FileEntryT) if not _M_games.__dict__.has_key('ISyncEndpoint'): _M_games.ISyncEndpoint = Ice.createTempClass() class ISyncEndpoint(_M_games.IService): def __init__(self): if __builtin__.type(self) == _M_games.ISyncEndpoint: raise RuntimeError('games.ISyncEndpoint is an abstract class')
elif other == None: return False return NotImplemented def __str__(self): return IcePy.stringify(self, _M_SRTControl._t_AntennaStatus) __repr__ = __str__ _M_SRTControl._t_AntennaStatus = IcePy.defineStruct('::SRTControl::AntennaStatus', AntennaStatus, (), ( ('az', (), IcePy._t_float), ('el', (), IcePy._t_float), ('aznow', (), IcePy._t_float), ('elnow', (), IcePy._t_float), ('axis', (), IcePy._t_int), ('tostow', (), IcePy._t_int), ('elatstow', (), IcePy._t_int), ('azatstow', (), IcePy._t_int), ('slew', (), IcePy._t_int), ('serialport', (), IcePy._t_string), ('lastSRTCom', (), IcePy._t_string), ('lastSerialMsg', (), IcePy._t_string) )) _M_SRTControl.AntennaStatus = AntennaStatus del AntennaStatus if not _M_SRTControl.__dict__.has_key('_t_anst'): _M_SRTControl._t_anst = IcePy.defineSequence('::SRTControl::anst', (), _M_SRTControl._t_AntennaStatus) if not _M_SRTControl.__dict__.has_key('specs'): _M_SRTControl.specs = Ice.createTempClass()
if self.freqsep != other.freqsep: return False return True def __ne__(self, other): return not self.__eq__(other) def __str__(self): return IcePy.stringify(self, _M_SRTClient._t_stamp) __repr__ = __str__ _M_SRTClient._t_stamp = IcePy.defineStruct( '::SRTClient::stamp', stamp, (), (('name', (), IcePy._t_string), ('timdate', (), IcePy._t_string), ('aznow', (), IcePy._t_float), ('elnow', (), IcePy._t_float), ('temperature', (), IcePy._t_float), ('freq0', (), IcePy._t_float), ('av', (), IcePy._t_int), ('avc', (), IcePy._t_int), ('nfreq', (), IcePy._t_int), ('freqsep', (), IcePy._t_float))) _M_SRTClient.stamp = stamp del stamp if 'specs' not in _M_SRTClient.__dict__: _M_SRTClient.specs = Ice.createTempClass() class specs(object): def __init__(self, sampleStamp=Ice._struct_marker, spec=None, avspec=None,
return -1 elif self.code > other.code: return 1 if self.msg < other.msg: return -1 elif self.msg > other.msg: return 1 return 0 def __str__(self): return IcePy.stringify(self, _M_com.xiaonei.wap.talk._t_Result) __repr__ = __str__ _M_com.xiaonei.wap.talk._t_Result = IcePy.defineStruct('::com::xiaonei::wap::talk::Result', Result, (), ( ('code', (), IcePy._t_int), ('msg', (), IcePy._t_string) )) _M_com.xiaonei.wap.talk.Result = Result del Result if not _M_com.xiaonei.wap.talk.__dict__.has_key('TalkService'): _M_com.xiaonei.wap.talk.TalkService = Ice.createTempClass() class TalkService(Ice.Object): def __init__(self): if __builtin__.type(self) == _M_com.xiaonei.wap.talk.TalkService: raise RuntimeError('com.xiaonei.wap.talk.TalkService is an abstract class') def ice_ids(self, current=None): return ('::Ice::Object', '::com::xiaonei::wap::talk::TalkService')
return False if self.currency != other.currency: return False return True def __ne__(self, other): return not self.__eq__(other) def __str__(self): return IcePy.stringify(self, _M_Bank._t_MoneyAmount) __repr__ = __str__ _M_Bank._t_MoneyAmount = IcePy.defineStruct('::Bank::MoneyAmount', MoneyAmount, (), (('amount', (), IcePy._t_double), ('currency', (), _M_Bank._t_CurrencyIce))) _M_Bank.MoneyAmount = MoneyAmount del MoneyAmount if 'Date' not in _M_Bank.__dict__: _M_Bank.Date = Ice.createTempClass() class Date(object): def __init__(self, day=0, month=0, year=0): self.day = day self.month = month self.year = year
_h = 0 _h = 5 * _h + __builtin__.hash(self.policySyncTime) return _h % 0x7fffffff def __eq__(self, other): if not self.policySyncTime == other.policySyncTime: return False return True def __str__(self): return IcePy.stringify(self, _M_MPMS._t_fpcControlInfo) __repr__ = __str__ _M_MPMS._t_fpcControlInfo = IcePy.defineStruct( '::MPMS::fpcControlInfo', fpcControlInfo, (("policySyncTime", IcePy._t_int), )) _M_MPMS.fpcControlInfo = fpcControlInfo del fpcControlInfo if not _M_MPMS.__dict__.has_key('MediaControlInfo'): _M_MPMS.MediaControlInfo = Ice.createTempClass() class MediaControlInfo(object): def __init__(self, id='', name='', url='', player='', width=0,
return False return NotImplemented def __ge__(self, other): if isinstance(other, _M_Ice.Current): return self.adapter >= other.adapter or self.con >= other.con or self.id >= other.id or self.facet >= other.facet or self.operation >= other.operation or self.mode >= other.mode or self.ctx >= other.ctx or self.requestId >= other.requestId elif other == None: return False return NotImplemented def __str__(self): return IcePy.stringify(self, _M_Ice._t_Current) __repr__ = __str__ _M_Ice._t_Current = IcePy.defineStruct('::Ice::Current', Current, (), ( ('adapter', (), _M_Ice._t_ObjectAdapter), ('con', (), _M_Ice._t_Connection), ('id', (), _M_Ice._t_Identity), ('facet', (), IcePy._t_string), ('operation', (), IcePy._t_string), ('mode', (), _M_Ice._t_OperationMode), ('ctx', (), _M_Ice._t_Context), ('requestId', (), IcePy._t_int) )) _M_Ice.Current = Current del Current # End of module Ice
return NotImplemented def __ge__(self, other): if isinstance(other, _M_IceStorm.LinkInfo): return self.theTopic >= other.theTopic or self.name >= other.name or self.cost >= other.cost elif other == None: return False return NotImplemented def __str__(self): return IcePy.stringify(self, _M_IceStorm._t_LinkInfo) __repr__ = __str__ _M_IceStorm._t_LinkInfo = IcePy.defineStruct( '::IceStorm::LinkInfo', LinkInfo, (), (('theTopic', (), _M_IceStorm._t_TopicPrx), ('name', (), IcePy._t_string), ('cost', (), IcePy._t_int))) _M_IceStorm.LinkInfo = LinkInfo del LinkInfo if not _M_IceStorm.__dict__.has_key('_t_LinkInfoSeq'): _M_IceStorm._t_LinkInfoSeq = IcePy.defineSequence( '::IceStorm::LinkInfoSeq', (), _M_IceStorm._t_LinkInfo) if not _M_IceStorm.__dict__.has_key('_t_QoS'): _M_IceStorm._t_QoS = IcePy.defineDictionary('::IceStorm::QoS', (), IcePy._t_string, IcePy._t_string) if not _M_IceStorm.__dict__.has_key('LinkExists'):
return r == 0 def __ne__(self, other): r = self.__compare(other) if r is NotImplemented: return r else: return r != 0 def __str__(self): return IcePy.stringify(self, _M_Notification._t_timeStamp) __repr__ = __str__ _M_Notification._t_timeStamp = IcePy.defineStruct( '::Notification::timeStamp', timeStamp, (), (('hour', (), IcePy._t_int), ('minute', (), IcePy._t_int), ('second', (), IcePy._t_int))) _M_Notification.timeStamp = timeStamp del timeStamp if 'caseResult' not in _M_Notification.__dict__: _M_Notification.caseResult = Ice.createTempClass() class caseResult(object): def __init__(self, registrationTimeStamp=Ice._struct_marker, expectedResolutionTime=0, resultMessage=''): if registrationTimeStamp is Ice._struct_marker: self.registrationTimeStamp = _M_Notification.timeStamp()
return True def __ne__(self, other): return not self.__eq__(other) def __str__(self): return IcePy.stringify(self, _M_SRTClient._t_stamp) __repr__ = __str__ _M_SRTClient._t_stamp = IcePy.defineStruct('::SRTClient::stamp', stamp, (), ( ('name', (), IcePy._t_string), ('timdate', (), IcePy._t_string), ('aznow', (), IcePy._t_float), ('elnow', (), IcePy._t_float), ('temperature', (), IcePy._t_float), ('freq0', (), IcePy._t_float), ('av', (), IcePy._t_int), ('avc', (), IcePy._t_int), ('nfreq', (), IcePy._t_int), ('freqsep', (), IcePy._t_float) )) _M_SRTClient.stamp = stamp del stamp if 'specs' not in _M_SRTClient.__dict__: _M_SRTClient.specs = Ice.createTempClass() class specs(object): def __init__(self, sampleStamp=Ice._struct_marker, spec=None, avspec=None, avspecc=None, specd=None): if sampleStamp is Ice._struct_marker: self.sampleStamp = _M_SRTClient.stamp()
def __ne__(self, other): r = self.__compare(other) if r is NotImplemented: return r else: return r != 0 def __str__(self): return IcePy.stringify(self, _M_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):
if not self.wallpaper == other.wallpaper: return False if not self.alNotification == other.alNotification: return False if not self.alAdvertisement == other.alAdvertisement: return False return True def __str__(self): return IcePy.stringify(self, _M_MPMS._t_fpcSetting) __repr__ = __str__ _M_MPMS._t_fpcSetting = IcePy.defineStruct('::MPMS::fpcSetting', fpcSetting, ( ("ieDefaultAddr", IcePy._t_string), ("wallpaper", IcePy._t_string), ("alNotification", IcePy._t_string), ("alAdvertisement", IcePy._t_string) )) _M_MPMS.fpcSetting = fpcSetting del fpcSetting _M_MPMS.MediaControlInfo = Ice.createTempClass() class MediaControlInfo(object): def __init__(self, url='', player='', width=0, height=0): self.url = url self.player = player self.width = width self.height = height def __hash__(self):
def __ne__(self, other): r = self.__compare(other) if r is NotImplemented: return r else: return r != 0 def __str__(self): return IcePy.stringify(self, _M_mp3App._t_Song) __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()
return -1 elif self.x > other.x: return 1 if self.y < other.y: return -1 elif self.y > other.y: return 1 return 0 def __str__(self): return IcePy.stringify(self, _M_echoes._t_ScreenLocation) __repr__ = __str__ _M_echoes._t_ScreenLocation = IcePy.defineStruct('::echoes::ScreenLocation', ScreenLocation, (), ( ('x', (), IcePy._t_int), ('y', (), IcePy._t_int) )) _M_echoes.ScreenLocation = ScreenLocation del ScreenLocation if not _M_echoes.__dict__.has_key('ScreenRegion'): _M_echoes.ScreenRegion = Ice.createTempClass() class ScreenRegion(object): def __init__(self, val): assert(val >= 0 and val < 10) self.value = val def __str__(self): if self.value == 0:
return False return NotImplemented def __str__(self): return IcePy.stringify(self, _M_FS._t_mystruct) __repr__ = __str__ _M_FS._t_mystruct = IcePy.defineStruct('::FS::mystruct', mystruct, (), ( ('mytype', (), IcePy._t_int), ('bo', (), IcePy._t_bool), ('by', (), IcePy._t_byte), ('sh', (), IcePy._t_short), ('i', (), IcePy._t_int), ('l', (), IcePy._t_long), ('f', (), IcePy._t_float), ('d', (), IcePy._t_double), ('str', (), IcePy._t_string), ('ss', (), _M_FS._t_StringSeq), ('sd', (), _M_FS._t_StringDict), ('s', (), _M_FS._t_Example), ('prx', (), IcePy._t_ObjectPrx) )) _M_FS.mystruct = mystruct del mystruct if not _M_FS.__dict__.has_key('EnumNone'): _M_FS.EnumNone = Ice.createTempClass() class EnumNone(object):
return r == 0 def __ne__(self, other): r = self.__compare(other) if r is NotImplemented: return r else: return r != 0 def __str__(self): return IcePy.stringify(self, _M_Office._t_basicCaseData) __repr__ = __str__ _M_Office._t_basicCaseData = IcePy.defineStruct( '::Office::basicCaseData', basicCaseData, (), (('uniqueID', (), IcePy._t_int), ('registrationTime', (), _M_Notification._t_timeStamp))) _M_Office.basicCaseData = basicCaseData del basicCaseData _M_Office._t_Reception = IcePy.defineValue('::Office::Reception', Ice.Value, -1, (), False, True, None, ()) if 'ReceptionPrx' not in _M_Office.__dict__: _M_Office.ReceptionPrx = Ice.createTempClass() class ReceptionPrx(Ice.ObjectPrx): def register(self, uniqueID, notifier, context=None): return _M_Office.Reception._op_register.invoke( self, ((uniqueID, notifier), context))
return False if self.amount != other.amount: return False return True def __ne__(self, other): return not self.__eq__(other) def __str__(self): return IcePy.stringify(self, _M_Bank._t_LoanOffer) __repr__ = __str__ _M_Bank._t_LoanOffer = IcePy.defineStruct( '::Bank::LoanOffer', LoanOffer, (), (('currency', (), IcePy._t_string), ('amountInPLN', (), IcePy._t_double), ('amount', (), IcePy._t_double))) _M_Bank.LoanOffer = LoanOffer del LoanOffer if 'AccountInfo' not in _M_Bank.__dict__: _M_Bank.AccountInfo = Ice.createTempClass() class AccountInfo(object): def __init__(self, firstName='', lastName='', amount=0.0, type=_M_Bank.AccountType.PREMIUM):
def __ne__(self, other): r = self.__compare(other) if r is NotImplemented: return r else: return r != 0 def __str__(self): return IcePy.stringify(self, _M_Domotics._t_colorRGB) __repr__ = __str__ _M_Domotics._t_colorRGB = IcePy.defineStruct('::Domotics::colorRGB', colorRGB, (), (('red', (), IcePy._t_int), ('green', (), IcePy._t_int), ('blue', (), IcePy._t_int))) _M_Domotics.colorRGB = colorRGB del colorRGB _M_Domotics._t_RGBLamp = IcePy.defineValue('::Domotics::RGBLamp', Ice.Value, -1, (), False, True, None, ()) if 'RGBLampPrx' not in _M_Domotics.__dict__: _M_Domotics.RGBLampPrx = Ice.createTempClass() class RGBLampPrx(_M_Domotics.LampPrx): def getColor(self, context=None): return _M_Domotics.RGBLamp._op_getColor.invoke(self, ((), context))
return r == 0 def __ne__(self, other): r = self.__compare(other) if r is NotImplemented: return r else: return r != 0 def __str__(self): return IcePy.stringify(self, _M_jderobot._t_Time) __repr__ = __str__ _M_jderobot._t_Time = IcePy.defineStruct('::jderobot::Time', Time, (), (('seconds', (), IcePy._t_long), ('useconds', (), IcePy._t_long))) _M_jderobot.Time = Time del Time # End of module jderobot # Start of module jderobot __name__ = 'jderobot' if 'JderobotException' not in _M_jderobot.__dict__: _M_jderobot.JderobotException = Ice.createTempClass() class JderobotException(Ice.UserException): def __init__(self, what=''):
if self.value != other.value: return False if self.currency != other.currency: return False return True def __ne__(self, other): return not self.__eq__(other) def __str__(self): return IcePy.stringify(self, _M_Bank._t_Money) __repr__ = __str__ _M_Bank._t_Money = IcePy.defineStruct('::Bank::Money', Money, (), (('value', (), IcePy._t_float), ('currency', (), _M_Bank._t_Currency))) _M_Bank.Money = Money del Money if 'Date' not in _M_Bank.__dict__: _M_Bank.Date = Ice.createTempClass() class Date(object): def __init__(self, day=0, month=0, year=0): self.day = day self.month = month self.year = year def __hash__(self):
return NotImplemented def __ge__(self, other): if isinstance(other, _M_WorldStateTopic.Position): return self.x >= other.x or self.y >= other.y elif other == None: return False return NotImplemented def __str__(self): return IcePy.stringify(self, _M_WorldStateTopic._t_Position) __repr__ = __str__ _M_WorldStateTopic._t_Position = IcePy.defineStruct('::WorldStateTopic::Position', Position, (), ( ('x', (), IcePy._t_float), ('y', (), IcePy._t_float) )) _M_WorldStateTopic.Position = Position del Position if not _M_WorldStateTopic.__dict__.has_key('Ball'): _M_WorldStateTopic.Ball = Ice.createTempClass() class Ball(object): def __init__(self, pos=Ice._struct_marker): if pos is Ice._struct_marker: self.pos = _M_WorldStateTopic.Position() else: self.pos = pos def __hash__(self):
return r == 0 def __ne__(self, other): r = self.__compare(other) if r is NotImplemented: return r else: return r != 0 def __str__(self): return IcePy.stringify(self, _M_Ice._t_ProtocolVersion) __repr__ = __str__ _M_Ice._t_ProtocolVersion = IcePy.defineStruct( '::Ice::ProtocolVersion', ProtocolVersion, (), (('major', (), IcePy._t_byte), ('minor', (), IcePy._t_byte))) _M_Ice.ProtocolVersion = ProtocolVersion del ProtocolVersion if 'EncodingVersion' not in _M_Ice.__dict__: _M_Ice.EncodingVersion = Ice.createTempClass() class EncodingVersion(object): """ A version structure for the encoding version. """ def __init__(self, major=0, minor=0): self.major = major self.minor = minor
return r == 0 def __ne__(self, other): r = self.__compare(other) if r is NotImplemented: return r else: return r != 0 def __str__(self): return IcePy.stringify(self, _M_Ice._t_Identity) __repr__ = __str__ _M_Ice._t_Identity = IcePy.defineStruct('::Ice::Identity', Identity, (), (('name', (), IcePy._t_string), ('category', (), IcePy._t_string))) _M_Ice.Identity = Identity del Identity if '_t_ObjectDict' not in _M_Ice.__dict__: _M_Ice._t_ObjectDict = IcePy.defineDictionary('::Ice::ObjectDict', (), _M_Ice._t_Identity, IcePy._t_Value) if '_t_IdentitySeq' not in _M_Ice.__dict__: _M_Ice._t_IdentitySeq = IcePy.defineSequence('::Ice::IdentitySeq', (), _M_Ice._t_Identity) # End of module Ice
def __ne__(self, other): r = self.__compare(other) if r is NotImplemented: return r else: return r != 0 def __str__(self): return IcePy.stringify(self, _M_Tester._t_SmallData) __repr__ = __str__ _M_Tester._t_SmallData = IcePy.defineStruct( '::Tester::SmallData', SmallData, (), (('n1', (), IcePy._t_int), ('n2', (), IcePy._t_int), ('s1', (), IcePy._t_string), ('b1', (), IcePy._t_bool), ('iSeq1', (), _M_Tester._t_SeqInt))) _M_Tester.SmallData = SmallData del SmallData if 'MediumData' not in _M_Tester.__dict__: _M_Tester.MediumData = Ice.createTempClass() class MediumData(object): def __init__(self, smallData=Ice._struct_marker, n3=0, n4=0, d1=0.0,
def __ge__(self, other): if isinstance(other, _M_IceStorm.LinkInfo): return self.theTopic >= other.theTopic or self.name >= other.name or self.cost >= other.cost elif other == None: return False return NotImplemented def __str__(self): return IcePy.stringify(self, _M_IceStorm._t_LinkInfo) __repr__ = __str__ _M_IceStorm._t_LinkInfo = IcePy.defineStruct('::IceStorm::LinkInfo', LinkInfo, (), ( ('theTopic', (), _M_IceStorm._t_TopicPrx), ('name', (), IcePy._t_string), ('cost', (), IcePy._t_int) )) _M_IceStorm.LinkInfo = LinkInfo del LinkInfo if not _M_IceStorm.__dict__.has_key('_t_LinkInfoSeq'): _M_IceStorm._t_LinkInfoSeq = IcePy.defineSequence('::IceStorm::LinkInfoSeq', (), _M_IceStorm._t_LinkInfo) if not _M_IceStorm.__dict__.has_key('_t_QoS'): _M_IceStorm._t_QoS = IcePy.defineDictionary('::IceStorm::QoS', (), IcePy._t_string, IcePy._t_string) if not _M_IceStorm.__dict__.has_key('LinkExists'): _M_IceStorm.LinkExists = Ice.createTempClass() class LinkExists(Ice.UserException):
def __ge__(self, other): if isinstance(other, _M_Demo.TimeOfDay): return self.hour >= other.hour or self.minute >= other.minute or self.second >= other.second elif other == None: return False return NotImplemented def __str__(self): return IcePy.stringify(self, _M_Demo._t_TimeOfDay) __repr__ = __str__ _M_Demo._t_TimeOfDay = IcePy.defineStruct('::Demo::TimeOfDay', TimeOfDay, (), (('hour', (), IcePy._t_short), ('minute', (), IcePy._t_short), ('second', (), IcePy._t_short))) _M_Demo.TimeOfDay = TimeOfDay del TimeOfDay if not _M_Demo.__dict__.has_key('Hello'): _M_Demo.Hello = Ice.createTempClass() class Hello(Ice.Object): def __init__(self): if __builtin__.type(self) == _M_Demo.Hello: raise RuntimeError('Demo.Hello is an abstract class') def ice_ids(self, current=None):
return r == 0 def __ne__(self, other): r = self.__compare(other) if r is NotImplemented: return r else: return r != 0 def __str__(self): return IcePy.stringify(self, _M_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(
return False return NotImplemented def __str__(self): return IcePy.stringify(self, _M_SRTControl._t_AntennaStatus) __repr__ = __str__ _M_SRTControl._t_AntennaStatus = IcePy.defineStruct('::SRTControl::AntennaStatus', AntennaStatus, (), ( ('now', (), IcePy._t_string), ('name', (), IcePy._t_string), ('az', (), IcePy._t_float), ('el', (), IcePy._t_float), ('aznow', (), IcePy._t_float), ('elnow', (), IcePy._t_float), ('axis', (), IcePy._t_int), ('tostow', (), IcePy._t_int), ('elatstow', (), IcePy._t_int), ('azatstow', (), IcePy._t_int), ('slew', (), IcePy._t_int), ('serialport', (), IcePy._t_string), ('lastSRTCom', (), IcePy._t_string), ('lastSerialMsg', (), IcePy._t_string) )) _M_SRTControl.AntennaStatus = AntennaStatus del AntennaStatus if not _M_SRTControl.__dict__.has_key('_t_anst'): _M_SRTControl._t_anst = IcePy.defineSequence('::SRTControl::anst', (), _M_SRTControl._t_AntennaStatus) if not _M_SRTControl.__dict__.has_key('stamp'):