zeroc-ice 3.7.11__cp313-cp313-macosx_10_13_universal2.whl

Ice/Router_ice.py

@@ -0,0 +1,350 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (c) ZeroC, Inc. All rights reserved.
+#
+#
+# Ice version 3.7.11
+#
+# <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"

Ice/ServantLocatorF_ice.py

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (c) ZeroC, Inc. All rights reserved.
+#
+#
+# Ice version 3.7.11
+#
+# <auto-generated>
+#
+# Generated from file `ServantLocatorF.ice'
+#
+# Warning: do not edit this file.
+#
+# </auto-generated>
+#
+
+from sys import version_info as _version_info_
+import Ice, IcePy
+
+# Start of module Ice
+_M_Ice = Ice.openModule('Ice')
+__name__ = 'Ice'
+
+if 'ServantLocator' not in _M_Ice.__dict__:
+    _M_Ice._t_ServantLocator = IcePy.declareValue('::Ice::ServantLocator')
+
+# End of module Ice

Ice/ServantLocator_ice.py

@@ -0,0 +1,110 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (c) ZeroC, Inc. All rights reserved.
+#
+#
+# Ice version 3.7.11
+#
+# <auto-generated>
+#
+# Generated from file `ServantLocator.ice'
+#
+# Warning: do not edit this file.
+#
+# </auto-generated>
+#
+
+from sys import version_info as _version_info_
+import Ice, IcePy
+import Ice.ObjectAdapterF_ice
+import Ice.Current_ice
+
+# Included module Ice
+_M_Ice = Ice.openModule('Ice')
+
+# Start of module Ice
+__name__ = 'Ice'
+
+if 'ServantLocator' not in _M_Ice.__dict__:
+    _M_Ice.ServantLocator = Ice.createTempClass()
+    class ServantLocator(object):
+        """
+        A servant locator is called by an object adapter to
+        locate a servant that is not found in its active servant map.
+        """
+        def __init__(self):
+            if Ice.getType(self) == _M_Ice.ServantLocator:
+                raise RuntimeError('Ice.ServantLocator is an abstract class')
+
+        def locate(self, curr):
+            """
+            Called before a request is dispatched if a
+            servant cannot be found in the object adapter's active servant
+            map. Note that the object adapter does not automatically insert
+            the returned servant into its active servant map. This must be
+            done by the servant locator implementation, if this is desired.
+            locate can throw any user exception. If it does, that exception
+            is marshaled back to the client. If the Slice definition for the
+            corresponding operation includes that user exception, the client
+            receives that user exception; otherwise, the client receives
+            UnknownUserException.
+            If locate throws any exception, the Ice run time does not
+            call finished.
+            If you call locate from your own code, you
+            must also call finished when you have finished using the
+            servant, provided that locate returned a non-null servant;
+            otherwise, you will get undefined behavior if you use
+            servant locators such as the Freeze Evictor.
+            Arguments:
+            curr -- Information about the current operation for which a servant is required.
+            Returns a tuple containing the following:
+            _retval -- The located servant, or null if no suitable servant has been found.
+            cookie -- A "cookie" that will be passed to finished.
+            Throws:
+            UserException -- The implementation can raise a UserException and the run time will marshal it as the result of the invocation.
+            """
+            raise NotImplementedError("method 'locate' not implemented")
+
+        def finished(self, curr, servant, cookie):
+            """
+            Called by the object adapter after a request has been
+            made. This operation is only called if locate was called
+            prior to the request and returned a non-null servant. This
+            operation can be used for cleanup purposes after a request.
+            finished can throw any user exception. If it does, that exception
+            is marshaled back to the client. If the Slice definition for the
+            corresponding operation includes that user exception, the client
+            receives that user exception; otherwise, the client receives
+            UnknownUserException.
+            If both the operation and finished throw an exception, the
+            exception thrown by finished is marshaled back to the client.
+            Arguments:
+            curr -- Information about the current operation call for which a servant was located by locate.
+            servant -- The servant that was returned by locate.
+            cookie -- The cookie that was returned by locate.
+            Throws:
+            UserException -- The implementation can raise a UserException and the run time will marshal it as the result of the invocation.
+            """
+            raise NotImplementedError("method 'finished' not implemented")
+
+        def deactivate(self, category):
+            """
+            Called when the object adapter in which this servant locator is
+            installed is destroyed.
+            Arguments:
+            category -- Indicates for which category the servant locator is being deactivated.
+            """
+            raise NotImplementedError("method 'deactivate' not implemented")
+
+        def __str__(self):
+            return IcePy.stringify(self, _M_Ice._t_ServantLocator)
+
+        __repr__ = __str__
+
+    _M_Ice._t_ServantLocator = IcePy.defineValue('::Ice::ServantLocator', ServantLocator, -1, (), False, True, None, ())
+    ServantLocator._ice_type = _M_Ice._t_ServantLocator
+
+    _M_Ice.ServantLocator = ServantLocator
+    del ServantLocator
+
+# End of module Ice

Ice/SliceChecksumDict_ice.py

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (c) ZeroC, Inc. All rights reserved.
+#
+#
+# Ice version 3.7.11
+#
+# <auto-generated>
+#
+# Generated from file `SliceChecksumDict.ice'
+#
+# Warning: do not edit this file.
+#
+# </auto-generated>
+#
+
+from sys import version_info as _version_info_
+import Ice, IcePy
+
+# Start of module Ice
+_M_Ice = Ice.openModule('Ice')
+__name__ = 'Ice'
+
+if '_t_SliceChecksumDict' not in _M_Ice.__dict__:
+    _M_Ice._t_SliceChecksumDict = IcePy.defineDictionary('::Ice::SliceChecksumDict', (), IcePy._t_string, IcePy._t_string)
+
+# End of module Ice
+
+Ice.sliceChecksums["::Ice::SliceChecksumDict"] = "d733c49f2c6d79a346ca7d695f0519"

Ice/ValueFactory_ice.py

@@ -0,0 +1,125 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (c) ZeroC, Inc. All rights reserved.
+#
+#
+# Ice version 3.7.11
+#
+# <auto-generated>
+#
+# Generated from file `ValueFactory.ice'
+#
+# Warning: do not edit this file.
+#
+# </auto-generated>
+#
+
+from sys import version_info as _version_info_
+import Ice, IcePy
+
+# Start of module Ice
+_M_Ice = Ice.openModule('Ice')
+__name__ = 'Ice'
+
+if 'ValueFactory' not in _M_Ice.__dict__:
+    _M_Ice.ValueFactory = Ice.createTempClass()
+    class ValueFactory(object):
+        """
+        A factory for values. Value factories are used in several
+        places, such as when Ice receives a class instance and
+        when Freeze restores a persistent value. Value factories
+        must be implemented by the application writer and registered
+        with the communicator.
+        """
+        def __init__(self):
+            if Ice.getType(self) == _M_Ice.ValueFactory:
+                raise RuntimeError('Ice.ValueFactory is an abstract class')
+
+        def create(self, type):
+            """
+            Create a new value for a given value type. The type is the
+            absolute Slice type id, i.e., the id relative to the
+            unnamed top-level Slice module. For example, the absolute
+            Slice type id for an interface Bar in the module
+            Foo is "::Foo::Bar".
+            Note that the leading "::" is required.
+            Arguments:
+            type -- The value type.
+            Returns: The value created for the given type, or nil if the factory is unable to create the value.
+            """
+            raise NotImplementedError("method 'create' not implemented")
+
+        def __str__(self):
+            return IcePy.stringify(self, _M_Ice._t_ValueFactory)
+
+        __repr__ = __str__
+
+    _M_Ice._t_ValueFactory = IcePy.defineValue('::Ice::ValueFactory', ValueFactory, -1, (), False, True, None, ())
+    ValueFactory._ice_type = _M_Ice._t_ValueFactory
+
+    _M_Ice.ValueFactory = ValueFactory
+    del ValueFactory
+
+if 'ValueFactoryManager' not in _M_Ice.__dict__:
+    _M_Ice.ValueFactoryManager = Ice.createTempClass()
+    class ValueFactoryManager(object):
+        """
+        A value factory manager maintains a collection of value factories.
+        An application can supply a custom implementation during communicator
+        initialization, otherwise Ice provides a default implementation.
+        """
+        def __init__(self):
+            if Ice.getType(self) == _M_Ice.ValueFactoryManager:
+                raise RuntimeError('Ice.ValueFactoryManager is an abstract class')
+
+        def add(self, factory, id):
+            """
+            Add a value factory. Attempting to add a factory with an id for
+            which a factory is already registered throws AlreadyRegisteredException.
+            When unmarshaling an Ice value, the Ice run time reads the
+            most-derived type id off the wire and attempts to create an
+            instance of the type using a factory. If no instance is created,
+            either because no factory was found, or because all factories
+            returned nil, the behavior of the Ice run time depends on the
+            format with which the value was marshaled:
+            If the value uses the "sliced" format, Ice ascends the class
+            hierarchy until it finds a type that is recognized by a factory,
+            or it reaches the least-derived type. If no factory is found that
+            can create an instance, the run time throws NoValueFactoryException.
+            If the value uses the "compact" format, Ice immediately raises
+            NoValueFactoryException.
+            The following order is used to locate a factory for a type:
+            The Ice run-time looks for a factory registered
+            specifically for the type.
+            If no instance has been created, the Ice run-time looks
+            for the default factory, which is registered with an empty type id.
+            If no instance has been created by any of the preceding
+            steps, the Ice run-time looks for a factory that may have been
+            statically generated by the language mapping for non-abstract classes.
+            Arguments:
+            factory -- The factory to add.
+            id -- The type id for which the factory can create instances, or an empty string for the default factory.
+            """
+            raise NotImplementedError("method 'add' not implemented")
+
+        def find(self, id):
+            """
+            Find an value factory registered with this communicator.
+            Arguments:
+            id -- The type id for which the factory can create instances, or an empty string for the default factory.
+            Returns: The value factory, or null if no value factory was found for the given id.
+            """
+            raise NotImplementedError("method 'find' not implemented")
+
+        def __str__(self):
+            return IcePy.stringify(self, _M_Ice._t_ValueFactoryManager)
+
+        __repr__ = __str__
+
+    _M_Ice._t_ValueFactoryManager = IcePy.defineValue('::Ice::ValueFactoryManager', ValueFactoryManager, -1, (), False, True, None, ())
+    ValueFactoryManager._ice_type = _M_Ice._t_ValueFactoryManager
+
+    _M_Ice.ValueFactoryManager = ValueFactoryManager
+    del ValueFactoryManager
+
+# End of module Ice