zeroc-ice 3.7.11__tar.gz → 3.8.0.post1__tar.gz

zeroc_ice-3.8.0.post1/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: zeroc-ice
+Version: 3.8.0.post1
+Summary: Ice is a comprehensive RPC framework with support for Python, C++, .NET, Java, JavaScript and more.
+Author-email: "ZeroC, Inc." <info@zeroc.com>
+License-Expression: GPL-2.0-only
+Project-URL: Homepage, https://zeroc.com/ice
+Project-URL: Repository, https://github.com/zeroc-ice/ice
+Project-URL: Documentation, https://code.zeroc.com/ice/3.8/api/python/index.html
+Project-URL: Issues, https://github.com/zeroc-ice/ice/issues
+Project-URL: Changelog, https://github.com/zeroc-ice/ice/blob/main/CHANGELOG-3.8.md
+Keywords: ice,RPC
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# Ice for Python
+
+[Examples] | [Documentation] | [API Reference] | [Building from source]
+
+The [Ice framework] provides everything you need to build networked applications,
+including RPC, pub/sub, server deployment, and more.
+
+Ice for Python is the Python implementation of the Ice framework.
+
+## Sample Code
+
+```slice
+// Slice definitions (Greeter.ice)
+
+module VisitorCenter
+{
+    /// Represents a simple greeter.
+    interface Greeter
+    {
+        /// Creates a personalized greeting.
+        /// @param name The name of the person to greet.
+        /// @return The greeting.
+        string greet(string name);
+    }
+}
+```
+
+```python
+# Client application (main.py)
+import Ice
+import asyncio
+import getpass
+import sys
+
+import VisitorCenter
+
+async def main():
+    async with Ice.Communicator(sys.argv, eventLoop=asyncio.get_running_loop()) as communicator:
+        greeter = VisitorCenter.GreeterPrx(communicator, "greeter:tcp -h localhost -p 4061")
+        greeting = await greeter.greetAsync(getpass.getuser())
+        print(greeting)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+```python
+# Server application (main.py)
+
+import Ice
+import chatbot
+import sys
+
+def main():
+    with Ice.Communicator(sys.argv) as communicator:
+        adapter = communicator.createObjectAdapterWithEndpoints("GreeterAdapter", "tcp -p 4061")
+        adapter.add(chatbot.Chatbot(), Ice.Identity(name="greeter"))
+
+        adapter.activate()
+        print("Listening on port 4061...")
+
+        try:
+            communicator.waitForShutdown()
+        except KeyboardInterrupt:
+            print("Caught Ctrl+C, exiting...")
+
+if __name__ == "__main__":
+    main()
+```
+
+```python
+# Greeter implementation (chatbot.py)
+import VisitorCenter
+
+class Chatbot(VisitorCenter.Greeter):
+    def greet(self, name: str, current: Ice.Current) -> str:
+        print(f"Dispatching greet request {{ name = '{name}' }}")
+        return f"Hello, {name}!"
+```
+
+[Examples]: https://github.com/zeroc-ice/ice-demos/tree/3.8/python
+[Documentation]: https://docs.zeroc.com/ice/3.8/python/
+[API Reference]: https://code.zeroc.com/ice/3.8/api/python/index.html
+[Building from source]: ./BUILDING.md
+[Ice framework]: https://github.com/zeroc-ice/ice

zeroc_ice-3.8.0.post1/README.md

@@ -0,0 +1,85 @@
+# Ice for Python
+
+[Examples] | [Documentation] | [API Reference] | [Building from source]
+
+The [Ice framework] provides everything you need to build networked applications,
+including RPC, pub/sub, server deployment, and more.
+
+Ice for Python is the Python implementation of the Ice framework.
+
+## Sample Code
+
+```slice
+// Slice definitions (Greeter.ice)
+
+module VisitorCenter
+{
+    /// Represents a simple greeter.
+    interface Greeter
+    {
+        /// Creates a personalized greeting.
+        /// @param name The name of the person to greet.
+        /// @return The greeting.
+        string greet(string name);
+    }
+}
+```
+
+```python
+# Client application (main.py)
+import Ice
+import asyncio
+import getpass
+import sys
+
+import VisitorCenter
+
+async def main():
+    async with Ice.Communicator(sys.argv, eventLoop=asyncio.get_running_loop()) as communicator:
+        greeter = VisitorCenter.GreeterPrx(communicator, "greeter:tcp -h localhost -p 4061")
+        greeting = await greeter.greetAsync(getpass.getuser())
+        print(greeting)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+```python
+# Server application (main.py)
+
+import Ice
+import chatbot
+import sys
+
+def main():
+    with Ice.Communicator(sys.argv) as communicator:
+        adapter = communicator.createObjectAdapterWithEndpoints("GreeterAdapter", "tcp -p 4061")
+        adapter.add(chatbot.Chatbot(), Ice.Identity(name="greeter"))
+
+        adapter.activate()
+        print("Listening on port 4061...")
+
+        try:
+            communicator.waitForShutdown()
+        except KeyboardInterrupt:
+            print("Caught Ctrl+C, exiting...")
+
+if __name__ == "__main__":
+    main()
+```
+
+```python
+# Greeter implementation (chatbot.py)
+import VisitorCenter
+
+class Chatbot(VisitorCenter.Greeter):
+    def greet(self, name: str, current: Ice.Current) -> str:
+        print(f"Dispatching greet request {{ name = '{name}' }}")
+        return f"Hello, {name}!"
+```
+
+[Examples]: https://github.com/zeroc-ice/ice-demos/tree/3.8/python
+[Documentation]: https://docs.zeroc.com/ice/3.8/python/
+[API Reference]: https://code.zeroc.com/ice/3.8/api/python/index.html
+[Building from source]: ./BUILDING.md
+[Ice framework]: https://github.com/zeroc-ice/ice

zeroc_ice-3.8.0.post1/dist/ice/cpp/include/Ice/AsyncResponseHandler.h

@@ -0,0 +1,85 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_ASYNC_RESPONSE_HANDLER_H
+#define ICE_ASYNC_RESPONSE_HANDLER_H
+
+#include "Current.h"
+#include "LocalExceptions.h"
+#include "OutgoingResponse.h"
+
+#include <atomic>
+
+namespace IceInternal
+{
+    // This class helps with the implementation of the AMD response and exception callbacks. It allows the dispatch
+    // thread and these two callbacks to share the same sendResponse and Current objects, and ensures sendResponse is
+    // called exactly once.
+    class AsyncResponseHandler final
+    {
+    public:
+        // This class typically holds a _copy_ of the incoming request current object.
+        AsyncResponseHandler(std::function<void(Ice::OutgoingResponse)> sendResponse, Ice::Current current)
+            : _sendResponse(std::move(sendResponse)),
+              _current(std::move(current))
+        {
+        }
+
+        void sendEmptyResponse() noexcept
+        {
+            if (!_responseSent.test_and_set())
+            {
+                _sendResponse(makeEmptyOutgoingResponse(_current));
+            }
+            // else we ignore this call.
+        }
+
+        void sendResponse(Ice::MarshaledResult marshaledResult) noexcept
+        {
+            if (!_responseSent.test_and_set())
+            {
+                _sendResponse(Ice::OutgoingResponse{std::move(marshaledResult).outputStream(), _current});
+            }
+            // else we ignore this call.
+        }
+
+        void sendResponse(bool ok, std::pair<const std::byte*, const std::byte*> encaps) noexcept
+        {
+            if (!_responseSent.test_and_set())
+            {
+                _sendResponse(makeOutgoingResponse(ok, encaps, _current));
+            }
+            // else we ignore this call.
+        }
+
+        void sendResponse(
+            const std::function<void(Ice::OutputStream*)>& marshal,
+            std::optional<Ice::FormatType> format = std::nullopt) noexcept
+        {
+            // It is critical to only call the _sendResponse function only once. Calling it multiple times results in an
+            // incorrect dispatch count.
+            if (!_responseSent.test_and_set())
+            {
+                _sendResponse(makeOutgoingResponse(marshal, _current, format));
+            }
+            // else we ignore this call.
+        }
+
+        void sendException(std::exception_ptr ex) noexcept
+        {
+            if (!_responseSent.test_and_set())
+            {
+                _sendResponse(makeOutgoingResponse(ex, _current));
+            }
+            // else we ignore this call.
+        }
+
+        [[nodiscard]] const Ice::Current& current() const noexcept { return _current; }
+
+    private:
+        const std::function<void(Ice::OutgoingResponse)> _sendResponse;
+        const Ice::Current _current;
+        std::atomic_flag _responseSent = ATOMIC_FLAG_INIT;
+    };
+}
+
+#endif

zeroc_ice-3.8.0.post1/dist/ice/cpp/include/Ice/BatchRequest.h

@@ -0,0 +1,39 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_BATCH_REQUEST_H
+#define ICE_BATCH_REQUEST_H
+
+#include "Config.h"
+
+#include <string_view>
+
+namespace Ice
+{
+    class ObjectPrx;
+
+    /// Represents a batch request. A batch request is created by invoking an operation on a batch-oneway or
+    /// batch-datagram proxy.
+    /// @headerfile Ice/Ice.h
+    class ICE_API BatchRequest
+    {
+    public:
+        virtual ~BatchRequest();
+
+        /// Queues this request.
+        virtual void enqueue() const = 0;
+
+        /// Gets the size of the request.
+        /// @return The number of bytes consumed by the request.
+        [[nodiscard]] virtual int getSize() const = 0;
+
+        /// Gets the name of the operation.
+        /// @return The operation name.
+        [[nodiscard]] virtual std::string_view getOperation() const = 0;
+
+        /// Gets the proxy used to create this batch request.
+        /// @return The proxy.
+        [[nodiscard]] virtual const ObjectPrx& getProxy() const = 0;
+    };
+}
+
+#endif

zeroc_ice-3.8.0.post1/dist/ice/cpp/include/Ice/BatchRequestQueueF.h

@@ -0,0 +1,14 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_BATCH_REQUEST_QUEUE_F_H
+#define ICE_BATCH_REQUEST_QUEUE_F_H
+
+#include <memory>
+
+namespace IceInternal
+{
+    class BatchRequestQueue;
+    using BatchRequestQueuePtr = std::shared_ptr<BatchRequestQueue>;
+}
+
+#endif

zeroc_ice-3.8.0.post1/dist/ice/cpp/include/Ice/Buffer.h

@@ -0,0 +1,159 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_BUFFER_H
+#define ICE_BUFFER_H
+
+#include "Config.h"
+
+#include <cassert>
+#include <cstddef>
+#include <utility>
+#include <vector>
+
+namespace IceInternal
+{
+    class Buffer
+    {
+    public:
+        Buffer() : i(b.begin()) {}
+        Buffer(const std::byte* beg, const std::byte* end) : b(beg, end), i(b.begin()) {}
+        Buffer(const std::vector<std::byte>& v) : b(v), i(b.begin()) {}
+        Buffer(Buffer& o, bool adopt) : b(o.b, adopt), i(b.begin()) {}
+
+        Buffer(Buffer&& other) noexcept : b(std::move(other.b)), i(other.i) { other.i = other.b.begin(); }
+
+        Buffer& operator=(Buffer&& other) noexcept
+        {
+            if (this != &other)
+            {
+                b = std::move(other.b);
+                i = other.i;
+                other.i = other.b.begin();
+            }
+            return *this;
+        }
+
+        Buffer(const Buffer&) = delete;
+        Buffer& operator=(const Buffer&) = delete;
+
+        void swapBuffer(Buffer& other) noexcept
+        {
+            b.swap(other.b);
+            std::swap(i, other.i);
+        }
+
+        class ICE_API Container
+        {
+        public:
+            //
+            // Standard vector-like operations.
+            //
+            using value_type = std::byte;
+            using iterator = std::byte*;
+            using const_iterator = const std::byte*;
+            using reference = std::byte&;
+            using const_reference = const std::byte&;
+            using pointer = std::byte*;
+            using size_type = size_t;
+
+            Container() noexcept;
+            Container(const_iterator, const_iterator) noexcept;
+            Container(const std::vector<value_type>&) noexcept;
+            Container(Container&, bool) noexcept;
+
+            Container(Container&&) noexcept;
+            Container& operator=(Container&&) noexcept;
+
+            Container(const Container&) = delete;
+            Container& operator=(const Container&) = delete;
+
+            ~Container();
+
+            iterator begin() { return _buf; }
+
+            [[nodiscard]] const_iterator begin() const { return _buf; }
+
+            iterator end() { return _buf + _size; }
+
+            [[nodiscard]] const_iterator end() const { return _buf + _size; }
+
+            [[nodiscard]] size_type size() const { return _size; }
+
+            [[nodiscard]] bool empty() const { return !_size; }
+
+            [[nodiscard]] bool ownsMemory() const noexcept { return _owned; }
+
+            void swap(Container&) noexcept;
+
+            void clear();
+
+            void resize(size_type n) // Inlined for performance reasons.
+            {
+                if (n == 0)
+                {
+                    clear();
+                }
+                else if (n > _capacity)
+                {
+                    reserve(n);
+                }
+                _size = n;
+            }
+
+            void reset()
+            {
+                if (_size > 0 && _size * 2 < _capacity)
+                {
+                    //
+                    // If the current buffer size is smaller than the
+                    // buffer capacity, we shrink the buffer memory to the
+                    // current size. This is to avoid holding onto too much
+                    // memory if it's not needed anymore.
+                    //
+                    if (++_shrinkCounter > 2)
+                    {
+                        reserve(_size);
+                        _shrinkCounter = 0;
+                    }
+                }
+                else
+                {
+                    _shrinkCounter = 0;
+                }
+                _size = 0;
+            }
+
+            void push_back(value_type v)
+            {
+                resize(_size + 1);
+                _buf[_size - 1] = v;
+            }
+
+            reference operator[](size_type n)
+            {
+                assert(n < _size);
+                return _buf[n];
+            }
+
+            const_reference operator[](size_type n) const
+            {
+                assert(n < _size);
+                return _buf[n];
+            }
+
+        private:
+            void reserve(size_type);
+
+            pointer _buf;
+            size_type _size;
+            size_type _capacity;
+            int _shrinkCounter;
+            bool _owned;
+        };
+
+        Container b;
+        Container::iterator i;
+    };
+}
+
+#endif