# -*- coding: utf-8 -*-
# **********************************************************************
#
# Copyright (c) 2003-2017 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.7.0
#
# <auto-generated>
#
# Generated from file `RecordVideo.ice'
#
# Warning: do not edit this file.
#
# </auto-generated>
#

from sys import version_info as _version_info_
import Ice, IcePy

# Start of module RecordVideo
_M_RecordVideo = Ice.openModule('RecordVideo')
__name__ = 'RecordVideo'

if '_t_ByteSequence' not in _M_RecordVideo.__dict__:
    _M_RecordVideo._t_ByteSequence = IcePy.defineSequence('::RecordVideo::ByteSequence', (), IcePy._t_byte)

_M_RecordVideo._t_Recorder = IcePy.defineValue('::RecordVideo::Recorder', Ice.Value, -1, (), False, True, None, ())

if 'RecorderPrx' not in _M_RecordVideo.__dict__:
    _M_RecordVideo.RecorderPrx = Ice.createTempClass()
    class RecorderPrx(Ice.ObjectPrx):

        def recordVideo(self, rtsp, ms, context=None):
            return _M_RecordVideo.Recorder._op_recordVideo.invoke(self, ((rtsp, ms), context))

        def recordVideoAsync(self, rtsp, ms, context=None):
            return _M_RecordVideo.Recorder._op_recordVideo.invokeAsync(self, ((rtsp, ms), context))

        def begin_recordVideo(self, rtsp, ms, _response=None, _ex=None, _sent=None, context=None):
            return _M_RecordVideo.Recorder._op_recordVideo.begin(self, ((rtsp, ms), _response, _ex, _sent, context))

        def end_recordVideo(self, _r):
            return _M_RecordVideo.Recorder._op_recordVideo.end(self, _r)

        @staticmethod
        def checkedCast(proxy, facetOrContext=None, context=None):
            return _M_RecordVideo.RecorderPrx.ice_checkedCast(proxy, '::RecordVideo::Recorder', facetOrContext, context)

        @staticmethod
        def uncheckedCast(proxy, facet=None):
            return _M_RecordVideo.RecorderPrx.ice_uncheckedCast(proxy, facet)

        @staticmethod
        def ice_staticId():
            return '::RecordVideo::Recorder'
    _M_RecordVideo._t_RecorderPrx = IcePy.defineProxy('::RecordVideo::Recorder', RecorderPrx)

    _M_RecordVideo.RecorderPrx = RecorderPrx
    del RecorderPrx

    _M_RecordVideo.Recorder = Ice.createTempClass()
    class Recorder(Ice.Object):

        def ice_ids(self, current=None):
            return ('::Ice::Object', '::RecordVideo::Recorder')

        def ice_id(self, current=None):
            return '::RecordVideo::Recorder'

        @staticmethod
        def ice_staticId():
            return '::RecordVideo::Recorder'

        def recordVideo(self, rtsp, ms, current=None):
            raise NotImplementedError("servant method 'recordVideo' not implemented")

        def __str__(self):
            return IcePy.stringify(self, _M_RecordVideo._t_RecorderDisp)

        __repr__ = __str__

    _M_RecordVideo._t_RecorderDisp = IcePy.defineClass('::RecordVideo::Recorder', Recorder, (), None, ())
    Recorder._ice_type = _M_RecordVideo._t_RecorderDisp

    Recorder._op_recordVideo = IcePy.Operation('recordVideo', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_string, False, 0), ((), IcePy._t_long, False, 0)), (), ((), IcePy._t_string, False, 0), ())

    _M_RecordVideo.Recorder = Recorder
    del Recorder

_M_RecordVideo._t_ImageGrabber = IcePy.defineValue('::RecordVideo::ImageGrabber', Ice.Value, -1, (), False, True, None, ())

if 'ImageGrabberPrx' not in _M_RecordVideo.__dict__:
    _M_RecordVideo.ImageGrabberPrx = Ice.createTempClass()
    class ImageGrabberPrx(Ice.ObjectPrx):

        def grabImage(self, index, time, context=None):
            return _M_RecordVideo.ImageGrabber._op_grabImage.invoke(self, ((index, time), context))

        def grabImageAsync(self, index, time, context=None):
            return _M_RecordVideo.ImageGrabber._op_grabImage.invokeAsync(self, ((index, time), context))

        def begin_grabImage(self, index, time, _response=None, _ex=None, _sent=None, context=None):
            return _M_RecordVideo.ImageGrabber._op_grabImage.begin(self, ((index, time), _response, _ex, _sent, context))

        def end_grabImage(self, _r):
            return _M_RecordVideo.ImageGrabber._op_grabImage.end(self, _r)

        def grabImageUrl(self, index, time, context=None):
            return _M_RecordVideo.ImageGrabber._op_grabImageUrl.invoke(self, ((index, time), context))

        def grabImageUrlAsync(self, index, time, context=None):
            return _M_RecordVideo.ImageGrabber._op_grabImageUrl.invokeAsync(self, ((index, time), context))

        def begin_grabImageUrl(self, index, time, _response=None, _ex=None, _sent=None, context=None):
            return _M_RecordVideo.ImageGrabber._op_grabImageUrl.begin(self, ((index, time), _response, _ex, _sent, context))

        def end_grabImageUrl(self, _r):
            return _M_RecordVideo.ImageGrabber._op_grabImageUrl.end(self, _r)

        @staticmethod
        def checkedCast(proxy, facetOrContext=None, context=None):
            return _M_RecordVideo.ImageGrabberPrx.ice_checkedCast(proxy, '::RecordVideo::ImageGrabber', facetOrContext, context)

        @staticmethod
        def uncheckedCast(proxy, facet=None):
            return _M_RecordVideo.ImageGrabberPrx.ice_uncheckedCast(proxy, facet)

        @staticmethod
        def ice_staticId():
            return '::RecordVideo::ImageGrabber'
    _M_RecordVideo._t_ImageGrabberPrx = IcePy.defineProxy('::RecordVideo::ImageGrabber', ImageGrabberPrx)

    _M_RecordVideo.ImageGrabberPrx = ImageGrabberPrx
    del ImageGrabberPrx

    _M_RecordVideo.ImageGrabber = Ice.createTempClass()
    class ImageGrabber(Ice.Object):

        def ice_ids(self, current=None):
            return ('::Ice::Object', '::RecordVideo::ImageGrabber')

        def ice_id(self, current=None):
            return '::RecordVideo::ImageGrabber'

        @staticmethod
        def ice_staticId():
            return '::RecordVideo::ImageGrabber'

        def grabImage(self, index, time, current=None):
            raise NotImplementedError("servant method 'grabImage' not implemented")

        def grabImageUrl(self, index, time, current=None):
            raise NotImplementedError("servant method 'grabImageUrl' not implemented")

        def __str__(self):
            return IcePy.stringify(self, _M_RecordVideo._t_ImageGrabberDisp)

        __repr__ = __str__

    _M_RecordVideo._t_ImageGrabberDisp = IcePy.defineClass('::RecordVideo::ImageGrabber', ImageGrabber, (), None, ())
    ImageGrabber._ice_type = _M_RecordVideo._t_ImageGrabberDisp

    ImageGrabber._op_grabImage = IcePy.Operation('grabImage', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_int, False, 0), ((), IcePy._t_string, False, 0)), (), ((), _M_RecordVideo._t_ByteSequence, False, 0), ())
    ImageGrabber._op_grabImageUrl = IcePy.Operation('grabImageUrl', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_int, False, 0), ((), IcePy._t_string, False, 0)), (), ((), IcePy._t_string, False, 0), ())

    _M_RecordVideo.ImageGrabber = ImageGrabber
    del ImageGrabber

_M_RecordVideo._t_LoopRecorder = IcePy.defineValue('::RecordVideo::LoopRecorder', Ice.Value, -1, (), False, True, None, ())

if 'LoopRecorderPrx' not in _M_RecordVideo.__dict__:
    _M_RecordVideo.LoopRecorderPrx = Ice.createTempClass()
    class LoopRecorderPrx(Ice.ObjectPrx):

        def addCamera(self, index, rtsp, context=None):
            return _M_RecordVideo.LoopRecorder._op_addCamera.invoke(self, ((index, rtsp), context))

        def addCameraAsync(self, index, rtsp, context=None):
            return _M_RecordVideo.LoopRecorder._op_addCamera.invokeAsync(self, ((index, rtsp), context))

        def begin_addCamera(self, index, rtsp, _response=None, _ex=None, _sent=None, context=None):
            return _M_RecordVideo.LoopRecorder._op_addCamera.begin(self, ((index, rtsp), _response, _ex, _sent, context))

        def end_addCamera(self, _r):
            return _M_RecordVideo.LoopRecorder._op_addCamera.end(self, _r)

        def removeCamera(self, index, context=None):
            return _M_RecordVideo.LoopRecorder._op_removeCamera.invoke(self, ((index, ), context))

        def removeCameraAsync(self, index, context=None):
            return _M_RecordVideo.LoopRecorder._op_removeCamera.invokeAsync(self, ((index, ), context))

        def begin_removeCamera(self, index, _response=None, _ex=None, _sent=None, context=None):
            return _M_RecordVideo.LoopRecorder._op_removeCamera.begin(self, ((index, ), _response, _ex, _sent, context))

        def end_removeCamera(self, _r):
            return _M_RecordVideo.LoopRecorder._op_removeCamera.end(self, _r)

        def clearCamera(self, context=None):
            return _M_RecordVideo.LoopRecorder._op_clearCamera.invoke(self, ((), context))

        def clearCameraAsync(self, context=None):
            return _M_RecordVideo.LoopRecorder._op_clearCamera.invokeAsync(self, ((), context))

        def begin_clearCamera(self, _response=None, _ex=None, _sent=None, context=None):
            return _M_RecordVideo.LoopRecorder._op_clearCamera.begin(self, ((), _response, _ex, _sent, context))

        def end_clearCamera(self, _r):
            return _M_RecordVideo.LoopRecorder._op_clearCamera.end(self, _r)

        def feedDog(self, index, context=None):
            return _M_RecordVideo.LoopRecorder._op_feedDog.invoke(self, ((index, ), context))

        def feedDogAsync(self, index, context=None):
            return _M_RecordVideo.LoopRecorder._op_feedDog.invokeAsync(self, ((index, ), context))

        def begin_feedDog(self, index, _response=None, _ex=None, _sent=None, context=None):
            return _M_RecordVideo.LoopRecorder._op_feedDog.begin(self, ((index, ), _response, _ex, _sent, context))

        def end_feedDog(self, _r):
            return _M_RecordVideo.LoopRecorder._op_feedDog.end(self, _r)

        @staticmethod
        def checkedCast(proxy, facetOrContext=None, context=None):
            return _M_RecordVideo.LoopRecorderPrx.ice_checkedCast(proxy, '::RecordVideo::LoopRecorder', facetOrContext, context)

        @staticmethod
        def uncheckedCast(proxy, facet=None):
            return _M_RecordVideo.LoopRecorderPrx.ice_uncheckedCast(proxy, facet)

        @staticmethod
        def ice_staticId():
            return '::RecordVideo::LoopRecorder'
    _M_RecordVideo._t_LoopRecorderPrx = IcePy.defineProxy('::RecordVideo::LoopRecorder', LoopRecorderPrx)

    _M_RecordVideo.LoopRecorderPrx = LoopRecorderPrx
    del LoopRecorderPrx

    _M_RecordVideo.LoopRecorder = Ice.createTempClass()
    class LoopRecorder(Ice.Object):

        def ice_ids(self, current=None):
            return ('::Ice::Object', '::RecordVideo::LoopRecorder')

        def ice_id(self, current=None):
            return '::RecordVideo::LoopRecorder'

        @staticmethod
        def ice_staticId():
            return '::RecordVideo::LoopRecorder'

        def addCamera(self, index, rtsp, current=None):
            raise NotImplementedError("servant method 'addCamera' not implemented")

        def removeCamera(self, index, current=None):
            raise NotImplementedError("servant method 'removeCamera' not implemented")

        def clearCamera(self, current=None):
            raise NotImplementedError("servant method 'clearCamera' not implemented")

        def feedDog(self, index, current=None):
            raise NotImplementedError("servant method 'feedDog' not implemented")

        def __str__(self):
            return IcePy.stringify(self, _M_RecordVideo._t_LoopRecorderDisp)

        __repr__ = __str__

    _M_RecordVideo._t_LoopRecorderDisp = IcePy.defineClass('::RecordVideo::LoopRecorder', LoopRecorder, (), None, ())
    LoopRecorder._ice_type = _M_RecordVideo._t_LoopRecorderDisp

    LoopRecorder._op_addCamera = IcePy.Operation('addCamera', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_string, False, 0), ((), IcePy._t_string, False, 0)), (), ((), IcePy._t_string, False, 0), ())
    LoopRecorder._op_removeCamera = IcePy.Operation('removeCamera', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_string, False, 0),), (), None, ())
    LoopRecorder._op_clearCamera = IcePy.Operation('clearCamera', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (), (), None, ())
    LoopRecorder._op_feedDog = IcePy.Operation('feedDog', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), IcePy._t_string, False, 0),), (), None, ())

    _M_RecordVideo.LoopRecorder = LoopRecorder
    del LoopRecorder

# End of module RecordVideo