# Generated from file `ObjectCache.ice'
import Ice, IcePy, __builtin__
if not Ice.__dict__.has_key("_struct_marker"):
Ice._struct_marker = object()
import Util_ice
# Included module MyUtil
_M_MyUtil = Ice.openModule('MyUtil')
# Start of module MyUtil
__name__ = 'MyUtil'
if not _M_MyUtil.__dict__.has_key('_t_ObjectMap'):
_M_MyUtil._t_ObjectMap = IcePy.defineDictionary('::MyUtil::ObjectMap', (), IcePy._t_long, IcePy._t_Object)
if not _M_MyUtil.__dict__.has_key('ObjectResult'):
_M_MyUtil.ObjectResult = Ice.createTempClass()
class ObjectResult(Ice.Object):
def __init__(self, data=None):
self.data = data
def ice_ids(self, current=None):
return ('::Ice::Object', '::MyUtil::ObjectResult')
def ice_id(self, current=None):
return '::MyUtil::ObjectResult'
def ice_staticId():
return '::MyUtil::ObjectResult'
# Included module Ice
_M_Ice = Ice.openModule('Ice')
# Included module omero.sys
_M_omero.sys = Ice.openModule('omero.sys')
# Start of module omero
__name__ = 'omero'
# Start of module omero.api
_M_omero.api = Ice.openModule('omero.api')
__name__ = 'omero.api'
if '_t_SearchMetadata' not in _M_omero.api.__dict__:
_M_omero.api._t_SearchMetadata = IcePy.defineDictionary(
'::omero::api::SearchMetadata', (), IcePy._t_string,
_M_omero.model._t_Annotation)
if '_t_StringSet' not in _M_omero.api.__dict__:
_M_omero.api._t_StringSet = IcePy.defineSequence('::omero::api::StringSet',
(), IcePy._t_string)
if '_t_LongList' not in _M_omero.api.__dict__:
_M_omero.api._t_LongList = IcePy.defineSequence('::omero::api::LongList',
(), IcePy._t_long)
if '_t_IntegerList' not in _M_omero.api.__dict__:
_M_omero.api._t_IntegerList = IcePy.defineSequence(
'::omero::api::IntegerList', (), IcePy._t_int)
if '_t_SearchMetadataList' not in _M_omero.api.__dict__:
def __hash__(self):
return self.value
def __cmp__(self, other):
return cmp(self.value, other.value)
FacialExpression.ExpressionSmile = FacialExpression(0)
FacialExpression.ExpressionUnknown = FacialExpression(1)
_M_echoes._t_FacialExpression = IcePy.defineEnum('::echoes::FacialExpression', FacialExpression, (), (FacialExpression.ExpressionSmile, FacialExpression.ExpressionUnknown))
_M_echoes.FacialExpression = FacialExpression
del FacialExpression
if not _M_echoes.__dict__.has_key('_t_Properties'):
_M_echoes._t_Properties = IcePy.defineDictionary('::echoes::Properties', (), IcePy._t_string, IcePy._t_string)
if not _M_echoes.__dict__.has_key('EchoesObject'):
_M_echoes.EchoesObject = Ice.createTempClass()
class EchoesObject(object):
def __init__(self, name='', props=None):
self.name = name
self.props = props
def __hash__(self):
_h = 0
_h = 5 * _h + __builtin__.hash(self.name)
if self.props:
for _i0 in self.props:
_h = 5 * _h + __builtin__.hash(_i0)
_h = 5 * _h + __builtin__.hash(self.props[_i0])
# Warning: do not edit this file.
#
# </auto-generated>
#
import Ice, IcePy
# Start of module MediaFile
_M_MediaFile = Ice.openModule('MediaFile')
__name__ = 'MediaFile'
if '_t_ByteString' not in _M_MediaFile.__dict__:
_M_MediaFile._t_ByteString = IcePy.defineSequence('::MediaFile::ByteString', (), IcePy._t_byte)
if '_t_FFMPEGParamsMap' not in _M_MediaFile.__dict__:
_M_MediaFile._t_FFMPEGParamsMap = IcePy.defineDictionary('::MediaFile::FFMPEGParamsMap', (), IcePy._t_string, IcePy._t_string)
if 'FileTransfer' not in _M_MediaFile.__dict__:
_M_MediaFile.FileTransfer = Ice.createTempClass()
class FileTransfer(Ice.Object):
def __init__(self):
if Ice.getType(self) == _M_MediaFile.FileTransfer:
raise RuntimeError('MediaFile.FileTransfer is an abstract class')
def ice_ids(self, current=None):
return ('::Ice::Object', '::MediaFile::FileTransfer')
def ice_id(self, current=None):
return '::MediaFile::FileTransfer'
def ice_staticId():
# Included module Ice
_M_Ice = Ice.openModule('Ice')
# Included module Glacier2
_M_Glacier2 = Ice.openModule('Glacier2')
# Start of module omero
__name__ = 'omero'
# Start of module omero.cmd
_M_omero.cmd = Ice.openModule('omero.cmd')
__name__ = 'omero.cmd'
_M_omero.cmd.__doc__ = '''Simplified API that is intended for passing'''
if not _M_omero.cmd.__dict__.has_key('_t_StringMap'):
_M_omero.cmd._t_StringMap = IcePy.defineDictionary('::omero::cmd::StringMap', (), IcePy._t_string, IcePy._t_string)
if not _M_omero.cmd.__dict__.has_key('_t_StringMapList'):
_M_omero.cmd._t_StringMapList = IcePy.defineSequence('::omero::cmd::StringMapList', (), _M_omero.cmd._t_StringMap)
if not _M_omero.cmd.__dict__.has_key('State'):
_M_omero.cmd.State = Ice.createTempClass()
class State(object):
def __init__(self, val):
assert(val >= 0 and val < 6)
self.value = val
def __str__(self):
return self._names[self.value]
('prx', (), IcePy._t_ObjectPrx),
('cluster', (), IcePy._t_int),
('mod', (), IcePy._t_int),
('status', (), IcePy._t_int),
('newset', (), IcePy._t_bool)
))
ServerStateInfo.ice_type = _M_xce.serverstate._t_ServerStateInfo
_M_xce.serverstate.ServerStateInfo = ServerStateInfo
del ServerStateInfo
_M_xce.serverstate.ServerStateInfoPrx = ServerStateInfoPrx
del ServerStateInfoPrx
if not _M_xce.serverstate.__dict__.has_key('_t_ServerPrxMap'):
_M_xce.serverstate._t_ServerPrxMap = IcePy.defineDictionary('::xce::serverstate::ServerPrxMap', (), IcePy._t_string, IcePy._t_ObjectPrx)
if not _M_xce.serverstate.__dict__.has_key('_t_ServerPrxStatusMap'):
_M_xce.serverstate._t_ServerPrxStatusMap = IcePy.defineDictionary('::xce::serverstate::ServerPrxStatusMap', (), IcePy._t_string, IcePy._t_int)
if not _M_xce.serverstate.__dict__.has_key('_t_Str2StrSeqMap'):
_M_xce.serverstate._t_Str2StrSeqMap = IcePy.defineDictionary('::xce::serverstate::Str2StrSeqMap', (), IcePy._t_string, _M_MyUtil._t_StrSeq)
if not _M_xce.serverstate.__dict__.has_key('ServerStateBackDoor'):
_M_xce.serverstate.ServerStateBackDoor = Ice.createTempClass()
class ServerStateBackDoor(Ice.Object):
def __init__(self):
if __builtin__.type(self) == _M_xce.serverstate.ServerStateBackDoor:
raise RuntimeError('xce.serverstate.ServerStateBackDoor is an abstract class')
def ice_ids(self, current=None):
_M_FS._t_Example = IcePy.defineClass('::FS::Example', Example, (), False, None, (), (('apilevel', (), IcePy._t_short),))
Example._ice_type = _M_FS._t_Example
_M_FS.Example = Example
del Example
_M_FS.ExamplePrx = ExamplePrx
del ExamplePrx
_M_FS._lambda = 0
if not _M_FS.__dict__.has_key('_t_StringSeq'):
_M_FS._t_StringSeq = IcePy.defineSequence('::FS::StringSeq', (), IcePy._t_string)
if not _M_FS.__dict__.has_key('_t_StringDict'):
_M_FS._t_StringDict = IcePy.defineDictionary('::FS::StringDict', (), IcePy._t_string, IcePy._t_string)
if not _M_FS.__dict__.has_key('mystruct'):
_M_FS.mystruct = Ice.createTempClass()
class mystruct(object):
def __init__(self, mytype=0, bo=False, by=0, sh=0, i=0, l=0, f=0.0, d=0.0, str='', ss=None, sd=None, s=None, prx=None):
self.mytype = mytype
self.bo = bo
self.by = by
self.sh = sh
self.i = i
self.l = l
self.f = f
self.d = d
self.str = str
self.ss = ss
_M_omero._t_RSetPrx = IcePy.defineProxy('::omero::RSet', RSetPrx)
_M_omero._t_RSet = IcePy.declareClass('::omero::RSet')
_M_omero._t_RSet = IcePy.defineClass('::omero::RSet', RSet, (), True, _M_omero._t_RCollection, (), ())
RSet._ice_type = _M_omero._t_RSet
_M_omero.RSet = RSet
del RSet
_M_omero.RSetPrx = RSetPrx
del RSetPrx
if not _M_omero.__dict__.has_key('_t_RTypeDict'):
_M_omero._t_RTypeDict = IcePy.defineDictionary('::omero::RTypeDict', (), IcePy._t_string, _M_omero._t_RType)
if not _M_omero.__dict__.has_key('RMap'):
_M_omero.RMap = Ice.createTempClass()
class RMap(_M_omero.RType):
'''Similar to [RCollection], the [RMap] class permits the passing
of a possible null [RTypeDict] where any other [RType] is
expected.'''
def __init__(self, _val=None):
if __builtin__.type(self) == _M_omero.RMap:
raise RuntimeError('omero.RMap is an abstract class')
_M_omero.RType.__init__(self)
self._val = _val
def ice_ids(self, current=None):
return ('::Ice::Object', '::omero::RMap', '::omero::RType')
('endpoint', (), IcePy._t_string),
('index', (), IcePy._t_long)
))
Jid.ice_type = _M_com.xiaonei.talk.common._t_Jid
_M_com.xiaonei.talk.common.Jid = Jid
del Jid
_M_com.xiaonei.talk.common.JidPrx = JidPrx
del JidPrx
if not _M_com.xiaonei.talk.common.__dict__.has_key('_t_JidSeq'):
_M_com.xiaonei.talk.common._t_JidSeq = IcePy.defineSequence('::com::xiaonei::talk::common::JidSeq', (), _M_com.xiaonei.talk.common._t_Jid)
if not _M_com.xiaonei.talk.common.__dict__.has_key('_t_JidMap'):
_M_com.xiaonei.talk.common._t_JidMap = IcePy.defineDictionary('::com::xiaonei::talk::common::JidMap', (), IcePy._t_int, _M_com.xiaonei.talk.common._t_Jid)
if not _M_com.xiaonei.talk.common.__dict__.has_key('_t_JidSeqMap'):
_M_com.xiaonei.talk.common._t_JidSeqMap = IcePy.defineDictionary('::com::xiaonei::talk::common::JidSeqMap', (), IcePy._t_int, _M_com.xiaonei.talk.common._t_JidSeq)
if not _M_com.xiaonei.talk.common.__dict__.has_key('SysJid'):
_M_com.xiaonei.talk.common.SysJid = Ice.createTempClass()
class SysJid(Ice.Object):
def __init__(self, node='', category=''):
self.node = node
self.category = category
def ice_ids(self, current=None):
return ('::Ice::Object', '::com::xiaonei::talk::common::SysJid')
def ice_id(self, current=None):
from sys import version_info as _version_info_
import Ice, IcePy
# Start of module HelperTypes
_M_HelperTypes = Ice.openModule('HelperTypes')
__name__ = 'HelperTypes'
if '_t_IntegerGroup' not in _M_HelperTypes.__dict__:
_M_HelperTypes._t_IntegerGroup = IcePy.defineSequence('::HelperTypes::IntegerGroup', (), IcePy._t_int)
if '_t_StringGroup' not in _M_HelperTypes.__dict__:
_M_HelperTypes._t_StringGroup = IcePy.defineSequence('::HelperTypes::StringGroup', (), IcePy._t_string)
if '_t_CountDict' not in _M_HelperTypes.__dict__:
_M_HelperTypes._t_CountDict = IcePy.defineDictionary('::HelperTypes::CountDict', (), IcePy._t_int, IcePy._t_int)
if '_t_StrToIntDict' not in _M_HelperTypes.__dict__:
_M_HelperTypes._t_StrToIntDict = IcePy.defineDictionary('::HelperTypes::StrToIntDict', (), IcePy._t_string, IcePy._t_int)
if '_t_GroupedIntegersDict' not in _M_HelperTypes.__dict__:
_M_HelperTypes._t_GroupedIntegersDict = IcePy.defineDictionary('::HelperTypes::GroupedIntegersDict', (), IcePy._t_string, _M_HelperTypes._t_IntegerGroup)
if '_t_GroupedStringDict' not in _M_HelperTypes.__dict__:
_M_HelperTypes._t_GroupedStringDict = IcePy.defineDictionary('::HelperTypes::GroupedStringDict', (), IcePy._t_int, _M_HelperTypes._t_StringGroup)
if '_t_DictSeq' not in _M_HelperTypes.__dict__:
_M_HelperTypes._t_DictSeq = IcePy.defineSequence('::HelperTypes::DictSeq', (), _M_HelperTypes._t_StrToIntDict)
# End of module HelperTypes
('username', (), IcePy._t_string, False, 0),
('password', (), IcePy._t_string, False, 0),
('channel', (), IcePy._t_int, False, 0), ('stream',
(), IcePy._t_int, False, 0),
('thirdparty', (), IcePy._t_bool, False, 0)))
DeviceStreamInfo._ice_type = _M_Vistek.Device._t_DeviceStreamInfo
_M_Vistek.Device.DeviceStreamInfo = DeviceStreamInfo
del DeviceStreamInfo
_M_Vistek.Device.DeviceStreamInfoPrx = DeviceStreamInfoPrx
del DeviceStreamInfoPrx
if '_t_DeviceStreamInfoMap' not in _M_Vistek.Device.__dict__:
_M_Vistek.Device._t_DeviceStreamInfoMap = IcePy.defineDictionary(
'::Vistek::Device::DeviceStreamInfoMap', (), IcePy._t_string,
_M_Vistek.Device._t_DeviceStreamInfo)
if 'RegisterInfo' not in _M_Vistek.Device.__dict__:
_M_Vistek.Device.RegisterInfo = Ice.createTempClass()
class RegisterInfo(Ice.Object):
def __init__(self,
id='',
type=_M_Vistek.Device.RegisterType.rtNormal,
ip="127.0.0.1",
port=0):
self.id = id
self.type = type
self.ip = ip
self.port = port
# **********************************************************************
#
# Copyright (c) 2003-2010 ZeroC, Inc. All rights reserved.
#
# This copy of Ice is licensed to you under the terms described in the
# ICE_LICENSE file included in this distribution.
#
# **********************************************************************
# Ice version 3.4.1
# <auto-generated>
#
# Generated from file `FacetMap.ice'
#
# Warning: do not edit this file.
#
# </auto-generated>
import Ice, IcePy, __builtin__
# Start of module Ice
_M_Ice = Ice.openModule('Ice')
__name__ = 'Ice'
if not _M_Ice.__dict__.has_key('_t_FacetMap'):
_M_Ice._t_FacetMap = IcePy.defineDictionary('::Ice::FacetMap', (), IcePy._t_string, IcePy._t_Object)
# End of module Ice
# Start of module omero
__name__ = 'omero'
# Start of module omero.sys
_M_omero.sys = Ice.openModule('omero.sys')
__name__ = 'omero.sys'
if '_t_LongList' not in _M_omero.sys.__dict__:
_M_omero.sys._t_LongList = IcePy.defineSequence('::omero::sys::LongList', (), IcePy._t_long)
if '_t_IntList' not in _M_omero.sys.__dict__:
_M_omero.sys._t_IntList = IcePy.defineSequence('::omero::sys::IntList', (), IcePy._t_int)
if '_t_CountMap' not in _M_omero.sys.__dict__:
_M_omero.sys._t_CountMap = IcePy.defineDictionary('::omero::sys::CountMap', (), IcePy._t_long, IcePy._t_long)
if '_t_ParamMap' not in _M_omero.sys.__dict__:
_M_omero.sys._t_ParamMap = IcePy.defineDictionary('::omero::sys::ParamMap', (), IcePy._t_string, _M_omero._t_RType)
if '_t_IdByteMap' not in _M_omero.sys.__dict__:
_M_omero.sys._t_IdByteMap = IcePy.defineDictionary('::omero::sys::IdByteMap', (), IcePy._t_long, _M_Ice._t_ByteSeq)
if 'EventContext' not in _M_omero.sys.__dict__:
_M_omero.sys._t_EventContext = IcePy.declareClass('::omero::sys::EventContext')
_M_omero.sys._t_EventContextPrx = IcePy.declareProxy('::omero::sys::EventContext')
# End of module omero.sys
__name__ = 'omero'
_M_xce.talk._t_Observer = IcePy.defineClass('::xce::talk::Observer', Observer, (), True, None, (), ())
Observer.ice_type = _M_xce.talk._t_Observer
Observer._op_update = IcePy.Operation('update', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), _M_MyUtil._t_Str2StrMap),), (), IcePy._t_bool, ())
_M_xce.talk.Observer = Observer
del Observer
_M_xce.talk.ObserverPrx = ObserverPrx
del ObserverPrx
if not _M_xce.talk.__dict__.has_key('_t_ObserverPool'):
_M_xce.talk._t_ObserverPool = IcePy.defineSequence('::xce::talk::ObserverPool', (), _M_xce.talk._t_ObserverPrx)
if not _M_xce.talk.__dict__.has_key('_t_ObserverPoolMap'):
_M_xce.talk._t_ObserverPoolMap = IcePy.defineDictionary('::xce::talk::ObserverPoolMap', (), IcePy._t_string, _M_xce.talk._t_ObserverPool)
if not _M_xce.talk.__dict__.has_key('IMStorm'):
_M_xce.talk.IMStorm = Ice.createTempClass()
class IMStorm(_M_com.xiaonei.talk.DeliverInterface):
def __init__(self):
if __builtin__.type(self) == _M_xce.talk.IMStorm:
raise RuntimeError('xce.talk.IMStorm is an abstract class')
def ice_ids(self, current=None):
return ('::Ice::Object', '::com::xiaonei::talk::DeliverInterface', '::xce::talk::IMStorm')
def ice_id(self, current=None):
return '::xce::talk::IMStorm'
def ice_staticId():
__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):
'''This exception indicates that an attempt was made to create a link
that already exists.'''
def __init__(self, name=''):
self.name = name
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
_ice_name = 'IceStorm::LinkExists'
_M_DataFlow.NDArrayPrx = NDArrayPrx
del NDArrayPrx
if '_t_NDArrayList' not in _M_DataFlow.__dict__:
_M_DataFlow._t_NDArrayList = IcePy.defineSequence(
'::DataFlow::NDArrayList', (), _M_DataFlow._t_NDArray)
if '_t_TensorList' not in _M_DataFlow.__dict__:
_M_DataFlow._t_TensorList = IcePy.defineSequence('::DataFlow::TensorList',
(),
_M_DataFlow._t_NDArray)
if '_t_TensorMap' not in _M_DataFlow.__dict__:
_M_DataFlow._t_TensorMap = IcePy.defineDictionary('::DataFlow::TensorMap',
(), IcePy._t_string,
_M_DataFlow._t_NDArray)
if 'IOData' not in _M_DataFlow.__dict__:
_M_DataFlow.IOData = Ice.createTempClass()
class IOData(Ice.Object):
def __init__(self, datas=None):
self.datas = datas
def ice_ids(self, current=None):
return ('::DataFlow::IOData', '::Ice::Object')
def ice_id(self, current=None):
return '::DataFlow::IOData'
#
# </auto-generated>
import Ice, IcePy, __builtin__
import Ice_ObjectAdapterF_ice
import Ice_ConnectionF_ice
import Ice_Identity_ice
# Included module Ice
_M_Ice = Ice.openModule('Ice')
# Start of module Ice
__name__ = 'Ice'
if not _M_Ice.__dict__.has_key('_t_Context'):
_M_Ice._t_Context = IcePy.defineDictionary('::Ice::Context', (), IcePy._t_string, IcePy._t_string)
if not _M_Ice.__dict__.has_key('OperationMode'):
_M_Ice.OperationMode = Ice.createTempClass()
class OperationMode(object):
'''The OperationMode determines the retry behavior an
invocation in case of a (potentially) recoverable error.'''
def __init__(self, val):
assert(val >= 0 and val < 3)
self.value = val
def __str__(self):
return self._names[self.value]
__repr__ = __str__
('mean', (), _M_omero.api._t_DoubleArray),
('stdDev', (), _M_omero.api._t_DoubleArray)
))
ShapeStats._ice_type = _M_omero.api._t_ShapeStats
_M_omero.api.ShapeStats = ShapeStats
del ShapeStats
_M_omero.api.ShapeStatsPrx = ShapeStatsPrx
del ShapeStatsPrx
if not _M_omero.api.__dict__.has_key('_t_ShapeStatsList'):
_M_omero.api._t_ShapeStatsList = IcePy.defineSequence('::omero::api::ShapeStatsList', (), _M_omero.api._t_ShapeStats)
if not _M_omero.api.__dict__.has_key('_t_LongRoiResultMap'):
_M_omero.api._t_LongRoiResultMap = IcePy.defineDictionary('::omero::api::LongRoiResultMap', (), IcePy._t_long, _M_omero.api._t_RoiResult)
if not _M_omero.api.__dict__.has_key('RoiStats'):
_M_omero.api.RoiStats = Ice.createTempClass()
class RoiStats(Ice.Object):
'''Container for ShapeStats, one with the combined values,
and one per shape.'''
def __init__(self, roiId=0, imageId=0, pixelsId=0, combined=None, perShape=None):
self.roiId = roiId
self.imageId = imageId
self.pixelsId = pixelsId
self.combined = combined
self.perShape = perShape
def ice_ids(self, current=None):
return ('::Ice::Object', '::omero::api::RoiStats')
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
# **********************************************************************
#
# Copyright (c) 2003-2010 ZeroC, Inc. All rights reserved.
#
# This copy of Ice is licensed to you under the terms described in the
# ICE_LICENSE file included in this distribution.
#
# **********************************************************************
# Ice version 3.4.1
# <auto-generated>
#
# Generated from file `SliceChecksumDict.ice'
#
# Warning: do not edit this file.
#
# </auto-generated>
import Ice, IcePy, __builtin__
# Start of module Ice
_M_Ice = Ice.openModule('Ice')
__name__ = 'Ice'
if not _M_Ice.__dict__.has_key('_t_SliceChecksumDict'):
_M_Ice._t_SliceChecksumDict = IcePy.defineDictionary('::Ice::SliceChecksumDict', (), IcePy._t_string, IcePy._t_string)
# End of module Ice
# Ice version 3.3.1
# Generated from file `sync.ice'
import Ice, IcePy, __builtin__
if not Ice.__dict__.has_key("_struct_marker"):
Ice._struct_marker = object()
# Start of module games
_M_games = Ice.openModule('games')
__name__ = 'games'
if not _M_games.__dict__.has_key('_t_HashValueSet'):
_M_games._t_HashValueSet = IcePy.defineDictionary('::games::HashValueSet',
(), IcePy._t_string,
IcePy._t_string)
if not _M_games.__dict__.has_key('_t_ReturnValueT'):
_M_games._t_ReturnValueT = IcePy.defineDictionary('::games::ReturnValueT',
(), IcePy._t_string,
IcePy._t_string)
if not _M_games.__dict__.has_key('_t_StreamDataT'):
_M_games._t_StreamDataT = IcePy.defineSequence('::games::StreamDataT', (),
IcePy._t_byte)
if not _M_games.__dict__.has_key('_t_StringListT'):
_M_games._t_StringListT = IcePy.defineSequence('::games::StringListT', (),
IcePy._t_string)
('units', (), IcePy._t_string),
('description', (), IcePy._t_string),
('display', (), IcePy._t_int),
('min', (), _M_gnuradio.ctrlport.GNURadio._t_Knob),
('max', (), _M_gnuradio.ctrlport.GNURadio._t_Knob),
('defaultvalue', (), _M_gnuradio.ctrlport.GNURadio._t_Knob)
))
_M_gnuradio.ctrlport.GNURadio.KnobProp = KnobProp
del KnobProp
if '_t_KnobIDList' not in _M_gnuradio.ctrlport.GNURadio.__dict__:
_M_gnuradio.ctrlport.GNURadio._t_KnobIDList = IcePy.defineSequence('::GNURadio::KnobIDList', (), IcePy._t_string)
if '_t_KnobMap' not in _M_gnuradio.ctrlport.GNURadio.__dict__:
_M_gnuradio.ctrlport.GNURadio._t_KnobMap = IcePy.defineDictionary('::GNURadio::KnobMap', (), IcePy._t_string, _M_gnuradio.ctrlport.GNURadio._t_Knob)
if '_t_KnobPropMap' not in _M_gnuradio.ctrlport.GNURadio.__dict__:
_M_gnuradio.ctrlport.GNURadio._t_KnobPropMap = IcePy.defineDictionary('::GNURadio::KnobPropMap', (), IcePy._t_string, _M_gnuradio.ctrlport.GNURadio._t_KnobProp)
if '_t_WaveformArgMap' not in _M_gnuradio.ctrlport.GNURadio.__dict__:
_M_gnuradio.ctrlport.GNURadio._t_WaveformArgMap = IcePy.defineDictionary('::GNURadio::WaveformArgMap', (), IcePy._t_string, IcePy._t_string)
if 'StreamReceiver' not in _M_gnuradio.ctrlport.GNURadio.__dict__:
_M_gnuradio.ctrlport.GNURadio.StreamReceiver = Ice.createTempClass()
class StreamReceiver(Ice.Object):
def __init__(self):
if Ice.getType(self) == _M_gnuradio.ctrlport.GNURadio.StreamReceiver:
raise RuntimeError('gnuradio.ctrlport.GNURadio.StreamReceiver is an abstract class')
def ice_ids(self, current=None):
# Included module Ice
_M_Ice = Ice.openModule('Ice')
# Included module omero.sys
_M_omero.sys = Ice.openModule('omero.sys')
# Start of module omero
__name__ = 'omero'
# Start of module omero.api
_M_omero.api = Ice.openModule('omero.api')
__name__ = 'omero.api'
if not _M_omero.api.__dict__.has_key('_t_SearchMetadata'):
_M_omero.api._t_SearchMetadata = IcePy.defineDictionary('::omero::api::SearchMetadata', (), IcePy._t_string, _M_omero.model._t_Annotation)
if not _M_omero.api.__dict__.has_key('_t_StringSet'):
_M_omero.api._t_StringSet = IcePy.defineSequence('::omero::api::StringSet', (), IcePy._t_string)
if not _M_omero.api.__dict__.has_key('_t_LongList'):
_M_omero.api._t_LongList = IcePy.defineSequence('::omero::api::LongList', (), IcePy._t_long)
if not _M_omero.api.__dict__.has_key('_t_IntegerList'):
_M_omero.api._t_IntegerList = IcePy.defineSequence('::omero::api::IntegerList', (), IcePy._t_int)
if not _M_omero.api.__dict__.has_key('_t_SearchMetadataList'):
_M_omero.api._t_SearchMetadataList = IcePy.defineSequence('::omero::api::SearchMetadataList', (), _M_omero.api._t_SearchMetadata)
if not _M_omero.api.__dict__.has_key('_t_ExperimenterList'):
_M_omero.api._t_ExperimenterList = IcePy.defineSequence('::omero::api::ExperimenterList', (), _M_omero.model._t_Experimenter)
#
from sys import version_info as _version_info_
import Ice, IcePy
# Start of module DataPool
_M_DataPool = Ice.openModule('DataPool')
__name__ = 'DataPool'
if '_t_StringSeq' not in _M_DataPool.__dict__:
_M_DataPool._t_StringSeq = IcePy.defineSequence('::DataPool::StringSeq',
(), IcePy._t_string)
if '_t_StringMap' not in _M_DataPool.__dict__:
_M_DataPool._t_StringMap = IcePy.defineDictionary('::DataPool::StringMap',
(), IcePy._t_string,
IcePy._t_string)
_M_DataPool.rpcPortDataServer = 21000
if 'InitParamManager' not in _M_DataPool.__dict__:
_M_DataPool.InitParamManager = Ice.createTempClass()
class InitParamManager(Ice.Object):
def __init__(self):
pass
def ice_ids(self, current=None):
return ('::DataPool::InitParamManager', '::Ice::Object')
def ice_id(self, current=None):
return IcePy.stringify(self, _M_Bank._t_LoanInfo)
__repr__ = __str__
_M_Bank._t_LoanInfo = IcePy.defineStruct('::Bank::LoanInfo', LoanInfo, (),
(('amountInNativeCurrency',
(), IcePy._t_long),
('amountInForeignCurrency',
(), IcePy._t_long)))
_M_Bank.LoanInfo = LoanInfo
del LoanInfo
if '_t_Funds' not in _M_Bank.__dict__:
_M_Bank._t_Funds = IcePy.defineDictionary('::Bank::Funds', (),
_M_Bank._t_Currency,
IcePy._t_long)
if 'AccountInfo' not in _M_Bank.__dict__:
_M_Bank.AccountInfo = Ice.createTempClass()
class AccountInfo(object):
def __init__(self,
isPremium=False,
hasLoan=False,
loanInfo=Ice._struct_marker,
funds=None):
self.isPremium = isPremium
self.hasLoan = hasLoan
if loanInfo is Ice._struct_marker:
self.loanInfo = _M_Bank.LoanInfo()
# **********************************************************************
# Ice version 3.3.1
# Generated from file `redirect.ice'
import Ice, IcePy, __builtin__
if not Ice.__dict__.has_key("_struct_marker"):
Ice._struct_marker = object()
# Start of module rd
_M_rd = Ice.openModule('rd')
__name__ = 'rd'
if not _M_rd.__dict__.has_key('_t_HashValueSet'):
_M_rd._t_HashValueSet = IcePy.defineDictionary('::rd::HashValueSet', (), IcePy._t_string, IcePy._t_string)
if not _M_rd.__dict__.has_key('_t_ReturnValueT'):
_M_rd._t_ReturnValueT = IcePy.defineDictionary('::rd::ReturnValueT', (), IcePy._t_string, IcePy._t_string)
if not _M_rd.__dict__.has_key('_t_StreamDataT'):
_M_rd._t_StreamDataT = IcePy.defineSequence('::rd::StreamDataT', (), IcePy._t_byte)
if not _M_rd.__dict__.has_key('_t_StringListT'):
_M_rd._t_StringListT = IcePy.defineSequence('::rd::StringListT', (), IcePy._t_string)
if not _M_rd.__dict__.has_key('_t_HashValueListT'):
_M_rd._t_HashValueListT = IcePy.defineSequence('::rd::HashValueListT', (), _M_rd._t_HashValueSet)
if not _M_rd.__dict__.has_key('_t_IntListT'):
_M_rd._t_IntListT = IcePy.defineSequence('::rd::IntListT', (), IcePy._t_int)
_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):
'''This exception indicates that an attempt was made to create a link
that already exists.'''
def __init__(self, name=''):
self.name = name
def __str__(self):
return IcePy.stringifyException(self)
__repr__ = __str__
return IcePy.stringify(self, _M_Bank._t_ClientData)
__repr__ = __str__
_M_Bank._t_ClientData = IcePy.defineStruct('::Bank::ClientData', ClientData, (), (
('name', (), IcePy._t_string),
('surname', (), IcePy._t_string),
('id', (), IcePy._t_string),
('income', (), IcePy._t_double)
))
_M_Bank.ClientData = ClientData
del ClientData
if '_t_LoanHistory' not in _M_Bank.__dict__:
_M_Bank._t_LoanHistory = IcePy.defineDictionary('::Bank::LoanHistory', (), IcePy._t_string, IcePy._t_string)
if '_t_LoanHistorySeq' not in _M_Bank.__dict__:
_M_Bank._t_LoanHistorySeq = IcePy.defineSequence('::Bank::LoanHistorySeq', (), _M_Bank._t_LoanHistory)
if 'AccountData' not in _M_Bank.__dict__:
_M_Bank.AccountData = Ice.createTempClass()
class AccountData(Ice.Value):
def __init__(self, accountType=_M_Bank.AccountType.Standard, funds=0.0, loans=Ice.Unset):
self.accountType = accountType
self.funds = funds
self.loans = loans
def ice_id(self):
return '::Bank::AccountData'
('nodes', (), _M_Vistek.Data._t_nodesList, False, 0)))
BootstrapViewRoot._ice_type = _M_Vistek.Data._t_BootstrapViewRoot
_M_Vistek.Data.BootstrapViewRoot = BootstrapViewRoot
del BootstrapViewRoot
_M_Vistek.Data.BootstrapViewRootPrx = BootstrapViewRootPrx
del BootstrapViewRootPrx
if '_t_viewRoot' not in _M_Vistek.Data.__dict__:
_M_Vistek.Data._t_viewRoot = IcePy.defineSequence(
'::Vistek::Data::viewRoot', (), _M_Vistek.Data._t_BootstrapViewRoot)
if '_t_dic' not in _M_Vistek.Data.__dict__:
_M_Vistek.Data._t_dic = IcePy.defineDictionary('::Vistek::Data::dic', (),
IcePy._t_string,
IcePy._t_string)
if '_t_eventSourceList' not in _M_Vistek.Data.__dict__:
_M_Vistek.Data._t_eventSourceList = IcePy.defineSequence(
'::Vistek::Data::eventSourceList', (), _M_Vistek.Data._t_dic)
if '_t_serviceList' not in _M_Vistek.Data.__dict__:
_M_Vistek.Data._t_serviceList = IcePy.defineSequence(
'::Vistek::Data::serviceList', (), _M_Vistek.Data._t_dic)
if '_t_serviceAndEvent' not in _M_Vistek.Data.__dict__:
_M_Vistek.Data._t_serviceAndEvent = IcePy.defineDictionary(
'::Vistek::Data::serviceAndEvent', (), IcePy._t_string,
_M_Vistek.Data._t_serviceList)
_M_Ice._t_UDPConnectionInfo = IcePy.defineValue(
'::Ice::UDPConnectionInfo', UDPConnectionInfo, -1, (), False, False,
_M_Ice._t_IPConnectionInfo,
(('mcastAddress', (), IcePy._t_string, False, 0),
('mcastPort',
(), IcePy._t_int, False, 0), ('rcvSize', (), IcePy._t_int, False, 0),
('sndSize', (), IcePy._t_int, False, 0)))
UDPConnectionInfo._ice_type = _M_Ice._t_UDPConnectionInfo
_M_Ice.UDPConnectionInfo = UDPConnectionInfo
del UDPConnectionInfo
if '_t_HeaderDict' not in _M_Ice.__dict__:
_M_Ice._t_HeaderDict = IcePy.defineDictionary('::Ice::HeaderDict', (),
IcePy._t_string,
IcePy._t_string)
if 'WSConnectionInfo' not in _M_Ice.__dict__:
_M_Ice.WSConnectionInfo = Ice.createTempClass()
class WSConnectionInfo(_M_Ice.ConnectionInfo):
"""
Provides access to the connection details of a WebSocket connection
Members:
headers -- The headers from the HTTP upgrade request.
"""
def __init__(self,
underlying=None,
incoming=False,
adapterName='',
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
Ice.sliceChecksums["::Ice::Identity"] = "a0c37867a69924a9fcc4bdf078f06da"
Ice.sliceChecksums["::Ice::IdentitySeq"] = "90afa299fd9e7d7a17268cc22b5ca42"
__repr__ = __str__
_M_ARIAPI._t_mapel = IcePy.defineStruct('::ARIAPI::mapel', mapel, (), (
('azeloff', (), _M_ARIAPI._t_delta),
('maspecs', (), _M_ARIAPI._t_specs)
))
_M_ARIAPI.mapel = mapel
del mapel
if '_t_map' not in _M_ARIAPI.__dict__:
_M_ARIAPI._t_map = IcePy.defineSequence('::ARIAPI::map', (), _M_ARIAPI._t_mapel)
if '_t_lsp' not in _M_ARIAPI.__dict__:
_M_ARIAPI._t_lsp = IcePy.defineDictionary('::ARIAPI::lsp', (), IcePy._t_string, _M_ARIAPI._t_specs)
if '_t_txtList' not in _M_ARIAPI.__dict__:
_M_ARIAPI._t_txtList = IcePy.defineSequence('::ARIAPI::txtList', (), IcePy._t_string)
if '_t_txtDict' not in _M_ARIAPI.__dict__:
_M_ARIAPI._t_txtDict = IcePy.defineDictionary('::ARIAPI::txtDict', (), IcePy._t_string, IcePy._t_string)
if '_t_boolDict' not in _M_ARIAPI.__dict__:
_M_ARIAPI._t_boolDict = IcePy.defineDictionary('::ARIAPI::boolDict', (), IcePy._t_string, IcePy._t_bool)
if 'RxSet' not in _M_ARIAPI.__dict__:
_M_ARIAPI.RxSet = Ice.createTempClass()
class RxSet(object):
def __init__(self, freq=0.0, mode=''):
self.freq = freq
# -*- coding: utf-8 -*-
#
# Copyright (c) ZeroC, Inc. All rights reserved.
#
#
# Ice version 3.7.3
#
# <auto-generated>
#
# Generated from file `FacetMap.ice'
#
# Warning: do not edit this file.
#
# </auto-generated>
#
from sys import version_info as _version_info_
import Ice, IcePy
# Start of module Ice
_M_Ice = Ice.openModule('Ice')
__name__ = 'Ice'
if '_t_FacetMap' not in _M_Ice.__dict__:
_M_Ice._t_FacetMap = IcePy.defineDictionary('::Ice::FacetMap', (),
IcePy._t_string,
IcePy._t_Value)
# End of module Ice
__repr__ = __str__
_ice_id = '::Accounts::InvalidPeselException'
_M_Accounts._t_InvalidPeselException = IcePy.defineException(
'::Accounts::InvalidPeselException', InvalidPeselException, (), False,
_M_Accounts._t_GenericException, ())
InvalidPeselException._ice_type = _M_Accounts._t_InvalidPeselException
_M_Accounts.InvalidPeselException = InvalidPeselException
del InvalidPeselException
if '_t_AccountBalance' not in _M_Accounts.__dict__:
_M_Accounts._t_AccountBalance = IcePy.defineDictionary(
'::Accounts::AccountBalance', (), _M_Accounts._t_Currency,
IcePy._t_double)
if 'AccountDetails' not in _M_Accounts.__dict__:
_M_Accounts.AccountDetails = Ice.createTempClass()
class AccountDetails(object):
def __init__(self, declaredMonthlyIncome=0.0, balance=None):
self.declaredMonthlyIncome = declaredMonthlyIncome
self.balance = balance
def __eq__(self, other):
if other is None:
return False
elif not isinstance(other, _M_Accounts.AccountDetails):
return NotImplemented
import Ice, IcePy
import Ice_BuiltinSequences_ice
# Included module Ice
_M_Ice = Ice.openModule('Ice')
# Start of module IceMX
_M_IceMX = Ice.openModule('IceMX')
__name__ = 'IceMX'
_M_IceMX.__doc__ = '''The Ice Management eXtension facility. It provides the
IceMX#MetricsAdmin interface for management clients to retrieve
metrics from Ice applications.'''
if '_t_StringIntDict' not in _M_IceMX.__dict__:
_M_IceMX._t_StringIntDict = IcePy.defineDictionary(
'::IceMX::StringIntDict', (), IcePy._t_string, IcePy._t_int)
if 'Metrics' not in _M_IceMX.__dict__:
_M_IceMX.Metrics = Ice.createTempClass()
class Metrics(Ice.Object):
'''The base class for metrics. A metrics object represents a
collection of measurements associated to a given a system.'''
def __init__(self,
id='',
total=0,
current=0,
totalLifetime=0,
failures=0):
self.id = id
self.total = total
_M_omero._t_RSet = IcePy.declareClass('::omero::RSet')
_M_omero._t_RSet = IcePy.defineClass('::omero::RSet', RSet, -1, (), True,
False, _M_omero._t_RCollection, (),
())
RSet._ice_type = _M_omero._t_RSet
_M_omero.RSet = RSet
del RSet
_M_omero.RSetPrx = RSetPrx
del RSetPrx
if '_t_RTypeDict' not in _M_omero.__dict__:
_M_omero._t_RTypeDict = IcePy.defineDictionary('::omero::RTypeDict', (),
IcePy._t_string,
_M_omero._t_RType)
if 'RMap' not in _M_omero.__dict__:
_M_omero.RMap = Ice.createTempClass()
class RMap(_M_omero.RType):
"""
Similar to {@code RCollection}, the {@code RMap} class permits the passing
of a possible null {@code RTypeDict} where any other {@code RType} is
expected.
"""
def __init__(self, _val=None):
if Ice.getType(self) == _M_omero.RMap:
raise RuntimeError('omero.RMap is an abstract class')
_M_omero.RType.__init__(self)
#
from sys import version_info as _version_info_
import Ice, IcePy
# Start of module filecenter
_M_filecenter = Ice.openModule('filecenter')
__name__ = 'filecenter'
if '_t_Bytes' not in _M_filecenter.__dict__:
_M_filecenter._t_Bytes = IcePy.defineSequence('::filecenter::Bytes', (),
IcePy._t_byte)
if '_t_ExtInfo' not in _M_filecenter.__dict__:
_M_filecenter._t_ExtInfo = IcePy.defineDictionary('::filecenter::ExtInfo',
(), IcePy._t_string,
IcePy._t_string)
if 'FileInfo' not in _M_filecenter.__dict__:
_M_filecenter.FileInfo = Ice.createTempClass()
class FileInfo(object):
def __init__(self,
creattime=0,
updatetime=0,
filesize=0,
filescore=0,
filename='',
filetype='',
filepath=''):
self.creattime = creattime
# Start of module omero
__name__ = 'omero'
# Start of module omero.sys
_M_omero.sys = Ice.openModule('omero.sys')
__name__ = 'omero.sys'
if not _M_omero.sys.__dict__.has_key('_t_LongList'):
_M_omero.sys._t_LongList = IcePy.defineSequence('::omero::sys::LongList', (), IcePy._t_long)
if not _M_omero.sys.__dict__.has_key('_t_IntList'):
_M_omero.sys._t_IntList = IcePy.defineSequence('::omero::sys::IntList', (), IcePy._t_int)
if not _M_omero.sys.__dict__.has_key('_t_CountMap'):
_M_omero.sys._t_CountMap = IcePy.defineDictionary('::omero::sys::CountMap', (), IcePy._t_long, IcePy._t_long)
if not _M_omero.sys.__dict__.has_key('_t_ParamMap'):
_M_omero.sys._t_ParamMap = IcePy.defineDictionary('::omero::sys::ParamMap', (), IcePy._t_string, _M_omero._t_RType)
if not _M_omero.sys.__dict__.has_key('_t_IdByteMap'):
_M_omero.sys._t_IdByteMap = IcePy.defineDictionary('::omero::sys::IdByteMap', (), IcePy._t_long, _M_Ice._t_ByteSeq)
if not _M_omero.sys.__dict__.has_key('EventContext'):
_M_omero.sys.EventContext = Ice.createTempClass()
class EventContext(Ice.Object):
'''Maps the ome.system.EventContext interface. Represents the
information known by the server security system about the
current user login.'''
def __init__(self, shareId=0, sessionId=0, sessionUuid='', userId=0, userName='', groupId=0, groupName='', isAdmin=False, eventId=0, eventType='', memberOfGroups=None, leaderOfGroups=None, groupPermissions=None):
self.shareId = shareId
_M_guitarlib._t_ActionPrx = IcePy.defineProxy('::guitarlib::Action', ActionPrx)
_M_guitarlib._t_Action = IcePy.defineClass('::guitarlib::Action', Action, (), True, None, (), ())
Action._ice_type = _M_guitarlib._t_Action
Action._op_perform = IcePy.Operation('perform', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), None, ())
Action._op_getEventType = IcePy.Operation('getEventType', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, False, (), (), (), IcePy._t_string, ())
_M_guitarlib.Action = Action
del Action
_M_guitarlib.ActionPrx = ActionPrx
del ActionPrx
if not _M_guitarlib.__dict__.has_key('_t_PropertyMap'):
_M_guitarlib._t_PropertyMap = IcePy.defineDictionary('::guitarlib::PropertyMap', (), IcePy._t_string, IcePy._t_string)
if not _M_guitarlib.__dict__.has_key('_t_EventList'):
_M_guitarlib._t_EventList = IcePy.defineSequence('::guitarlib::EventList', (), _M_guitarlib._t_ActionPrx)
if not _M_guitarlib.__dict__.has_key('_t_WidgetList'):
_M_guitarlib._t_WidgetList = IcePy.defineSequence('::guitarlib::WidgetList', (), _M_guitarlib._t_WidgetPrx)
if not _M_guitarlib.__dict__.has_key('Widget'):
_M_guitarlib.Widget = Ice.createTempClass()
class Widget(Ice.Object):
def __init__(self):
if __builtin__.type(self) == _M_guitarlib.Widget:
raise RuntimeError('guitarlib.Widget is an abstract class')
def ice_ids(self, current=None):
_M_RoboCompJointMotor._t_MotorState = IcePy.defineStruct('::RoboCompJointMotor::MotorState', MotorState, (), (
('pos', (), IcePy._t_float),
('vel', (), IcePy._t_float),
('power', (), IcePy._t_float),
('timeStamp', (), IcePy._t_string),
('p', (), IcePy._t_int),
('v', (), IcePy._t_int),
('isMoving', (), IcePy._t_bool)
))
_M_RoboCompJointMotor.MotorState = MotorState
del MotorState
if '_t_MotorStateMap' not in _M_RoboCompJointMotor.__dict__:
_M_RoboCompJointMotor._t_MotorStateMap = IcePy.defineDictionary('::RoboCompJointMotor::MotorStateMap', (), IcePy._t_string, _M_RoboCompJointMotor._t_MotorState)
if 'MotorParams' not in _M_RoboCompJointMotor.__dict__:
_M_RoboCompJointMotor.MotorParams = Ice.createTempClass()
class MotorParams(object):
def __init__(self, name='', busId=0, minPos=0.0, maxPos=0.0, maxVelocity=0.0, zeroPos=0.0, invertedSign=False):
self.name = name
self.busId = busId
self.minPos = minPos
self.maxPos = maxPos
self.maxVelocity = maxVelocity
self.zeroPos = zeroPos
self.invertedSign = invertedSign
def __eq__(self, other):
if other is None:
#
# </auto-generated>
#
from sys import version_info as _version_info_
import Ice, IcePy
import Ice.BuiltinSequences_ice
# Included module Ice
_M_Ice = Ice.openModule('Ice')
# Start of module Ice
__name__ = 'Ice'
if '_t_PropertyDict' not in _M_Ice.__dict__:
_M_Ice._t_PropertyDict = IcePy.defineDictionary('::Ice::PropertyDict', (), IcePy._t_string, IcePy._t_string)
_M_Ice._t_PropertiesAdmin = IcePy.defineValue('::Ice::PropertiesAdmin', Ice.Value, -1, (), False, True, None, ())
if 'PropertiesAdminPrx' not in _M_Ice.__dict__:
_M_Ice.PropertiesAdminPrx = Ice.createTempClass()
class PropertiesAdminPrx(Ice.ObjectPrx):
"""
Get a property by key. If the property is not set, an empty
string is returned.
Arguments:
key -- The property key.
context -- The request context for the invocation.
Returns: The property value.
"""
# Included module omero.api
_M_omero.api = Ice.openModule('omero.api')
# Start of module omero
__name__ = 'omero'
# Start of module omero.cmd
_M_omero.cmd = Ice.openModule('omero.cmd')
__name__ = 'omero.cmd'
_M_omero.cmd.__doc__ = """
Simplified API that is intended for passing
"""
if '_t_StringMap' not in _M_omero.cmd.__dict__:
_M_omero.cmd._t_StringMap = IcePy.defineDictionary(
'::omero::cmd::StringMap', (), IcePy._t_string, IcePy._t_string)
if '_t_StringMapList' not in _M_omero.cmd.__dict__:
_M_omero.cmd._t_StringMapList = IcePy.defineSequence(
'::omero::cmd::StringMapList', (), _M_omero.cmd._t_StringMap)
if 'State' not in _M_omero.cmd.__dict__:
_M_omero.cmd.State = Ice.createTempClass()
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]
# **********************************************************************
#
# Copyright (c) 2003-2010 ZeroC, Inc. All rights reserved.
#
# This copy of Ice is licensed to you under the terms described in the
# ICE_LICENSE file included in this distribution.
#
# **********************************************************************
# Ice version 3.4.1
# <auto-generated>
#
# Generated from file `SliceChecksumDict.ice'
#
# Warning: do not edit this file.
#
# </auto-generated>
import Ice, IcePy, __builtin__
# Start of module Ice
_M_Ice = Ice.openModule('Ice')
__name__ = 'Ice'
if not _M_Ice.__dict__.has_key('_t_SliceChecksumDict'):
_M_Ice._t_SliceChecksumDict = IcePy.defineDictionary(
'::Ice::SliceChecksumDict', (), IcePy._t_string, IcePy._t_string)
# End of module Ice
_M_MyUtil._t_LongSeq = IcePy.defineSequence('::MyUtil::LongSeq', (), IcePy._t_long)
if not _M_MyUtil.__dict__.has_key('_t_LongArray'):
_M_MyUtil._t_LongArray = IcePy.defineSequence('::MyUtil::LongArray', (), IcePy._t_long)
if not _M_MyUtil.__dict__.has_key('_t_StrSeq'):
_M_MyUtil._t_StrSeq = IcePy.defineSequence('::MyUtil::StrSeq', (), IcePy._t_string)
if not _M_MyUtil.__dict__.has_key('_t_StringArray'):
_M_MyUtil._t_StringArray = IcePy.defineSequence('::MyUtil::StringArray', (), IcePy._t_string)
if not _M_MyUtil.__dict__.has_key('_t_StrList'):
_M_MyUtil._t_StrList = IcePy.defineSequence('::MyUtil::StrList', (), IcePy._t_string)
if not _M_MyUtil.__dict__.has_key('_t_Int2IntMap'):
_M_MyUtil._t_Int2IntMap = IcePy.defineDictionary('::MyUtil::Int2IntMap', (), IcePy._t_int, IcePy._t_int)
if not _M_MyUtil.__dict__.has_key('_t_Int2StrMap'):
_M_MyUtil._t_Int2StrMap = IcePy.defineDictionary('::MyUtil::Int2StrMap', (), IcePy._t_int, IcePy._t_string)
if not _M_MyUtil.__dict__.has_key('_t_Long2IntMap'):
_M_MyUtil._t_Long2IntMap = IcePy.defineDictionary('::MyUtil::Long2IntMap', (), IcePy._t_long, IcePy._t_int)
if not _M_MyUtil.__dict__.has_key('_t_Long2LongMap'):
_M_MyUtil._t_Long2LongMap = IcePy.defineDictionary('::MyUtil::Long2LongMap', (), IcePy._t_long, IcePy._t_long)
if not _M_MyUtil.__dict__.has_key('_t_Str2IntMap'):
_M_MyUtil._t_Str2IntMap = IcePy.defineDictionary('::MyUtil::Str2IntMap', (), IcePy._t_string, IcePy._t_int)
if not _M_MyUtil.__dict__.has_key('_t_Str2LongMap'):
_M_MyUtil._t_Str2LongMap = IcePy.defineDictionary('::MyUtil::Str2LongMap', (), IcePy._t_string, IcePy._t_long)
_M_FS.Example = Example
del Example
_M_FS.ExamplePrx = ExamplePrx
del ExamplePrx
_M_FS._lambda = 0
if not _M_FS.__dict__.has_key('_t_StringSeq'):
_M_FS._t_StringSeq = IcePy.defineSequence('::FS::StringSeq', (),
IcePy._t_string)
if not _M_FS.__dict__.has_key('_t_StringDict'):
_M_FS._t_StringDict = IcePy.defineDictionary('::FS::StringDict', (),
IcePy._t_string,
IcePy._t_string)
if not _M_FS.__dict__.has_key('mystruct'):
_M_FS.mystruct = Ice.createTempClass()
class mystruct(object):
def __init__(self,
mytype=0,
bo=False,
by=0,
sh=0,
i=0,
l=0,
f=0.0,
d=0.0,
#
# Warning: do not edit this file.
#
# </auto-generated>
import Ice, IcePy, __builtin__
import Ice_BuiltinSequences_ice
# Included module Ice
_M_Ice = Ice.openModule('Ice')
# Start of module Ice
__name__ = 'Ice'
if not _M_Ice.__dict__.has_key('_t_PropertyDict'):
_M_Ice._t_PropertyDict = IcePy.defineDictionary('::Ice::PropertyDict', (), IcePy._t_string, IcePy._t_string)
if not _M_Ice.__dict__.has_key('Properties'):
_M_Ice.Properties = Ice.createTempClass()
class Properties(object):
'''A property set used to configure Ice and Ice applications.
Properties are key/value pairs, with both keys and values
being strings. By convention, property keys should have the form
application-name\[.category\[.sub-category]].name.'''
def __init__(self):
if __builtin__.type(self) == _M_Ice.Properties:
raise RuntimeError('Ice.Properties is an abstract class')
def getProperty(self, key):
'''Get a property by key. If the property is not set, an empty
string is returned.
