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

from sys import version_info as _version_info_
import Ice, IcePy
import Ice.BuiltinSequences_ice

# Included module Ice
_M_Ice = Ice.openModule('Ice')

# Start of module Ice
__name__ = 'Ice'

_M_Ice._t_Router = IcePy.defineValue('::Ice::Router', Ice.Value, -1, (), False, True, None, ())

if 'RouterPrx' not in _M_Ice.__dict__:
    _M_Ice.RouterPrx = Ice.createTempClass()
    class RouterPrx(Ice.ObjectPrx):

        """
        Get the router's client proxy, i.e., the proxy to use for
        forwarding requests from the client to the router.
        If a null proxy is returned, the client will forward requests
        to the router's endpoints.
        Arguments:
        context -- The request context for the invocation.
        Returns a tuple containing the following:
        _retval -- The router's client proxy.
        hasRoutingTable -- Indicates whether or not the router supports a routing table. If it is supported, the Ice runtime will call addProxies to populate the routing table. This out parameter is only supported starting with Ice 3.7. The Ice runtime assumes the router has a routing table if the optional is not set.
        """
        def getClientProxy(self, context=None):
            return _M_Ice.Router._op_getClientProxy.invoke(self, ((), context))

        """
        Get the router's client proxy, i.e., the proxy to use for
        forwarding requests from the client to the router.
        If a null proxy is returned, the client will forward requests
        to the router's endpoints.
        Arguments:
        context -- The request context for the invocation.
        Returns: A future object for the invocation.
        """
        def getClientProxyAsync(self, context=None):
            return _M_Ice.Router._op_getClientProxy.invokeAsync(self, ((), context))

        """
        Get the router's client proxy, i.e., the proxy to use for
        forwarding requests from the client to the router.
        If a null proxy is returned, the client will forward requests
        to the router's endpoints.
        Arguments:
        _response -- The asynchronous response callback.
        _ex -- The asynchronous exception callback.
        _sent -- The asynchronous sent callback.
        context -- The request context for the invocation.
        Returns: An asynchronous result object for the invocation.
        """
        def begin_getClientProxy(self, _response=None, _ex=None, _sent=None, context=None):
            return _M_Ice.Router._op_getClientProxy.begin(self, ((), _response, _ex, _sent, context))

        """
        Get the router's client proxy, i.e., the proxy to use for
        forwarding requests from the client to the router.
        If a null proxy is returned, the client will forward requests
        to the router's endpoints.
        Arguments:
        Returns a tuple containing the following:
        _retval -- The router's client proxy.
        hasRoutingTable -- Indicates whether or not the router supports a routing table. If it is supported, the Ice runtime will call addProxies to populate the routing table. This out parameter is only supported starting with Ice 3.7. The Ice runtime assumes the router has a routing table if the optional is not set.
        """
        def end_getClientProxy(self, _r):
            return _M_Ice.Router._op_getClientProxy.end(self, _r)

        """
        Get the router's server proxy, i.e., the proxy to use for
        forwarding requests from the server to the router.
        Arguments:
        context -- The request context for the invocation.
        Returns: The router's server proxy.
        """
        def getServerProxy(self, context=None):
            return _M_Ice.Router._op_getServerProxy.invoke(self, ((), context))

        """
        Get the router's server proxy, i.e., the proxy to use for
        forwarding requests from the server to the router.
        Arguments:
        context -- The request context for the invocation.
        Returns: A future object for the invocation.
        """
        def getServerProxyAsync(self, context=None):
            return _M_Ice.Router._op_getServerProxy.invokeAsync(self, ((), context))

        """
        Get the router's server proxy, i.e., the proxy to use for
        forwarding requests from the server to the router.
        Arguments:
        _response -- The asynchronous response callback.
        _ex -- The asynchronous exception callback.
        _sent -- The asynchronous sent callback.
        context -- The request context for the invocation.
        Returns: An asynchronous result object for the invocation.
        """
        def begin_getServerProxy(self, _response=None, _ex=None, _sent=None, context=None):
            return _M_Ice.Router._op_getServerProxy.begin(self, ((), _response, _ex, _sent, context))

        """
        Get the router's server proxy, i.e., the proxy to use for
        forwarding requests from the server to the router.
        Arguments:
        Returns: The router's server proxy.
        """
        def end_getServerProxy(self, _r):
            return _M_Ice.Router._op_getServerProxy.end(self, _r)

        """
        Add new proxy information to the router's routing table.
        Arguments:
        proxies -- The proxies to add.
        context -- The request context for the invocation.
        Returns: Proxies discarded by the router.
        """
        def addProxies(self, proxies, context=None):
            return _M_Ice.Router._op_addProxies.invoke(self, ((proxies, ), context))

        """
        Add new proxy information to the router's routing table.
        Arguments:
        proxies -- The proxies to add.
        context -- The request context for the invocation.
        Returns: A future object for the invocation.
        """
        def addProxiesAsync(self, proxies, context=None):
            return _M_Ice.Router._op_addProxies.invokeAsync(self, ((proxies, ), context))

        """
        Add new proxy information to the router's routing table.
        Arguments:
        proxies -- The proxies to add.
        _response -- The asynchronous response callback.
        _ex -- The asynchronous exception callback.
        _sent -- The asynchronous sent callback.
        context -- The request context for the invocation.
        Returns: An asynchronous result object for the invocation.
        """
        def begin_addProxies(self, proxies, _response=None, _ex=None, _sent=None, context=None):
            return _M_Ice.Router._op_addProxies.begin(self, ((proxies, ), _response, _ex, _sent, context))

        """
        Add new proxy information to the router's routing table.
        Arguments:
        proxies -- The proxies to add.
        Returns: Proxies discarded by the router.
        """
        def end_addProxies(self, _r):
            return _M_Ice.Router._op_addProxies.end(self, _r)

        @staticmethod
        def checkedCast(proxy, facetOrContext=None, context=None):
            return _M_Ice.RouterPrx.ice_checkedCast(proxy, '::Ice::Router', facetOrContext, context)

        @staticmethod
        def uncheckedCast(proxy, facet=None):
            return _M_Ice.RouterPrx.ice_uncheckedCast(proxy, facet)

        @staticmethod
        def ice_staticId():
            return '::Ice::Router'
    _M_Ice._t_RouterPrx = IcePy.defineProxy('::Ice::Router', RouterPrx)

    _M_Ice.RouterPrx = RouterPrx
    del RouterPrx

    _M_Ice.Router = Ice.createTempClass()
    class Router(Ice.Object):

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

        def ice_id(self, current=None):
            return '::Ice::Router'

        @staticmethod
        def ice_staticId():
            return '::Ice::Router'

        def getClientProxy(self, current=None):
            """
            Get the router's client proxy, i.e., the proxy to use for
            forwarding requests from the client to the router.
            If a null proxy is returned, the client will forward requests
            to the router's endpoints.
            Arguments:
            current -- The Current object for the invocation.
            Returns: A future object for the invocation.
            """
            raise NotImplementedError("servant method 'getClientProxy' not implemented")

        def getServerProxy(self, current=None):
            """
            Get the router's server proxy, i.e., the proxy to use for
            forwarding requests from the server to the router.
            Arguments:
            current -- The Current object for the invocation.
            Returns: A future object for the invocation.
            """
            raise NotImplementedError("servant method 'getServerProxy' not implemented")

        def addProxies(self, proxies, current=None):
            """
            Add new proxy information to the router's routing table.
            Arguments:
            proxies -- The proxies to add.
            current -- The Current object for the invocation.
            Returns: A future object for the invocation.
            """
            raise NotImplementedError("servant method 'addProxies' not implemented")

        def __str__(self):
            return IcePy.stringify(self, _M_Ice._t_RouterDisp)

        __repr__ = __str__

    _M_Ice._t_RouterDisp = IcePy.defineClass('::Ice::Router', Router, (), None, ())
    Router._ice_type = _M_Ice._t_RouterDisp

    Router._op_getClientProxy = IcePy.Operation('getClientProxy', Ice.OperationMode.Idempotent, Ice.OperationMode.Nonmutating, False, None, (), (), (((), IcePy._t_bool, True, 1),), ((), IcePy._t_ObjectPrx, False, 0), ())
    Router._op_getServerProxy = IcePy.Operation('getServerProxy', Ice.OperationMode.Idempotent, Ice.OperationMode.Nonmutating, False, None, (), (), (), ((), IcePy._t_ObjectPrx, False, 0), ())
    Router._op_addProxies = IcePy.Operation('addProxies', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, False, None, (), (((), _M_Ice._t_ObjectProxySeq, False, 0),), (), ((), _M_Ice._t_ObjectProxySeq, False, 0), ())

    _M_Ice.Router = Router
    del Router

_M_Ice._t_RouterFinder = IcePy.defineValue('::Ice::RouterFinder', Ice.Value, -1, (), False, True, None, ())

if 'RouterFinderPrx' not in _M_Ice.__dict__:
    _M_Ice.RouterFinderPrx = Ice.createTempClass()
    class RouterFinderPrx(Ice.ObjectPrx):

        """
        Get the router proxy implemented by the process hosting this
        finder object. The proxy might point to several replicas.
        Arguments:
        context -- The request context for the invocation.
        Returns: The router proxy.
        """
        def getRouter(self, context=None):
            return _M_Ice.RouterFinder._op_getRouter.invoke(self, ((), context))

        """
        Get the router proxy implemented by the process hosting this
        finder object. The proxy might point to several replicas.
        Arguments:
        context -- The request context for the invocation.
        Returns: A future object for the invocation.
        """
        def getRouterAsync(self, context=None):
            return _M_Ice.RouterFinder._op_getRouter.invokeAsync(self, ((), context))

        """
        Get the router proxy implemented by the process hosting this
        finder object. The proxy might point to several replicas.
        Arguments:
        _response -- The asynchronous response callback.
        _ex -- The asynchronous exception callback.
        _sent -- The asynchronous sent callback.
        context -- The request context for the invocation.
        Returns: An asynchronous result object for the invocation.
        """
        def begin_getRouter(self, _response=None, _ex=None, _sent=None, context=None):
            return _M_Ice.RouterFinder._op_getRouter.begin(self, ((), _response, _ex, _sent, context))

        """
        Get the router proxy implemented by the process hosting this
        finder object. The proxy might point to several replicas.
        Arguments:
        Returns: The router proxy.
        """
        def end_getRouter(self, _r):
            return _M_Ice.RouterFinder._op_getRouter.end(self, _r)

        @staticmethod
        def checkedCast(proxy, facetOrContext=None, context=None):
            return _M_Ice.RouterFinderPrx.ice_checkedCast(proxy, '::Ice::RouterFinder', facetOrContext, context)

        @staticmethod
        def uncheckedCast(proxy, facet=None):
            return _M_Ice.RouterFinderPrx.ice_uncheckedCast(proxy, facet)

        @staticmethod
        def ice_staticId():
            return '::Ice::RouterFinder'
    _M_Ice._t_RouterFinderPrx = IcePy.defineProxy('::Ice::RouterFinder', RouterFinderPrx)

    _M_Ice.RouterFinderPrx = RouterFinderPrx
    del RouterFinderPrx

    _M_Ice.RouterFinder = Ice.createTempClass()
    class RouterFinder(Ice.Object):

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

        def ice_id(self, current=None):
            return '::Ice::RouterFinder'

        @staticmethod
        def ice_staticId():
            return '::Ice::RouterFinder'

        def getRouter(self, current=None):
            """
            Get the router proxy implemented by the process hosting this
            finder object. The proxy might point to several replicas.
            Arguments:
            current -- The Current object for the invocation.
            Returns: A future object for the invocation.
            """
            raise NotImplementedError("servant method 'getRouter' not implemented")

        def __str__(self):
            return IcePy.stringify(self, _M_Ice._t_RouterFinderDisp)

        __repr__ = __str__

    _M_Ice._t_RouterFinderDisp = IcePy.defineClass('::Ice::RouterFinder', RouterFinder, (), None, ())
    RouterFinder._ice_type = _M_Ice._t_RouterFinderDisp

    RouterFinder._op_getRouter = IcePy.Operation('getRouter', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, None, (), (), (), ((), _M_Ice._t_RouterPrx, False, 0), ())

    _M_Ice.RouterFinder = RouterFinder
    del RouterFinder

# End of module Ice

Ice.sliceChecksums["::Ice::Router"] = "5d699ae7ef13629643981f91ff236c55"
Ice.sliceChecksums["::Ice::RouterFinder"] = "94c0f14a95fc3b15b808186b4c3c512"
