def end_setAllocationTimeout(self, _r):
return _M_IceGrid.Session._op_setAllocationTimeout.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_IceGrid.SessionPrx.ice_checkedCast(
proxy, '::IceGrid::Session', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_IceGrid.SessionPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_IceGrid._t_SessionPrx = IcePy.defineProxy('::IceGrid::Session',
SessionPrx)
_M_IceGrid._t_Session = IcePy.defineClass('::IceGrid::Session', Session,
(), True, None,
(_M_Glacier2._t_Session, ), ())
Session._ice_type = _M_IceGrid._t_Session
Session._op_keepAlive = IcePy.Operation('keepAlive',
Ice.OperationMode.Idempotent,
Ice.OperationMode.Idempotent,
False, (), (), (), None, ())
Session._op_allocateObjectById = IcePy.Operation(
'allocateObjectById', Ice.OperationMode.Normal,
Ice.OperationMode.Normal, True, (), (((), _M_Ice._t_Identity), ), (),
IcePy._t_ObjectPrx, (_M_IceGrid._t_ObjectNotRegisteredException,
_M_IceGrid._t_AllocationException))
def begin_convertToMp4(self, filename, _response=None, _ex=None, _sent=None, _ctx=None):
return _M_MediaFile.FileTransfer._op_convertToMp4.begin(self, ((filename, ), _response, _ex, _sent, _ctx))
def end_convertToMp4(self, _r):
return _M_MediaFile.FileTransfer._op_convertToMp4.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_MediaFile.FileTransferPrx.ice_checkedCast(proxy, '::MediaFile::FileTransfer', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_MediaFile.FileTransferPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_MediaFile._t_FileTransferPrx = IcePy.defineProxy('::MediaFile::FileTransfer', FileTransferPrx)
_M_MediaFile._t_FileTransfer = IcePy.defineClass('::MediaFile::FileTransfer', FileTransfer, -1, (), True, False, None, (), ())
FileTransfer._ice_type = _M_MediaFile._t_FileTransfer
FileTransfer._op_send = IcePy.Operation('send', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_string, False, 0), ((), IcePy._t_int, False, 0), ((), _M_MediaFile._t_ByteString, False, 0)), (), None, ())
FileTransfer._op_removeFile = IcePy.Operation('removeFile', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_string, False, 0),), (), None, ())
FileTransfer._op_isFileExists = IcePy.Operation('isFileExists', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_string, False, 0),), (), ((), IcePy._t_bool, False, 0), ())
FileTransfer._op_convertToMp4 = IcePy.Operation('convertToMp4', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_string, False, 0),), (), ((), IcePy._t_string, False, 0), ())
_M_MediaFile.FileTransfer = FileTransfer
del FileTransfer
_M_MediaFile.FileTransferPrx = FileTransferPrx
del FileTransferPrx
def begin_linkedAnnotationList(self, _response=None, _ex=None, _sent=None, _ctx=None):
return _M_omero.model.WellSample._op_linkedAnnotationList.begin(self, ((), _response, _ex, _sent, _ctx))
def end_linkedAnnotationList(self, _r):
return _M_omero.model.WellSample._op_linkedAnnotationList.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_omero.model.WellSamplePrx.ice_checkedCast(proxy, '::omero::model::WellSample', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.WellSamplePrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_omero.model._t_WellSamplePrx = IcePy.defineProxy('::omero::model::WellSample', WellSamplePrx)
_M_omero.model._t_WellSample = IcePy.declareClass('::omero::model::WellSample')
_M_omero.model._t_WellSample = IcePy.defineClass('::omero::model::WellSample', WellSample, (), True, _M_omero.model._t_IObject, (), (
('_version', (), _M_omero._t_RInt),
('_posX', (), _M_omero._t_RDouble),
('_posY', (), _M_omero._t_RDouble),
('_timepoint', (), _M_omero._t_RTime),
('_plateAcquisition', (), _M_omero.model._t_PlateAcquisition),
('_well', (), _M_omero.model._t_Well),
('_image', (), _M_omero.model._t_Image),
('_annotationLinksSeq', (), _M_omero.model._t_WellSampleAnnotationLinksSeq),
('_annotationLinksLoaded', (), IcePy._t_bool),
('_annotationLinksCountPerOwner', (), _M_omero.sys._t_CountMap)
))
def end_indexObject(self, _r):
return _M_omero.api.IUpdate._op_indexObject.end(self, _r)
def indexObject_async(self, _cb, row, _ctx=None):
return _M_omero.api.IUpdate._op_indexObject.invokeAsync(self, (_cb, (row, ), _ctx))
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_omero.api.IUpdatePrx.ice_checkedCast(proxy, '::omero::api::IUpdate', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.api.IUpdatePrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_omero.api._t_IUpdatePrx = IcePy.defineProxy('::omero::api::IUpdate', IUpdatePrx)
_M_omero.api._t_IUpdate = IcePy.defineClass('::omero::api::IUpdate', IUpdate, (), True, None, (_M_omero.api._t_ServiceInterface,), ())
IUpdate._ice_type = _M_omero.api._t_IUpdate
IUpdate._op_saveObject = IcePy.Operation('saveObject', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, (), (((), _M_omero.model._t_IObject),), (), None, (_M_omero._t_ServerError,))
IUpdate._op_saveCollection = IcePy.Operation('saveCollection', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, (), (((), _M_omero.api._t_IObjectList),), (), None, (_M_omero._t_ServerError,))
IUpdate._op_saveAndReturnObject = IcePy.Operation('saveAndReturnObject', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, (), (((), _M_omero.model._t_IObject),), (), _M_omero.model._t_IObject, (_M_omero._t_ServerError,))
IUpdate._op_saveArray = IcePy.Operation('saveArray', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, (), (((), _M_omero.api._t_IObjectList),), (), None, (_M_omero._t_ServerError,))
IUpdate._op_saveAndReturnArray = IcePy.Operation('saveAndReturnArray', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, (), (((), _M_omero.api._t_IObjectList),), (), _M_omero.api._t_IObjectList, (_M_omero._t_ServerError,))
IUpdate._op_saveAndReturnIds = IcePy.Operation('saveAndReturnIds', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, (), (((), _M_omero.api._t_IObjectList),), (), _M_omero.sys._t_LongList, (_M_omero._t_ServerError,))
IUpdate._op_deleteObject = IcePy.Operation('deleteObject', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, (), (((), _M_omero.model._t_IObject),), (), None, (_M_omero._t_ServerError,))
IUpdate._op_indexObject = IcePy.Operation('indexObject', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, (), (((), _M_omero.model._t_IObject),), (), None, (_M_omero._t_ServerError,))
_M_omero.api.IUpdate = IUpdate
del IUpdate
def begin_setTarget(self, theTarget, _response=None, _ex=None, _sent=None, _ctx=None):
return _M_omero.model.ActionOnAction._op_setTarget.begin(self, ((theTarget, ), _response, _ex, _sent, _ctx))
def end_setTarget(self, _r):
return _M_omero.model.ActionOnAction._op_setTarget.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_omero.model.ActionOnActionPrx.ice_checkedCast(proxy, '::omero::model::ActionOnAction', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.ActionOnActionPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_omero.model._t_ActionOnActionPrx = IcePy.defineProxy('::omero::model::ActionOnAction', ActionOnActionPrx)
_M_omero.model._t_ActionOnAction = IcePy.declareClass('::omero::model::ActionOnAction')
_M_omero.model._t_ActionOnAction = IcePy.defineClass('::omero::model::ActionOnAction', ActionOnAction, (), True, _M_omero.model._t_Action, (), (('_target', (), _M_omero.model._t_Action),))
ActionOnAction._ice_type = _M_omero.model._t_ActionOnAction
ActionOnAction._op_getTarget = IcePy.Operation('getTarget', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero.model._t_Action, ())
ActionOnAction._op_setTarget = IcePy.Operation('setTarget', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), _M_omero.model._t_Action),), (), None, ())
_M_omero.model.ActionOnAction = ActionOnAction
del ActionOnAction
_M_omero.model.ActionOnActionPrx = ActionOnActionPrx
del ActionOnActionPrx
def begin_setTarget(self, theTarget, _response=None, _ex=None, _sent=None, _ctx=None):
return _M_omero.model.ActionOnDataSample._op_setTarget.begin(self, ((theTarget, ), _response, _ex, _sent, _ctx))
def end_setTarget(self, _r):
return _M_omero.model.ActionOnDataSample._op_setTarget.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_omero.model.ActionOnDataSamplePrx.ice_checkedCast(proxy, '::omero::model::ActionOnDataSample', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.ActionOnDataSamplePrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_omero.model._t_ActionOnDataSamplePrx = IcePy.defineProxy('::omero::model::ActionOnDataSample', ActionOnDataSamplePrx)
_M_omero.model._t_ActionOnDataSample = IcePy.declareClass('::omero::model::ActionOnDataSample')
_M_omero.model._t_ActionOnDataSample = IcePy.defineClass('::omero::model::ActionOnDataSample', ActionOnDataSample, (), True, _M_omero.model._t_Action, (), (('_target', (), _M_omero.model._t_DataSample),))
ActionOnDataSample._ice_type = _M_omero.model._t_ActionOnDataSample
ActionOnDataSample._op_getTarget = IcePy.Operation('getTarget', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero.model._t_DataSample, ())
ActionOnDataSample._op_setTarget = IcePy.Operation('setTarget', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), _M_omero.model._t_DataSample),), (), None, ())
_M_omero.model.ActionOnDataSample = ActionOnDataSample
del ActionOnDataSample
_M_omero.model.ActionOnDataSamplePrx = ActionOnDataSamplePrx
del ActionOnDataSamplePrx
def begin_link(self, theParent, theChild, _response=None, _ex=None, _sent=None, _ctx=None):
return _M_omero.model.GroupExperimenterMap._op_link.begin(self, ((theParent, theChild), _response, _ex, _sent, _ctx))
def end_link(self, _r):
return _M_omero.model.GroupExperimenterMap._op_link.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_omero.model.GroupExperimenterMapPrx.ice_checkedCast(proxy, '::omero::model::GroupExperimenterMap', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.GroupExperimenterMapPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_omero.model._t_GroupExperimenterMapPrx = IcePy.defineProxy('::omero::model::GroupExperimenterMap', GroupExperimenterMapPrx)
_M_omero.model._t_GroupExperimenterMap = IcePy.declareClass('::omero::model::GroupExperimenterMap')
_M_omero.model._t_GroupExperimenterMap = IcePy.defineClass('::omero::model::GroupExperimenterMap', GroupExperimenterMap, (), True, _M_omero.model._t_IObject, (), (
('_version', (), _M_omero._t_RInt),
('_parent', (), _M_omero.model._t_ExperimenterGroup),
('_child', (), _M_omero.model._t_Experimenter),
('_owner', (), _M_omero._t_RBool)
))
GroupExperimenterMap._ice_type = _M_omero.model._t_GroupExperimenterMap
GroupExperimenterMap._op_getVersion = IcePy.Operation('getVersion', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero._t_RInt, ())
GroupExperimenterMap._op_setVersion = IcePy.Operation('setVersion', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), _M_omero._t_RInt),), (), None, ())
GroupExperimenterMap._op_getParent = IcePy.Operation('getParent', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero.model._t_ExperimenterGroup, ())
GroupExperimenterMap._op_setParent = IcePy.Operation('setParent', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), _M_omero.model._t_ExperimenterGroup),), (), None, ())
return _M_omero.model.ArcPrx.ice_checkedCast(
proxy, '::omero::model::Arc', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.ArcPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
def ice_staticId():
return '::omero::model::Arc'
ice_staticId = staticmethod(ice_staticId)
_M_omero.model._t_ArcPrx = IcePy.defineProxy('::omero::model::Arc', ArcPrx)
_M_omero.model._t_Arc = IcePy.declareClass('::omero::model::Arc')
_M_omero.model._t_Arc = IcePy.defineClass(
'::omero::model::Arc', Arc, -1, (), True, False,
_M_omero.model._t_LightSource, (),
(('_type', (), _M_omero.model._t_ArcType, False, 0), ))
Arc._ice_type = _M_omero.model._t_Arc
Arc._op_getType = IcePy.Operation(
'getType', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False,
None, (), (), (), ((), _M_omero.model._t_ArcType, False, 0), ())
Arc._op_setType = IcePy.Operation(
'setType', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False,
None, (), (((), _M_omero.model._t_ArcType, False, 0), ), (), None, ())
"""
def end_getMetricsFailures(self, _r):
return _M_IceMX.MetricsAdmin._op_getMetricsFailures.end(self, _r)
@staticmethod
def checkedCast(proxy, facetOrContext=None, context=None):
return _M_IceMX.MetricsAdminPrx.ice_checkedCast(proxy, '::IceMX::MetricsAdmin', facetOrContext, context)
@staticmethod
def uncheckedCast(proxy, facet=None):
return _M_IceMX.MetricsAdminPrx.ice_uncheckedCast(proxy, facet)
@staticmethod
def ice_staticId():
return '::IceMX::MetricsAdmin'
_M_IceMX._t_MetricsAdminPrx = IcePy.defineProxy('::IceMX::MetricsAdmin', MetricsAdminPrx)
_M_IceMX.MetricsAdminPrx = MetricsAdminPrx
del MetricsAdminPrx
_M_IceMX.MetricsAdmin = Ice.createTempClass()
class MetricsAdmin(Ice.Object):
def ice_ids(self, current=None):
return ('::Ice::Object', '::IceMX::MetricsAdmin')
def ice_id(self, current=None):
return '::IceMX::MetricsAdmin'
@staticmethod
def ice_staticId():
_M_jderobot.NavdataDataPrx = Ice.createTempClass()
class NavdataDataPrx(Ice.ObjectPrx):
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_jderobot.NavdataDataPrx.ice_checkedCast(proxy, '::jderobot::NavdataData', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_jderobot.NavdataDataPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
def ice_staticId():
return '::jderobot::NavdataData'
ice_staticId = staticmethod(ice_staticId)
_M_jderobot._t_NavdataDataPrx = IcePy.defineProxy('::jderobot::NavdataData', NavdataDataPrx)
_M_jderobot._t_NavdataData = IcePy.defineClass('::jderobot::NavdataData', NavdataData, -1, (), False, False, None, (), (
('vehicle', (), IcePy._t_int, False, 0),
('state', (), IcePy._t_int, False, 0),
('batteryPercent', (), IcePy._t_float, False, 0),
('magX', (), IcePy._t_int, False, 0),
('magY', (), IcePy._t_int, False, 0),
('magZ', (), IcePy._t_int, False, 0),
('pressure', (), IcePy._t_int, False, 0),
('temp', (), IcePy._t_int, False, 0),
('windSpeed', (), IcePy._t_float, False, 0),
('windAngle', (), IcePy._t_float, False, 0),
('windCompAngle', (), IcePy._t_float, False, 0),
('rotX', (), IcePy._t_float, False, 0),
('rotY', (), IcePy._t_float, False, 0),
return _M_jderobot.SonarDataPrx.ice_checkedCast(
proxy, '::jderobot::SonarData', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_jderobot.SonarDataPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
def ice_staticId():
return '::jderobot::SonarData'
ice_staticId = staticmethod(ice_staticId)
_M_jderobot._t_SonarDataPrx = IcePy.defineProxy('::jderobot::SonarData',
SonarDataPrx)
_M_jderobot._t_SonarData = IcePy.defineClass(
'::jderobot::SonarData', SonarData, -1, (), False, False, None, (),
(('range', (), IcePy._t_float, False, 0),
('minAngle', (), IcePy._t_float, False, 0),
('maxAngle', (), IcePy._t_float, False, 0),
('minRange', (), IcePy._t_float, False, 0),
('maxRange', (), IcePy._t_float, False, 0),
('timeStamp', (), _M_jderobot._t_Time, False, 0)))
SonarData._ice_type = _M_jderobot._t_SonarData
_M_jderobot.SonarData = SonarData
del SonarData
_M_jderobot.SonarDataPrx = SonarDataPrx
return _M_omero.model.ChannelPrx.ice_checkedCast(
proxy, '::omero::model::Channel', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.ChannelPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
def ice_staticId():
return '::omero::model::Channel'
ice_staticId = staticmethod(ice_staticId)
_M_omero.model._t_ChannelPrx = IcePy.defineProxy('::omero::model::Channel',
ChannelPrx)
_M_omero.model._t_Channel = IcePy.declareClass('::omero::model::Channel')
_M_omero.model._t_Channel = IcePy.defineClass(
'::omero::model::Channel', Channel, -1, (), True, False,
_M_omero.model._t_IObject, (),
(('_version', (), _M_omero._t_RInt, False, 0),
('_statsInfo', (), _M_omero.model._t_StatsInfo, False, 0),
('_red', (), _M_omero._t_RInt, False, 0),
('_green', (), _M_omero._t_RInt, False, 0),
('_blue', (), _M_omero._t_RInt, False, 0),
('_alpha',
(), _M_omero._t_RInt, False, 0), ('_lookupTable',
(), _M_omero._t_RString, False, 0),
('_logicalChannel', (), _M_omero.model._t_LogicalChannel, False, 0),
proxy, '::omero::model::ScreenPlateLink', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.ScreenPlateLinkPrx.ice_uncheckedCast(
proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
def ice_staticId():
return '::omero::model::ScreenPlateLink'
ice_staticId = staticmethod(ice_staticId)
_M_omero.model._t_ScreenPlateLinkPrx = IcePy.defineProxy(
'::omero::model::ScreenPlateLink', ScreenPlateLinkPrx)
_M_omero.model._t_ScreenPlateLink = IcePy.declareClass(
'::omero::model::ScreenPlateLink')
_M_omero.model._t_ScreenPlateLink = IcePy.defineClass(
'::omero::model::ScreenPlateLink', ScreenPlateLink, -1, (), True,
False, _M_omero.model._t_IObject, (),
(('_version', (), _M_omero._t_RInt, False, 0),
('_parent', (), _M_omero.model._t_Screen, False, 0),
('_child', (), _M_omero.model._t_Plate, False, 0)))
ScreenPlateLink._ice_type = _M_omero.model._t_ScreenPlateLink
ScreenPlateLink._op_getVersion = IcePy.Operation(
'getVersion', Ice.OperationMode.Normal, Ice.OperationMode.Normal,
False, None, (), (), (), ((), _M_omero._t_RInt, False, 0), ())
return _M_omero.model.CorrectionPrx.ice_checkedCast(
proxy, '::omero::model::Correction', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.CorrectionPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
def ice_staticId():
return '::omero::model::Correction'
ice_staticId = staticmethod(ice_staticId)
_M_omero.model._t_CorrectionPrx = IcePy.defineProxy(
'::omero::model::Correction', CorrectionPrx)
_M_omero.model._t_Correction = IcePy.declareClass(
'::omero::model::Correction')
_M_omero.model._t_Correction = IcePy.defineClass(
'::omero::model::Correction', Correction, -1, (), True, False,
_M_omero.model._t_IObject, (),
(('_value', (), _M_omero._t_RString, False, 0), ))
Correction._ice_type = _M_omero.model._t_Correction
Correction._op_getValue = IcePy.Operation(
'getValue', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False,
None, (), (), (), ((), _M_omero._t_RString, False, 0), ())
Correction._op_setValue = IcePy.Operation(
'setValue', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False,
def userGaze(self, loc, _ctx=None):
return _M_echoes.GazeListener._op_userGaze.invoke(self, ((loc, ), _ctx))
def userVisibilityChanged(self, visible, _ctx=None):
return _M_echoes.GazeListener._op_userVisibilityChanged.invoke(self, ((visible, ), _ctx))
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_echoes.GazeListenerPrx.ice_checkedCast(proxy, '::echoes::GazeListener', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_echoes.GazeListenerPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_echoes._t_GazeListenerPrx = IcePy.defineProxy('::echoes::GazeListener', GazeListenerPrx)
_M_echoes._t_GazeListener = IcePy.defineClass('::echoes::GazeListener', GazeListener, (), True, None, (), ())
GazeListener.ice_type = _M_echoes._t_GazeListener
GazeListener._op_userGaze = IcePy.Operation('userGaze', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), _M_echoes._t_ScreenLocation),), (), None, ())
GazeListener._op_userVisibilityChanged = IcePy.Operation('userVisibilityChanged', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), IcePy._t_bool),), (), None, ())
_M_echoes.GazeListener = GazeListener
del GazeListener
_M_echoes.GazeListenerPrx = GazeListenerPrx
del GazeListenerPrx
# End of module echoes
return _M_app.Server._op_LibvlcPlayerPause.end(self, _r)
@staticmethod
def checkedCast(proxy, facetOrContext=None, context=None):
return _M_app.ServerPrx.ice_checkedCast(proxy, '::app::Server',
facetOrContext, context)
@staticmethod
def uncheckedCast(proxy, facet=None):
return _M_app.ServerPrx.ice_uncheckedCast(proxy, facet)
@staticmethod
def ice_staticId():
return '::app::Server'
_M_app._t_ServerPrx = IcePy.defineProxy('::app::Server', ServerPrx)
_M_app.ServerPrx = ServerPrx
del ServerPrx
_M_app.Server = Ice.createTempClass()
class Server(Ice.Object):
def ice_ids(self, current=None):
return ('::Ice::Object', '::app::Server')
def ice_id(self, current=None):
return '::app::Server'
@staticmethod
def ice_staticId():
def initManagement( self, NumberOfPlanets, simDuration, maxPlanetMass, centralStarMass, _ctx = None ):
return _M_MksIce.Management._op_initManagement.invoke( self, ( ( NumberOfPlanets, simDuration, maxPlanetMass, centralStarMass ), _ctx ) )
def getData( self, _ctx = None ):
return _M_MksIce.Management._op_getData.invoke( self, ( (), _ctx ) )
def checkedCast( proxy, facetOrCtx = None, _ctx = None ):
return _M_MksIce.ManagementPrx.ice_checkedCast( proxy, '::MksIce::Management', facetOrCtx, _ctx )
checkedCast = staticmethod( checkedCast )
def uncheckedCast( proxy, facet = None ):
return _M_MksIce.ManagementPrx.ice_uncheckedCast( proxy, facet )
uncheckedCast = staticmethod( uncheckedCast )
_M_MksIce._t_ManagementPrx = IcePy.defineProxy( '::MksIce::Management', ManagementPrx )
_M_MksIce._t_Management = IcePy.defineClass( '::MksIce::Management', Management, (), True, None, (), () )
Management.ice_type = _M_MksIce._t_Management
Management._op_initManagement = IcePy.Operation( 'initManagement', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), ( ( (), IcePy._t_int ), ( (), IcePy._t_int ), ( (), IcePy._t_double ), ( (), IcePy._t_double ) ), (), None, () )
Management._op_getData = IcePy.Operation( 'getData', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), IcePy._t_string, () )
_M_MksIce.Management = Management
del Management
_M_MksIce.ManagementPrx = ManagementPrx
del ManagementPrx
# End of module MksIce
def end_setType(self, _r):
return _M_omero.model.Microscope._op_setType.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_omero.model.MicroscopePrx.ice_checkedCast(proxy, '::omero::model::Microscope', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.MicroscopePrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
def ice_staticId():
return '::omero::model::Microscope'
ice_staticId = staticmethod(ice_staticId)
_M_omero.model._t_MicroscopePrx = IcePy.defineProxy('::omero::model::Microscope', MicroscopePrx)
_M_omero.model._t_Microscope = IcePy.declareClass('::omero::model::Microscope')
_M_omero.model._t_Microscope = IcePy.defineClass('::omero::model::Microscope', Microscope, -1, (), True, False, _M_omero.model._t_IObject, (), (
('_version', (), _M_omero._t_RInt, False, 0),
('_manufacturer', (), _M_omero._t_RString, False, 0),
('_model', (), _M_omero._t_RString, False, 0),
('_lotNumber', (), _M_omero._t_RString, False, 0),
('_serialNumber', (), _M_omero._t_RString, False, 0),
('_type', (), _M_omero.model._t_MicroscopeType, False, 0)
))
Microscope._ice_type = _M_omero.model._t_Microscope
Microscope._op_getVersion = IcePy.Operation('getVersion', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (), (), ((), _M_omero._t_RInt, False, 0), ())
Microscope._op_setVersion = IcePy.Operation('setVersion', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), _M_omero._t_RInt, False, 0),), (), None, ())
def begin_link(self, theParent, theChild, _response=None, _ex=None, _sent=None, _ctx=None):
return _M_omero.model.ExperimenterGroupAnnotationLink._op_link.begin(self, ((theParent, theChild), _response, _ex, _sent, _ctx))
def end_link(self, _r):
return _M_omero.model.ExperimenterGroupAnnotationLink._op_link.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_omero.model.ExperimenterGroupAnnotationLinkPrx.ice_checkedCast(proxy, '::omero::model::ExperimenterGroupAnnotationLink', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.ExperimenterGroupAnnotationLinkPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_omero.model._t_ExperimenterGroupAnnotationLinkPrx = IcePy.defineProxy('::omero::model::ExperimenterGroupAnnotationLink', ExperimenterGroupAnnotationLinkPrx)
_M_omero.model._t_ExperimenterGroupAnnotationLink = IcePy.declareClass('::omero::model::ExperimenterGroupAnnotationLink')
_M_omero.model._t_ExperimenterGroupAnnotationLink = IcePy.defineClass('::omero::model::ExperimenterGroupAnnotationLink', ExperimenterGroupAnnotationLink, (), True, _M_omero.model._t_IObject, (), (
('_version', (), _M_omero._t_RInt),
('_parent', (), _M_omero.model._t_ExperimenterGroup),
('_child', (), _M_omero.model._t_Annotation)
))
ExperimenterGroupAnnotationLink._ice_type = _M_omero.model._t_ExperimenterGroupAnnotationLink
ExperimenterGroupAnnotationLink._op_getVersion = IcePy.Operation('getVersion', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero._t_RInt, ())
ExperimenterGroupAnnotationLink._op_setVersion = IcePy.Operation('setVersion', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), _M_omero._t_RInt),), (), None, ())
ExperimenterGroupAnnotationLink._op_getParent = IcePy.Operation('getParent', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero.model._t_ExperimenterGroup, ())
ExperimenterGroupAnnotationLink._op_setParent = IcePy.Operation('setParent', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), _M_omero.model._t_ExperimenterGroup),), (), None, ())
ExperimenterGroupAnnotationLink._op_getChild = IcePy.Operation('getChild', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero.model._t_Annotation, ())
@staticmethod
def checkedCast(proxy, facetOrContext=None, context=None):
return _M_Accounts.AccountManagerPrx.ice_checkedCast(
proxy, '::Accounts::AccountManager', facetOrContext, context)
@staticmethod
def uncheckedCast(proxy, facet=None):
return _M_Accounts.AccountManagerPrx.ice_uncheckedCast(
proxy, facet)
@staticmethod
def ice_staticId():
return '::Accounts::AccountManager'
_M_Accounts._t_AccountManagerPrx = IcePy.defineProxy(
'::Accounts::AccountManager', AccountManagerPrx)
_M_Accounts.AccountManagerPrx = AccountManagerPrx
del AccountManagerPrx
_M_Accounts.AccountManager = Ice.createTempClass()
class AccountManager(Ice.Object):
def ice_ids(self, current=None):
return ('::Accounts::AccountManager', '::Ice::Object')
def ice_id(self, current=None):
return '::Accounts::AccountManager'
@staticmethod
def ice_staticId():
def begin_setValue(self, theValue, _response=None, _ex=None, _sent=None, _ctx=None):
return _M_omero.model.ActionCategory._op_setValue.begin(self, ((theValue, ), _response, _ex, _sent, _ctx))
def end_setValue(self, _r):
return _M_omero.model.ActionCategory._op_setValue.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_omero.model.ActionCategoryPrx.ice_checkedCast(proxy, '::omero::model::ActionCategory', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.ActionCategoryPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_omero.model._t_ActionCategoryPrx = IcePy.defineProxy('::omero::model::ActionCategory', ActionCategoryPrx)
_M_omero.model._t_ActionCategory = IcePy.declareClass('::omero::model::ActionCategory')
_M_omero.model._t_ActionCategory = IcePy.defineClass('::omero::model::ActionCategory', ActionCategory, (), True, _M_omero.model._t_IObject, (), (('_value', (), _M_omero._t_RString),))
ActionCategory._ice_type = _M_omero.model._t_ActionCategory
ActionCategory._op_getValue = IcePy.Operation('getValue', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero._t_RString, ())
ActionCategory._op_setValue = IcePy.Operation('setValue', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), _M_omero._t_RString),), (), None, ())
_M_omero.model.ActionCategory = ActionCategory
del ActionCategory
_M_omero.model.ActionCategoryPrx = ActionCategoryPrx
del ActionCategoryPrx
return _M_Temp.Temperature._op_getTemperature.invoke(self, ((n, ), _ctx))
def begin_getTemperature(self, n, _response=None, _ex=None, _sent=None, _ctx=None):
return _M_Temp.Temperature._op_getTemperature.begin(self, ((n, ), _response, _ex, _sent, _ctx))
def end_getTemperature(self, _r):
return _M_Temp.Temperature._op_getTemperature.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_Temp.TemperaturePrx.ice_checkedCast(proxy, '::Temp::Temperature', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_Temp.TemperaturePrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_Temp._t_TemperaturePrx = IcePy.defineProxy('::Temp::Temperature', TemperaturePrx)
_M_Temp._t_Temperature = IcePy.defineClass('::Temp::Temperature', Temperature, -1, (), True, False, None, (), ())
Temperature._ice_type = _M_Temp._t_Temperature
Temperature._op_getTemperature = IcePy.Operation('getTemperature', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_int, False, 0),), (), ((), IcePy._t_float, False, 0), ())
_M_Temp.Temperature = Temperature
del Temperature
_M_Temp.TemperaturePrx = TemperaturePrx
del TemperaturePrx
# End of module Temp
def begin_setConf(self, theConf, _response=None, _ex=None, _sent=None, _ctx=None):
return _M_omero.model.ActionSetup._op_setConf.begin(self, ((theConf, ), _response, _ex, _sent, _ctx))
def end_setConf(self, _r):
return _M_omero.model.ActionSetup._op_setConf.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_omero.model.ActionSetupPrx.ice_checkedCast(proxy, '::omero::model::ActionSetup', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.ActionSetupPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_omero.model._t_ActionSetupPrx = IcePy.defineProxy('::omero::model::ActionSetup', ActionSetupPrx)
_M_omero.model._t_ActionSetup = IcePy.declareClass('::omero::model::ActionSetup')
_M_omero.model._t_ActionSetup = IcePy.defineClass('::omero::model::ActionSetup', ActionSetup, (), True, _M_omero.model._t_IObject, (), (
('_version', (), _M_omero._t_RInt),
('_vid', (), _M_omero._t_RString),
('_label', (), _M_omero._t_RString),
('_conf', (), _M_omero._t_RString)
))
ActionSetup._ice_type = _M_omero.model._t_ActionSetup
ActionSetup._op_getVersion = IcePy.Operation('getVersion', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero._t_RInt, ())
ActionSetup._op_setVersion = IcePy.Operation('setVersion', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), _M_omero._t_RInt),), (), None, ())
ActionSetup._op_getVid = IcePy.Operation('getVid', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero._t_RString, ())
ActionSetup._op_setVid = IcePy.Operation('setVid', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), _M_omero._t_RString),), (), None, ())
"""
def end_addProxies(self, _r):
return _M_Ice.Router._op_addProxies.end(self, _r)
@staticmethod
def checkedCast(proxy, facetOrContext=None, context=None):
return _M_Ice.RouterPrx.ice_checkedCast(proxy, '::Ice::Router', facetOrContext, context)
@staticmethod
def uncheckedCast(proxy, facet=None):
return _M_Ice.RouterPrx.ice_uncheckedCast(proxy, facet)
@staticmethod
def ice_staticId():
return '::Ice::Router'
_M_Ice._t_RouterPrx = IcePy.defineProxy('::Ice::Router', RouterPrx)
_M_Ice.RouterPrx = RouterPrx
del RouterPrx
_M_Ice.Router = Ice.createTempClass()
class Router(Ice.Object):
def ice_ids(self, current=None):
return ('::Ice::Object', '::Ice::Router')
def ice_id(self, current=None):
return '::Ice::Router'
@staticmethod
def ice_staticId():
def begin_setLaneUK(self, theLaneUK, _response=None, _ex=None, _sent=None, _ctx=None):
return _M_omero.model.Lane._op_setLaneUK.begin(self, ((theLaneUK, ), _response, _ex, _sent, _ctx))
def end_setLaneUK(self, _r):
return _M_omero.model.Lane._op_setLaneUK.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_omero.model.LanePrx.ice_checkedCast(proxy, '::omero::model::Lane', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.LanePrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_omero.model._t_LanePrx = IcePy.defineProxy('::omero::model::Lane', LanePrx)
_M_omero.model._t_Lane = IcePy.declareClass('::omero::model::Lane')
_M_omero.model._t_Lane = IcePy.defineClass('::omero::model::Lane', Lane, (), True, _M_omero.model._t_Container, (), (
('_flowCell', (), _M_omero.model._t_FlowCell),
('_slot', (), _M_omero._t_RInt),
('_laneUK', (), _M_omero._t_RString)
))
Lane._ice_type = _M_omero.model._t_Lane
Lane._op_getFlowCell = IcePy.Operation('getFlowCell', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero.model._t_FlowCell, ())
Lane._op_setFlowCell = IcePy.Operation('setFlowCell', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), _M_omero.model._t_FlowCell),), (), None, ())
Lane._op_getSlot = IcePy.Operation('getSlot', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero._t_RInt, ())
Lane._op_setSlot = IcePy.Operation('setSlot', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), _M_omero._t_RInt),), (), None, ())
Lane._op_getLaneUK = IcePy.Operation('getLaneUK', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero._t_RString, ())
proxy, '::omero::model::ContrastMethod', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.ContrastMethodPrx.ice_uncheckedCast(
proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
def ice_staticId():
return '::omero::model::ContrastMethod'
ice_staticId = staticmethod(ice_staticId)
_M_omero.model._t_ContrastMethodPrx = IcePy.defineProxy(
'::omero::model::ContrastMethod', ContrastMethodPrx)
_M_omero.model._t_ContrastMethod = IcePy.declareClass(
'::omero::model::ContrastMethod')
_M_omero.model._t_ContrastMethod = IcePy.defineClass(
'::omero::model::ContrastMethod', ContrastMethod, -1, (), True, False,
_M_omero.model._t_IObject, (),
(('_value', (), _M_omero._t_RString, False, 0), ))
ContrastMethod._ice_type = _M_omero.model._t_ContrastMethod
ContrastMethod._op_getValue = IcePy.Operation(
'getValue', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False,
None, (), (), (), ((), _M_omero._t_RString, False, 0), ())
ContrastMethod._op_setValue = IcePy.Operation(
'setValue', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False,
def begin_link(self, theParent, theChild, _response=None, _ex=None, _sent=None, _ctx=None):
return _M_omero.model.ProjectAnnotationLink._op_link.begin(self, ((theParent, theChild), _response, _ex, _sent, _ctx))
def end_link(self, _r):
return _M_omero.model.ProjectAnnotationLink._op_link.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_omero.model.ProjectAnnotationLinkPrx.ice_checkedCast(proxy, '::omero::model::ProjectAnnotationLink', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.ProjectAnnotationLinkPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_omero.model._t_ProjectAnnotationLinkPrx = IcePy.defineProxy('::omero::model::ProjectAnnotationLink', ProjectAnnotationLinkPrx)
_M_omero.model._t_ProjectAnnotationLink = IcePy.declareClass('::omero::model::ProjectAnnotationLink')
_M_omero.model._t_ProjectAnnotationLink = IcePy.defineClass('::omero::model::ProjectAnnotationLink', ProjectAnnotationLink, (), True, _M_omero.model._t_IObject, (), (
('_version', (), _M_omero._t_RInt),
('_parent', (), _M_omero.model._t_Project),
('_child', (), _M_omero.model._t_Annotation)
))
ProjectAnnotationLink._ice_type = _M_omero.model._t_ProjectAnnotationLink
ProjectAnnotationLink._op_getVersion = IcePy.Operation('getVersion', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero._t_RInt, ())
ProjectAnnotationLink._op_setVersion = IcePy.Operation('setVersion', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), _M_omero._t_RInt),), (), None, ())
ProjectAnnotationLink._op_getParent = IcePy.Operation('getParent', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero.model._t_Project, ())
ProjectAnnotationLink._op_setParent = IcePy.Operation('setParent', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), _M_omero.model._t_Project),), (), None, ())
ProjectAnnotationLink._op_getChild = IcePy.Operation('getChild', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero.model._t_Annotation, ())
def end_setValue(self, _r):
return _M_omero.model.Format._op_setValue.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_omero.model.FormatPrx.ice_checkedCast(proxy, '::omero::model::Format', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.FormatPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
def ice_staticId():
return '::omero::model::Format'
ice_staticId = staticmethod(ice_staticId)
_M_omero.model._t_FormatPrx = IcePy.defineProxy('::omero::model::Format', FormatPrx)
_M_omero.model._t_Format = IcePy.declareClass('::omero::model::Format')
_M_omero.model._t_Format = IcePy.defineClass('::omero::model::Format', Format, -1, (), True, False, _M_omero.model._t_IObject, (), (('_value', (), _M_omero._t_RString, False, 0),))
Format._ice_type = _M_omero.model._t_Format
Format._op_getValue = IcePy.Operation('getValue', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (), (), ((), _M_omero._t_RString, False, 0), ())
Format._op_setValue = IcePy.Operation('setValue', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), _M_omero._t_RString, False, 0),), (), None, ())
_M_omero.model.Format = Format
del Format
_M_omero.model.FormatPrx = FormatPrx
del FormatPrx
def begin_setBitResolution(self, theBitResolution, _response=None, _ex=None, _sent=None, _ctx=None):
return _M_omero.model.QuantumDef._op_setBitResolution.begin(self, ((theBitResolution, ), _response, _ex, _sent, _ctx))
def end_setBitResolution(self, _r):
return _M_omero.model.QuantumDef._op_setBitResolution.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_omero.model.QuantumDefPrx.ice_checkedCast(proxy, '::omero::model::QuantumDef', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.QuantumDefPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_omero.model._t_QuantumDefPrx = IcePy.defineProxy('::omero::model::QuantumDef', QuantumDefPrx)
_M_omero.model._t_QuantumDef = IcePy.declareClass('::omero::model::QuantumDef')
_M_omero.model._t_QuantumDef = IcePy.defineClass('::omero::model::QuantumDef', QuantumDef, (), True, _M_omero.model._t_IObject, (), (
('_version', (), _M_omero._t_RInt),
('_cdStart', (), _M_omero._t_RInt),
('_cdEnd', (), _M_omero._t_RInt),
('_bitResolution', (), _M_omero._t_RInt)
))
QuantumDef._ice_type = _M_omero.model._t_QuantumDef
QuantumDef._op_getVersion = IcePy.Operation('getVersion', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero._t_RInt, ())
QuantumDef._op_setVersion = IcePy.Operation('setVersion', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), _M_omero._t_RInt),), (), None, ())
QuantumDef._op_getCdStart = IcePy.Operation('getCdStart', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero._t_RInt, ())
QuantumDef._op_setCdStart = IcePy.Operation('setCdStart', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), _M_omero._t_RInt),), (), None, ())
def end_setTextValue(self, _r):
return _M_omero.model.Polyline._op_setTextValue.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_omero.model.PolylinePrx.ice_checkedCast(proxy, '::omero::model::Polyline', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.PolylinePrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
def ice_staticId():
return '::omero::model::Polyline'
ice_staticId = staticmethod(ice_staticId)
_M_omero.model._t_PolylinePrx = IcePy.defineProxy('::omero::model::Polyline', PolylinePrx)
_M_omero.model._t_Polyline = IcePy.declareClass('::omero::model::Polyline')
_M_omero.model._t_Polyline = IcePy.defineClass('::omero::model::Polyline', Polyline, -1, (), True, False, _M_omero.model._t_Shape, (), (
('_points', (), _M_omero._t_RString, False, 0),
('_markerStart', (), _M_omero._t_RString, False, 0),
('_markerEnd', (), _M_omero._t_RString, False, 0),
('_textValue', (), _M_omero._t_RString, False, 0)
))
Polyline._ice_type = _M_omero.model._t_Polyline
Polyline._op_getPoints = IcePy.Operation('getPoints', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (), (), ((), _M_omero._t_RString, False, 0), ())
Polyline._op_setPoints = IcePy.Operation('setPoints', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), _M_omero._t_RString, False, 0),), (), None, ())
Polyline._op_getMarkerStart = IcePy.Operation('getMarkerStart', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (), (), ((), _M_omero._t_RString, False, 0), ())
Polyline._op_setMarkerStart = IcePy.Operation('setMarkerStart', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), _M_omero._t_RString, False, 0),), (), None, ())
def begin_link(self, theParent, theChild, _response=None, _ex=None, _sent=None, _ctx=None):
return _M_omero.model.AnnotationAnnotationLink._op_link.begin(self, ((theParent, theChild), _response, _ex, _sent, _ctx))
def end_link(self, _r):
return _M_omero.model.AnnotationAnnotationLink._op_link.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_omero.model.AnnotationAnnotationLinkPrx.ice_checkedCast(proxy, '::omero::model::AnnotationAnnotationLink', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.AnnotationAnnotationLinkPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_omero.model._t_AnnotationAnnotationLinkPrx = IcePy.defineProxy('::omero::model::AnnotationAnnotationLink', AnnotationAnnotationLinkPrx)
_M_omero.model._t_AnnotationAnnotationLink = IcePy.declareClass('::omero::model::AnnotationAnnotationLink')
_M_omero.model._t_AnnotationAnnotationLink = IcePy.defineClass('::omero::model::AnnotationAnnotationLink', AnnotationAnnotationLink, (), True, _M_omero.model._t_IObject, (), (
('_version', (), _M_omero._t_RInt),
('_parent', (), _M_omero.model._t_Annotation),
('_child', (), _M_omero.model._t_Annotation)
))
AnnotationAnnotationLink._ice_type = _M_omero.model._t_AnnotationAnnotationLink
AnnotationAnnotationLink._op_getVersion = IcePy.Operation('getVersion', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero._t_RInt, ())
AnnotationAnnotationLink._op_setVersion = IcePy.Operation('setVersion', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), _M_omero._t_RInt),), (), None, ())
AnnotationAnnotationLink._op_getParent = IcePy.Operation('getParent', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero.model._t_Annotation, ())
AnnotationAnnotationLink._op_setParent = IcePy.Operation('setParent', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), _M_omero.model._t_Annotation),), (), None, ())
AnnotationAnnotationLink._op_getChild = IcePy.Operation('getChild', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero.model._t_Annotation, ())
proxy, '::omero::model::FolderRoiLink', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.FolderRoiLinkPrx.ice_uncheckedCast(
proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
def ice_staticId():
return '::omero::model::FolderRoiLink'
ice_staticId = staticmethod(ice_staticId)
_M_omero.model._t_FolderRoiLinkPrx = IcePy.defineProxy(
'::omero::model::FolderRoiLink', FolderRoiLinkPrx)
_M_omero.model._t_FolderRoiLink = IcePy.declareClass(
'::omero::model::FolderRoiLink')
_M_omero.model._t_FolderRoiLink = IcePy.defineClass(
'::omero::model::FolderRoiLink', FolderRoiLink, -1, (), True, False,
_M_omero.model._t_IObject, (),
(('_version', (), _M_omero._t_RInt, False, 0),
('_parent', (), _M_omero.model._t_Folder, False, 0),
('_child', (), _M_omero.model._t_Roi, False, 0)))
FolderRoiLink._ice_type = _M_omero.model._t_FolderRoiLink
FolderRoiLink._op_getVersion = IcePy.Operation(
'getVersion', Ice.OperationMode.Normal, Ice.OperationMode.Normal,
False, None, (), (), (), ((), _M_omero._t_RInt, False, 0), ())
def begin_setValue(self, theValue, _response=None, _ex=None, _sent=None, _ctx=None):
return _M_omero.model.AcquisitionMode._op_setValue.begin(self, ((theValue, ), _response, _ex, _sent, _ctx))
def end_setValue(self, _r):
return _M_omero.model.AcquisitionMode._op_setValue.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_omero.model.AcquisitionModePrx.ice_checkedCast(proxy, '::omero::model::AcquisitionMode', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.AcquisitionModePrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_omero.model._t_AcquisitionModePrx = IcePy.defineProxy('::omero::model::AcquisitionMode', AcquisitionModePrx)
_M_omero.model._t_AcquisitionMode = IcePy.declareClass('::omero::model::AcquisitionMode')
_M_omero.model._t_AcquisitionMode = IcePy.defineClass('::omero::model::AcquisitionMode', AcquisitionMode, (), True, _M_omero.model._t_IObject, (), (('_value', (), _M_omero._t_RString),))
AcquisitionMode._ice_type = _M_omero.model._t_AcquisitionMode
AcquisitionMode._op_getValue = IcePy.Operation('getValue', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero._t_RString, ())
AcquisitionMode._op_setValue = IcePy.Operation('setValue', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), _M_omero._t_RString),), (), None, ())
_M_omero.model.AcquisitionMode = AcquisitionMode
del AcquisitionMode
_M_omero.model.AcquisitionModePrx = AcquisitionModePrx
del AcquisitionModePrx
@staticmethod
def checkedCast(proxy, facetOrContext=None, context=None):
return _M_IceGrid.UserAccountMapperPrx.ice_checkedCast(
proxy, '::IceGrid::UserAccountMapper', facetOrContext, context)
@staticmethod
def uncheckedCast(proxy, facet=None):
return _M_IceGrid.UserAccountMapperPrx.ice_uncheckedCast(
proxy, facet)
@staticmethod
def ice_staticId():
return '::IceGrid::UserAccountMapper'
_M_IceGrid._t_UserAccountMapperPrx = IcePy.defineProxy(
'::IceGrid::UserAccountMapper', UserAccountMapperPrx)
_M_IceGrid.UserAccountMapperPrx = UserAccountMapperPrx
del UserAccountMapperPrx
_M_IceGrid.UserAccountMapper = Ice.createTempClass()
class UserAccountMapper(Ice.Object):
def ice_ids(self, current=None):
return ('::Ice::Object', '::IceGrid::UserAccountMapper')
def ice_id(self, current=None):
return '::IceGrid::UserAccountMapper'
@staticmethod
def ice_staticId():
def begin_setRef(self, theRef, _response=None, _ex=None, _sent=None, _ctx=None):
return _M_omero.model.Thumbnail._op_setRef.begin(self, ((theRef, ), _response, _ex, _sent, _ctx))
def end_setRef(self, _r):
return _M_omero.model.Thumbnail._op_setRef.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_omero.model.ThumbnailPrx.ice_checkedCast(proxy, '::omero::model::Thumbnail', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.ThumbnailPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_omero.model._t_ThumbnailPrx = IcePy.defineProxy('::omero::model::Thumbnail', ThumbnailPrx)
_M_omero.model._t_Thumbnail = IcePy.declareClass('::omero::model::Thumbnail')
_M_omero.model._t_Thumbnail = IcePy.defineClass('::omero::model::Thumbnail', Thumbnail, (), True, _M_omero.model._t_IObject, (), (
('_version', (), _M_omero._t_RInt),
('_pixels', (), _M_omero.model._t_Pixels),
('_mimeType', (), _M_omero._t_RString),
('_sizeX', (), _M_omero._t_RInt),
('_sizeY', (), _M_omero._t_RInt),
('_ref', (), _M_omero._t_RString)
))
Thumbnail._ice_type = _M_omero.model._t_Thumbnail
Thumbnail._op_getVersion = IcePy.Operation('getVersion', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero._t_RInt, ())
Thumbnail._op_setVersion = IcePy.Operation('setVersion', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), _M_omero._t_RInt),), (), None, ())
return _M_IceStorm.TopicPrx.ice_checkedCast(
proxy, '::IceStorm::Topic', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_IceStorm.TopicPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
def ice_staticId():
return '::IceStorm::Topic'
ice_staticId = staticmethod(ice_staticId)
_M_IceStorm._t_TopicPrx = IcePy.defineProxy('::IceStorm::Topic', TopicPrx)
_M_IceStorm._t_Topic = IcePy.defineClass('::IceStorm::Topic', Topic, -1,
(), True, False, None, (), ())
Topic._ice_type = _M_IceStorm._t_Topic
Topic._op_getName = IcePy.Operation('getName',
Ice.OperationMode.Idempotent,
Ice.OperationMode.Nonmutating, False,
None, (), (), (),
((), IcePy._t_string, False, 0), ())
Topic._op_getPublisher = IcePy.Operation(
'getPublisher', Ice.OperationMode.Idempotent,
Ice.OperationMode.Nonmutating, False, None, (), (), (),
((), IcePy._t_ObjectPrx, False, 0), ())
Topic._op_getNonReplicatedPublisher = IcePy.Operation(
def begin_setBarcode(self, theBarcode, _response=None, _ex=None, _sent=None, _ctx=None):
return _M_omero.model.Chip._op_setBarcode.begin(self, ((theBarcode, ), _response, _ex, _sent, _ctx))
def end_setBarcode(self, _r):
return _M_omero.model.Chip._op_setBarcode.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_omero.model.ChipPrx.ice_checkedCast(proxy, '::omero::model::Chip', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.ChipPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_omero.model._t_ChipPrx = IcePy.defineProxy('::omero::model::Chip', ChipPrx)
_M_omero.model._t_Chip = IcePy.declareClass('::omero::model::Chip')
_M_omero.model._t_Chip = IcePy.defineClass('::omero::model::Chip', Chip, (), True, _M_omero.model._t_Device, (), (('_barcode', (), _M_omero._t_RString),))
Chip._ice_type = _M_omero.model._t_Chip
Chip._op_getBarcode = IcePy.Operation('getBarcode', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero._t_RString, ())
Chip._op_setBarcode = IcePy.Operation('setBarcode', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), _M_omero._t_RString),), (), None, ())
_M_omero.model.Chip = Chip
del Chip
_M_omero.model.ChipPrx = ChipPrx
del ChipPrx
def end_setMessage(self, _r):
return _M_omero.model.DBPatch._op_setMessage.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_omero.model.DBPatchPrx.ice_checkedCast(proxy, '::omero::model::DBPatch', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.DBPatchPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
def ice_staticId():
return '::omero::model::DBPatch'
ice_staticId = staticmethod(ice_staticId)
_M_omero.model._t_DBPatchPrx = IcePy.defineProxy('::omero::model::DBPatch', DBPatchPrx)
_M_omero.model._t_DBPatch = IcePy.declareClass('::omero::model::DBPatch')
_M_omero.model._t_DBPatch = IcePy.defineClass('::omero::model::DBPatch', DBPatch, -1, (), True, False, _M_omero.model._t_IObject, (), (
('_currentVersion', (), _M_omero._t_RString, False, 0),
('_currentPatch', (), _M_omero._t_RInt, False, 0),
('_previousVersion', (), _M_omero._t_RString, False, 0),
('_previousPatch', (), _M_omero._t_RInt, False, 0),
('_finished', (), _M_omero._t_RTime, False, 0),
('_message', (), _M_omero._t_RString, False, 0)
))
DBPatch._ice_type = _M_omero.model._t_DBPatch
DBPatch._op_getCurrentVersion = IcePy.Operation('getCurrentVersion', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (), (), ((), _M_omero._t_RString, False, 0), ())
DBPatch._op_setCurrentVersion = IcePy.Operation('setCurrentVersion', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), _M_omero._t_RString, False, 0),), (), None, ())
return IcePy.stringify(self, _M_omero.model._t_SequencerOutput)
__repr__ = __str__
_M_omero.model.SequencerOutputPrx = Ice.createTempClass()
class SequencerOutputPrx(_M_omero.model.DataSamplePrx):
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_omero.model.SequencerOutputPrx.ice_checkedCast(proxy, '::omero::model::SequencerOutput', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.SequencerOutputPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_omero.model._t_SequencerOutputPrx = IcePy.defineProxy('::omero::model::SequencerOutput', SequencerOutputPrx)
_M_omero.model._t_SequencerOutput = IcePy.declareClass('::omero::model::SequencerOutput')
_M_omero.model._t_SequencerOutput = IcePy.defineClass('::omero::model::SequencerOutput', SequencerOutput, (), True, _M_omero.model._t_DataSample, (), ())
SequencerOutput._ice_type = _M_omero.model._t_SequencerOutput
_M_omero.model.SequencerOutput = SequencerOutput
del SequencerOutput
_M_omero.model.SequencerOutputPrx = SequencerOutputPrx
del SequencerOutputPrx
# End of module omero.model
__name__ = 'omero'
return _M_Ice.Process._op_writeMessage.end(self, _r)
@staticmethod
def checkedCast(proxy, facetOrContext=None, context=None):
return _M_Ice.ProcessPrx.ice_checkedCast(proxy, '::Ice::Process',
facetOrContext, context)
@staticmethod
def uncheckedCast(proxy, facet=None):
return _M_Ice.ProcessPrx.ice_uncheckedCast(proxy, facet)
@staticmethod
def ice_staticId():
return '::Ice::Process'
_M_Ice._t_ProcessPrx = IcePy.defineProxy('::Ice::Process', ProcessPrx)
_M_Ice.ProcessPrx = ProcessPrx
del ProcessPrx
_M_Ice.Process = Ice.createTempClass()
class Process(Ice.Object):
def ice_ids(self, current=None):
return ('::Ice::Object', '::Ice::Process')
def ice_id(self, current=None):
return '::Ice::Process'
@staticmethod
def ice_staticId():
return IcePy.stringify(self, _M_FS._t_Example)
__repr__ = __str__
_M_FS.ExamplePrx = Ice.createTempClass()
class ExamplePrx(Ice.ObjectPrx):
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_FS.ExamplePrx.ice_checkedCast(proxy, '::FS::Example', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_FS.ExamplePrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_FS._t_ExamplePrx = IcePy.defineProxy('::FS::Example', ExamplePrx)
_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)
def end_checkStatus(self, _r):
return _M_Demo.Printer._op_checkStatus.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_Demo.PrinterPrx.ice_checkedCast(proxy, '::Demo::Printer',
facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_Demo.PrinterPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_Demo._t_PrinterPrx = IcePy.defineProxy('::Demo::Printer', PrinterPrx)
_M_Demo._t_Printer = IcePy.defineClass('::Demo::Printer', Printer, (),
True, None, (), ())
Printer._ice_type = _M_Demo._t_Printer
Printer._op_sendString = IcePy.Operation('sendString',
Ice.OperationMode.Normal,
Ice.OperationMode.Normal, False,
(), (((), IcePy._t_string), ), (),
None, ())
Printer._op_checkStatus = IcePy.Operation('checkStatus',
Ice.OperationMode.Normal,
Ice.OperationMode.Normal, False,
(), (), (), IcePy._t_string, ())
def begin_setSnpMarkersSetUK(self, theSnpMarkersSetUK, _response=None, _ex=None, _sent=None, _ctx=None):
return _M_omero.model.SNPMarkersSet._op_setSnpMarkersSetUK.begin(self, ((theSnpMarkersSetUK, ), _response, _ex, _sent, _ctx))
def end_setSnpMarkersSetUK(self, _r):
return _M_omero.model.SNPMarkersSet._op_setSnpMarkersSetUK.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_omero.model.SNPMarkersSetPrx.ice_checkedCast(proxy, '::omero::model::SNPMarkersSet', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.SNPMarkersSetPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_omero.model._t_SNPMarkersSetPrx = IcePy.defineProxy('::omero::model::SNPMarkersSet', SNPMarkersSetPrx)
_M_omero.model._t_SNPMarkersSet = IcePy.declareClass('::omero::model::SNPMarkersSet')
_M_omero.model._t_SNPMarkersSet = IcePy.defineClass('::omero::model::SNPMarkersSet', SNPMarkersSet, (), True, _M_omero.model._t_IObject, (), (
('_version', (), _M_omero._t_RInt),
('_label', (), _M_omero._t_RString),
('_maker', (), _M_omero._t_RString),
('_model', (), _M_omero._t_RString),
('_release', (), _M_omero._t_RString),
('_markersSetVID', (), _M_omero._t_RString),
('_snpMarkersSetUK', (), _M_omero._t_RString)
))
SNPMarkersSet._ice_type = _M_omero.model._t_SNPMarkersSet
SNPMarkersSet._op_getVersion = IcePy.Operation('getVersion', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero._t_RInt, ())
defined by this timeout, IceGrid might reap the session.
Returns:
The timeout (in seconds).'''
def end_getSessionTimeout(self, _r):
return _M_IceGrid.Registry._op_getSessionTimeout.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_IceGrid.RegistryPrx.ice_checkedCast(proxy, '::IceGrid::Registry', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_IceGrid.RegistryPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_IceGrid._t_RegistryPrx = IcePy.defineProxy('::IceGrid::Registry', RegistryPrx)
_M_IceGrid._t_Registry = IcePy.defineClass('::IceGrid::Registry', Registry, (), True, None, (), ())
Registry._ice_type = _M_IceGrid._t_Registry
Registry._op_createSession = IcePy.Operation('createSession', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), IcePy._t_string), ((), IcePy._t_string)), (), _M_IceGrid._t_SessionPrx, (_M_IceGrid._t_PermissionDeniedException,))
Registry._op_createAdminSession = IcePy.Operation('createAdminSession', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), IcePy._t_string), ((), IcePy._t_string)), (), _M_IceGrid._t_AdminSessionPrx, (_M_IceGrid._t_PermissionDeniedException,))
Registry._op_createSessionFromSecureConnection = IcePy.Operation('createSessionFromSecureConnection', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_IceGrid._t_SessionPrx, (_M_IceGrid._t_PermissionDeniedException,))
Registry._op_createAdminSessionFromSecureConnection = IcePy.Operation('createAdminSessionFromSecureConnection', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_IceGrid._t_AdminSessionPrx, (_M_IceGrid._t_PermissionDeniedException,))
Registry._op_getSessionTimeout = IcePy.Operation('getSessionTimeout', Ice.OperationMode.Idempotent, Ice.OperationMode.Nonmutating, False, (), (), (), IcePy._t_int, ())
_M_IceGrid.Registry = Registry
del Registry
_M_IceGrid.RegistryPrx = RegistryPrx
del RegistryPrx
return IcePy.stringify(self, _M_omero.model._t_CommentAnnotation)
__repr__ = __str__
_M_omero.model.CommentAnnotationPrx = Ice.createTempClass()
class CommentAnnotationPrx(_M_omero.model.TextAnnotationPrx):
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_omero.model.CommentAnnotationPrx.ice_checkedCast(proxy, '::omero::model::CommentAnnotation', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.CommentAnnotationPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_omero.model._t_CommentAnnotationPrx = IcePy.defineProxy('::omero::model::CommentAnnotation', CommentAnnotationPrx)
_M_omero.model._t_CommentAnnotation = IcePy.declareClass('::omero::model::CommentAnnotation')
_M_omero.model._t_CommentAnnotation = IcePy.defineClass('::omero::model::CommentAnnotation', CommentAnnotation, (), True, _M_omero.model._t_TextAnnotation, (), ())
CommentAnnotation._ice_type = _M_omero.model._t_CommentAnnotation
_M_omero.model.CommentAnnotation = CommentAnnotation
del CommentAnnotation
_M_omero.model.CommentAnnotationPrx = CommentAnnotationPrx
del CommentAnnotationPrx
# End of module omero.model
__name__ = 'omero'
proxy, '::omero::model::ShapeAnnotationLink', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.ShapeAnnotationLinkPrx.ice_uncheckedCast(
proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
def ice_staticId():
return '::omero::model::ShapeAnnotationLink'
ice_staticId = staticmethod(ice_staticId)
_M_omero.model._t_ShapeAnnotationLinkPrx = IcePy.defineProxy(
'::omero::model::ShapeAnnotationLink', ShapeAnnotationLinkPrx)
_M_omero.model._t_ShapeAnnotationLink = IcePy.declareClass(
'::omero::model::ShapeAnnotationLink')
_M_omero.model._t_ShapeAnnotationLink = IcePy.defineClass(
'::omero::model::ShapeAnnotationLink', ShapeAnnotationLink, -1, (),
True, False, _M_omero.model._t_IObject, (),
(('_version', (), _M_omero._t_RInt, False, 0),
('_parent', (), _M_omero.model._t_Shape, False, 0),
('_child', (), _M_omero.model._t_Annotation, False, 0)))
ShapeAnnotationLink._ice_type = _M_omero.model._t_ShapeAnnotationLink
ShapeAnnotationLink._op_getVersion = IcePy.Operation(
'getVersion', Ice.OperationMode.Normal, Ice.OperationMode.Normal,
False, None, (), (), (), ((), _M_omero._t_RInt, False, 0), ())
def end_resetEnumerations(self, _r):
return _M_omero.api.ITypes._op_resetEnumerations.end(self, _r)
def resetEnumerations_async(self, _cb, enumClass, _ctx=None):
return _M_omero.api.ITypes._op_resetEnumerations.invokeAsync(self, (_cb, (enumClass, ), _ctx))
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_omero.api.ITypesPrx.ice_checkedCast(proxy, '::omero::api::ITypes', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.api.ITypesPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_omero.api._t_ITypesPrx = IcePy.defineProxy('::omero::api::ITypes', ITypesPrx)
_M_omero.api._t_ITypes = IcePy.defineClass('::omero::api::ITypes', ITypes, (), True, None, (_M_omero.api._t_ServiceInterface,), ())
ITypes._ice_type = _M_omero.api._t_ITypes
ITypes._op_createEnumeration = IcePy.Operation('createEnumeration', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, (), (((), _M_omero.model._t_IObject),), (), _M_omero.model._t_IObject, (_M_omero._t_ServerError,))
ITypes._op_getEnumeration = IcePy.Operation('getEnumeration', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, True, (), (((), IcePy._t_string), ((), IcePy._t_string)), (), _M_omero.model._t_IObject, (_M_omero._t_ServerError,))
ITypes._op_allEnumerations = IcePy.Operation('allEnumerations', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, True, (), (((), IcePy._t_string),), (), _M_omero.api._t_IObjectList, (_M_omero._t_ServerError,))
ITypes._op_updateEnumeration = IcePy.Operation('updateEnumeration', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, (), (((), _M_omero.model._t_IObject),), (), _M_omero.model._t_IObject, (_M_omero._t_ServerError,))
ITypes._op_updateEnumerations = IcePy.Operation('updateEnumerations', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, (), (((), _M_omero.api._t_IObjectList),), (), None, (_M_omero._t_ServerError,))
ITypes._op_deleteEnumeration = IcePy.Operation('deleteEnumeration', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, (), (((), _M_omero.model._t_IObject),), (), None, (_M_omero._t_ServerError,))
ITypes._op_getEnumerationTypes = IcePy.Operation('getEnumerationTypes', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, True, (), (), (), _M_omero.api._t_StringSet, (_M_omero._t_ServerError,))
ITypes._op_getAnnotationTypes = IcePy.Operation('getAnnotationTypes', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, True, (), (), (), _M_omero.api._t_StringSet, (_M_omero._t_ServerError,))
ITypes._op_getEnumerationsWithEntries = IcePy.Operation('getEnumerationsWithEntries', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, True, (), (), (), _M_omero.api._t_IObjectListMap, (_M_omero._t_ServerError,))
ITypes._op_getOriginalEnumerations = IcePy.Operation('getOriginalEnumerations', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, (), (), (), _M_omero.api._t_IObjectList, (_M_omero._t_ServerError,))
ITypes._op_resetEnumerations = IcePy.Operation('resetEnumerations', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, (), (((), IcePy._t_string),), (), None, (_M_omero._t_ServerError,))
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.OriginalFileAnnotationLinkPrx.ice_uncheckedCast(
proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
def ice_staticId():
return '::omero::model::OriginalFileAnnotationLink'
ice_staticId = staticmethod(ice_staticId)
_M_omero.model._t_OriginalFileAnnotationLinkPrx = IcePy.defineProxy(
'::omero::model::OriginalFileAnnotationLink',
OriginalFileAnnotationLinkPrx)
_M_omero.model._t_OriginalFileAnnotationLink = IcePy.declareClass(
'::omero::model::OriginalFileAnnotationLink')
_M_omero.model._t_OriginalFileAnnotationLink = IcePy.defineClass(
'::omero::model::OriginalFileAnnotationLink',
OriginalFileAnnotationLink, -1, (), True, False,
_M_omero.model._t_IObject, (),
(('_version', (), _M_omero._t_RInt, False, 0),
('_parent', (), _M_omero.model._t_OriginalFile, False, 0),
('_child', (), _M_omero.model._t_Annotation, False, 0)))
OriginalFileAnnotationLink._ice_type = _M_omero.model._t_OriginalFileAnnotationLink
OriginalFileAnnotationLink._op_getVersion = IcePy.Operation(
def begin_setValue(self, theValue, _response=None, _ex=None, _sent=None, _ctx=None):
return _M_omero.model.JobStatus._op_setValue.begin(self, ((theValue, ), _response, _ex, _sent, _ctx))
def end_setValue(self, _r):
return _M_omero.model.JobStatus._op_setValue.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_omero.model.JobStatusPrx.ice_checkedCast(proxy, '::omero::model::JobStatus', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.JobStatusPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_omero.model._t_JobStatusPrx = IcePy.defineProxy('::omero::model::JobStatus', JobStatusPrx)
_M_omero.model._t_JobStatus = IcePy.declareClass('::omero::model::JobStatus')
_M_omero.model._t_JobStatus = IcePy.defineClass('::omero::model::JobStatus', JobStatus, (), True, _M_omero.model._t_IObject, (), (('_value', (), _M_omero._t_RString),))
JobStatus._ice_type = _M_omero.model._t_JobStatus
JobStatus._op_getValue = IcePy.Operation('getValue', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero._t_RString, ())
JobStatus._op_setValue = IcePy.Operation('setValue', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), _M_omero._t_RString),), (), None, ())
_M_omero.model.JobStatus = JobStatus
del JobStatus
_M_omero.model.JobStatusPrx = JobStatusPrx
del JobStatusPrx
return _M_omero.model.IObjectPrx.ice_checkedCast(
proxy, '::omero::model::IObject', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.IObjectPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
def ice_staticId():
return '::omero::model::IObject'
ice_staticId = staticmethod(ice_staticId)
_M_omero.model._t_IObjectPrx = IcePy.defineProxy('::omero::model::IObject',
IObjectPrx)
_M_omero.model._t_IObject = IcePy.declareClass('::omero::model::IObject')
_M_omero.model._t_IObject = IcePy.defineClass(
'::omero::model::IObject', IObject, -1, (), True, False, None, (),
(('_id', (), _M_omero._t_RLong, False, 0),
('_details', (), _M_omero.model._t_Details, False, 0),
('_loaded', (), IcePy._t_bool, False, 0)))
IObject._ice_type = _M_omero.model._t_IObject
IObject._op_getId = IcePy.Operation('getId', Ice.OperationMode.Normal,
Ice.OperationMode.Normal, False, None,
(), (), (),
((), _M_omero._t_RLong, False, 0), ())
IObject._op_setId = IcePy.Operation('setId', Ice.OperationMode.Normal,
def begin_getTeamColour(self, _response=None, _ex=None, _sent=None, _ctx=None):
return _M_WorldStateTopic.WorldState._op_getTeamColour.begin(self, ((), _response, _ex, _sent, _ctx))
def end_getTeamColour(self, _r):
return _M_WorldStateTopic.WorldState._op_getTeamColour.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_WorldStateTopic.WorldStatePrx.ice_checkedCast(proxy, '::WorldStateTopic::WorldState', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_WorldStateTopic.WorldStatePrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_WorldStateTopic._t_WorldStatePrx = IcePy.defineProxy('::WorldStateTopic::WorldState', WorldStatePrx)
_M_WorldStateTopic._t_WorldState = IcePy.defineClass('::WorldStateTopic::WorldState', WorldState, (), True, None, (), ())
WorldState._ice_type = _M_WorldStateTopic._t_WorldState
WorldState._op_getUpdateID = IcePy.Operation('getUpdateID', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), IcePy._t_long, ())
WorldState._op_getBallPosition = IcePy.Operation('getBallPosition', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_WorldStateTopic._t_Ball, ())
WorldState._op_getYellowRobot = IcePy.Operation('getYellowRobot', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_WorldStateTopic._t_Robot, ())
WorldState._op_getBlueRobot = IcePy.Operation('getBlueRobot', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_WorldStateTopic._t_Robot, ())
WorldState._op_getPitch = IcePy.Operation('getPitch', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), IcePy._t_int, ())
WorldState._op_getShootingDirection = IcePy.Operation('getShootingDirection', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), IcePy._t_int, ())
WorldState._op_getTeamColour = IcePy.Operation('getTeamColour', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), IcePy._t_int, ())
_M_WorldStateTopic.WorldState = WorldState
del WorldState
return _M_M.I._op_guardarDB.end(self, _r)
@staticmethod
def checkedCast(proxy, facetOrContext=None, context=None):
return _M_M.IPrx.ice_checkedCast(proxy, '::M::I', facetOrContext,
context)
@staticmethod
def uncheckedCast(proxy, facet=None):
return _M_M.IPrx.ice_uncheckedCast(proxy, facet)
@staticmethod
def ice_staticId():
return '::M::I'
_M_M._t_IPrx = IcePy.defineProxy('::M::I', IPrx)
_M_M.IPrx = IPrx
del IPrx
_M_M.I = Ice.createTempClass()
class I(Ice.Object):
def ice_ids(self, current=None):
return ('::Ice::Object', '::M::I')
def ice_id(self, current=None):
return '::M::I'
@staticmethod
def ice_staticId():
def begin_setGlobalMax(self, theGlobalMax, _response=None, _ex=None, _sent=None, _ctx=None):
return _M_omero.model.StatsInfo._op_setGlobalMax.begin(self, ((theGlobalMax, ), _response, _ex, _sent, _ctx))
def end_setGlobalMax(self, _r):
return _M_omero.model.StatsInfo._op_setGlobalMax.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_omero.model.StatsInfoPrx.ice_checkedCast(proxy, '::omero::model::StatsInfo', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.StatsInfoPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_omero.model._t_StatsInfoPrx = IcePy.defineProxy('::omero::model::StatsInfo', StatsInfoPrx)
_M_omero.model._t_StatsInfo = IcePy.declareClass('::omero::model::StatsInfo')
_M_omero.model._t_StatsInfo = IcePy.defineClass('::omero::model::StatsInfo', StatsInfo, (), True, _M_omero.model._t_IObject, (), (
('_version', (), _M_omero._t_RInt),
('_globalMin', (), _M_omero._t_RDouble),
('_globalMax', (), _M_omero._t_RDouble)
))
StatsInfo._ice_type = _M_omero.model._t_StatsInfo
StatsInfo._op_getVersion = IcePy.Operation('getVersion', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero._t_RInt, ())
StatsInfo._op_setVersion = IcePy.Operation('setVersion', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), _M_omero._t_RInt),), (), None, ())
StatsInfo._op_getGlobalMin = IcePy.Operation('getGlobalMin', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero._t_RDouble, ())
StatsInfo._op_setGlobalMin = IcePy.Operation('setGlobalMin', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), _M_omero._t_RDouble),), (), None, ())
StatsInfo._op_getGlobalMax = IcePy.Operation('getGlobalMax', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero._t_RDouble, ())
def end_setL(self, _r):
return _M_jderobot.Motors._op_setL.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_jderobot.MotorsPrx.ice_checkedCast(proxy, '::jderobot::Motors', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_jderobot.MotorsPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
def ice_staticId():
return '::jderobot::Motors'
ice_staticId = staticmethod(ice_staticId)
_M_jderobot._t_MotorsPrx = IcePy.defineProxy('::jderobot::Motors', MotorsPrx)
_M_jderobot._t_Motors = IcePy.defineClass('::jderobot::Motors', Motors, -1, (), True, False, None, (), ())
Motors._ice_type = _M_jderobot._t_Motors
Motors._op_getV = IcePy.Operation('getV', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (), (), ((), IcePy._t_float, False, 0), ())
Motors._op_setV = IcePy.Operation('setV', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_float, False, 0),), (), ((), IcePy._t_int, False, 0), ())
Motors._op_getW = IcePy.Operation('getW', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (), (), ((), IcePy._t_float, False, 0), ())
Motors._op_setW = IcePy.Operation('setW', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_float, False, 0),), (), ((), IcePy._t_int, False, 0), ())
Motors._op_getL = IcePy.Operation('getL', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (), (), ((), IcePy._t_float, False, 0), ())
Motors._op_setL = IcePy.Operation('setL', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_float, False, 0),), (), ((), IcePy._t_int, False, 0), ())
_M_jderobot.Motors = Motors
del Motors
_M_jderobot.MotorsPrx = MotorsPrx
def begin_setMicrobeamManipulation(self, theMicrobeamManipulation, _response=None, _ex=None, _sent=None, _ctx=None):
return _M_omero.model.LightSettings._op_setMicrobeamManipulation.begin(self, ((theMicrobeamManipulation, ), _response, _ex, _sent, _ctx))
def end_setMicrobeamManipulation(self, _r):
return _M_omero.model.LightSettings._op_setMicrobeamManipulation.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_omero.model.LightSettingsPrx.ice_checkedCast(proxy, '::omero::model::LightSettings', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.LightSettingsPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_omero.model._t_LightSettingsPrx = IcePy.defineProxy('::omero::model::LightSettings', LightSettingsPrx)
_M_omero.model._t_LightSettings = IcePy.declareClass('::omero::model::LightSettings')
_M_omero.model._t_LightSettings = IcePy.defineClass('::omero::model::LightSettings', LightSettings, (), True, _M_omero.model._t_IObject, (), (
('_version', (), _M_omero._t_RInt),
('_attenuation', (), _M_omero._t_RDouble),
('_wavelength', (), _M_omero._t_RInt),
('_lightSource', (), _M_omero.model._t_LightSource),
('_microbeamManipulation', (), _M_omero.model._t_MicrobeamManipulation)
))
LightSettings._ice_type = _M_omero.model._t_LightSettings
LightSettings._op_getVersion = IcePy.Operation('getVersion', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero._t_RInt, ())
LightSettings._op_setVersion = IcePy.Operation('setVersion', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), _M_omero._t_RInt),), (), None, ())
LightSettings._op_getAttenuation = IcePy.Operation('getAttenuation', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero._t_RDouble, ())
def end_getPeriod(self, _r):
return _M_Account.Investment._op_getPeriod.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_Account.InvestmentPrx.ice_checkedCast(proxy, '::Account::Investment', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_Account.InvestmentPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
def ice_staticId():
return '::Account::Investment'
ice_staticId = staticmethod(ice_staticId)
_M_Account._t_InvestmentPrx = IcePy.defineProxy('::Account::Investment', InvestmentPrx)
_M_Account._t_Investment = IcePy.defineClass('::Account::Investment', Investment, -1, (), True, False, None, (), (
('rate', (), IcePy._t_float, False, 0),
('balance', (), IcePy._t_int, False, 0),
('period', (), IcePy._t_int, False, 0)
))
Investment._ice_type = _M_Account._t_Investment
Investment._op_getRate = IcePy.Operation('getRate', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (), (), ((), IcePy._t_float, False, 0), ())
Investment._op_getBalance = IcePy.Operation('getBalance', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (), (), ((), IcePy._t_int, False, 0), ())
Investment._op_getPeriod = IcePy.Operation('getPeriod', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (), (), ((), IcePy._t_int, False, 0), ())
_M_Account.Investment = Investment
del Investment
def begin_setLastUpdate(self, theLastUpdate, _response=None, _ex=None, _sent=None, _ctx=None):
return _M_omero.model.Individual._op_setLastUpdate.begin(self, ((theLastUpdate, ), _response, _ex, _sent, _ctx))
def end_setLastUpdate(self, _r):
return _M_omero.model.Individual._op_setLastUpdate.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_omero.model.IndividualPrx.ice_checkedCast(proxy, '::omero::model::Individual', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.IndividualPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_omero.model._t_IndividualPrx = IcePy.defineProxy('::omero::model::Individual', IndividualPrx)
_M_omero.model._t_Individual = IcePy.defineClass('::omero::model::Individual', Individual, (), True, _M_omero.model._t_IObject, (), (
('_version', (), _M_omero._t_RInt),
('_vid', (), _M_omero._t_RString),
('_gender', (), _M_omero.model._t_Gender),
('_father', (), _M_omero.model._t_Individual),
('_fatherTrusted', (), _M_omero._t_RBool),
('_mother', (), _M_omero.model._t_Individual),
('_motherTrusted', (), _M_omero._t_RBool),
('_action', (), _M_omero.model._t_Action),
('_lastUpdate', (), _M_omero.model._t_ActionOnAction)
))
Individual._ice_type = _M_omero.model._t_Individual
Individual._op_getVersion = IcePy.Operation('getVersion', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_omero._t_RInt, ())
registry.
Returns:
The proxy of the query object.'''
def end_getLocalQuery(self, _r):
return _M_IceGrid.Locator._op_getLocalQuery.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_IceGrid.LocatorPrx.ice_checkedCast(proxy, '::IceGrid::Locator', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_IceGrid.LocatorPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_IceGrid._t_LocatorPrx = IcePy.defineProxy('::IceGrid::Locator', LocatorPrx)
_M_IceGrid._t_Locator = IcePy.defineClass('::IceGrid::Locator', Locator, (), True, None, (_M_Ice._t_Locator,), ())
Locator._ice_type = _M_IceGrid._t_Locator
Locator._op_getLocalRegistry = IcePy.Operation('getLocalRegistry', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, False, (), (), (), _M_IceGrid._t_RegistryPrx, ())
Locator._op_getLocalQuery = IcePy.Operation('getLocalQuery', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, False, (), (), (), _M_IceGrid._t_QueryPrx, ())
_M_IceGrid.Locator = Locator
del Locator
_M_IceGrid.LocatorPrx = LocatorPrx
del LocatorPrx
# End of module IceGrid
def begin_setDescription(self, theDescription, _response=None, _ex=None, _sent=None, _ctx=None):
return _M_omero.model.Reagent._op_setDescription.begin(self, ((theDescription, ), _response, _ex, _sent, _ctx))
def end_setDescription(self, _r):
return _M_omero.model.Reagent._op_setDescription.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_omero.model.ReagentPrx.ice_checkedCast(proxy, '::omero::model::Reagent', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.ReagentPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
_M_omero.model._t_ReagentPrx = IcePy.defineProxy('::omero::model::Reagent', ReagentPrx)
_M_omero.model._t_Reagent = IcePy.declareClass('::omero::model::Reagent')
_M_omero.model._t_Reagent = IcePy.defineClass('::omero::model::Reagent', Reagent, (), True, _M_omero.model._t_IObject, (), (
('_version', (), _M_omero._t_RInt),
('_name', (), _M_omero._t_RString),
('_reagentIdentifier', (), _M_omero._t_RString),
('_screen', (), _M_omero.model._t_Screen),
('_wellLinksSeq', (), _M_omero.model._t_ReagentWellLinksSeq),
('_wellLinksLoaded', (), IcePy._t_bool),
('_wellLinksCountPerOwner', (), _M_omero.sys._t_CountMap),
('_annotationLinksSeq', (), _M_omero.model._t_ReagentAnnotationLinksSeq),
('_annotationLinksLoaded', (), IcePy._t_bool),
('_annotationLinksCountPerOwner', (), _M_omero.sys._t_CountMap),
('_description', (), _M_omero._t_RString)
def end_link(self, _r):
return _M_omero.model.DatasetImageLink._op_link.end(self, _r)
def checkedCast(proxy, facetOrCtx=None, _ctx=None):
return _M_omero.model.DatasetImageLinkPrx.ice_checkedCast(proxy, '::omero::model::DatasetImageLink', facetOrCtx, _ctx)
checkedCast = staticmethod(checkedCast)
def uncheckedCast(proxy, facet=None):
return _M_omero.model.DatasetImageLinkPrx.ice_uncheckedCast(proxy, facet)
uncheckedCast = staticmethod(uncheckedCast)
def ice_staticId():
return '::omero::model::DatasetImageLink'
ice_staticId = staticmethod(ice_staticId)
_M_omero.model._t_DatasetImageLinkPrx = IcePy.defineProxy('::omero::model::DatasetImageLink', DatasetImageLinkPrx)
_M_omero.model._t_DatasetImageLink = IcePy.declareClass('::omero::model::DatasetImageLink')
_M_omero.model._t_DatasetImageLink = IcePy.defineClass('::omero::model::DatasetImageLink', DatasetImageLink, -1, (), True, False, _M_omero.model._t_IObject, (), (
('_version', (), _M_omero._t_RInt, False, 0),
('_parent', (), _M_omero.model._t_Dataset, False, 0),
('_child', (), _M_omero.model._t_Image, False, 0)
))
DatasetImageLink._ice_type = _M_omero.model._t_DatasetImageLink
DatasetImageLink._op_getVersion = IcePy.Operation('getVersion', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (), (), ((), _M_omero._t_RInt, False, 0), ())
DatasetImageLink._op_setVersion = IcePy.Operation('setVersion', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), _M_omero._t_RInt, False, 0),), (), None, ())
DatasetImageLink._op_getParent = IcePy.Operation('getParent', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (), (), ((), _M_omero.model._t_Dataset, False, 0), ())
DatasetImageLink._op_setParent = IcePy.Operation('setParent', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), _M_omero.model._t_Dataset, False, 0),), (), None, ())
DatasetImageLink._op_getChild = IcePy.Operation('getChild', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (), (), ((), _M_omero.model._t_Image, False, 0), ())