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):
