# **********************************************************************
#
# Copyright (c) 2003-2013 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.5.0
#
# <auto-generated>
#
# Generated from file `endpoint.ice'
#
# Warning: do not edit this file.
#
# </auto-generated>
#

import Ice, IcePy

# Start of module EndPointCtrl
_M_EndPointCtrl = Ice.openModule('EndPointCtrl')
__name__ = 'EndPointCtrl'

if 'TransType' not in _M_EndPointCtrl.__dict__:
    _M_EndPointCtrl.TransType = Ice.createTempClass()
    class TransType(Ice.EnumBase):

        def __init__(self, _n, _v):
            Ice.EnumBase.__init__(self, _n, _v)

        def valueOf(self, _n):
            if _n in self._enumerators:
                return self._enumerators[_n]
            return None
        valueOf = classmethod(valueOf)

    TransType.tcp = TransType("tcp", 0)
    TransType.udp = TransType("udp", 1)
    TransType.sctp = TransType("sctp", 2)
    TransType._enumerators = { 0:TransType.tcp, 1:TransType.udp, 2:TransType.sctp }

    _M_EndPointCtrl._t_TransType = IcePy.defineEnum('::EndPointCtrl::TransType', TransType, (), TransType._enumerators)

    _M_EndPointCtrl.TransType = TransType
    del TransType

if 'Endpoint' not in _M_EndPointCtrl.__dict__:
    _M_EndPointCtrl.Endpoint = Ice.createTempClass()
    class Endpoint(object):
        def __init__(self, ctrlAddr='', svcAddr=''):
            self.ctrlAddr = ctrlAddr
            self.svcAddr = svcAddr

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

        def __compare(self, other):
            if other is None:
                return 1
            elif not isinstance(other, _M_EndPointCtrl.Endpoint):
                return NotImplemented
            else:
                if self.ctrlAddr is None or other.ctrlAddr is None:
                    if self.ctrlAddr != other.ctrlAddr:
                        return (-1 if self.ctrlAddr is None else 1)
                else:
                    if self.ctrlAddr < other.ctrlAddr:
                        return -1
                    elif self.ctrlAddr > other.ctrlAddr:
                        return 1
                if self.svcAddr is None or other.svcAddr is None:
                    if self.svcAddr != other.svcAddr:
                        return (-1 if self.svcAddr is None else 1)
                else:
                    if self.svcAddr < other.svcAddr:
                        return -1
                    elif self.svcAddr > other.svcAddr:
                        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_EndPointCtrl._t_Endpoint)

        __repr__ = __str__

    _M_EndPointCtrl._t_Endpoint = IcePy.defineStruct('::EndPointCtrl::Endpoint', Endpoint, (), (
        ('ctrlAddr', (), IcePy._t_string),
        ('svcAddr', (), IcePy._t_string)
    ))

    _M_EndPointCtrl.Endpoint = Endpoint
    del Endpoint

if 'Pair' not in _M_EndPointCtrl.__dict__:
    _M_EndPointCtrl.Pair = Ice.createTempClass()
    class Pair(object):
        def __init__(self, uuid='', type=_M_EndPointCtrl.TransType.tcp, ipver=0, ep1=Ice._struct_marker, ep2=Ice._struct_marker):
            self.uuid = uuid
            self.type = type
            self.ipver = ipver
            if ep1 is Ice._struct_marker:
                self.ep1 = _M_EndPointCtrl.Endpoint()
            else:
                self.ep1 = ep1
            if ep2 is Ice._struct_marker:
                self.ep2 = _M_EndPointCtrl.Endpoint()
            else:
                self.ep2 = ep2

        def __hash__(self):
            _h = 0
            _h = 5 * _h + Ice.getHash(self.uuid)
            _h = 5 * _h + Ice.getHash(self.type)
            _h = 5 * _h + Ice.getHash(self.ipver)
            _h = 5 * _h + Ice.getHash(self.ep1)
            _h = 5 * _h + Ice.getHash(self.ep2)
            return _h % 0x7fffffff

        def __compare(self, other):
            if other is None:
                return 1
            elif not isinstance(other, _M_EndPointCtrl.Pair):
                return NotImplemented
            else:
                if self.uuid is None or other.uuid is None:
                    if self.uuid != other.uuid:
                        return (-1 if self.uuid is None else 1)
                else:
                    if self.uuid < other.uuid:
                        return -1
                    elif self.uuid > other.uuid:
                        return 1
                if self.type is None or other.type is None:
                    if self.type != other.type:
                        return (-1 if self.type is None else 1)
                else:
                    if self.type < other.type:
                        return -1
                    elif self.type > other.type:
                        return 1
                if self.ipver is None or other.ipver is None:
                    if self.ipver != other.ipver:
                        return (-1 if self.ipver is None else 1)
                else:
                    if self.ipver < other.ipver:
                        return -1
                    elif self.ipver > other.ipver:
                        return 1
                if self.ep1 is None or other.ep1 is None:
                    if self.ep1 != other.ep1:
                        return (-1 if self.ep1 is None else 1)
                else:
                    if self.ep1 < other.ep1:
                        return -1
                    elif self.ep1 > other.ep1:
                        return 1
                if self.ep2 is None or other.ep2 is None:
                    if self.ep2 != other.ep2:
                        return (-1 if self.ep2 is None else 1)
                else:
                    if self.ep2 < other.ep2:
                        return -1
                    elif self.ep2 > other.ep2:
                        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_EndPointCtrl._t_Pair)

        __repr__ = __str__

    _M_EndPointCtrl._t_Pair = IcePy.defineStruct('::EndPointCtrl::Pair', Pair, (), (
        ('uuid', (), IcePy._t_string),
        ('type', (), _M_EndPointCtrl._t_TransType),
        ('ipver', (), IcePy._t_int),
        ('ep1', (), _M_EndPointCtrl._t_Endpoint),
        ('ep2', (), _M_EndPointCtrl._t_Endpoint)
    ))

    _M_EndPointCtrl.Pair = Pair
    del Pair

if 'GetResultItem' not in _M_EndPointCtrl.__dict__:
    _M_EndPointCtrl.GetResultItem = Ice.createTempClass()
    class GetResultItem(object):
        def __init__(self, uuid='', needStop=False):
            self.uuid = uuid
            self.needStop = needStop

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

        def __compare(self, other):
            if other is None:
                return 1
            elif not isinstance(other, _M_EndPointCtrl.GetResultItem):
                return NotImplemented
            else:
                if self.uuid is None or other.uuid is None:
                    if self.uuid != other.uuid:
                        return (-1 if self.uuid is None else 1)
                else:
                    if self.uuid < other.uuid:
                        return -1
                    elif self.uuid > other.uuid:
                        return 1
                if self.needStop is None or other.needStop is None:
                    if self.needStop != other.needStop:
                        return (-1 if self.needStop is None else 1)
                else:
                    if self.needStop < other.needStop:
                        return -1
                    elif self.needStop > other.needStop:
                        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_EndPointCtrl._t_GetResultItem)

        __repr__ = __str__

    _M_EndPointCtrl._t_GetResultItem = IcePy.defineStruct('::EndPointCtrl::GetResultItem', GetResultItem, (), (
        ('uuid', (), IcePy._t_string),
        ('needStop', (), IcePy._t_bool)
    ))

    _M_EndPointCtrl.GetResultItem = GetResultItem
    del GetResultItem

if '_t_Qpair' not in _M_EndPointCtrl.__dict__:
    _M_EndPointCtrl._t_Qpair = IcePy.defineSequence('::EndPointCtrl::Qpair', (), _M_EndPointCtrl._t_Pair)

if '_t_QGetResultUuid' not in _M_EndPointCtrl.__dict__:
    _M_EndPointCtrl._t_QGetResultUuid = IcePy.defineSequence('::EndPointCtrl::QGetResultUuid', (), _M_EndPointCtrl._t_GetResultItem)

if 'AddPairResult' not in _M_EndPointCtrl.__dict__:
    _M_EndPointCtrl.AddPairResult = Ice.createTempClass()
    class AddPairResult(object):
        def __init__(self, uuid='', port=0):
            self.uuid = uuid
            self.port = port

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

        def __compare(self, other):
            if other is None:
                return 1
            elif not isinstance(other, _M_EndPointCtrl.AddPairResult):
                return NotImplemented
            else:
                if self.uuid is None or other.uuid is None:
                    if self.uuid != other.uuid:
                        return (-1 if self.uuid is None else 1)
                else:
                    if self.uuid < other.uuid:
                        return -1
                    elif self.uuid > other.uuid:
                        return 1
                if self.port is None or other.port is None:
                    if self.port != other.port:
                        return (-1 if self.port is None else 1)
                else:
                    if self.port < other.port:
                        return -1
                    elif self.port > other.port:
                        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_EndPointCtrl._t_AddPairResult)

        __repr__ = __str__

    _M_EndPointCtrl._t_AddPairResult = IcePy.defineStruct('::EndPointCtrl::AddPairResult', AddPairResult, (), (
        ('uuid', (), IcePy._t_string),
        ('port', (), IcePy._t_short)
    ))

    _M_EndPointCtrl.AddPairResult = AddPairResult
    del AddPairResult

if '_t_QaddPairResult' not in _M_EndPointCtrl.__dict__:
    _M_EndPointCtrl._t_QaddPairResult = IcePy.defineSequence('::EndPointCtrl::QaddPairResult', (), _M_EndPointCtrl._t_AddPairResult)

if 'StatsType' not in _M_EndPointCtrl.__dict__:
    _M_EndPointCtrl.StatsType = Ice.createTempClass()
    class StatsType(Ice.EnumBase):

        def __init__(self, _n, _v):
            Ice.EnumBase.__init__(self, _n, _v)

        def valueOf(self, _n):
            if _n in self._enumerators:
                return self._enumerators[_n]
            return None
        valueOf = classmethod(valueOf)

    StatsType.sendbytes = StatsType("sendbytes", 0)
    StatsType.sendbps = StatsType("sendbps", 1)
    StatsType.recvbytes = StatsType("recvbytes", 2)
    StatsType.recvbps = StatsType("recvbps", 3)
    StatsType.retransmits = StatsType("retransmits", 4)
    StatsType.omitted = StatsType("omitted", 5)
    StatsType.jitterms = StatsType("jitterms", 6)
    StatsType.lostpackets = StatsType("lostpackets", 7)
    StatsType.packets = StatsType("packets", 8)
    StatsType.lostpercent = StatsType("lostpercent", 9)
    StatsType._enumerators = { 0:StatsType.sendbytes, 1:StatsType.sendbps, 2:StatsType.recvbytes, 3:StatsType.recvbps, 4:StatsType.retransmits, 5:StatsType.omitted, 6:StatsType.jitterms, 7:StatsType.lostpackets, 8:StatsType.packets, 9:StatsType.lostpercent }

    _M_EndPointCtrl._t_StatsType = IcePy.defineEnum('::EndPointCtrl::StatsType', StatsType, (), StatsType._enumerators)

    _M_EndPointCtrl.StatsType = StatsType
    del StatsType

if 'StatsItem' not in _M_EndPointCtrl.__dict__:
    _M_EndPointCtrl.StatsItem = Ice.createTempClass()
    class StatsItem(object):
        def __init__(self, type=_M_EndPointCtrl.StatsType.sendbytes, value=0.0):
            self.type = type
            self.value = value

        def __eq__(self, other):
            if other is None:
                return False
            elif not isinstance(other, _M_EndPointCtrl.StatsItem):
                return NotImplemented
            else:
                if self.type != other.type:
                    return False
                if self.value != other.value:
                    return False
                return True

        def __ne__(self, other):
            return not self.__eq__(other)

        def __str__(self):
            return IcePy.stringify(self, _M_EndPointCtrl._t_StatsItem)

        __repr__ = __str__

    _M_EndPointCtrl._t_StatsItem = IcePy.defineStruct('::EndPointCtrl::StatsItem', StatsItem, (), (
        ('type', (), _M_EndPointCtrl._t_StatsType),
        ('value', (), IcePy._t_double)
    ))

    _M_EndPointCtrl.StatsItem = StatsItem
    del StatsItem

if '_t_QstatsList' not in _M_EndPointCtrl.__dict__:
    _M_EndPointCtrl._t_QstatsList = IcePy.defineSequence('::EndPointCtrl::QstatsList', (), _M_EndPointCtrl._t_StatsItem)

if 'StatsTimeItem' not in _M_EndPointCtrl.__dict__:
    _M_EndPointCtrl.StatsTimeItem = Ice.createTempClass()
    class StatsTimeItem(object):
        def __init__(self, timestamp=0, statslist=None):
            self.timestamp = timestamp
            self.statslist = statslist

        def __eq__(self, other):
            if other is None:
                return False
            elif not isinstance(other, _M_EndPointCtrl.StatsTimeItem):
                return NotImplemented
            else:
                if self.timestamp != other.timestamp:
                    return False
                if self.statslist != other.statslist:
                    return False
                return True

        def __ne__(self, other):
            return not self.__eq__(other)

        def __str__(self):
            return IcePy.stringify(self, _M_EndPointCtrl._t_StatsTimeItem)

        __repr__ = __str__

    _M_EndPointCtrl._t_StatsTimeItem = IcePy.defineStruct('::EndPointCtrl::StatsTimeItem', StatsTimeItem, (), (
        ('timestamp', (), IcePy._t_long),
        ('statslist', (), _M_EndPointCtrl._t_QstatsList)
    ))

    _M_EndPointCtrl.StatsTimeItem = StatsTimeItem
    del StatsTimeItem

if '_t_QstatsTimeList' not in _M_EndPointCtrl.__dict__:
    _M_EndPointCtrl._t_QstatsTimeList = IcePy.defineSequence('::EndPointCtrl::QstatsTimeList', (), _M_EndPointCtrl._t_StatsTimeItem)

if 'PairStatus' not in _M_EndPointCtrl.__dict__:
    _M_EndPointCtrl.PairStatus = Ice.createTempClass()
    class PairStatus(Ice.EnumBase):

        def __init__(self, _n, _v):
            Ice.EnumBase.__init__(self, _n, _v)

        def valueOf(self, _n):
            if _n in self._enumerators:
                return self._enumerators[_n]
            return None
        valueOf = classmethod(valueOf)

    PairStatus.idle = PairStatus("idle", 0)
    PairStatus.init = PairStatus("init", 1)
    PairStatus.running = PairStatus("running", 2)
    PairStatus._enumerators = { 0:PairStatus.idle, 1:PairStatus.init, 2:PairStatus.running }

    _M_EndPointCtrl._t_PairStatus = IcePy.defineEnum('::EndPointCtrl::PairStatus', PairStatus, (), PairStatus._enumerators)

    _M_EndPointCtrl.PairStatus = PairStatus
    del PairStatus

if 'PairStats' not in _M_EndPointCtrl.__dict__:
    _M_EndPointCtrl.PairStats = Ice.createTempClass()
    class PairStats(object):
        def __init__(self, uuid='', status=_M_EndPointCtrl.PairStatus.idle, statstimelist=None):
            self.uuid = uuid
            self.status = status
            self.statstimelist = statstimelist

        def __eq__(self, other):
            if other is None:
                return False
            elif not isinstance(other, _M_EndPointCtrl.PairStats):
                return NotImplemented
            else:
                if self.uuid != other.uuid:
                    return False
                if self.status != other.status:
                    return False
                if self.statstimelist != other.statstimelist:
                    return False
                return True

        def __ne__(self, other):
            return not self.__eq__(other)

        def __str__(self):
            return IcePy.stringify(self, _M_EndPointCtrl._t_PairStats)

        __repr__ = __str__

    _M_EndPointCtrl._t_PairStats = IcePy.defineStruct('::EndPointCtrl::PairStats', PairStats, (), (
        ('uuid', (), IcePy._t_string),
        ('status', (), _M_EndPointCtrl._t_PairStatus),
        ('statstimelist', (), _M_EndPointCtrl._t_QstatsTimeList)
    ))

    _M_EndPointCtrl.PairStats = PairStats
    del PairStats

if '_t_QpairStatsList' not in _M_EndPointCtrl.__dict__:
    _M_EndPointCtrl._t_QpairStatsList = IcePy.defineSequence('::EndPointCtrl::QpairStatsList', (), _M_EndPointCtrl._t_PairStats)

if 'EndPointCtrlInt' not in _M_EndPointCtrl.__dict__:
    _M_EndPointCtrl.EndPointCtrlInt = Ice.createTempClass()
    class EndPointCtrlInt(Ice.Object):
        def __init__(self):
            if Ice.getType(self) == _M_EndPointCtrl.EndPointCtrlInt:
                raise RuntimeError('EndPointCtrl.EndPointCtrlInt is an abstract class')

        def ice_ids(self, current=None):
            return ('::EndPointCtrl::EndPointCtrlInt', '::Ice::Object')

        def ice_id(self, current=None):
            return '::EndPointCtrl::EndPointCtrlInt'

        def ice_staticId():
            return '::EndPointCtrl::EndPointCtrlInt'
        ice_staticId = staticmethod(ice_staticId)

        def AddPairs(self, pairlist, current=None):
            pass

        def DelPairs(self, uuidlist, current=None):
            pass

        def GetResults(self, uuidlist, current=None):
            pass

        def Ep2AddPairs(self, pairlist, current=None):
            pass

        def Ep2DelPairs(self, uuidlist, current=None):
            pass

        def Ep2GetResults(self, uuidlist, current=None):
            pass

        def __str__(self):
            return IcePy.stringify(self, _M_EndPointCtrl._t_EndPointCtrlInt)

        __repr__ = __str__

    _M_EndPointCtrl.EndPointCtrlIntPrx = Ice.createTempClass()
    class EndPointCtrlIntPrx(Ice.ObjectPrx):

        def AddPairs(self, pairlist, _ctx=None):
            return _M_EndPointCtrl.EndPointCtrlInt._op_AddPairs.invoke(self, ((pairlist, ), _ctx))

        def begin_AddPairs(self, pairlist, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_EndPointCtrl.EndPointCtrlInt._op_AddPairs.begin(self, ((pairlist, ), _response, _ex, _sent, _ctx))

        def end_AddPairs(self, _r):
            return _M_EndPointCtrl.EndPointCtrlInt._op_AddPairs.end(self, _r)

        def DelPairs(self, uuidlist, _ctx=None):
            return _M_EndPointCtrl.EndPointCtrlInt._op_DelPairs.invoke(self, ((uuidlist, ), _ctx))

        def begin_DelPairs(self, uuidlist, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_EndPointCtrl.EndPointCtrlInt._op_DelPairs.begin(self, ((uuidlist, ), _response, _ex, _sent, _ctx))

        def end_DelPairs(self, _r):
            return _M_EndPointCtrl.EndPointCtrlInt._op_DelPairs.end(self, _r)

        def GetResults(self, uuidlist, _ctx=None):
            return _M_EndPointCtrl.EndPointCtrlInt._op_GetResults.invoke(self, ((uuidlist, ), _ctx))

        def begin_GetResults(self, uuidlist, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_EndPointCtrl.EndPointCtrlInt._op_GetResults.begin(self, ((uuidlist, ), _response, _ex, _sent, _ctx))

        def end_GetResults(self, _r):
            return _M_EndPointCtrl.EndPointCtrlInt._op_GetResults.end(self, _r)

        def Ep2AddPairs(self, pairlist, _ctx=None):
            return _M_EndPointCtrl.EndPointCtrlInt._op_Ep2AddPairs.invoke(self, ((pairlist, ), _ctx))

        def begin_Ep2AddPairs(self, pairlist, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_EndPointCtrl.EndPointCtrlInt._op_Ep2AddPairs.begin(self, ((pairlist, ), _response, _ex, _sent, _ctx))

        def end_Ep2AddPairs(self, _r):
            return _M_EndPointCtrl.EndPointCtrlInt._op_Ep2AddPairs.end(self, _r)

        def Ep2DelPairs(self, uuidlist, _ctx=None):
            return _M_EndPointCtrl.EndPointCtrlInt._op_Ep2DelPairs.invoke(self, ((uuidlist, ), _ctx))

        def begin_Ep2DelPairs(self, uuidlist, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_EndPointCtrl.EndPointCtrlInt._op_Ep2DelPairs.begin(self, ((uuidlist, ), _response, _ex, _sent, _ctx))

        def end_Ep2DelPairs(self, _r):
            return _M_EndPointCtrl.EndPointCtrlInt._op_Ep2DelPairs.end(self, _r)

        def Ep2GetResults(self, uuidlist, _ctx=None):
            return _M_EndPointCtrl.EndPointCtrlInt._op_Ep2GetResults.invoke(self, ((uuidlist, ), _ctx))

        def begin_Ep2GetResults(self, uuidlist, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_EndPointCtrl.EndPointCtrlInt._op_Ep2GetResults.begin(self, ((uuidlist, ), _response, _ex, _sent, _ctx))

        def end_Ep2GetResults(self, _r):
            return _M_EndPointCtrl.EndPointCtrlInt._op_Ep2GetResults.end(self, _r)

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_EndPointCtrl.EndPointCtrlIntPrx.ice_checkedCast(proxy, '::EndPointCtrl::EndPointCtrlInt', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_EndPointCtrl.EndPointCtrlIntPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

    _M_EndPointCtrl._t_EndPointCtrlIntPrx = IcePy.defineProxy('::EndPointCtrl::EndPointCtrlInt', EndPointCtrlIntPrx)

    _M_EndPointCtrl._t_EndPointCtrlInt = IcePy.defineClass('::EndPointCtrl::EndPointCtrlInt', EndPointCtrlInt, -1, (), True, False, None, (), ())
    EndPointCtrlInt._ice_type = _M_EndPointCtrl._t_EndPointCtrlInt

    EndPointCtrlInt._op_AddPairs = IcePy.Operation('AddPairs', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), _M_EndPointCtrl._t_Qpair, False, 0),), (), ((), _M_EndPointCtrl._t_QaddPairResult, False, 0), ())
    EndPointCtrlInt._op_DelPairs = IcePy.Operation('DelPairs', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), _M_EndPointCtrl._t_QGetResultUuid, False, 0),), (), None, ())
    EndPointCtrlInt._op_GetResults = IcePy.Operation('GetResults', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), _M_EndPointCtrl._t_QGetResultUuid, False, 0),), (), ((), _M_EndPointCtrl._t_QpairStatsList, False, 0), ())
    EndPointCtrlInt._op_Ep2AddPairs = IcePy.Operation('Ep2AddPairs', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), _M_EndPointCtrl._t_Qpair, False, 0),), (), ((), _M_EndPointCtrl._t_QaddPairResult, False, 0), ())
    EndPointCtrlInt._op_Ep2DelPairs = IcePy.Operation('Ep2DelPairs', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), _M_EndPointCtrl._t_QGetResultUuid, False, 0),), (), None, ())
    EndPointCtrlInt._op_Ep2GetResults = IcePy.Operation('Ep2GetResults', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (((), _M_EndPointCtrl._t_QGetResultUuid, False, 0),), (), ((), _M_EndPointCtrl._t_QpairStatsList, False, 0), ())

    _M_EndPointCtrl.EndPointCtrlInt = EndPointCtrlInt
    del EndPointCtrlInt

    _M_EndPointCtrl.EndPointCtrlIntPrx = EndPointCtrlIntPrx
    del EndPointCtrlIntPrx

# End of module EndPointCtrl
