# Generated from file `MP3Manager.ice'
#
# Warning: do not edit this file.
#
# </auto-generated>
#
from sys import version_info as _version_info_
import Ice, IcePy
# Start of module AppServer
_M_AppServer = Ice.openModule('AppServer')
__name__ = 'AppServer'
if 'Track' not in _M_AppServer.__dict__:
_M_AppServer.Track = Ice.createTempClass()
class Track(Ice.Object):
def __init__(self, id='', title='', artist='', album='', path=''):
self.id = id
self.title = title
self.artist = artist
self.album = album
self.path = path
def ice_ids(self, current=None):
return ('::AppServer::Track', '::Ice::Object')
def ice_id(self, current=None):
return '::AppServer::Track'
#
# Generated from file `WorldState.ice'
#
# Warning: do not edit this file.
#
# </auto-generated>
#
import Ice, IcePy, __builtin__
# Start of module WorldStateTopic
_M_WorldStateTopic = Ice.openModule('WorldStateTopic')
__name__ = 'WorldStateTopic'
if not _M_WorldStateTopic.__dict__.has_key('Position'):
_M_WorldStateTopic.Position = Ice.createTempClass()
class Position(object):
def __init__(self, x=0.0, y=0.0):
self.x = x
self.y = y
def __hash__(self):
_h = 0
_h = 5 * _h + __builtin__.hash(self.x)
_h = 5 * _h + __builtin__.hash(self.y)
return _h % 0x7fffffff
def __lt__(self, other):
if isinstance(other, _M_WorldStateTopic.Position):
return self.x < other.x or self.y < other.y
elif other == None:
# </auto-generated>
#
from sys import version_info as _version_info_
import Ice, IcePy
import Ice.LoggerF_ice
import Ice.BuiltinSequences_ice
# Included module Ice
_M_Ice = Ice.openModule('Ice')
# Start of module Ice
__name__ = 'Ice'
if 'Plugin' not in _M_Ice.__dict__:
_M_Ice.Plugin = Ice.createTempClass()
class Plugin(object):
"""
A communicator plug-in. A plug-in generally adds a feature to a
communicator, such as support for a protocol.
The communicator loads its plug-ins in two stages: the first stage
creates the plug-ins, and the second stage invokes Plugin#initialize on
each one.
"""
def __init__(self):
if Ice.getType(self) == _M_Ice.Plugin:
raise RuntimeError('Ice.Plugin is an abstract class')
def initialize(self):
"""
Perform any necessary initialization steps.
# </auto-generated>
#
from sys import version_info as _version_info_
import Ice, IcePy
# Start of module PetFoodSensors
_M_PetFoodSensors = Ice.openModule('PetFoodSensors')
__name__ = 'PetFoodSensors'
_M_PetFoodSensors._t_SensorControl = IcePy.defineValue(
'::PetFoodSensors::SensorControl', Ice.Value, -1, (), False, True, None,
())
if 'SensorControlPrx' not in _M_PetFoodSensors.__dict__:
_M_PetFoodSensors.SensorControlPrx = Ice.createTempClass()
class SensorControlPrx(Ice.ObjectPrx):
def motorTime(self, time, context=None):
return _M_PetFoodSensors.SensorControl._op_motorTime.invoke(
self, ((time, ), context))
def motorTimeAsync(self, time, context=None):
return _M_PetFoodSensors.SensorControl._op_motorTime.invokeAsync(
self, ((time, ), context))
def begin_motorTime(self,
time,
_response=None,
_ex=None,
_sent=None,
# Start of module omero
__name__ = 'omero'
# Start of module omero.model
__name__ = 'omero.model'
if not _M_omero.model.__dict__.has_key('Pixels'):
_M_omero.model._t_Pixels = IcePy.declareClass('::omero::model::Pixels')
_M_omero.model._t_PixelsPrx = IcePy.declareProxy('::omero::model::Pixels')
if not _M_omero.model.__dict__.has_key('Details'):
_M_omero.model._t_Details = IcePy.declareClass('::omero::model::Details')
_M_omero.model._t_DetailsPrx = IcePy.declareProxy('::omero::model::Details')
if not _M_omero.model.__dict__.has_key('Thumbnail'):
_M_omero.model.Thumbnail = Ice.createTempClass()
class Thumbnail(_M_omero.model.IObject):
def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _pixels=None, _mimeType=None, _sizeX=None, _sizeY=None, _ref=None):
if __builtin__.type(self) == _M_omero.model.Thumbnail:
raise RuntimeError('omero.model.Thumbnail is an abstract class')
_M_omero.model.IObject.__init__(self, _id, _details, _loaded)
self._version = _version
self._pixels = _pixels
self._mimeType = _mimeType
self._sizeX = _sizeX
self._sizeY = _sizeY
self._ref = _ref
def ice_ids(self, current=None):
return ('::Ice::Object', '::omero::model::IObject', '::omero::model::Thumbnail')
# Generated from file `meta-server.ice'
#
# Warning: do not edit this file.
#
# </auto-generated>
#
from sys import version_info as _version_info_
import Ice, IcePy
# Start of module MetaServer
_M_MetaServer = Ice.openModule('MetaServer')
__name__ = 'MetaServer'
if 'Song' not in _M_MetaServer.__dict__:
_M_MetaServer.Song = Ice.createTempClass()
class Song(object):
def __init__(self, name='', author='', album='', path=''):
self.name = name
self.author = author
self.album = album
self.path = path
def __hash__(self):
_h = 0
_h = 5 * _h + Ice.getHash(self.name)
_h = 5 * _h + Ice.getHash(self.author)
_h = 5 * _h + Ice.getHash(self.album)
_h = 5 * _h + Ice.getHash(self.path)
return _h % 0x7fffffff
__name__ = 'omero.model'
if not _M_omero.model.__dict__.has_key('DataSampleStatus'):
_M_omero.model._t_DataSampleStatus = IcePy.declareClass('::omero::model::DataSampleStatus')
_M_omero.model._t_DataSampleStatusPrx = IcePy.declareProxy('::omero::model::DataSampleStatus')
if not _M_omero.model.__dict__.has_key('Action'):
_M_omero.model._t_Action = IcePy.declareClass('::omero::model::Action')
_M_omero.model._t_ActionPrx = IcePy.declareProxy('::omero::model::Action')
if not _M_omero.model.__dict__.has_key('Details'):
_M_omero.model._t_Details = IcePy.declareClass('::omero::model::Details')
_M_omero.model._t_DetailsPrx = IcePy.declareProxy('::omero::model::Details')
if not _M_omero.model.__dict__.has_key('SequencerOutput'):
_M_omero.model.SequencerOutput = Ice.createTempClass()
class SequencerOutput(_M_omero.model.DataSample):
def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _vid=None, _label=None, _creationDate=None, _status=None, _action=None):
if __builtin__.type(self) == _M_omero.model.SequencerOutput:
raise RuntimeError('omero.model.SequencerOutput is an abstract class')
_M_omero.model.DataSample.__init__(self, _id, _details, _loaded, _version, _vid, _label, _creationDate, _status, _action)
def ice_ids(self, current=None):
return ('::Ice::Object', '::omero::model::DataSample', '::omero::model::IObject', '::omero::model::SequencerOutput')
def ice_id(self, current=None):
return '::omero::model::SequencerOutput'
def ice_staticId():
return '::omero::model::SequencerOutput'
ice_staticId = staticmethod(ice_staticId)
if not _M_omero.model.__dict__.has_key('Annotation'):
_M_omero.model._t_Annotation = IcePy.declareClass('::omero::model::Annotation')
_M_omero.model._t_AnnotationPrx = IcePy.declareProxy('::omero::model::Annotation')
if not _M_omero.model.__dict__.has_key('Details'):
_M_omero.model._t_Details = IcePy.declareClass('::omero::model::Details')
_M_omero.model._t_DetailsPrx = IcePy.declareProxy('::omero::model::Details')
if not _M_omero.model.__dict__.has_key('_t_WellSampleAnnotationLinksSeq'):
_M_omero.model._t_WellSampleAnnotationLinksSeq = IcePy.defineSequence('::omero::model::WellSampleAnnotationLinksSeq', (), _M_omero.model._t_WellSampleAnnotationLink)
if not _M_omero.model.__dict__.has_key('_t_WellSampleLinkedAnnotationSeq'):
_M_omero.model._t_WellSampleLinkedAnnotationSeq = IcePy.defineSequence('::omero::model::WellSampleLinkedAnnotationSeq', (), _M_omero.model._t_Annotation)
if not _M_omero.model.__dict__.has_key('WellSample'):
_M_omero.model.WellSample = Ice.createTempClass()
class WellSample(_M_omero.model.IObject):
def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _posX=None, _posY=None, _timepoint=None, _plateAcquisition=None, _well=None, _image=None, _annotationLinksSeq=None, _annotationLinksLoaded=False, _annotationLinksCountPerOwner=None):
if __builtin__.type(self) == _M_omero.model.WellSample:
raise RuntimeError('omero.model.WellSample is an abstract class')
_M_omero.model.IObject.__init__(self, _id, _details, _loaded)
self._version = _version
self._posX = _posX
self._posY = _posY
self._timepoint = _timepoint
self._plateAcquisition = _plateAcquisition
self._well = _well
self._image = _image
self._annotationLinksSeq = _annotationLinksSeq
self._annotationLinksLoaded = _annotationLinksLoaded
self._annotationLinksCountPerOwner = _annotationLinksCountPerOwner
# Included module omero.api
_M_omero.api = Ice.openModule('omero.api')
# Start of module omero
__name__ = 'omero'
# Start of module omero.model
__name__ = 'omero.model'
if not _M_omero.model.__dict__.has_key('Details'):
_M_omero.model._t_Details = IcePy.declareClass('::omero::model::Details')
_M_omero.model._t_DetailsPrx = IcePy.declareProxy('::omero::model::Details')
if not _M_omero.model.__dict__.has_key('Chip'):
_M_omero.model.Chip = Ice.createTempClass()
class Chip(_M_omero.model.Device):
def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _vid=None, _label=None, _maker=None, _model=None, _release=None, _barcode=None):
if __builtin__.type(self) == _M_omero.model.Chip:
raise RuntimeError('omero.model.Chip is an abstract class')
_M_omero.model.Device.__init__(self, _id, _details, _loaded, _version, _vid, _label, _maker, _model, _release)
self._barcode = _barcode
def ice_ids(self, current=None):
return ('::Ice::Object', '::omero::model::Chip', '::omero::model::Device', '::omero::model::IObject')
def ice_id(self, current=None):
return '::omero::model::Chip'
def ice_staticId():
return '::omero::model::Chip'
__name__ = 'omero.model'
if not _M_omero.model.__dict__.has_key('ExperimenterGroup'):
_M_omero.model._t_ExperimenterGroup = IcePy.declareClass('::omero::model::ExperimenterGroup')
_M_omero.model._t_ExperimenterGroupPrx = IcePy.declareProxy('::omero::model::ExperimenterGroup')
if not _M_omero.model.__dict__.has_key('Annotation'):
_M_omero.model._t_Annotation = IcePy.declareClass('::omero::model::Annotation')
_M_omero.model._t_AnnotationPrx = IcePy.declareProxy('::omero::model::Annotation')
if not _M_omero.model.__dict__.has_key('Details'):
_M_omero.model._t_Details = IcePy.declareClass('::omero::model::Details')
_M_omero.model._t_DetailsPrx = IcePy.declareProxy('::omero::model::Details')
if not _M_omero.model.__dict__.has_key('ExperimenterGroupAnnotationLink'):
_M_omero.model.ExperimenterGroupAnnotationLink = Ice.createTempClass()
class ExperimenterGroupAnnotationLink(_M_omero.model.IObject):
def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _parent=None, _child=None):
if __builtin__.type(self) == _M_omero.model.ExperimenterGroupAnnotationLink:
raise RuntimeError('omero.model.ExperimenterGroupAnnotationLink is an abstract class')
_M_omero.model.IObject.__init__(self, _id, _details, _loaded)
self._version = _version
self._parent = _parent
self._child = _child
def ice_ids(self, current=None):
return ('::Ice::Object', '::omero::model::ExperimenterGroupAnnotationLink', '::omero::model::IObject')
def ice_id(self, current=None):
return '::omero::model::ExperimenterGroupAnnotationLink'
_M_omero.model._t_DevicePrx = IcePy.declareProxy('::omero::model::Device')
if not _M_omero.model.__dict__.has_key('ActionCategory'):
_M_omero.model._t_ActionCategory = IcePy.declareClass('::omero::model::ActionCategory')
_M_omero.model._t_ActionCategoryPrx = IcePy.declareProxy('::omero::model::ActionCategory')
if not _M_omero.model.__dict__.has_key('Study'):
_M_omero.model._t_Study = IcePy.declareClass('::omero::model::Study')
_M_omero.model._t_StudyPrx = IcePy.declareProxy('::omero::model::Study')
if not _M_omero.model.__dict__.has_key('Details'):
_M_omero.model._t_Details = IcePy.declareClass('::omero::model::Details')
_M_omero.model._t_DetailsPrx = IcePy.declareProxy('::omero::model::Details')
if not _M_omero.model.__dict__.has_key('ActionOnDataSample'):
_M_omero.model.ActionOnDataSample = Ice.createTempClass()
class ActionOnDataSample(_M_omero.model.Action):
def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _vid=None, _beginTime=None, _endTime=None, _setup=None, _device=None, _actionCategory=None, _operator=None, _context=None, _description=None, _target=None):
if __builtin__.type(self) == _M_omero.model.ActionOnDataSample:
raise RuntimeError('omero.model.ActionOnDataSample is an abstract class')
_M_omero.model.Action.__init__(self, _id, _details, _loaded, _version, _vid, _beginTime, _endTime, _setup, _device, _actionCategory, _operator, _context, _description)
self._target = _target
def ice_ids(self, current=None):
return ('::Ice::Object', '::omero::model::Action', '::omero::model::ActionOnDataSample', '::omero::model::IObject')
def ice_id(self, current=None):
return '::omero::model::ActionOnDataSample'
def ice_staticId():
return '::omero::model::ActionOnDataSample'
# Warning: do not edit this file.
#
# </auto-generated>
import Ice, IcePy, __builtin__
import Ice_LoggerF_ice
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('Plugin'):
_M_Ice.Plugin = Ice.createTempClass()
class Plugin(object):
'''A communicator plug-in. A plug-in generally adds a feature to a
communicator, such as support for a protocol.
The communicator loads its plug-ins in two stages: the first stage
creates the plug-ins, and the second stage invokes Plugin.initialize on
each one.'''
def __init__(self):
if __builtin__.type(self) == _M_Ice.Plugin:
raise RuntimeError('Ice.Plugin is an abstract class')
def initialize(self):
'''Perform any necessary initialization steps.'''
pass
import Ice, IcePy, __builtin__
import Ice_BuiltinSequences_ice
import Ice_EndpointF_ice
# Included module Ice
_M_Ice = Ice.openModule("Ice")
# Start of module Ice
__name__ = "Ice"
_M_Ice.TCPEndpointType = 1
_M_Ice.UDPEndpointType = 3
if not _M_Ice.__dict__.has_key("EndpointInfo"):
_M_Ice.EndpointInfo = Ice.createTempClass()
class EndpointInfo(object):
"""Base class providing access to the endpoint details."""
def __init__(self, timeout=0, compress=False):
if __builtin__.type(self) == _M_Ice.EndpointInfo:
raise RuntimeError("Ice.EndpointInfo is an abstract class")
self.timeout = timeout
self.compress = compress
def type(self):
"""Returns the type of the endpoint."""
pass
def datagram(self):
#
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():
return '::MediaFile::FileTransfer'
ice_staticId = staticmethod(ice_staticId)
__name__ = 'omero.model'
if not _M_omero.model.__dict__.has_key('ExperimenterGroup'):
_M_omero.model._t_ExperimenterGroup = IcePy.declareClass('::omero::model::ExperimenterGroup')
_M_omero.model._t_ExperimenterGroupPrx = IcePy.declareProxy('::omero::model::ExperimenterGroup')
if not _M_omero.model.__dict__.has_key('Experimenter'):
_M_omero.model._t_Experimenter = IcePy.declareClass('::omero::model::Experimenter')
_M_omero.model._t_ExperimenterPrx = IcePy.declareProxy('::omero::model::Experimenter')
if not _M_omero.model.__dict__.has_key('Details'):
_M_omero.model._t_Details = IcePy.declareClass('::omero::model::Details')
_M_omero.model._t_DetailsPrx = IcePy.declareProxy('::omero::model::Details')
if not _M_omero.model.__dict__.has_key('GroupExperimenterMap'):
_M_omero.model.GroupExperimenterMap = Ice.createTempClass()
class GroupExperimenterMap(_M_omero.model.IObject):
def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _parent=None, _child=None, _owner=None):
if __builtin__.type(self) == _M_omero.model.GroupExperimenterMap:
raise RuntimeError('omero.model.GroupExperimenterMap is an abstract class')
_M_omero.model.IObject.__init__(self, _id, _details, _loaded)
self._version = _version
self._parent = _parent
self._child = _child
self._owner = _owner
def ice_ids(self, current=None):
return ('::Ice::Object', '::omero::model::GroupExperimenterMap', '::omero::model::IObject')
def ice_id(self, current=None):
return '::omero::model::GroupExperimenterMap'
__name__ = 'omero.model'
if not _M_omero.model.__dict__.has_key('Project'):
_M_omero.model._t_Project = IcePy.declareClass('::omero::model::Project')
_M_omero.model._t_ProjectPrx = IcePy.declareProxy('::omero::model::Project')
if not _M_omero.model.__dict__.has_key('Annotation'):
_M_omero.model._t_Annotation = IcePy.declareClass('::omero::model::Annotation')
_M_omero.model._t_AnnotationPrx = IcePy.declareProxy('::omero::model::Annotation')
if not _M_omero.model.__dict__.has_key('Details'):
_M_omero.model._t_Details = IcePy.declareClass('::omero::model::Details')
_M_omero.model._t_DetailsPrx = IcePy.declareProxy('::omero::model::Details')
if not _M_omero.model.__dict__.has_key('ProjectAnnotationLink'):
_M_omero.model.ProjectAnnotationLink = Ice.createTempClass()
class ProjectAnnotationLink(_M_omero.model.IObject):
def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _parent=None, _child=None):
if __builtin__.type(self) == _M_omero.model.ProjectAnnotationLink:
raise RuntimeError('omero.model.ProjectAnnotationLink is an abstract class')
_M_omero.model.IObject.__init__(self, _id, _details, _loaded)
self._version = _version
self._parent = _parent
self._child = _child
def ice_ids(self, current=None):
return ('::Ice::Object', '::omero::model::IObject', '::omero::model::ProjectAnnotationLink')
def ice_id(self, current=None):
return '::omero::model::ProjectAnnotationLink'
#
# Generated from file `fs.ice'
#
# Warning: do not edit this file.
#
# </auto-generated>
#
import Ice, IcePy, __builtin__
# Start of module FS
_M_FS = Ice.openModule('FS')
__name__ = 'FS'
if not _M_FS.__dict__.has_key('Example'):
_M_FS.Example = Ice.createTempClass()
class Example(Ice.Object):
def __init__(self, apilevel=0):
self.apilevel = apilevel
def ice_ids(self, current=None):
return ('::FS::Example', '::Ice::Object')
def ice_id(self, current=None):
return '::FS::Example'
def ice_staticId():
return '::FS::Example'
ice_staticId = staticmethod(ice_staticId)
def __str__(self):
# Included module omero.api
_M_omero.api = Ice.openModule('omero.api')
# Start of module omero
__name__ = 'omero'
# Start of module omero.model
__name__ = 'omero.model'
if not _M_omero.model.__dict__.has_key('Details'):
_M_omero.model._t_Details = IcePy.declareClass('::omero::model::Details')
_M_omero.model._t_DetailsPrx = IcePy.declareProxy('::omero::model::Details')
if not _M_omero.model.__dict__.has_key('QuantumDef'):
_M_omero.model.QuantumDef = Ice.createTempClass()
class QuantumDef(_M_omero.model.IObject):
def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _cdStart=None, _cdEnd=None, _bitResolution=None):
if __builtin__.type(self) == _M_omero.model.QuantumDef:
raise RuntimeError('omero.model.QuantumDef is an abstract class')
_M_omero.model.IObject.__init__(self, _id, _details, _loaded)
self._version = _version
self._cdStart = _cdStart
self._cdEnd = _cdEnd
self._bitResolution = _bitResolution
def ice_ids(self, current=None):
return ('::Ice::Object', '::omero::model::IObject', '::omero::model::QuantumDef')
def ice_id(self, current=None):
return '::omero::model::QuantumDef'
#
# </auto-generated>
#
import Ice, IcePy, __builtin__
import Ice_BuiltinSequences_ice
# Included module Ice
_M_Ice = Ice.openModule('Ice')
# Start of module Glacier2
_M_Glacier2 = Ice.openModule('Glacier2')
__name__ = 'Glacier2'
if not _M_Glacier2.__dict__.has_key('SSLInfo'):
_M_Glacier2.SSLInfo = Ice.createTempClass()
class SSLInfo(object):
'''Information taken from an SSL connection used for permissions
verification.'''
def __init__(self, remoteHost='', remotePort=0, localHost='', localPort=0, cipher='', certs=None):
self.remoteHost = remoteHost
self.remotePort = remotePort
self.localHost = localHost
self.localPort = localPort
self.cipher = cipher
self.certs = certs
def __hash__(self):
_h = 0
_h = 5 * _h + __builtin__.hash(self.remoteHost)
_h = 5 * _h + __builtin__.hash(self.remotePort)
_M_omero.model._t_DevicePrx = IcePy.declareProxy('::omero::model::Device')
if not _M_omero.model.__dict__.has_key('ActionCategory'):
_M_omero.model._t_ActionCategory = IcePy.declareClass('::omero::model::ActionCategory')
_M_omero.model._t_ActionCategoryPrx = IcePy.declareProxy('::omero::model::ActionCategory')
if not _M_omero.model.__dict__.has_key('Study'):
_M_omero.model._t_Study = IcePy.declareClass('::omero::model::Study')
_M_omero.model._t_StudyPrx = IcePy.declareProxy('::omero::model::Study')
if not _M_omero.model.__dict__.has_key('Details'):
_M_omero.model._t_Details = IcePy.declareClass('::omero::model::Details')
_M_omero.model._t_DetailsPrx = IcePy.declareProxy('::omero::model::Details')
if not _M_omero.model.__dict__.has_key('ActionOnAction'):
_M_omero.model.ActionOnAction = Ice.createTempClass()
class ActionOnAction(_M_omero.model.Action):
def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _vid=None, _beginTime=None, _endTime=None, _setup=None, _device=None, _actionCategory=None, _operator=None, _context=None, _description=None, _target=None):
if __builtin__.type(self) == _M_omero.model.ActionOnAction:
raise RuntimeError('omero.model.ActionOnAction is an abstract class')
_M_omero.model.Action.__init__(self, _id, _details, _loaded, _version, _vid, _beginTime, _endTime, _setup, _device, _actionCategory, _operator, _context, _description)
self._target = _target
def ice_ids(self, current=None):
return ('::Ice::Object', '::omero::model::Action', '::omero::model::ActionOnAction', '::omero::model::IObject')
def ice_id(self, current=None):
return '::omero::model::ActionOnAction'
def ice_staticId():
return '::omero::model::ActionOnAction'
_M_omero.model.enums.ActionCategoryALIQUOTING = "ALIQUOTING"
_M_omero.model.enums.ActionCategoryMEASUREMENT = "MEASUREMENT"
_M_omero.model.enums.ActionCategoryPROCESSING = "PROCESSING"
# End of module omero.model.enums
__name__ = 'omero.model'
if not _M_omero.model.__dict__.has_key('Details'):
_M_omero.model._t_Details = IcePy.declareClass('::omero::model::Details')
_M_omero.model._t_DetailsPrx = IcePy.declareProxy('::omero::model::Details')
if not _M_omero.model.__dict__.has_key('ActionCategory'):
_M_omero.model.ActionCategory = Ice.createTempClass()
class ActionCategory(_M_omero.model.IObject):
def __init__(self, _id=None, _details=None, _loaded=False, _value=None):
if __builtin__.type(self) == _M_omero.model.ActionCategory:
raise RuntimeError('omero.model.ActionCategory is an abstract class')
_M_omero.model.IObject.__init__(self, _id, _details, _loaded)
self._value = _value
def ice_ids(self, current=None):
return ('::Ice::Object', '::omero::model::ActionCategory', '::omero::model::IObject')
def ice_id(self, current=None):
return '::omero::model::ActionCategory'
def ice_staticId():
return '::omero::model::ActionCategory'
_M_Ice = Ice.openModule('Ice')
# Start of module IceGrid
_M_IceGrid = Ice.openModule('IceGrid')
__name__ = 'IceGrid'
if not _M_IceGrid.__dict__.has_key('Registry'):
_M_IceGrid._t_Registry = IcePy.declareClass('::IceGrid::Registry')
_M_IceGrid._t_RegistryPrx = IcePy.declareProxy('::IceGrid::Registry')
if not _M_IceGrid.__dict__.has_key('Query'):
_M_IceGrid._t_Query = IcePy.declareClass('::IceGrid::Query')
_M_IceGrid._t_QueryPrx = IcePy.declareProxy('::IceGrid::Query')
if not _M_IceGrid.__dict__.has_key('Locator'):
_M_IceGrid.Locator = Ice.createTempClass()
class Locator(_M_Ice.Locator):
'''The IceGrid locator interface provides access to the Query
and Registry object of the IceGrid registry.'''
def __init__(self):
if __builtin__.type(self) == _M_IceGrid.Locator:
raise RuntimeError('IceGrid.Locator is an abstract class')
def ice_ids(self, current=None):
return ('::Ice::Locator', '::Ice::Object', '::IceGrid::Locator')
def ice_id(self, current=None):
return '::IceGrid::Locator'
def ice_staticId():
# Included module omero.api
_M_omero.api = Ice.openModule('omero.api')
# Start of module omero
__name__ = 'omero'
# Start of module omero.model
__name__ = 'omero.model'
if not _M_omero.model.__dict__.has_key('Details'):
_M_omero.model._t_Details = IcePy.declareClass('::omero::model::Details')
_M_omero.model._t_DetailsPrx = IcePy.declareProxy('::omero::model::Details')
if not _M_omero.model.__dict__.has_key('SNPMarkersSet'):
_M_omero.model.SNPMarkersSet = Ice.createTempClass()
class SNPMarkersSet(_M_omero.model.IObject):
def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _label=None, _maker=None, _model=None, _release=None, _markersSetVID=None, _snpMarkersSetUK=None):
if __builtin__.type(self) == _M_omero.model.SNPMarkersSet:
raise RuntimeError('omero.model.SNPMarkersSet is an abstract class')
_M_omero.model.IObject.__init__(self, _id, _details, _loaded)
self._version = _version
self._label = _label
self._maker = _maker
self._model = _model
self._release = _release
self._markersSetVID = _markersSetVID
self._snpMarkersSetUK = _snpMarkersSetUK
def ice_ids(self, current=None):
return ('::Ice::Object', '::omero::model::IObject', '::omero::model::SNPMarkersSet')
_M_omero.model.enums.JobStatusWaiting = "Waiting"
_M_omero.model.enums.JobStatusFinished = "Finished"
_M_omero.model.enums.JobStatusCancelled = "Cancelled"
# End of module omero.model.enums
__name__ = 'omero.model'
if not _M_omero.model.__dict__.has_key('Details'):
_M_omero.model._t_Details = IcePy.declareClass('::omero::model::Details')
_M_omero.model._t_DetailsPrx = IcePy.declareProxy('::omero::model::Details')
if not _M_omero.model.__dict__.has_key('JobStatus'):
_M_omero.model.JobStatus = Ice.createTempClass()
class JobStatus(_M_omero.model.IObject):
def __init__(self, _id=None, _details=None, _loaded=False, _value=None):
if __builtin__.type(self) == _M_omero.model.JobStatus:
raise RuntimeError('omero.model.JobStatus is an abstract class')
_M_omero.model.IObject.__init__(self, _id, _details, _loaded)
self._value = _value
def ice_ids(self, current=None):
return ('::Ice::Object', '::omero::model::IObject', '::omero::model::JobStatus')
def ice_id(self, current=None):
return '::omero::model::JobStatus'
def ice_staticId():
return '::omero::model::JobStatus'
_M_omero.sys = Ice.openModule('omero.sys')
# Included module omero.api
_M_omero.api = Ice.openModule('omero.api')
# Included module omero.grid
_M_omero.grid = Ice.openModule('omero.grid')
# Start of module omero
__name__ = 'omero'
# Start of module omero.api
__name__ = 'omero.api'
if not _M_omero.api.__dict__.has_key('IUpdate'):
_M_omero.api.IUpdate = Ice.createTempClass()
class IUpdate(_M_omero.api.ServiceInterface):
'''See IUpdate.html'''
def __init__(self):
if __builtin__.type(self) == _M_omero.api.IUpdate:
raise RuntimeError('omero.api.IUpdate is an abstract class')
def ice_ids(self, current=None):
return ('::Ice::Object', '::omero::api::IUpdate', '::omero::api::ServiceInterface')
def ice_id(self, current=None):
return '::omero::api::IUpdate'
def ice_staticId():
return '::omero::api::IUpdate'
ice_staticId = staticmethod(ice_staticId)
# <auto-generated>
#
# Generated from file `Control.ice'
#
# Warning: do not edit this file.
#
# </auto-generated>
import Ice, IcePy, __builtin__
# Start of module ControlTopic
_M_ControlTopic = Ice.openModule('ControlTopic')
__name__ = 'ControlTopic'
if not _M_ControlTopic.__dict__.has_key('Control'):
_M_ControlTopic.Control = Ice.createTempClass()
class Control(Ice.Object):
def __init__(self):
if __builtin__.type(self) == _M_ControlTopic.Control:
raise RuntimeError('ControlTopic.Control is an abstract class')
def ice_ids(self, current=None):
return ('::ControlTopic::Control', '::Ice::Object')
def ice_id(self, current=None):
return '::ControlTopic::Control'
def ice_staticId():
return '::ControlTopic::Control'
#
# Generated from file `ObjectFactory.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("ObjectFactory"):
_M_Ice.ObjectFactory = Ice.createTempClass()
class ObjectFactory(object):
"""A factory for objects. Object factories are used in several
places, for example, when receiving "objects by value" and
when Freeze restores a persistent object. Object factories
must be implemented by the application writer, and registered
with the communicator."""
def __init__(self):
if __builtin__.type(self) == _M_Ice.ObjectFactory:
raise RuntimeError("Ice.ObjectFactory is an abstract class")
def create(self, type):
"""Create a new object for a given object type. The type is the
absolute Slice type id, i.e., the id relative to the
_M_omero.model._t_FlowCellPrx = IcePy.declareProxy('::omero::model::FlowCell')
if not _M_omero.model.__dict__.has_key('ContainerStatus'):
_M_omero.model._t_ContainerStatus = IcePy.declareClass('::omero::model::ContainerStatus')
_M_omero.model._t_ContainerStatusPrx = IcePy.declareProxy('::omero::model::ContainerStatus')
if not _M_omero.model.__dict__.has_key('Action'):
_M_omero.model._t_Action = IcePy.declareClass('::omero::model::Action')
_M_omero.model._t_ActionPrx = IcePy.declareProxy('::omero::model::Action')
if not _M_omero.model.__dict__.has_key('Details'):
_M_omero.model._t_Details = IcePy.declareClass('::omero::model::Details')
_M_omero.model._t_DetailsPrx = IcePy.declareProxy('::omero::model::Details')
if not _M_omero.model.__dict__.has_key('Lane'):
_M_omero.model.Lane = Ice.createTempClass()
class Lane(_M_omero.model.Container):
def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _vid=None, _label=None, _creationDate=None, _action=None, _lastUpdate=None, _barcode=None, _status=None, _flowCell=None, _slot=None, _laneUK=None):
if __builtin__.type(self) == _M_omero.model.Lane:
raise RuntimeError('omero.model.Lane is an abstract class')
_M_omero.model.Container.__init__(self, _id, _details, _loaded, _version, _vid, _label, _creationDate, _action, _lastUpdate, _barcode, _status)
self._flowCell = _flowCell
self._slot = _slot
self._laneUK = _laneUK
def ice_ids(self, current=None):
return ('::Ice::Object', '::omero::model::Container', '::omero::model::IObject', '::omero::model::Lane', '::omero::model::VLCollection')
def ice_id(self, current=None):
return '::omero::model::Lane'
__name__ = 'omero.model'
if not _M_omero.model.__dict__.has_key('AnnotationAnnotationLink'):
_M_omero.model._t_AnnotationAnnotationLink = IcePy.declareClass('::omero::model::AnnotationAnnotationLink')
_M_omero.model._t_AnnotationAnnotationLinkPrx = IcePy.declareProxy('::omero::model::AnnotationAnnotationLink')
if not _M_omero.model.__dict__.has_key('Annotation'):
_M_omero.model._t_Annotation = IcePy.declareClass('::omero::model::Annotation')
_M_omero.model._t_AnnotationPrx = IcePy.declareProxy('::omero::model::Annotation')
if not _M_omero.model.__dict__.has_key('Details'):
_M_omero.model._t_Details = IcePy.declareClass('::omero::model::Details')
_M_omero.model._t_DetailsPrx = IcePy.declareProxy('::omero::model::Details')
if not _M_omero.model.__dict__.has_key('CommentAnnotation'):
_M_omero.model.CommentAnnotation = Ice.createTempClass()
class CommentAnnotation(_M_omero.model.TextAnnotation):
def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _ns=None, _description=None, _annotationLinksSeq=None, _annotationLinksLoaded=False, _annotationLinksCountPerOwner=None, _textValue=None):
if __builtin__.type(self) == _M_omero.model.CommentAnnotation:
raise RuntimeError('omero.model.CommentAnnotation is an abstract class')
_M_omero.model.TextAnnotation.__init__(self, _id, _details, _loaded, _version, _ns, _description, _annotationLinksSeq, _annotationLinksLoaded, _annotationLinksCountPerOwner, _textValue)
def ice_ids(self, current=None):
return ('::Ice::Object', '::omero::model::Annotation', '::omero::model::CommentAnnotation', '::omero::model::IObject', '::omero::model::TextAnnotation')
def ice_id(self, current=None):
return '::omero::model::CommentAnnotation'
def ice_staticId():
return '::omero::model::CommentAnnotation'
ice_staticId = staticmethod(ice_staticId)
# </auto-generated>
#
from sys import version_info as _version_info_
import Ice, IcePy
import Ice.ObjectAdapterF_ice
import Ice.Current_ice
# Included module Ice
_M_Ice = Ice.openModule('Ice')
# Start of module Ice
__name__ = 'Ice'
if 'ServantLocator' not in _M_Ice.__dict__:
_M_Ice.ServantLocator = Ice.createTempClass()
class ServantLocator(object):
"""
A servant locator is called by an object adapter to
locate a servant that is not found in its active servant map.
"""
def __init__(self):
if Ice.getType(self) == _M_Ice.ServantLocator:
raise RuntimeError('Ice.ServantLocator is an abstract class')
def locate(self, curr):
"""
Called before a request is dispatched if a
servant cannot be found in the object adapter's active servant
map. Note that the object adapter does not automatically insert
the returned servant into its active servant map. This must be
_M_omero.model._t_AnnotationAnnotationLinkPrx = IcePy.declareProxy(
'::omero::model::AnnotationAnnotationLink')
if 'Annotation' not in _M_omero.model.__dict__:
_M_omero.model._t_Annotation = IcePy.declareClass(
'::omero::model::Annotation')
_M_omero.model._t_AnnotationPrx = IcePy.declareProxy(
'::omero::model::Annotation')
if 'Details' not in _M_omero.model.__dict__:
_M_omero.model._t_Details = IcePy.declareClass('::omero::model::Details')
_M_omero.model._t_DetailsPrx = IcePy.declareProxy(
'::omero::model::Details')
if 'TimestampAnnotation' not in _M_omero.model.__dict__:
_M_omero.model.TimestampAnnotation = Ice.createTempClass()
class TimestampAnnotation(_M_omero.model.BasicAnnotation):
def __init__(self,
_id=None,
_details=None,
_loaded=False,
_version=None,
_ns=None,
_name=None,
_description=None,
_annotationLinksSeq=None,
_annotationLinksLoaded=False,
_annotationLinksCountPerOwner=None,
_timeValue=None):
if Ice.getType(self) == _M_omero.model.TimestampAnnotation:
# Included module omero.api
_M_omero.api = Ice.openModule('omero.api')
# Start of module omero
__name__ = 'omero'
# Start of module omero.model
__name__ = 'omero.model'
if not _M_omero.model.__dict__.has_key('Details'):
_M_omero.model._t_Details = IcePy.declareClass('::omero::model::Details')
_M_omero.model._t_DetailsPrx = IcePy.declareProxy('::omero::model::Details')
if not _M_omero.model.__dict__.has_key('StatsInfo'):
_M_omero.model.StatsInfo = Ice.createTempClass()
class StatsInfo(_M_omero.model.IObject):
def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _globalMin=None, _globalMax=None):
if __builtin__.type(self) == _M_omero.model.StatsInfo:
raise RuntimeError('omero.model.StatsInfo is an abstract class')
_M_omero.model.IObject.__init__(self, _id, _details, _loaded)
self._version = _version
self._globalMin = _globalMin
self._globalMax = _globalMax
def ice_ids(self, current=None):
return ('::Ice::Object', '::omero::model::IObject', '::omero::model::StatsInfo')
def ice_id(self, current=None):
return '::omero::model::StatsInfo'
# Included module omero.api
_M_omero.api = Ice.openModule('omero.api')
# Start of module omero
__name__ = 'omero'
# Start of module omero.model
__name__ = 'omero.model'
if not _M_omero.model.__dict__.has_key('Details'):
_M_omero.model._t_Details = IcePy.declareClass('::omero::model::Details')
_M_omero.model._t_DetailsPrx = IcePy.declareProxy('::omero::model::Details')
if not _M_omero.model.__dict__.has_key('ActionSetup'):
_M_omero.model.ActionSetup = Ice.createTempClass()
class ActionSetup(_M_omero.model.IObject):
def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _vid=None, _label=None, _conf=None):
if __builtin__.type(self) == _M_omero.model.ActionSetup:
raise RuntimeError('omero.model.ActionSetup is an abstract class')
_M_omero.model.IObject.__init__(self, _id, _details, _loaded)
self._version = _version
self._vid = _vid
self._label = _label
self._conf = _conf
def ice_ids(self, current=None):
return ('::Ice::Object', '::omero::model::ActionSetup', '::omero::model::IObject')
def ice_id(self, current=None):
return '::omero::model::ActionSetup'
__name__ = 'omero.model'
if not _M_omero.model.__dict__.has_key('LightSource'):
_M_omero.model._t_LightSource = IcePy.declareClass('::omero::model::LightSource')
_M_omero.model._t_LightSourcePrx = IcePy.declareProxy('::omero::model::LightSource')
if not _M_omero.model.__dict__.has_key('MicrobeamManipulation'):
_M_omero.model._t_MicrobeamManipulation = IcePy.declareClass('::omero::model::MicrobeamManipulation')
_M_omero.model._t_MicrobeamManipulationPrx = IcePy.declareProxy('::omero::model::MicrobeamManipulation')
if not _M_omero.model.__dict__.has_key('Details'):
_M_omero.model._t_Details = IcePy.declareClass('::omero::model::Details')
_M_omero.model._t_DetailsPrx = IcePy.declareProxy('::omero::model::Details')
if not _M_omero.model.__dict__.has_key('LightSettings'):
_M_omero.model.LightSettings = Ice.createTempClass()
class LightSettings(_M_omero.model.IObject):
def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _attenuation=None, _wavelength=None, _lightSource=None, _microbeamManipulation=None):
if __builtin__.type(self) == _M_omero.model.LightSettings:
raise RuntimeError('omero.model.LightSettings is an abstract class')
_M_omero.model.IObject.__init__(self, _id, _details, _loaded)
self._version = _version
self._attenuation = _attenuation
self._wavelength = _wavelength
self._lightSource = _lightSource
self._microbeamManipulation = _microbeamManipulation
def ice_ids(self, current=None):
return ('::Ice::Object', '::omero::model::IObject', '::omero::model::LightSettings')
def ice_id(self, current=None):
_M_omero.sys = Ice.openModule('omero.sys')
# Included module omero.api
_M_omero.api = Ice.openModule('omero.api')
# Included module omero.grid
_M_omero.grid = Ice.openModule('omero.grid')
# Start of module omero
__name__ = 'omero'
# Start of module omero.api
__name__ = 'omero.api'
if not _M_omero.api.__dict__.has_key('ITypes'):
_M_omero.api.ITypes = Ice.createTempClass()
class ITypes(_M_omero.api.ServiceInterface):
'''See ITypes.html'''
def __init__(self):
if __builtin__.type(self) == _M_omero.api.ITypes:
raise RuntimeError('omero.api.ITypes is an abstract class')
def ice_ids(self, current=None):
return ('::Ice::Object', '::omero::api::ITypes', '::omero::api::ServiceInterface')
def ice_id(self, current=None):
return '::omero::api::ITypes'
def ice_staticId():
return '::omero::api::ITypes'
ice_staticId = staticmethod(ice_staticId)
_M_omero.model._t_IndividualPrx = IcePy.declareProxy('::omero::model::Individual')
if not _M_omero.model.__dict__.has_key('Action'):
_M_omero.model._t_Action = IcePy.declareClass('::omero::model::Action')
_M_omero.model._t_ActionPrx = IcePy.declareProxy('::omero::model::Action')
if not _M_omero.model.__dict__.has_key('ActionOnAction'):
_M_omero.model._t_ActionOnAction = IcePy.declareClass('::omero::model::ActionOnAction')
_M_omero.model._t_ActionOnActionPrx = IcePy.declareProxy('::omero::model::ActionOnAction')
if not _M_omero.model.__dict__.has_key('Details'):
_M_omero.model._t_Details = IcePy.declareClass('::omero::model::Details')
_M_omero.model._t_DetailsPrx = IcePy.declareProxy('::omero::model::Details')
if not _M_omero.model.__dict__.has_key('Individual'):
_M_omero.model.Individual = Ice.createTempClass()
class Individual(_M_omero.model.IObject):
def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _vid=None, _gender=None, _father=None, _fatherTrusted=None, _mother=None, _motherTrusted=None, _action=None, _lastUpdate=None):
if __builtin__.type(self) == _M_omero.model.Individual:
raise RuntimeError('omero.model.Individual is an abstract class')
_M_omero.model.IObject.__init__(self, _id, _details, _loaded)
self._version = _version
self._vid = _vid
self._gender = _gender
self._father = _father
self._fatherTrusted = _fatherTrusted
self._mother = _mother
self._motherTrusted = _motherTrusted
self._action = _action
self._lastUpdate = _lastUpdate
import IceGrid_Exception_ice
# Included module Ice
_M_Ice = Ice.openModule('Ice')
# Included module IceGrid
_M_IceGrid = Ice.openModule('IceGrid')
# Start of module IceGrid
__name__ = 'IceGrid'
_M_IceGrid.__doc__ = '''IceGrid is a server activation and deployment tool. IceGrid,
simplifies the complex task of deploying applications in a
heterogeneous computer network.'''
if 'LoadSample' not in _M_IceGrid.__dict__:
_M_IceGrid.LoadSample = Ice.createTempClass()
class LoadSample(Ice.EnumBase):
'''Determines which load sampling interval to use.'''
def __init__(self, _n, _v):
Ice.EnumBase.__init__(self, _n, _v)
def valueOf(self, _n):
if _n in self._enumerators:
return self._enumerators[_n]
return None
valueOf = classmethod(valueOf)
LoadSample.LoadSample1 = LoadSample("LoadSample1", 0)
LoadSample.LoadSample5 = LoadSample("LoadSample5", 1)
_M_omero.model._t_DetailsPrx = IcePy.declareProxy('::omero::model::Details')
if not _M_omero.model.__dict__.has_key('_t_ReagentWellLinksSeq'):
_M_omero.model._t_ReagentWellLinksSeq = IcePy.defineSequence('::omero::model::ReagentWellLinksSeq', (), _M_omero.model._t_WellReagentLink)
if not _M_omero.model.__dict__.has_key('_t_ReagentLinkedWellSeq'):
_M_omero.model._t_ReagentLinkedWellSeq = IcePy.defineSequence('::omero::model::ReagentLinkedWellSeq', (), _M_omero.model._t_Well)
if not _M_omero.model.__dict__.has_key('_t_ReagentAnnotationLinksSeq'):
_M_omero.model._t_ReagentAnnotationLinksSeq = IcePy.defineSequence('::omero::model::ReagentAnnotationLinksSeq', (), _M_omero.model._t_ReagentAnnotationLink)
if not _M_omero.model.__dict__.has_key('_t_ReagentLinkedAnnotationSeq'):
_M_omero.model._t_ReagentLinkedAnnotationSeq = IcePy.defineSequence('::omero::model::ReagentLinkedAnnotationSeq', (), _M_omero.model._t_Annotation)
if not _M_omero.model.__dict__.has_key('Reagent'):
_M_omero.model.Reagent = Ice.createTempClass()
class Reagent(_M_omero.model.IObject):
def __init__(self, _id=None, _details=None, _loaded=False, _version=None, _name=None, _reagentIdentifier=None, _screen=None, _wellLinksSeq=None, _wellLinksLoaded=False, _wellLinksCountPerOwner=None, _annotationLinksSeq=None, _annotationLinksLoaded=False, _annotationLinksCountPerOwner=None, _description=None):
if __builtin__.type(self) == _M_omero.model.Reagent:
raise RuntimeError('omero.model.Reagent is an abstract class')
_M_omero.model.IObject.__init__(self, _id, _details, _loaded)
self._version = _version
self._name = _name
self._reagentIdentifier = _reagentIdentifier
self._screen = _screen
self._wellLinksSeq = _wellLinksSeq
self._wellLinksLoaded = _wellLinksLoaded
self._wellLinksCountPerOwner = _wellLinksCountPerOwner
self._annotationLinksSeq = _annotationLinksSeq
self._annotationLinksLoaded = _annotationLinksLoaded
self._annotationLinksCountPerOwner = _annotationLinksCountPerOwner
# **********************************************************************
# Ice version 3.3.1
# Generated from file `MKS_Server.ice'
import Ice, IcePy, __builtin__
if not Ice.__dict__.has_key( '_struct_marker' ):
Ice._struct_marker = object()
# Start of module MksIce
_M_MksIce = Ice.openModule( 'MksIce' )
__name__ = 'MksIce'
if not _M_MksIce.__dict__.has_key( 'Management' ):
_M_MksIce.Management = Ice.createTempClass()
class Management( Ice.Object ):
def __init__( self ):
if __builtin__.type( self ) == _M_MksIce.Management:
raise RuntimeError( 'MksIce.Management is an abstract class' )
def ice_ids( self, current = None ):
return ( '::Ice::Object', '::MksIce::Management' )
def ice_id( self, current = None ):
return '::MksIce::Management'
def ice_staticId():
return '::MksIce::Management'
ice_staticId = staticmethod( ice_staticId )
