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_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=''):
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_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=''):
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'):
