valueOf = classmethod(valueOf) Currency.PLN = Currency("PLN", 0) Currency.USD = Currency("USD", 1) Currency.EUR = Currency("EUR", 2) Currency.GBP = Currency("GBP", 3) Currency.CHF = Currency("CHF", 4) Currency._enumerators = { 0: Currency.PLN, 1: Currency.USD, 2: Currency.EUR, 3: Currency.GBP, 4: Currency.CHF } _M_Bank._t_Currency = IcePy.defineEnum('::Bank::Currency', Currency, (), Currency._enumerators) _M_Bank.Currency = Currency del Currency if 'AccountError' not in _M_Bank.__dict__: _M_Bank.AccountError = Ice.createTempClass() class AccountError(Ice.EnumBase): def __init__(self, _n, _v): Ice.EnumBase.__init__(self, _n, _v) def valueOf(self, _n): if _n in self._enumerators: return self._enumerators[_n] return None
valueOf = classmethod(valueOf) LogMessageType.PrintMessage = LogMessageType("PrintMessage", 0) LogMessageType.TraceMessage = LogMessageType("TraceMessage", 1) LogMessageType.WarningMessage = LogMessageType("WarningMessage", 2) LogMessageType.ErrorMessage = LogMessageType("ErrorMessage", 3) LogMessageType._enumerators = { 0: LogMessageType.PrintMessage, 1: LogMessageType.TraceMessage, 2: LogMessageType.WarningMessage, 3: LogMessageType.ErrorMessage } _M_Ice._t_LogMessageType = IcePy.defineEnum('::Ice::LogMessageType', LogMessageType, (), LogMessageType._enumerators) _M_Ice.LogMessageType = LogMessageType del LogMessageType if '_t_LogMessageTypeSeq' not in _M_Ice.__dict__: _M_Ice._t_LogMessageTypeSeq = IcePy.defineSequence( '::Ice::LogMessageTypeSeq', (), _M_Ice._t_LogMessageType) if 'LogMessage' not in _M_Ice.__dict__: _M_Ice.LogMessage = Ice.createTempClass() class LogMessage(object): '''A complete log message.''' def __init__(self,
def __cmp__(self, other): return cmp(self.value, other.value) ScreenRegion.ScreenTopLeft = ScreenRegion(0) ScreenRegion.ScreenTopMiddle = ScreenRegion(1) ScreenRegion.ScreenTopRight = ScreenRegion(2) ScreenRegion.ScreenMiddleLeft = ScreenRegion(3) ScreenRegion.ScreenMiddleMiddle = ScreenRegion(4) ScreenRegion.ScreenMiddleRight = ScreenRegion(5) ScreenRegion.ScreenBottomLeft = ScreenRegion(6) ScreenRegion.ScreenBottomMiddle = ScreenRegion(7) ScreenRegion.ScreenBottomRight = ScreenRegion(8) ScreenRegion.ScreenUnknown = ScreenRegion(9) _M_echoes._t_ScreenRegion = IcePy.defineEnum('::echoes::ScreenRegion', ScreenRegion, (), (ScreenRegion.ScreenTopLeft, ScreenRegion.ScreenTopMiddle, ScreenRegion.ScreenTopRight, ScreenRegion.ScreenMiddleLeft, ScreenRegion.ScreenMiddleMiddle, ScreenRegion.ScreenMiddleRight, ScreenRegion.ScreenBottomLeft, ScreenRegion.ScreenBottomMiddle, ScreenRegion.ScreenBottomRight, ScreenRegion.ScreenUnknown)) _M_echoes.ScreenRegion = ScreenRegion del ScreenRegion if not _M_echoes.__dict__.has_key('FacialExpression'): _M_echoes.FacialExpression = Ice.createTempClass() class FacialExpression(object): def __init__(self, val): assert(val >= 0 and val < 2) self.value = val def __str__(self): if self.value == 0: return 'ExpressionSmile'
Ice.EnumBase.__init__(self, _n, _v) def valueOf(self, _n): if _n in self._enumerators: return self._enumerators[_n] return None valueOf = classmethod(valueOf) currency.PLN = currency("PLN", 0) currency.USD = currency("USD", 1) currency.EUR = currency("EUR", 2) currency.CHF = currency("CHF", 3) currency._enumerators = {0: currency.PLN, 1: currency.USD, 2: currency.EUR, 3: currency.CHF} _M_Bank._t_currency = IcePy.defineEnum("::Bank::currency", currency, (), currency._enumerators) _M_Bank.currency = currency del currency if "accountType" not in _M_Bank.__dict__: _M_Bank.accountType = Ice.createTempClass() class accountType(Ice.EnumBase): def __init__(self, _n, _v): Ice.EnumBase.__init__(self, _n, _v) def valueOf(self, _n): if _n in self._enumerators: return self._enumerators[_n] return None
if isinstance(other, _M_omero.cmd.State): return self.value >= other.value; elif other == None: return False return NotImplemented _names = ('ALL', 'ACTIVE', 'INACTIVE', 'SUCCESS', 'FAILURE', 'CANCELLED') State.ALL = State(0) State.ACTIVE = State(1) State.INACTIVE = State(2) State.SUCCESS = State(3) State.FAILURE = State(4) State.CANCELLED = State(5) _M_omero.cmd._t_State = IcePy.defineEnum('::omero::cmd::State', State, (), (State.ALL, State.ACTIVE, State.INACTIVE, State.SUCCESS, State.FAILURE, State.CANCELLED)) _M_omero.cmd.State = State del State if not _M_omero.cmd.__dict__.has_key('_t_StateList'): _M_omero.cmd._t_StateList = IcePy.defineSequence('::omero::cmd::StateList', (), _M_omero.cmd._t_State) if not _M_omero.cmd.__dict__.has_key('Handle'): _M_omero.cmd._t_Handle = IcePy.declareClass('::omero::cmd::Handle') _M_omero.cmd._t_HandlePrx = IcePy.declareProxy('::omero::cmd::Handle') if not _M_omero.cmd.__dict__.has_key('Status'): _M_omero.cmd.Status = Ice.createTempClass() class Status(Ice.Object): def __init__(self, source=None, category='', name='', flags=None, parameters=None, steps=0, startTime=0, stepStartTimes=None, stepStopTimes=None, stopTime=0):
_M_Ice.EndpointSelectionType = Ice.createTempClass() class EndpointSelectionType(Ice.EnumBase): """ Determines the order in which the Ice run time uses the endpoints in a proxy when establishing a connection. Enumerators: Random -- Random causes the endpoints to be arranged in a random order. Ordered -- Ordered forces the Ice run time to use the endpoints in the order they appeared in the proxy. """ def __init__(self, _n, _v): Ice.EnumBase.__init__(self, _n, _v) def valueOf(self, _n): if _n in self._enumerators: return self._enumerators[_n] return None valueOf = classmethod(valueOf) EndpointSelectionType.Random = EndpointSelectionType("Random", 0) EndpointSelectionType.Ordered = EndpointSelectionType("Ordered", 1) EndpointSelectionType._enumerators = { 0:EndpointSelectionType.Random, 1:EndpointSelectionType.Ordered } _M_Ice._t_EndpointSelectionType = IcePy.defineEnum('::Ice::EndpointSelectionType', EndpointSelectionType, (), EndpointSelectionType._enumerators) _M_Ice.EndpointSelectionType = EndpointSelectionType del EndpointSelectionType # End of module Ice
def __init__(self, _n, _v): Ice.EnumBase.__init__(self, _n, _v) def valueOf(self, _n): if _n in self._enumerators: return self._enumerators[_n] return None valueOf = classmethod(valueOf) PowerMode.ON = PowerMode("ON", 0) PowerMode.OFF = PowerMode("OFF", 1) PowerMode._enumerators = {0: PowerMode.ON, 1: PowerMode.OFF} _M_SmartHouse._t_PowerMode = IcePy.defineEnum('::SmartHouse::PowerMode', PowerMode, (), PowerMode._enumerators) _M_SmartHouse.PowerMode = PowerMode del PowerMode if 'LightMode' not in _M_SmartHouse.__dict__: _M_SmartHouse.LightMode = Ice.createTempClass() class LightMode(Ice.EnumBase): def __init__(self, _n, _v): Ice.EnumBase.__init__(self, _n, _v) def valueOf(self, _n): if _n in self._enumerators: return self._enumerators[_n]
def __init__(self, _n, _v): Ice.EnumBase.__init__(self, _n, _v) def valueOf(self, _n): if _n in self._enumerators: return self._enumerators[_n] return None valueOf = classmethod(valueOf) Currency.PLN = Currency("PLN", 0) Currency.EUR = Currency("EUR", 1) Currency.USD = Currency("USD", 2) Currency.CHF = Currency("CHF", 3) Currency._enumerators = { 0:Currency.PLN, 1:Currency.EUR, 2:Currency.USD, 3:Currency.CHF } _M_FinancialNews._t_Currency = IcePy.defineEnum('::FinancialNews::Currency', Currency, (), Currency._enumerators) _M_FinancialNews.Currency = Currency del Currency if 'FinancialNewsReceiver' not in _M_FinancialNews.__dict__: _M_FinancialNews.FinancialNewsReceiver = Ice.createTempClass() class FinancialNewsReceiver(Ice.Object): def __init__(self): if Ice.getType(self) == _M_FinancialNews.FinancialNewsReceiver: raise RuntimeError('FinancialNews.FinancialNewsReceiver is an abstract class') def ice_ids(self, current=None): return ('::FinancialNews::FinancialNewsReceiver', '::Ice::Object') def ice_id(self, current=None):
valueOf = classmethod(valueOf) ACMClose.CloseOff = ACMClose("CloseOff", 0) ACMClose.CloseOnIdle = ACMClose("CloseOnIdle", 1) ACMClose.CloseOnInvocation = ACMClose("CloseOnInvocation", 2) ACMClose.CloseOnInvocationAndIdle = ACMClose("CloseOnInvocationAndIdle", 3) ACMClose.CloseOnIdleForceful = ACMClose("CloseOnIdleForceful", 4) ACMClose._enumerators = { 0: ACMClose.CloseOff, 1: ACMClose.CloseOnIdle, 2: ACMClose.CloseOnInvocation, 3: ACMClose.CloseOnInvocationAndIdle, 4: ACMClose.CloseOnIdleForceful } _M_Ice._t_ACMClose = IcePy.defineEnum('::Ice::ACMClose', ACMClose, (), ACMClose._enumerators) _M_Ice.ACMClose = ACMClose del ACMClose if 'ACMHeartbeat' not in _M_Ice.__dict__: _M_Ice.ACMHeartbeat = Ice.createTempClass() class ACMHeartbeat(Ice.EnumBase): def __init__(self, _n, _v): Ice.EnumBase.__init__(self, _n, _v) def valueOf(self, _n): if _n in self._enumerators: return self._enumerators[_n] return None
return NotImplemented def __ge__(self, other): if isinstance(other, _M_omero.constants.projection.ProjectionType): return self.value >= other.value; elif other == None: return False return NotImplemented _names = ('MAXIMUMINTENSITY', 'MEANINTENSITY', 'SUMINTENSITY') ProjectionType.MAXIMUMINTENSITY = ProjectionType(0) ProjectionType.MEANINTENSITY = ProjectionType(1) ProjectionType.SUMINTENSITY = ProjectionType(2) _M_omero.constants.projection._t_ProjectionType = IcePy.defineEnum('::omero::constants::projection::ProjectionType', ProjectionType, (), (ProjectionType.MAXIMUMINTENSITY, ProjectionType.MEANINTENSITY, ProjectionType.SUMINTENSITY)) _M_omero.constants.projection.ProjectionType = ProjectionType del ProjectionType # End of module omero.constants.projection __name__ = 'omero.constants' # Start of module omero.constants.topics _M_omero.constants.topics = Ice.openModule('omero.constants.topics') __name__ = 'omero.constants.topics' _M_omero.constants.topics.PROCESSORACCEPTS = "/internal/ProcessorAccept" _M_omero.constants.topics.HEARTBEAT = "/public/HeartBeat"
class State(Ice.EnumBase): def __init__(self, _n, _v): Ice.EnumBase.__init__(self, _n, _v) def valueOf(self, _n): if _n in self._enumerators: return self._enumerators[_n] return None valueOf = classmethod(valueOf) State.Running = State("Running", 0) State.Off = State("Off", 1) State._enumerators = {0: State.Running, 1: State.Off} _M_Smarthouse._t_State = IcePy.defineEnum('::Smarthouse::State', State, (), State._enumerators) _M_Smarthouse.State = State del State if '_t_Lines' not in _M_Smarthouse.__dict__: _M_Smarthouse._t_Lines = IcePy.defineSequence('::Smarthouse::Lines', (), IcePy._t_string) if 'OvenProgram' not in _M_Smarthouse.__dict__: _M_Smarthouse.OvenProgram = Ice.createTempClass() class OvenProgram(object): def __init__(self, temperature=0.0, hours=0, minutes=0, seconds=0): self.temperature = temperature self.hours = hours
KnobType.KNOBINT = KnobType("KNOBINT", 2) KnobType.KNOBFLOAT = KnobType("KNOBFLOAT", 3) KnobType.KNOBDOUBLE = KnobType("KNOBDOUBLE", 4) KnobType.KNOBSTRING = KnobType("KNOBSTRING", 5) KnobType.KNOBLONG = KnobType("KNOBLONG", 6) KnobType.KNOBVECBOOL = KnobType("KNOBVECBOOL", 7) KnobType.KNOBVECCHAR = KnobType("KNOBVECCHAR", 8) KnobType.KNOBVECINT = KnobType("KNOBVECINT", 9) KnobType.KNOBVECFLOAT = KnobType("KNOBVECFLOAT", 10) KnobType.KNOBVECDOUBLE = KnobType("KNOBVECDOUBLE", 11) KnobType.KNOBVECSTRING = KnobType("KNOBVECSTRING", 12) KnobType.KNOBVECLONG = KnobType("KNOBVECLONG", 13) KnobType.KNOBSHORT = KnobType("KNOBSHORT", 14) KnobType._enumerators = { 0:KnobType.KNOBBOOL, 1:KnobType.KNOBCHAR, 2:KnobType.KNOBINT, 3:KnobType.KNOBFLOAT, 4:KnobType.KNOBDOUBLE, 5:KnobType.KNOBSTRING, 6:KnobType.KNOBLONG, 7:KnobType.KNOBVECBOOL, 8:KnobType.KNOBVECCHAR, 9:KnobType.KNOBVECINT, 10:KnobType.KNOBVECFLOAT, 11:KnobType.KNOBVECDOUBLE, 12:KnobType.KNOBVECSTRING, 13:KnobType.KNOBVECLONG, 14:KnobType.KNOBSHORT } _M_gnuradio.ctrlport.GNURadio._t_KnobType = IcePy.defineEnum('::GNURadio::KnobType', KnobType, (), KnobType._enumerators) _M_gnuradio.ctrlport.GNURadio.KnobType = KnobType del KnobType _M_gnuradio.ctrlport.GNURadio.DISPNULL = 0 _M_gnuradio.ctrlport.GNURadio.DISPTIME = 1 _M_gnuradio.ctrlport.GNURadio.DISPXY = 2 _M_gnuradio.ctrlport.GNURadio.DISPPSD = 4 _M_gnuradio.ctrlport.GNURadio.DISPSPEC = 8 _M_gnuradio.ctrlport.GNURadio.DISPRAST = 16
return self.value != other.value; elif other == None: return False return NotImplemented def __gt__(self, other): if isinstance(other, _M_Ice.EndpointSelectionType): return self.value > other.value; elif other == None: return False return NotImplemented def __ge__(self, other): if isinstance(other, _M_Ice.EndpointSelectionType): return self.value >= other.value; elif other == None: return False return NotImplemented _names = ('Random', 'Ordered') EndpointSelectionType.Random = EndpointSelectionType(0) EndpointSelectionType.Ordered = EndpointSelectionType(1) _M_Ice._t_EndpointSelectionType = IcePy.defineEnum('::Ice::EndpointSelectionType', EndpointSelectionType, (), (EndpointSelectionType.Random, EndpointSelectionType.Ordered)) _M_Ice.EndpointSelectionType = EndpointSelectionType del EndpointSelectionType # End of module Ice
def __hash__(self): return self.value def __cmp__(self, other): return cmp(self.value, other.value) UserActionType.UserRespondedToBid = UserActionType(0) UserActionType.UserActivityRelevantAction = UserActionType(1) UserActionType.UserGaveRequestedObject = UserActionType(2) UserActionType.UserGaveUnrequestedObject = UserActionType(3) UserActionType.UserUnrelatedAction = UserActionType(4) UserActionType.UserNoAction = UserActionType(5) UserActionType.UserInitiated = UserActionType(6) UserActionType.UserTouchedAgent = UserActionType(7) _M_echoes._t_UserActionType = IcePy.defineEnum('::echoes::UserActionType', UserActionType, (), (UserActionType.UserRespondedToBid, UserActionType.UserActivityRelevantAction, UserActionType.UserGaveRequestedObject, UserActionType.UserGaveUnrequestedObject, UserActionType.UserUnrelatedAction, UserActionType.UserNoAction, UserActionType.UserInitiated, UserActionType.UserTouchedAgent)) _M_echoes.UserActionType = UserActionType del UserActionType if not _M_echoes.__dict__.has_key('EventListener'): _M_echoes.EventListener = Ice.createTempClass() class EventListener(Ice.Object): def __init__(self): if __builtin__.type(self) == _M_echoes.EventListener: raise RuntimeError('echoes.EventListener is an abstract class') def ice_ids(self, current=None): return ('::Ice::Object', '::echoes::EventListener') def ice_id(self, current=None):
ThreadState.ThreadStateIdle = ThreadState("ThreadStateIdle", 0) ThreadState.ThreadStateInUseForIO = ThreadState("ThreadStateInUseForIO", 1) ThreadState.ThreadStateInUseForUser = ThreadState( "ThreadStateInUseForUser", 2) ThreadState.ThreadStateInUseForOther = ThreadState( "ThreadStateInUseForOther", 3) ThreadState._enumerators = { 0: ThreadState.ThreadStateIdle, 1: ThreadState.ThreadStateInUseForIO, 2: ThreadState.ThreadStateInUseForUser, 3: ThreadState.ThreadStateInUseForOther } _M_Ice.Instrumentation._t_ThreadState = IcePy.defineEnum( '::Ice::Instrumentation::ThreadState', ThreadState, (), ThreadState._enumerators) _M_Ice.Instrumentation.ThreadState = ThreadState del ThreadState if 'ThreadObserver' not in _M_Ice.Instrumentation.__dict__: _M_Ice.Instrumentation.ThreadObserver = Ice.createTempClass() class ThreadObserver(_M_Ice.Instrumentation.Observer): """ The thread observer interface to instrument Ice threads. This can be threads from the Ice thread pool or utility threads used by the Ice core. """ def __init__(self):
return self._enumerators[_n] return None valueOf = classmethod(valueOf) OperationMode.Normal = OperationMode("Normal", 0) OperationMode.Nonmutating = OperationMode("Nonmutating", 1) OperationMode.Idempotent = OperationMode("Idempotent", 2) OperationMode._enumerators = { 0: OperationMode.Normal, 1: OperationMode.Nonmutating, 2: OperationMode.Idempotent } _M_Ice._t_OperationMode = IcePy.defineEnum('::Ice::OperationMode', OperationMode, (), OperationMode._enumerators) _M_Ice.OperationMode = OperationMode del OperationMode if 'Current' not in _M_Ice.__dict__: _M_Ice.Current = Ice.createTempClass() class Current(object): """ Information about the current method invocation for servers. Each operation on the server has a Current as its implicit final parameter. Current is mostly used for Ice services. Most applications ignore this parameter. Members:
return NotImplemented def __ge__(self, other): if isinstance(other, _M_Ice.OperationMode): return self.value >= other.value; elif other == None: return False return NotImplemented _names = ('Normal', 'Nonmutating', 'Idempotent') OperationMode.Normal = OperationMode(0) OperationMode.Nonmutating = OperationMode(1) OperationMode.Idempotent = OperationMode(2) _M_Ice._t_OperationMode = IcePy.defineEnum('::Ice::OperationMode', OperationMode, (), (OperationMode.Normal, OperationMode.Nonmutating, OperationMode.Idempotent)) _M_Ice.OperationMode = OperationMode del OperationMode if not _M_Ice.__dict__.has_key('Current'): _M_Ice.Current = Ice.createTempClass() class Current(object): '''Information about the current method invocation for servers. Each operation on the server has a Current as its implicit final parameter. Current is mostly used for Ice services. Most applications ignore this parameter.''' def __init__(self, adapter=None, con=None, id=Ice._struct_marker, facet='', operation='', mode=_M_Ice.OperationMode.Normal, ctx=None, requestId=0): self.adapter = adapter self.con = con if id is Ice._struct_marker:
valueOf = classmethod(valueOf) ReplayerStatus.WAITING = ReplayerStatus("WAITING", 0) ReplayerStatus.PLAYING = ReplayerStatus("PLAYING", 1) ReplayerStatus.PAUSED = ReplayerStatus("PAUSED", 2) ReplayerStatus.FINISHED = ReplayerStatus("FINISHED", 3) ReplayerStatus._enumerators = { 0: ReplayerStatus.WAITING, 1: ReplayerStatus.PLAYING, 2: ReplayerStatus.PAUSED, 3: ReplayerStatus.FINISHED } _M_jderobot._t_ReplayerStatus = IcePy.defineEnum( '::jderobot::ReplayerStatus', ReplayerStatus, (), ReplayerStatus._enumerators) _M_jderobot.ReplayerStatus = ReplayerStatus del ReplayerStatus if 'replayControl' not in _M_jderobot.__dict__: _M_jderobot.replayControl = Ice.createTempClass() class replayControl(Ice.Object): def __init__(self): if Ice.getType(self) == _M_jderobot.replayControl: raise RuntimeError( 'jderobot.replayControl is an abstract class') def ice_ids(self, current=None):
def valueOf(self, _n): if _n in self._enumerators: return self._enumerators[_n] return None valueOf = classmethod(valueOf) AccountType.PREMIUM = AccountType("PREMIUM", 0) AccountType.STANDARD = AccountType("STANDARD", 1) AccountType._enumerators = { 0: AccountType.PREMIUM, 1: AccountType.STANDARD } _M_Bank._t_AccountType = IcePy.defineEnum('::Bank::AccountType', AccountType, (), AccountType._enumerators) _M_Bank.AccountType = AccountType del AccountType if 'Currency' not in _M_Bank.__dict__: _M_Bank.Currency = Ice.createTempClass() class Currency(Ice.EnumBase): def __init__(self, _n, _v): Ice.EnumBase.__init__(self, _n, _v) def valueOf(self, _n): if _n in self._enumerators: return self._enumerators[_n]
return False return NotImplemented def __gt__(self, other): if isinstance(other, _M_Ice.EndpointSelectionType): return self.value > other.value elif other == None: return False return NotImplemented def __ge__(self, other): if isinstance(other, _M_Ice.EndpointSelectionType): return self.value >= other.value elif other == None: return False return NotImplemented _names = ('Random', 'Ordered') EndpointSelectionType.Random = EndpointSelectionType(0) EndpointSelectionType.Ordered = EndpointSelectionType(1) _M_Ice._t_EndpointSelectionType = IcePy.defineEnum( '::Ice::EndpointSelectionType', EndpointSelectionType, (), (EndpointSelectionType.Random, EndpointSelectionType.Ordered)) _M_Ice.EndpointSelectionType = EndpointSelectionType del EndpointSelectionType # End of module Ice
DeviceType.Digitizer = DeviceType("Digitizer", 3) DeviceType.VectorNetworkAnalyzer = DeviceType("VectorNetworkAnalyzer", 4) DeviceType.DelayGenerator = DeviceType("DelayGenerator", 5) DeviceType.DCSource = DeviceType("DCSource", 6) DeviceType._enumerators = { 0: DeviceType.Dummy, 1: DeviceType.ArbitraryWaveformGenerator, 2: DeviceType.ParametricSignalGenerator, 3: DeviceType.Digitizer, 4: DeviceType.VectorNetworkAnalyzer, 5: DeviceType.DelayGenerator, 6: DeviceType.DCSource } _M_device_repo_ice._t_DeviceType = IcePy.defineEnum( '::device_repo_ice::DeviceType', DeviceType, (), DeviceType._enumerators) _M_device_repo_ice.DeviceType = DeviceType del DeviceType if 'DataType' not in _M_device_repo_ice.__dict__: _M_device_repo_ice.DataType = Ice.createTempClass() class DataType(Ice.EnumBase): def __init__(self, _n, _v): Ice.EnumBase.__init__(self, _n, _v) def valueOf(self, _n): if _n in self._enumerators: return self._enumerators[_n]
valueOf = classmethod(valueOf) CurrencyIce.PLN = CurrencyIce("PLN", 0) CurrencyIce.EUR = CurrencyIce("EUR", 1) CurrencyIce.USD = CurrencyIce("USD", 2) CurrencyIce.GBP = CurrencyIce("GBP", 3) CurrencyIce._enumerators = { 0: CurrencyIce.PLN, 1: CurrencyIce.EUR, 2: CurrencyIce.USD, 3: CurrencyIce.GBP } _M_Bank._t_CurrencyIce = IcePy.defineEnum('::Bank::CurrencyIce', CurrencyIce, (), CurrencyIce._enumerators) _M_Bank.CurrencyIce = CurrencyIce del CurrencyIce if 'MoneyAmount' not in _M_Bank.__dict__: _M_Bank.MoneyAmount = Ice.createTempClass() class MoneyAmount(object): def __init__(self, amount=0, currency=_M_Bank.CurrencyIce.PLN): self.amount = amount self.currency = currency def __hash__(self): _h = 0
__repr__ = __str__ def __hash__(self): return self.value def __cmp__(self, other): return cmp(self.value, other.value) Engagement.DisengTotal = Engagement(0) Engagement.DisengMinus = Engagement(1) Engagement.DisengPlus = Engagement(2) Engagement.Eng = Engagement(3) Engagement.EngPlus = Engagement(4) Engagement.EngPlusPlus = Engagement(5) _M_echoes._t_Engagement = IcePy.defineEnum('::echoes::Engagement', Engagement, (), (Engagement.DisengTotal, Engagement.DisengMinus, Engagement.DisengPlus, Engagement.Eng, Engagement.EngPlus, Engagement.EngPlusPlus)) _M_echoes.Engagement = Engagement del Engagement if not _M_echoes.__dict__.has_key('ChildModel'): _M_echoes.ChildModel = Ice.createTempClass() class ChildModel(Ice.Object): def __init__(self): if __builtin__.type(self) == _M_echoes.ChildModel: raise RuntimeError('echoes.ChildModel is an abstract class') def ice_ids(self, current=None): return ('::Ice::Object', '::echoes::ChildModel') def ice_id(self, current=None):
return self._enumerators[_n] return None valueOf = classmethod(valueOf) CompressBatch.Yes = CompressBatch("Yes", 0) CompressBatch.No = CompressBatch("No", 1) CompressBatch.BasedOnProxy = CompressBatch("BasedOnProxy", 2) CompressBatch._enumerators = { 0: CompressBatch.Yes, 1: CompressBatch.No, 2: CompressBatch.BasedOnProxy } _M_Ice._t_CompressBatch = IcePy.defineEnum('::Ice::CompressBatch', CompressBatch, (), CompressBatch._enumerators) _M_Ice.CompressBatch = CompressBatch del CompressBatch if 'ConnectionInfo' not in _M_Ice.__dict__: _M_Ice.ConnectionInfo = Ice.createTempClass() class ConnectionInfo(object): """ Base class providing access to the connection details. Members: underlying -- The information of the underyling transport or null if there's no underlying transport. incoming -- Whether or not the connection is an incoming or outgoing
Currency.PLN = Currency("PLN", 0) Currency.EUR = Currency("EUR", 1) Currency.USD = Currency("USD", 2) Currency.GBP = Currency("GBP", 3) Currency.CHF = Currency("CHF", 4) Currency.JPY = Currency("JPY", 5) Currency._enumerators = { 0: Currency.PLN, 1: Currency.EUR, 2: Currency.USD, 3: Currency.GBP, 4: Currency.CHF, 5: Currency.JPY } _M_Bank._t_Currency = IcePy.defineEnum('::Bank::Currency', Currency, (), Currency._enumerators) _M_Bank.Currency = Currency del Currency if 'LoanInfo' not in _M_Bank.__dict__: _M_Bank.LoanInfo = Ice.createTempClass() class LoanInfo(object): def __init__(self, amountInNativeCurrency=0, amountInForeignCurrency=0): self.amountInNativeCurrency = amountInNativeCurrency self.amountInForeignCurrency = amountInForeignCurrency def __hash__(self):
def __init__(self, _n, _v): Ice.EnumBase.__init__(self, _n, _v) def valueOf(self, _n): if _n in self._enumerators: return self._enumerators[_n] return None valueOf = classmethod(valueOf) operation.MIN = operation("MIN", 0) operation.MAX = operation("MAX", 1) operation.AVG = operation("AVG", 2) operation._enumerators = { 0:operation.MIN, 1:operation.MAX, 2:operation.AVG } _M_Demo._t_operation = IcePy.defineEnum('::Demo::operation', operation, (), operation._enumerators) _M_Demo.operation = operation del operation _M_Demo._t_Calc = IcePy.defineValue('::Demo::Calc', Ice.Value, -1, (), False, True, None, ()) if 'CalcPrx' not in _M_Demo.__dict__: _M_Demo.CalcPrx = Ice.createTempClass() class CalcPrx(Ice.ObjectPrx): def add(self, a, b, context=None): return _M_Demo.Calc._op_add.invoke(self, ((a, b), context)) def addAsync(self, a, b, context=None): return _M_Demo.Calc._op_add.invokeAsync(self, ((a, b), context))
return NotImplemented def __ge__(self, other): if isinstance(other, _M_IceGrid.LoadSample): return self.value >= other.value; elif other == None: return False return NotImplemented _names = ('LoadSample1', 'LoadSample5', 'LoadSample15') LoadSample.LoadSample1 = LoadSample(0) LoadSample.LoadSample5 = LoadSample(1) LoadSample.LoadSample15 = LoadSample(2) _M_IceGrid._t_LoadSample = IcePy.defineEnum('::IceGrid::LoadSample', LoadSample, (), (LoadSample.LoadSample1, LoadSample.LoadSample5, LoadSample.LoadSample15)) _M_IceGrid.LoadSample = LoadSample del LoadSample if not _M_IceGrid.__dict__.has_key('Query'): _M_IceGrid.Query = Ice.createTempClass() class Query(Ice.Object): '''The IceGrid query interface. This interface is accessible to Ice clients who wish to look up well-known objects.''' def __init__(self): if __builtin__.type(self) == _M_IceGrid.Query: raise RuntimeError('IceGrid.Query is an abstract class') def ice_ids(self, current=None): return ('::Ice::Object', '::IceGrid::Query')
def __init__(self, _n, _v): Ice.EnumBase.__init__(self, _n, _v) def valueOf(self, _n): if _n in self._enumerators: return self._enumerators[_n] return None valueOf = classmethod(valueOf) Currency.PLN = Currency("PLN", 0) Currency.EUR = Currency("EUR", 1) Currency.USD = Currency("USD", 2) Currency.CHF = Currency("CHF", 3) Currency._enumerators = { 0:Currency.PLN, 1:Currency.EUR, 2:Currency.USD, 3:Currency.CHF } _M_Bank._t_Currency = IcePy.defineEnum('::Bank::Currency', Currency, (), Currency._enumerators) _M_Bank.Currency = Currency del Currency if 'accountType' not in _M_Bank.__dict__: _M_Bank.accountType = Ice.createTempClass() class accountType(Ice.EnumBase): def __init__(self, _n, _v): Ice.EnumBase.__init__(self, _n, _v) def valueOf(self, _n): if _n in self._enumerators: return self._enumerators[_n] return None
octal escapes. Characters with ordinal values 127 and below are encoded as \\t, \\n (etc.) or an octal escape. Use this mode to generate strings compatible with Ice 3.6 and earlier. """ def __init__(self, _n, _v): Ice.EnumBase.__init__(self, _n, _v) def valueOf(self, _n): if _n in self._enumerators: return self._enumerators[_n] return None valueOf = classmethod(valueOf) ToStringMode.Unicode = ToStringMode("Unicode", 0) ToStringMode.ASCII = ToStringMode("ASCII", 1) ToStringMode.Compat = ToStringMode("Compat", 2) ToStringMode._enumerators = { 0: ToStringMode.Unicode, 1: ToStringMode.ASCII, 2: ToStringMode.Compat } _M_Ice._t_ToStringMode = IcePy.defineEnum('::Ice::ToStringMode', ToStringMode, (), ToStringMode._enumerators) _M_Ice.ToStringMode = ToStringMode del ToStringMode # End of module Ice
def __init__(self, _n, _v): Ice.EnumBase.__init__(self, _n, _v) def valueOf(self, _n): if _n in self._enumerators: return self._enumerators[_n] return None valueOf = classmethod(valueOf) Currency.EUR = Currency("EUR", 0) Currency.USD = Currency("USD", 1) Currency.CHF = Currency("CHF", 2) Currency._enumerators = { 0:Currency.EUR, 1:Currency.USD, 2:Currency.CHF } _M_assignment2._t_Currency = IcePy.defineEnum('::assignment2::Currency', Currency, (), Currency._enumerators) _M_assignment2.Currency = Currency del Currency if 'UserNotLoggedException' not in _M_assignment2.__dict__: _M_assignment2.UserNotLoggedException = Ice.createTempClass() class UserNotLoggedException(Ice.UserException): def __init__(self): pass def __str__(self): return IcePy.stringifyException(self) __repr__ = __str__
valueOf = classmethod(valueOf) LogLevel.Trace = LogLevel("Trace", 0) LogLevel.Debug = LogLevel("Debug", 1) LogLevel.Info = LogLevel("Info", 2) LogLevel.Warn = LogLevel("Warn", 3) LogLevel.Error = LogLevel("Error", 4) LogLevel._enumerators = { 0: LogLevel.Trace, 1: LogLevel.Debug, 2: LogLevel.Info, 3: LogLevel.Warn, 4: LogLevel.Error } _M_omero.constants._t_LogLevel = IcePy.defineEnum( '::omero::constants::LogLevel', LogLevel, (), LogLevel._enumerators) _M_omero.constants.LogLevel = LogLevel del LogLevel # Start of module omero.constants.metadata _M_omero.constants.metadata = Ice.openModule('omero.constants.metadata') __name__ = 'omero.constants.metadata' _M_omero.constants.metadata.__doc__ = """ Namespaces for the omero.api.IMetadata interface. """ _M_omero.constants.metadata.NSINSIGHTTAGSET = "openmicroscopy.org/omero/insight/tagset" _M_omero.constants.metadata.NSINSIGHTRATING = "openmicroscopy.org/omero/insight/rating"
def __init__(self, _n, _v): Ice.EnumBase.__init__(self, _n, _v) def valueOf(self, _n): if _n in self._enumerators: return self._enumerators[_n] return None valueOf = classmethod(valueOf) Currency.PLN = Currency("PLN", 0) Currency.USD = Currency("USD", 1) Currency.EUR = Currency("EUR", 2) Currency._enumerators = { 0:Currency.PLN, 1:Currency.USD, 2:Currency.EUR } _M_Demo._t_Currency = IcePy.defineEnum('::Demo::Currency', Currency, (), Currency._enumerators) _M_Demo.Currency = Currency del Currency if 'Money' not in _M_Demo.__dict__: _M_Demo.Money = Ice.createTempClass() class Money(object): def __init__(self, currency=_M_Demo.Currency.PLN, value=0): self.currency = currency self.value = value def __hash__(self): _h = 0 _h = 5 * _h + Ice.getHash(self.currency) _h = 5 * _h + Ice.getHash(self.value)
def __init__(self, _n, _v): Ice.EnumBase.__init__(self, _n, _v) def valueOf(self, _n): if _n in self._enumerators: return self._enumerators[_n] return None valueOf = classmethod(valueOf) PowerState.ON = PowerState("ON", 0) PowerState.OFF = PowerState("OFF", 1) PowerState._enumerators = {0: PowerState.ON, 1: PowerState.OFF} _M_SmartHouse._t_PowerState = IcePy.defineEnum('::SmartHouse::PowerState', PowerState, (), PowerState._enumerators) _M_SmartHouse.PowerState = PowerState del PowerState if 'CoffeeType' not in _M_SmartHouse.__dict__: _M_SmartHouse.CoffeeType = Ice.createTempClass() class CoffeeType(Ice.EnumBase): def __init__(self, _n, _v): Ice.EnumBase.__init__(self, _n, _v) def valueOf(self, _n): if _n in self._enumerators: return self._enumerators[_n]
def valueOf(self, _n): if _n in self._enumerators: return self._enumerators[_n] return None valueOf = classmethod(valueOf) accountType.STANDARD = accountType("STANDARD", 0) accountType.PREMIUM = accountType("PREMIUM", 1) accountType._enumerators = { 0: accountType.STANDARD, 1: accountType.PREMIUM } _M_Bank._t_accountType = IcePy.defineEnum('::Bank::accountType', accountType, (), accountType._enumerators) _M_Bank.accountType = accountType del accountType if 'AccountData' not in _M_Bank.__dict__: _M_Bank.AccountData = Ice.createTempClass() class AccountData(object): def __init__(self, name='', surname='', pesel=0, income=0.0, type=_M_Bank.accountType.STANDARD,
elif self.value == 1: return 'TrackMode' return None __repr__ = __str__ def __hash__(self): return self.value def __cmp__(self, other): return cmp(self.value, other.value) HeadTrackerMode.ModelMode = HeadTrackerMode(0) HeadTrackerMode.TrackMode = HeadTrackerMode(1) _M_echoes._t_HeadTrackerMode = IcePy.defineEnum('::echoes::HeadTrackerMode', HeadTrackerMode, (), (HeadTrackerMode.ModelMode, HeadTrackerMode.TrackMode)) _M_echoes.HeadTrackerMode = HeadTrackerMode del HeadTrackerMode if not _M_echoes.__dict__.has_key('HeadTracker'): _M_echoes.HeadTracker = Ice.createTempClass() class HeadTracker(Ice.Object): def __init__(self): if __builtin__.type(self) == _M_echoes.HeadTracker: raise RuntimeError('echoes.HeadTracker is an abstract class') def ice_ids(self, current=None): return ('::Ice::Object', '::echoes::HeadTracker') def ice_id(self, current=None):
State.ALL = State("ALL", 0) State.ACTIVE = State("ACTIVE", 1) State.INACTIVE = State("INACTIVE", 2) State.SUCCESS = State("SUCCESS", 3) State.FAILURE = State("FAILURE", 4) State.CANCELLED = State("CANCELLED", 5) State._enumerators = { 0: State.ALL, 1: State.ACTIVE, 2: State.INACTIVE, 3: State.SUCCESS, 4: State.FAILURE, 5: State.CANCELLED } _M_omero.cmd._t_State = IcePy.defineEnum('::omero::cmd::State', State, (), State._enumerators) _M_omero.cmd.State = State del State if '_t_StateList' not in _M_omero.cmd.__dict__: _M_omero.cmd._t_StateList = IcePy.defineSequence('::omero::cmd::StateList', (), _M_omero.cmd._t_State) if 'Handle' not in _M_omero.cmd.__dict__: _M_omero.cmd._t_Handle = IcePy.declareClass('::omero::cmd::Handle') _M_omero.cmd._t_HandlePrx = IcePy.declareProxy('::omero::cmd::Handle') if 'Status' not in _M_omero.cmd.__dict__: _M_omero.cmd.Status = Ice.createTempClass()
elif other == None: return False return NotImplemented def __ge__(self, other): if isinstance(other, _M_FS.EnumNone): return self.value >= other.value; elif other == None: return False return NotImplemented _names = ('None',) EnumNone._None = EnumNone(0) _M_FS._t_EnumNone = IcePy.defineEnum('::FS::EnumNone', EnumNone, (), (EnumNone._None,)) _M_FS.EnumNone = EnumNone del EnumNone if not _M_FS.__dict__.has_key('myexcep'): _M_FS.myexcep = Ice.createTempClass() class myexcep(Ice.UserException): def __init__(self, _lambda=0): self._lambda = _lambda def __str__(self): return IcePy.stringifyException(self) __repr__ = __str__
def __init__(self, _n, _v): Ice.EnumBase.__init__(self, _n, _v) def valueOf(self, _n): if _n in self._enumerators: return self._enumerators[_n] return None valueOf = classmethod(valueOf) DeviceState.ON = DeviceState("ON", 0) DeviceState.OFF = DeviceState("OFF", 1) DeviceState._enumerators = {0: DeviceState.ON, 1: DeviceState.OFF} _M_IotController._t_DeviceState = IcePy.defineEnum( '::IotController::DeviceState', DeviceState, (), DeviceState._enumerators) _M_IotController.DeviceState = DeviceState del DeviceState if 'DeviceInfo' not in _M_IotController.__dict__: _M_IotController.DeviceInfo = Ice.createTempClass() class DeviceInfo(Ice.Value): def __init__(self, id=0, name='', state=_M_IotController.DeviceState.ON): self.id = id self.name = name
return self._enumerators[_n] return None valueOf = classmethod(valueOf) LoadSample.LoadSample1 = LoadSample("LoadSample1", 0) LoadSample.LoadSample5 = LoadSample("LoadSample5", 1) LoadSample.LoadSample15 = LoadSample("LoadSample15", 2) LoadSample._enumerators = { 0: LoadSample.LoadSample1, 1: LoadSample.LoadSample5, 2: LoadSample.LoadSample15 } _M_IceGrid._t_LoadSample = IcePy.defineEnum('::IceGrid::LoadSample', LoadSample, (), LoadSample._enumerators) _M_IceGrid.LoadSample = LoadSample del LoadSample if 'Query' not in _M_IceGrid.__dict__: _M_IceGrid.Query = Ice.createTempClass() class Query(Ice.Object): '''The IceGrid query interface. This interface is accessible to Ice clients who wish to look up well-known objects.''' def __init__(self): if Ice.getType(self) == _M_IceGrid.Query: raise RuntimeError('IceGrid.Query is an abstract class')
def valueOf(self, _n): if _n in self._enumerators: return self._enumerators[_n] return None valueOf = classmethod(valueOf) AccountType.Premium = AccountType("Premium", 0) AccountType.Standard = AccountType("Standard", 1) AccountType._enumerators = { 0: AccountType.Premium, 1: AccountType.Standard } _M_BankService._t_AccountType = IcePy.defineEnum( '::BankService::AccountType', AccountType, (), AccountType._enumerators) _M_BankService.AccountType = AccountType del AccountType if 'AccountDetails' not in _M_BankService.__dict__: _M_BankService.AccountDetails = Ice.createTempClass() class AccountDetails(object): def __init__(self, income=0.0, balance=0.0, type=_M_BankService.AccountType.Premium): self.income = income self.balance = balance
elif other == None: return False return NotImplemented def __ge__(self, other): if isinstance(other, _M_FS.EnumNone): return self.value >= other.value elif other == None: return False return NotImplemented _names = ('None', ) EnumNone._None = EnumNone(0) _M_FS._t_EnumNone = IcePy.defineEnum('::FS::EnumNone', EnumNone, (), (EnumNone._None, )) _M_FS.EnumNone = EnumNone del EnumNone if not _M_FS.__dict__.has_key('myexcep'): _M_FS.myexcep = Ice.createTempClass() class myexcep(Ice.UserException): def __init__(self, _lambda=0): self._lambda = _lambda def __str__(self): return IcePy.stringifyException(self) __repr__ = __str__
def __ge__(self, other): if isinstance(other, _M_IceGrid.LoadSample): return self.value >= other.value elif other == None: return False return NotImplemented _names = ('LoadSample1', 'LoadSample5', 'LoadSample15') LoadSample.LoadSample1 = LoadSample(0) LoadSample.LoadSample5 = LoadSample(1) LoadSample.LoadSample15 = LoadSample(2) _M_IceGrid._t_LoadSample = IcePy.defineEnum( '::IceGrid::LoadSample', LoadSample, (), (LoadSample.LoadSample1, LoadSample.LoadSample5, LoadSample.LoadSample15)) _M_IceGrid.LoadSample = LoadSample del LoadSample if not _M_IceGrid.__dict__.has_key('Query'): _M_IceGrid.Query = Ice.createTempClass() class Query(Ice.Object): '''The IceGrid query interface. This interface is accessible to Ice clients who wish to look up well-known objects.''' def __init__(self): if __builtin__.type(self) == _M_IceGrid.Query: raise RuntimeError('IceGrid.Query is an abstract class')
return self._enumerators[_n] return None valueOf = classmethod(valueOf) DeviceStatus.Idle = DeviceStatus("Idle", 0) DeviceStatus.Occupied = DeviceStatus("Occupied", 1) DeviceStatus.Malfunction = DeviceStatus("Malfunction", 2) DeviceStatus._enumerators = { 0: DeviceStatus.Idle, 1: DeviceStatus.Occupied, 2: DeviceStatus.Malfunction } _M_device_repo_ice._t_DeviceStatus = IcePy.defineEnum( '::device_repo_ice::DeviceStatus', DeviceStatus, (), DeviceStatus._enumerators) _M_device_repo_ice.DeviceStatus = DeviceStatus del DeviceStatus if 'DeviceEntry' not in _M_device_repo_ice.__dict__: _M_device_repo_ice.DeviceEntry = Ice.createTempClass() class DeviceEntry(object): def __init__(self, id='', type=_M_device_repo_ice.DeviceType.Dummy): self.id = id self.type = type def __hash__(self): _h = 0
__repr__ = __str__ def __hash__(self): return self.value def __cmp__(self, other): return cmp(self.value, other.value) OnlineStat.OFFLINE = OnlineStat(0) OnlineStat.INVISIABLE = OnlineStat(1) OnlineStat.NOTAVAILABLE = OnlineStat(2) OnlineStat.BUSY = OnlineStat(3) OnlineStat.AWAY = OnlineStat(4) OnlineStat.ONLINE = OnlineStat(5) _M_com.xiaonei.talk.common._t_OnlineStat = IcePy.defineEnum('::com::xiaonei::talk::common::OnlineStat', OnlineStat, (), (OnlineStat.OFFLINE, OnlineStat.INVISIABLE, OnlineStat.NOTAVAILABLE, OnlineStat.BUSY, OnlineStat.AWAY, OnlineStat.ONLINE)) _M_com.xiaonei.talk.common.OnlineStat = OnlineStat del OnlineStat if not _M_com.xiaonei.talk.common.__dict__.has_key('Avatar'): _M_com.xiaonei.talk.common.Avatar = Ice.createTempClass() class Avatar(Ice.Object): def __init__(self, jid=None, stat=_M_com.xiaonei.talk.common.OnlineStat.OFFLINE, ver='', ext='', stamp=0): self.jid = jid self.stat = stat self.ver = ver self.ext = ext self.stamp = stamp def ice_ids(self, current=None):