# -*- coding: utf-8 -*-
# **********************************************************************
#
# Copyright (c) 2003-2016 ZeroC, Inc. All rights reserved.
#
# This copy of Ice is licensed to you under the terms described in the
# ICE_LICENSE file included in this distribution.
#
# **********************************************************************
#
# Ice version 3.6.3
#
# <auto-generated>
#
# Generated from file `Laboratory.ice'
#
# Warning: do not edit this file.
#
# </auto-generated>
#

from sys import version_info as _version_info_
import Ice, IcePy

# Start of module Laboratory
_M_Laboratory = Ice.openModule('Laboratory')
__name__ = 'Laboratory'

if '_t_StringList' not in _M_Laboratory.__dict__:
    _M_Laboratory._t_StringList = IcePy.defineSequence('::Laboratory::StringList', (), IcePy._t_string)

if 'Device' not in _M_Laboratory.__dict__:
    _M_Laboratory.Device = Ice.createTempClass()
    class Device(Ice.Object):
        def __init__(self):
            if Ice.getType(self) == _M_Laboratory.Device:
                raise RuntimeError('Laboratory.Device is an abstract class')

        def ice_ids(self, current=None):
            return ('::Ice::Object', '::Laboratory::Device')

        def ice_id(self, current=None):
            return '::Laboratory::Device'

        def ice_staticId():
            return '::Laboratory::Device'
        ice_staticId = staticmethod(ice_staticId)

        def getDeviceFunctions(self, current=None):
            pass

        def getState(self, current=None):
            pass

        def __str__(self):
            return IcePy.stringify(self, _M_Laboratory._t_Device)

        __repr__ = __str__

    _M_Laboratory.DevicePrx = Ice.createTempClass()
    class DevicePrx(Ice.ObjectPrx):

        def getDeviceFunctions(self, _ctx=None):
            return _M_Laboratory.Device._op_getDeviceFunctions.invoke(self, ((), _ctx))

        def begin_getDeviceFunctions(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_Laboratory.Device._op_getDeviceFunctions.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_getDeviceFunctions(self, _r):
            return _M_Laboratory.Device._op_getDeviceFunctions.end(self, _r)

        def getState(self, _ctx=None):
            return _M_Laboratory.Device._op_getState.invoke(self, ((), _ctx))

        def begin_getState(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_Laboratory.Device._op_getState.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_getState(self, _r):
            return _M_Laboratory.Device._op_getState.end(self, _r)

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_Laboratory.DevicePrx.ice_checkedCast(proxy, '::Laboratory::Device', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_Laboratory.DevicePrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

        def ice_staticId():
            return '::Laboratory::Device'
        ice_staticId = staticmethod(ice_staticId)

    _M_Laboratory._t_DevicePrx = IcePy.defineProxy('::Laboratory::Device', DevicePrx)

    _M_Laboratory._t_Device = IcePy.defineClass('::Laboratory::Device', Device, -1, (), True, False, None, (), ())
    Device._ice_type = _M_Laboratory._t_Device

    Device._op_getDeviceFunctions = IcePy.Operation('getDeviceFunctions', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (), (), ((), _M_Laboratory._t_StringList, False, 0), ())
    Device._op_getState = IcePy.Operation('getState', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (), (), ((), IcePy._t_string, False, 0), ())

    _M_Laboratory.Device = Device
    del Device

    _M_Laboratory.DevicePrx = DevicePrx
    del DevicePrx

if 'Reporter' not in _M_Laboratory.__dict__:
    _M_Laboratory.Reporter = Ice.createTempClass()
    class Reporter(Ice.Object):
        def __init__(self):
            if Ice.getType(self) == _M_Laboratory.Reporter:
                raise RuntimeError('Laboratory.Reporter is an abstract class')

        def ice_ids(self, current=None):
            return ('::Ice::Object', '::Laboratory::Reporter')

        def ice_id(self, current=None):
            return '::Laboratory::Reporter'

        def ice_staticId():
            return '::Laboratory::Reporter'
        ice_staticId = staticmethod(ice_staticId)

        def report(self, message, current=None):
            pass

        def __str__(self):
            return IcePy.stringify(self, _M_Laboratory._t_Reporter)

        __repr__ = __str__

    _M_Laboratory.ReporterPrx = Ice.createTempClass()
    class ReporterPrx(Ice.ObjectPrx):

        def report(self, message, _ctx=None):
            return _M_Laboratory.Reporter._op_report.invoke(self, ((message, ), _ctx))

        def begin_report(self, message, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_Laboratory.Reporter._op_report.begin(self, ((message, ), _response, _ex, _sent, _ctx))

        def end_report(self, _r):
            return _M_Laboratory.Reporter._op_report.end(self, _r)

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_Laboratory.ReporterPrx.ice_checkedCast(proxy, '::Laboratory::Reporter', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_Laboratory.ReporterPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

        def ice_staticId():
            return '::Laboratory::Reporter'
        ice_staticId = staticmethod(ice_staticId)

    _M_Laboratory._t_ReporterPrx = IcePy.defineProxy('::Laboratory::Reporter', ReporterPrx)

    _M_Laboratory._t_Reporter = IcePy.defineClass('::Laboratory::Reporter', Reporter, -1, (), True, False, None, (), ())
    Reporter._ice_type = _M_Laboratory._t_Reporter

    Reporter._op_report = IcePy.Operation('report', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_string, False, 0),), (), None, ())

    _M_Laboratory.Reporter = Reporter
    del Reporter

    _M_Laboratory.ReporterPrx = ReporterPrx
    del ReporterPrx

if 'DeviceNotExistException' not in _M_Laboratory.__dict__:
    _M_Laboratory.DeviceNotExistException = Ice.createTempClass()
    class DeviceNotExistException(Ice.UserException):
        def __init__(self, info=''):
            self.info = info

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Laboratory::DeviceNotExistException'

    _M_Laboratory._t_DeviceNotExistException = IcePy.defineException('::Laboratory::DeviceNotExistException', DeviceNotExistException, (), False, None, (('info', (), IcePy._t_string, False, 0),))
    DeviceNotExistException._ice_type = _M_Laboratory._t_DeviceNotExistException

    _M_Laboratory.DeviceNotExistException = DeviceNotExistException
    del DeviceNotExistException

if 'DeviceAlreadyControlledException' not in _M_Laboratory.__dict__:
    _M_Laboratory.DeviceAlreadyControlledException = Ice.createTempClass()
    class DeviceAlreadyControlledException(Ice.UserException):
        def __init__(self, info=''):
            self.info = info

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Laboratory::DeviceAlreadyControlledException'

    _M_Laboratory._t_DeviceAlreadyControlledException = IcePy.defineException('::Laboratory::DeviceAlreadyControlledException', DeviceAlreadyControlledException, (), False, None, (('info', (), IcePy._t_string, False, 0),))
    DeviceAlreadyControlledException._ice_type = _M_Laboratory._t_DeviceAlreadyControlledException

    _M_Laboratory.DeviceAlreadyControlledException = DeviceAlreadyControlledException
    del DeviceAlreadyControlledException

if 'DeviceNotControlledException' not in _M_Laboratory.__dict__:
    _M_Laboratory.DeviceNotControlledException = Ice.createTempClass()
    class DeviceNotControlledException(Ice.UserException):
        def __init__(self, info=''):
            self.info = info

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Laboratory::DeviceNotControlledException'

    _M_Laboratory._t_DeviceNotControlledException = IcePy.defineException('::Laboratory::DeviceNotControlledException', DeviceNotControlledException, (), False, None, (('info', (), IcePy._t_string, False, 0),))
    DeviceNotControlledException._ice_type = _M_Laboratory._t_DeviceNotControlledException

    _M_Laboratory.DeviceNotControlledException = DeviceNotControlledException
    del DeviceNotControlledException

if 'Lab' not in _M_Laboratory.__dict__:
    _M_Laboratory.Lab = Ice.createTempClass()
    class Lab(Ice.Object):
        def __init__(self):
            if Ice.getType(self) == _M_Laboratory.Lab:
                raise RuntimeError('Laboratory.Lab is an abstract class')

        def ice_ids(self, current=None):
            return ('::Ice::Object', '::Laboratory::Lab')

        def ice_id(self, current=None):
            return '::Laboratory::Lab'

        def ice_staticId():
            return '::Laboratory::Lab'
        ice_staticId = staticmethod(ice_staticId)

        def getDevices(self, current=None):
            pass

        def takeControlOverDevice(self, device, username, current=None):
            pass

        def releaseDevice(self, device, username, current=None):
            pass

        def getAvailableFunctionsForDevice(self, device, current=None):
            pass

        def __str__(self):
            return IcePy.stringify(self, _M_Laboratory._t_Lab)

        __repr__ = __str__

    _M_Laboratory.LabPrx = Ice.createTempClass()
    class LabPrx(Ice.ObjectPrx):

        def getDevices(self, _ctx=None):
            return _M_Laboratory.Lab._op_getDevices.invoke(self, ((), _ctx))

        def begin_getDevices(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_Laboratory.Lab._op_getDevices.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_getDevices(self, _r):
            return _M_Laboratory.Lab._op_getDevices.end(self, _r)

        def takeControlOverDevice(self, device, username, _ctx=None):
            return _M_Laboratory.Lab._op_takeControlOverDevice.invoke(self, ((device, username), _ctx))

        def begin_takeControlOverDevice(self, device, username, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_Laboratory.Lab._op_takeControlOverDevice.begin(self, ((device, username), _response, _ex, _sent, _ctx))

        def end_takeControlOverDevice(self, _r):
            return _M_Laboratory.Lab._op_takeControlOverDevice.end(self, _r)

        def releaseDevice(self, device, username, _ctx=None):
            return _M_Laboratory.Lab._op_releaseDevice.invoke(self, ((device, username), _ctx))

        def begin_releaseDevice(self, device, username, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_Laboratory.Lab._op_releaseDevice.begin(self, ((device, username), _response, _ex, _sent, _ctx))

        def end_releaseDevice(self, _r):
            return _M_Laboratory.Lab._op_releaseDevice.end(self, _r)

        def getAvailableFunctionsForDevice(self, device, _ctx=None):
            return _M_Laboratory.Lab._op_getAvailableFunctionsForDevice.invoke(self, ((device, ), _ctx))

        def begin_getAvailableFunctionsForDevice(self, device, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_Laboratory.Lab._op_getAvailableFunctionsForDevice.begin(self, ((device, ), _response, _ex, _sent, _ctx))

        def end_getAvailableFunctionsForDevice(self, _r):
            return _M_Laboratory.Lab._op_getAvailableFunctionsForDevice.end(self, _r)

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_Laboratory.LabPrx.ice_checkedCast(proxy, '::Laboratory::Lab', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_Laboratory.LabPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

        def ice_staticId():
            return '::Laboratory::Lab'
        ice_staticId = staticmethod(ice_staticId)

    _M_Laboratory._t_LabPrx = IcePy.defineProxy('::Laboratory::Lab', LabPrx)

    _M_Laboratory._t_Lab = IcePy.defineClass('::Laboratory::Lab', Lab, -1, (), True, False, None, (), ())
    Lab._ice_type = _M_Laboratory._t_Lab

    Lab._op_getDevices = IcePy.Operation('getDevices', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (), (), ((), _M_Laboratory._t_StringList, False, 0), ())
    Lab._op_takeControlOverDevice = IcePy.Operation('takeControlOverDevice', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_string, False, 0), ((), IcePy._t_string, False, 0)), (), ((), _M_Laboratory._t_DevicePrx, False, 0), (_M_Laboratory._t_DeviceNotExistException, _M_Laboratory._t_DeviceAlreadyControlledException))
    Lab._op_releaseDevice = IcePy.Operation('releaseDevice', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_string, False, 0), ((), IcePy._t_string, False, 0)), (), None, (_M_Laboratory._t_DeviceNotExistException, _M_Laboratory._t_DeviceNotControlledException))
    Lab._op_getAvailableFunctionsForDevice = IcePy.Operation('getAvailableFunctionsForDevice', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_string, False, 0),), (), ((), _M_Laboratory._t_StringList, False, 0), (_M_Laboratory._t_DeviceNotExistException,))

    _M_Laboratory.Lab = Lab
    del Lab

    _M_Laboratory.LabPrx = LabPrx
    del LabPrx

if 'RotationOutOfRangeException' not in _M_Laboratory.__dict__:
    _M_Laboratory.RotationOutOfRangeException = Ice.createTempClass()
    class RotationOutOfRangeException(Ice.UserException):
        def __init__(self, minAngle=0.0, maxAngle=0.0, currentAngle=0.0, message=''):
            self.minAngle = minAngle
            self.maxAngle = maxAngle
            self.currentAngle = currentAngle
            self.message = message

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Laboratory::RotationOutOfRangeException'

    _M_Laboratory._t_RotationOutOfRangeException = IcePy.defineException('::Laboratory::RotationOutOfRangeException', RotationOutOfRangeException, (), False, None, (
        ('minAngle', (), IcePy._t_float, False, 0),
        ('maxAngle', (), IcePy._t_float, False, 0),
        ('currentAngle', (), IcePy._t_float, False, 0),
        ('message', (), IcePy._t_string, False, 0)
    ))
    RotationOutOfRangeException._ice_type = _M_Laboratory._t_RotationOutOfRangeException

    _M_Laboratory.RotationOutOfRangeException = RotationOutOfRangeException
    del RotationOutOfRangeException

if 'ZoomOutOfRangeException' not in _M_Laboratory.__dict__:
    _M_Laboratory.ZoomOutOfRangeException = Ice.createTempClass()
    class ZoomOutOfRangeException(Ice.UserException):
        def __init__(self, minZoom=0, maxZoom=0, message=''):
            self.minZoom = minZoom
            self.maxZoom = maxZoom
            self.message = message

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Laboratory::ZoomOutOfRangeException'

    _M_Laboratory._t_ZoomOutOfRangeException = IcePy.defineException('::Laboratory::ZoomOutOfRangeException', ZoomOutOfRangeException, (), False, None, (
        ('minZoom', (), IcePy._t_int, False, 0),
        ('maxZoom', (), IcePy._t_int, False, 0),
        ('message', (), IcePy._t_string, False, 0)
    ))
    ZoomOutOfRangeException._ice_type = _M_Laboratory._t_ZoomOutOfRangeException

    _M_Laboratory.ZoomOutOfRangeException = ZoomOutOfRangeException
    del ZoomOutOfRangeException

if 'FocalLengthOutOfRangeException' not in _M_Laboratory.__dict__:
    _M_Laboratory.FocalLengthOutOfRangeException = Ice.createTempClass()
    class FocalLengthOutOfRangeException(Ice.UserException):
        def __init__(self, minFocalLength=0.0, maxFocalLength=0.0, current=0.0, message=''):
            self.minFocalLength = minFocalLength
            self.maxFocalLength = maxFocalLength
            self.current = current
            self.message = message

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Laboratory::FocalLengthOutOfRangeException'

    _M_Laboratory._t_FocalLengthOutOfRangeException = IcePy.defineException('::Laboratory::FocalLengthOutOfRangeException', FocalLengthOutOfRangeException, (), False, None, (
        ('minFocalLength', (), IcePy._t_float, False, 0),
        ('maxFocalLength', (), IcePy._t_float, False, 0),
        ('current', (), IcePy._t_float, False, 0),
        ('message', (), IcePy._t_string, False, 0)
    ))
    FocalLengthOutOfRangeException._ice_type = _M_Laboratory._t_FocalLengthOutOfRangeException

    _M_Laboratory.FocalLengthOutOfRangeException = FocalLengthOutOfRangeException
    del FocalLengthOutOfRangeException

if 'Camera' not in _M_Laboratory.__dict__:
    _M_Laboratory.Camera = Ice.createTempClass()
    class Camera(_M_Laboratory.Device):
        def __init__(self):
            if Ice.getType(self) == _M_Laboratory.Camera:
                raise RuntimeError('Laboratory.Camera is an abstract class')

        def ice_ids(self, current=None):
            return ('::Ice::Object', '::Laboratory::Camera', '::Laboratory::Device')

        def ice_id(self, current=None):
            return '::Laboratory::Camera'

        def ice_staticId():
            return '::Laboratory::Camera'
        ice_staticId = staticmethod(ice_staticId)

        def setZoom(self, zoom, current=None):
            pass

        def rotateLeft(self, angle, current=None):
            pass

        def rotateRight(self, angle, current=None):
            pass

        def rotateTop(self, angle, current=None):
            pass

        def rotateDown(self, angle, current=None):
            pass

        def __str__(self):
            return IcePy.stringify(self, _M_Laboratory._t_Camera)

        __repr__ = __str__

    _M_Laboratory.CameraPrx = Ice.createTempClass()
    class CameraPrx(_M_Laboratory.DevicePrx):

        def setZoom(self, zoom, _ctx=None):
            return _M_Laboratory.Camera._op_setZoom.invoke(self, ((zoom, ), _ctx))

        def begin_setZoom(self, zoom, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_Laboratory.Camera._op_setZoom.begin(self, ((zoom, ), _response, _ex, _sent, _ctx))

        def end_setZoom(self, _r):
            return _M_Laboratory.Camera._op_setZoom.end(self, _r)

        def rotateLeft(self, angle, _ctx=None):
            return _M_Laboratory.Camera._op_rotateLeft.invoke(self, ((angle, ), _ctx))

        def begin_rotateLeft(self, angle, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_Laboratory.Camera._op_rotateLeft.begin(self, ((angle, ), _response, _ex, _sent, _ctx))

        def end_rotateLeft(self, _r):
            return _M_Laboratory.Camera._op_rotateLeft.end(self, _r)

        def rotateRight(self, angle, _ctx=None):
            return _M_Laboratory.Camera._op_rotateRight.invoke(self, ((angle, ), _ctx))

        def begin_rotateRight(self, angle, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_Laboratory.Camera._op_rotateRight.begin(self, ((angle, ), _response, _ex, _sent, _ctx))

        def end_rotateRight(self, _r):
            return _M_Laboratory.Camera._op_rotateRight.end(self, _r)

        def rotateTop(self, angle, _ctx=None):
            return _M_Laboratory.Camera._op_rotateTop.invoke(self, ((angle, ), _ctx))

        def begin_rotateTop(self, angle, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_Laboratory.Camera._op_rotateTop.begin(self, ((angle, ), _response, _ex, _sent, _ctx))

        def end_rotateTop(self, _r):
            return _M_Laboratory.Camera._op_rotateTop.end(self, _r)

        def rotateDown(self, angle, _ctx=None):
            return _M_Laboratory.Camera._op_rotateDown.invoke(self, ((angle, ), _ctx))

        def begin_rotateDown(self, angle, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_Laboratory.Camera._op_rotateDown.begin(self, ((angle, ), _response, _ex, _sent, _ctx))

        def end_rotateDown(self, _r):
            return _M_Laboratory.Camera._op_rotateDown.end(self, _r)

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_Laboratory.CameraPrx.ice_checkedCast(proxy, '::Laboratory::Camera', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_Laboratory.CameraPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

        def ice_staticId():
            return '::Laboratory::Camera'
        ice_staticId = staticmethod(ice_staticId)

    _M_Laboratory._t_CameraPrx = IcePy.defineProxy('::Laboratory::Camera', CameraPrx)

    _M_Laboratory._t_Camera = IcePy.defineClass('::Laboratory::Camera', Camera, -1, (), True, False, None, (_M_Laboratory._t_Device,), ())
    Camera._ice_type = _M_Laboratory._t_Camera

    Camera._op_setZoom = IcePy.Operation('setZoom', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_int, False, 0),), (), None, (_M_Laboratory._t_ZoomOutOfRangeException,))
    Camera._op_rotateLeft = IcePy.Operation('rotateLeft', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_float, False, 0),), (), None, (_M_Laboratory._t_RotationOutOfRangeException,))
    Camera._op_rotateRight = IcePy.Operation('rotateRight', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_float, False, 0),), (), None, (_M_Laboratory._t_RotationOutOfRangeException,))
    Camera._op_rotateTop = IcePy.Operation('rotateTop', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_float, False, 0),), (), None, (_M_Laboratory._t_RotationOutOfRangeException,))
    Camera._op_rotateDown = IcePy.Operation('rotateDown', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_float, False, 0),), (), None, (_M_Laboratory._t_RotationOutOfRangeException,))

    _M_Laboratory.Camera = Camera
    del Camera

    _M_Laboratory.CameraPrx = CameraPrx
    del CameraPrx

if 'NightCamera' not in _M_Laboratory.__dict__:
    _M_Laboratory.NightCamera = Ice.createTempClass()
    class NightCamera(_M_Laboratory.Camera):
        def __init__(self):
            if Ice.getType(self) == _M_Laboratory.NightCamera:
                raise RuntimeError('Laboratory.NightCamera is an abstract class')

        def ice_ids(self, current=None):
            return ('::Ice::Object', '::Laboratory::Camera', '::Laboratory::Device', '::Laboratory::NightCamera')

        def ice_id(self, current=None):
            return '::Laboratory::NightCamera'

        def ice_staticId():
            return '::Laboratory::NightCamera'
        ice_staticId = staticmethod(ice_staticId)

        def switchNightModeOption(self, current=None):
            pass

        def __str__(self):
            return IcePy.stringify(self, _M_Laboratory._t_NightCamera)

        __repr__ = __str__

    _M_Laboratory.NightCameraPrx = Ice.createTempClass()
    class NightCameraPrx(_M_Laboratory.CameraPrx):

        def switchNightModeOption(self, _ctx=None):
            return _M_Laboratory.NightCamera._op_switchNightModeOption.invoke(self, ((), _ctx))

        def begin_switchNightModeOption(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_Laboratory.NightCamera._op_switchNightModeOption.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_switchNightModeOption(self, _r):
            return _M_Laboratory.NightCamera._op_switchNightModeOption.end(self, _r)

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_Laboratory.NightCameraPrx.ice_checkedCast(proxy, '::Laboratory::NightCamera', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_Laboratory.NightCameraPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

        def ice_staticId():
            return '::Laboratory::NightCamera'
        ice_staticId = staticmethod(ice_staticId)

    _M_Laboratory._t_NightCameraPrx = IcePy.defineProxy('::Laboratory::NightCamera', NightCameraPrx)

    _M_Laboratory._t_NightCamera = IcePy.defineClass('::Laboratory::NightCamera', NightCamera, -1, (), True, False, None, (_M_Laboratory._t_Camera,), ())
    NightCamera._ice_type = _M_Laboratory._t_NightCamera

    NightCamera._op_switchNightModeOption = IcePy.Operation('switchNightModeOption', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (), (), None, ())

    _M_Laboratory.NightCamera = NightCamera
    del NightCamera

    _M_Laboratory.NightCameraPrx = NightCameraPrx
    del NightCameraPrx

if 'VariableFocalLenCamera' not in _M_Laboratory.__dict__:
    _M_Laboratory.VariableFocalLenCamera = Ice.createTempClass()
    class VariableFocalLenCamera(_M_Laboratory.Camera):
        def __init__(self):
            if Ice.getType(self) == _M_Laboratory.VariableFocalLenCamera:
                raise RuntimeError('Laboratory.VariableFocalLenCamera is an abstract class')

        def ice_ids(self, current=None):
            return ('::Ice::Object', '::Laboratory::Camera', '::Laboratory::Device', '::Laboratory::VariableFocalLenCamera')

        def ice_id(self, current=None):
            return '::Laboratory::VariableFocalLenCamera'

        def ice_staticId():
            return '::Laboratory::VariableFocalLenCamera'
        ice_staticId = staticmethod(ice_staticId)

        def increaseFocalLength(self, focalLength, current=None):
            pass

        def decreaseFocalLength(self, focalLength, current=None):
            pass

        def setFocalLength(self, focalLength, current=None):
            pass

        def __str__(self):
            return IcePy.stringify(self, _M_Laboratory._t_VariableFocalLenCamera)

        __repr__ = __str__

    _M_Laboratory.VariableFocalLenCameraPrx = Ice.createTempClass()
    class VariableFocalLenCameraPrx(_M_Laboratory.CameraPrx):

        def increaseFocalLength(self, focalLength, _ctx=None):
            return _M_Laboratory.VariableFocalLenCamera._op_increaseFocalLength.invoke(self, ((focalLength, ), _ctx))

        def begin_increaseFocalLength(self, focalLength, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_Laboratory.VariableFocalLenCamera._op_increaseFocalLength.begin(self, ((focalLength, ), _response, _ex, _sent, _ctx))

        def end_increaseFocalLength(self, _r):
            return _M_Laboratory.VariableFocalLenCamera._op_increaseFocalLength.end(self, _r)

        def decreaseFocalLength(self, focalLength, _ctx=None):
            return _M_Laboratory.VariableFocalLenCamera._op_decreaseFocalLength.invoke(self, ((focalLength, ), _ctx))

        def begin_decreaseFocalLength(self, focalLength, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_Laboratory.VariableFocalLenCamera._op_decreaseFocalLength.begin(self, ((focalLength, ), _response, _ex, _sent, _ctx))

        def end_decreaseFocalLength(self, _r):
            return _M_Laboratory.VariableFocalLenCamera._op_decreaseFocalLength.end(self, _r)

        def setFocalLength(self, focalLength, _ctx=None):
            return _M_Laboratory.VariableFocalLenCamera._op_setFocalLength.invoke(self, ((focalLength, ), _ctx))

        def begin_setFocalLength(self, focalLength, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_Laboratory.VariableFocalLenCamera._op_setFocalLength.begin(self, ((focalLength, ), _response, _ex, _sent, _ctx))

        def end_setFocalLength(self, _r):
            return _M_Laboratory.VariableFocalLenCamera._op_setFocalLength.end(self, _r)

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_Laboratory.VariableFocalLenCameraPrx.ice_checkedCast(proxy, '::Laboratory::VariableFocalLenCamera', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_Laboratory.VariableFocalLenCameraPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

        def ice_staticId():
            return '::Laboratory::VariableFocalLenCamera'
        ice_staticId = staticmethod(ice_staticId)

    _M_Laboratory._t_VariableFocalLenCameraPrx = IcePy.defineProxy('::Laboratory::VariableFocalLenCamera', VariableFocalLenCameraPrx)

    _M_Laboratory._t_VariableFocalLenCamera = IcePy.defineClass('::Laboratory::VariableFocalLenCamera', VariableFocalLenCamera, -1, (), True, False, None, (_M_Laboratory._t_Camera,), ())
    VariableFocalLenCamera._ice_type = _M_Laboratory._t_VariableFocalLenCamera

    VariableFocalLenCamera._op_increaseFocalLength = IcePy.Operation('increaseFocalLength', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_float, False, 0),), (), None, (_M_Laboratory._t_FocalLengthOutOfRangeException,))
    VariableFocalLenCamera._op_decreaseFocalLength = IcePy.Operation('decreaseFocalLength', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_float, False, 0),), (), None, (_M_Laboratory._t_FocalLengthOutOfRangeException,))
    VariableFocalLenCamera._op_setFocalLength = IcePy.Operation('setFocalLength', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_float, False, 0),), (), None, (_M_Laboratory._t_FocalLengthOutOfRangeException,))

    _M_Laboratory.VariableFocalLenCamera = VariableFocalLenCamera
    del VariableFocalLenCamera

    _M_Laboratory.VariableFocalLenCameraPrx = VariableFocalLenCameraPrx
    del VariableFocalLenCameraPrx

if 'BadRobotStateException' not in _M_Laboratory.__dict__:
    _M_Laboratory.BadRobotStateException = Ice.createTempClass()
    class BadRobotStateException(Ice.UserException):
        def __init__(self, reason=''):
            self.reason = reason

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Laboratory::BadRobotStateException'

    _M_Laboratory._t_BadRobotStateException = IcePy.defineException('::Laboratory::BadRobotStateException', BadRobotStateException, (), False, None, (('reason', (), IcePy._t_string, False, 0),))
    BadRobotStateException._ice_type = _M_Laboratory._t_BadRobotStateException

    _M_Laboratory.BadRobotStateException = BadRobotStateException
    del BadRobotStateException

if 'Point' not in _M_Laboratory.__dict__:
    _M_Laboratory.Point = Ice.createTempClass()
    class Point(object):
        def __init__(self, x=0, y=0):
            self.x = x
            self.y = y

        def __hash__(self):
            _h = 0
            _h = 5 * _h + Ice.getHash(self.x)
            _h = 5 * _h + Ice.getHash(self.y)
            return _h % 0x7fffffff

        def __compare(self, other):
            if other is None:
                return 1
            elif not isinstance(other, _M_Laboratory.Point):
                return NotImplemented
            else:
                if self.x is None or other.x is None:
                    if self.x != other.x:
                        return (-1 if self.x is None else 1)
                else:
                    if self.x < other.x:
                        return -1
                    elif self.x > other.x:
                        return 1
                if self.y is None or other.y is None:
                    if self.y != other.y:
                        return (-1 if self.y is None else 1)
                else:
                    if self.y < other.y:
                        return -1
                    elif self.y > other.y:
                        return 1
                return 0

        def __lt__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r < 0

        def __le__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r <= 0

        def __gt__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r > 0

        def __ge__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r >= 0

        def __eq__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r == 0

        def __ne__(self, other):
            r = self.__compare(other)
            if r is NotImplemented:
                return r
            else:
                return r != 0

        def __str__(self):
            return IcePy.stringify(self, _M_Laboratory._t_Point)

        __repr__ = __str__

    _M_Laboratory._t_Point = IcePy.defineStruct('::Laboratory::Point', Point, (), (
        ('x', (), IcePy._t_int),
        ('y', (), IcePy._t_int)
    ))

    _M_Laboratory.Point = Point
    del Point

if 'Robot' not in _M_Laboratory.__dict__:
    _M_Laboratory.Robot = Ice.createTempClass()
    class Robot(_M_Laboratory.Device):
        def __init__(self):
            if Ice.getType(self) == _M_Laboratory.Robot:
                raise RuntimeError('Laboratory.Robot is an abstract class')

        def ice_ids(self, current=None):
            return ('::Ice::Object', '::Laboratory::Device', '::Laboratory::Robot')

        def ice_id(self, current=None):
            return '::Laboratory::Robot'

        def ice_staticId():
            return '::Laboratory::Robot'
        ice_staticId = staticmethod(ice_staticId)

        def turnOn(self, current=None):
            pass

        def turnOff(self, current=None):
            pass

        def moveTo(self, point, current=None):
            pass

        def __str__(self):
            return IcePy.stringify(self, _M_Laboratory._t_Robot)

        __repr__ = __str__

    _M_Laboratory.RobotPrx = Ice.createTempClass()
    class RobotPrx(_M_Laboratory.DevicePrx):

        def turnOn(self, _ctx=None):
            return _M_Laboratory.Robot._op_turnOn.invoke(self, ((), _ctx))

        def begin_turnOn(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_Laboratory.Robot._op_turnOn.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_turnOn(self, _r):
            return _M_Laboratory.Robot._op_turnOn.end(self, _r)

        def turnOff(self, _ctx=None):
            return _M_Laboratory.Robot._op_turnOff.invoke(self, ((), _ctx))

        def begin_turnOff(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_Laboratory.Robot._op_turnOff.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_turnOff(self, _r):
            return _M_Laboratory.Robot._op_turnOff.end(self, _r)

        def moveTo(self, point, _ctx=None):
            return _M_Laboratory.Robot._op_moveTo.invoke(self, ((point, ), _ctx))

        def begin_moveTo(self, point, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_Laboratory.Robot._op_moveTo.begin(self, ((point, ), _response, _ex, _sent, _ctx))

        def end_moveTo(self, _r):
            return _M_Laboratory.Robot._op_moveTo.end(self, _r)

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_Laboratory.RobotPrx.ice_checkedCast(proxy, '::Laboratory::Robot', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_Laboratory.RobotPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

        def ice_staticId():
            return '::Laboratory::Robot'
        ice_staticId = staticmethod(ice_staticId)

    _M_Laboratory._t_RobotPrx = IcePy.defineProxy('::Laboratory::Robot', RobotPrx)

    _M_Laboratory._t_Robot = IcePy.defineClass('::Laboratory::Robot', Robot, -1, (), True, False, None, (_M_Laboratory._t_Device,), ())
    Robot._ice_type = _M_Laboratory._t_Robot

    Robot._op_turnOn = IcePy.Operation('turnOn', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (), (), None, (_M_Laboratory._t_BadRobotStateException,))
    Robot._op_turnOff = IcePy.Operation('turnOff', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (), (), None, (_M_Laboratory._t_BadRobotStateException,))
    Robot._op_moveTo = IcePy.Operation('moveTo', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), _M_Laboratory._t_Point, False, 0),), (), None, (_M_Laboratory._t_BadRobotStateException,))

    _M_Laboratory.Robot = Robot
    del Robot

    _M_Laboratory.RobotPrx = RobotPrx
    del RobotPrx

if 'ArmLengthOutOfRangeException' not in _M_Laboratory.__dict__:
    _M_Laboratory.ArmLengthOutOfRangeException = Ice.createTempClass()
    class ArmLengthOutOfRangeException(Ice.UserException):
        def __init__(self, minLength=0, maxLength=0, message=''):
            self.minLength = minLength
            self.maxLength = maxLength
            self.message = message

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Laboratory::ArmLengthOutOfRangeException'

    _M_Laboratory._t_ArmLengthOutOfRangeException = IcePy.defineException('::Laboratory::ArmLengthOutOfRangeException', ArmLengthOutOfRangeException, (), False, None, (
        ('minLength', (), IcePy._t_int, False, 0),
        ('maxLength', (), IcePy._t_int, False, 0),
        ('message', (), IcePy._t_string, False, 0)
    ))
    ArmLengthOutOfRangeException._ice_type = _M_Laboratory._t_ArmLengthOutOfRangeException

    _M_Laboratory.ArmLengthOutOfRangeException = ArmLengthOutOfRangeException
    del ArmLengthOutOfRangeException

if 'BadArmStateException' not in _M_Laboratory.__dict__:
    _M_Laboratory.BadArmStateException = Ice.createTempClass()
    class BadArmStateException(Ice.UserException):
        def __init__(self, message=''):
            self.message = message

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Laboratory::BadArmStateException'

    _M_Laboratory._t_BadArmStateException = IcePy.defineException('::Laboratory::BadArmStateException', BadArmStateException, (), False, None, (('message', (), IcePy._t_string, False, 0),))
    BadArmStateException._ice_type = _M_Laboratory._t_BadArmStateException

    _M_Laboratory.BadArmStateException = BadArmStateException
    del BadArmStateException

if 'RobotWithArm' not in _M_Laboratory.__dict__:
    _M_Laboratory.RobotWithArm = Ice.createTempClass()
    class RobotWithArm(_M_Laboratory.Robot):
        def __init__(self):
            if Ice.getType(self) == _M_Laboratory.RobotWithArm:
                raise RuntimeError('Laboratory.RobotWithArm is an abstract class')

        def ice_ids(self, current=None):
            return ('::Ice::Object', '::Laboratory::Device', '::Laboratory::Robot', '::Laboratory::RobotWithArm')

        def ice_id(self, current=None):
            return '::Laboratory::RobotWithArm'

        def ice_staticId():
            return '::Laboratory::RobotWithArm'
        ice_staticId = staticmethod(ice_staticId)

        def releaseArm(self, distance, current=None):
            pass

        def pocketArm(self, current=None):
            pass

        def grabItem(self, power, current=None):
            pass

        def dropItem(self, current=None):
            pass

        def __str__(self):
            return IcePy.stringify(self, _M_Laboratory._t_RobotWithArm)

        __repr__ = __str__

    _M_Laboratory.RobotWithArmPrx = Ice.createTempClass()
    class RobotWithArmPrx(_M_Laboratory.RobotPrx):

        def releaseArm(self, distance, _ctx=None):
            return _M_Laboratory.RobotWithArm._op_releaseArm.invoke(self, ((distance, ), _ctx))

        def begin_releaseArm(self, distance, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_Laboratory.RobotWithArm._op_releaseArm.begin(self, ((distance, ), _response, _ex, _sent, _ctx))

        def end_releaseArm(self, _r):
            return _M_Laboratory.RobotWithArm._op_releaseArm.end(self, _r)

        def pocketArm(self, _ctx=None):
            return _M_Laboratory.RobotWithArm._op_pocketArm.invoke(self, ((), _ctx))

        def begin_pocketArm(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_Laboratory.RobotWithArm._op_pocketArm.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_pocketArm(self, _r):
            return _M_Laboratory.RobotWithArm._op_pocketArm.end(self, _r)

        def grabItem(self, power, _ctx=None):
            return _M_Laboratory.RobotWithArm._op_grabItem.invoke(self, ((power, ), _ctx))

        def begin_grabItem(self, power, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_Laboratory.RobotWithArm._op_grabItem.begin(self, ((power, ), _response, _ex, _sent, _ctx))

        def end_grabItem(self, _r):
            return _M_Laboratory.RobotWithArm._op_grabItem.end(self, _r)

        def dropItem(self, _ctx=None):
            return _M_Laboratory.RobotWithArm._op_dropItem.invoke(self, ((), _ctx))

        def begin_dropItem(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_Laboratory.RobotWithArm._op_dropItem.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_dropItem(self, _r):
            return _M_Laboratory.RobotWithArm._op_dropItem.end(self, _r)

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_Laboratory.RobotWithArmPrx.ice_checkedCast(proxy, '::Laboratory::RobotWithArm', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_Laboratory.RobotWithArmPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

        def ice_staticId():
            return '::Laboratory::RobotWithArm'
        ice_staticId = staticmethod(ice_staticId)

    _M_Laboratory._t_RobotWithArmPrx = IcePy.defineProxy('::Laboratory::RobotWithArm', RobotWithArmPrx)

    _M_Laboratory._t_RobotWithArm = IcePy.defineClass('::Laboratory::RobotWithArm', RobotWithArm, -1, (), True, False, None, (_M_Laboratory._t_Robot,), ())
    RobotWithArm._ice_type = _M_Laboratory._t_RobotWithArm

    RobotWithArm._op_releaseArm = IcePy.Operation('releaseArm', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_int, False, 0),), (), None, (_M_Laboratory._t_ArmLengthOutOfRangeException, _M_Laboratory._t_BadRobotStateException))
    RobotWithArm._op_pocketArm = IcePy.Operation('pocketArm', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (), (), None, (_M_Laboratory._t_BadArmStateException, _M_Laboratory._t_BadRobotStateException))
    RobotWithArm._op_grabItem = IcePy.Operation('grabItem', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_int, False, 0),), (), None, (_M_Laboratory._t_BadArmStateException, _M_Laboratory._t_BadRobotStateException))
    RobotWithArm._op_dropItem = IcePy.Operation('dropItem', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (), (), None, (_M_Laboratory._t_BadArmStateException, _M_Laboratory._t_BadRobotStateException))

    _M_Laboratory.RobotWithArm = RobotWithArm
    del RobotWithArm

    _M_Laboratory.RobotWithArmPrx = RobotWithArmPrx
    del RobotWithArmPrx

if 'ShovelHeightOutOfRangeException' not in _M_Laboratory.__dict__:
    _M_Laboratory.ShovelHeightOutOfRangeException = Ice.createTempClass()
    class ShovelHeightOutOfRangeException(Ice.UserException):
        def __init__(self, minShovelHeight=0, maxShovelHeight=0, message=''):
            self.minShovelHeight = minShovelHeight
            self.maxShovelHeight = maxShovelHeight
            self.message = message

        def __str__(self):
            return IcePy.stringifyException(self)

        __repr__ = __str__

        _ice_name = 'Laboratory::ShovelHeightOutOfRangeException'

    _M_Laboratory._t_ShovelHeightOutOfRangeException = IcePy.defineException('::Laboratory::ShovelHeightOutOfRangeException', ShovelHeightOutOfRangeException, (), False, None, (
        ('minShovelHeight', (), IcePy._t_int, False, 0),
        ('maxShovelHeight', (), IcePy._t_int, False, 0),
        ('message', (), IcePy._t_string, False, 0)
    ))
    ShovelHeightOutOfRangeException._ice_type = _M_Laboratory._t_ShovelHeightOutOfRangeException

    _M_Laboratory.ShovelHeightOutOfRangeException = ShovelHeightOutOfRangeException
    del ShovelHeightOutOfRangeException

if 'RobotWithShovel' not in _M_Laboratory.__dict__:
    _M_Laboratory.RobotWithShovel = Ice.createTempClass()
    class RobotWithShovel(_M_Laboratory.Robot):
        def __init__(self):
            if Ice.getType(self) == _M_Laboratory.RobotWithShovel:
                raise RuntimeError('Laboratory.RobotWithShovel is an abstract class')

        def ice_ids(self, current=None):
            return ('::Ice::Object', '::Laboratory::Device', '::Laboratory::Robot', '::Laboratory::RobotWithShovel')

        def ice_id(self, current=None):
            return '::Laboratory::RobotWithShovel'

        def ice_staticId():
            return '::Laboratory::RobotWithShovel'
        ice_staticId = staticmethod(ice_staticId)

        def setShovelHeight(self, height, current=None):
            pass

        def __str__(self):
            return IcePy.stringify(self, _M_Laboratory._t_RobotWithShovel)

        __repr__ = __str__

    _M_Laboratory.RobotWithShovelPrx = Ice.createTempClass()
    class RobotWithShovelPrx(_M_Laboratory.RobotPrx):

        def setShovelHeight(self, height, _ctx=None):
            return _M_Laboratory.RobotWithShovel._op_setShovelHeight.invoke(self, ((height, ), _ctx))

        def begin_setShovelHeight(self, height, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_Laboratory.RobotWithShovel._op_setShovelHeight.begin(self, ((height, ), _response, _ex, _sent, _ctx))

        def end_setShovelHeight(self, _r):
            return _M_Laboratory.RobotWithShovel._op_setShovelHeight.end(self, _r)

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_Laboratory.RobotWithShovelPrx.ice_checkedCast(proxy, '::Laboratory::RobotWithShovel', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_Laboratory.RobotWithShovelPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

        def ice_staticId():
            return '::Laboratory::RobotWithShovel'
        ice_staticId = staticmethod(ice_staticId)

    _M_Laboratory._t_RobotWithShovelPrx = IcePy.defineProxy('::Laboratory::RobotWithShovel', RobotWithShovelPrx)

    _M_Laboratory._t_RobotWithShovel = IcePy.defineClass('::Laboratory::RobotWithShovel', RobotWithShovel, -1, (), True, False, None, (_M_Laboratory._t_Robot,), ())
    RobotWithShovel._ice_type = _M_Laboratory._t_RobotWithShovel

    RobotWithShovel._op_setShovelHeight = IcePy.Operation('setShovelHeight', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_int, False, 0),), (), None, (_M_Laboratory._t_ShovelHeightOutOfRangeException, _M_Laboratory._t_BadRobotStateException))

    _M_Laboratory.RobotWithShovel = RobotWithShovel
    del RobotWithShovel

    _M_Laboratory.RobotWithShovelPrx = RobotWithShovelPrx
    del RobotWithShovelPrx

# End of module Laboratory
