zeroc-ice 3.7.11 → 3.8.1

data/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

data/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

data/dist/ice/cpp/include/Ice/BatchRequestQueueF.h

@@ -1,20 +1,14 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_BATCH_REQUEST_QUEUE_F_H
 #define ICE_BATCH_REQUEST_QUEUE_F_H
 
-#include <IceUtil/Shared.h>
-#include <Ice/Handle.h>
+#include <memory>
 
 namespace IceInternal
 {
-
-class BatchRequestQueue;
-ICE_API IceUtil::Shared* upCast(BatchRequestQueue*);
-typedef IceInternal::Handle<BatchRequestQueue> BatchRequestQueuePtr;
-
+    class BatchRequestQueue;
+    using BatchRequestQueuePtr = std::shared_ptr<BatchRequestQueue>;
 }
 
 #endif

data/dist/ice/cpp/include/Ice/Buffer.h

@@ -1,154 +1,159 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_BUFFER_H
 #define ICE_BUFFER_H
 
-#include <Ice/Config.h>
+#include "Config.h"
 
-namespace IceInternal
-{
+#include <cassert>
+#include <cstddef>
+#include <utility>
+#include <vector>
 
-class ICE_API Buffer : private IceUtil::noncopyable
+namespace IceInternal
 {
-public:
-
-    Buffer() : i(b.begin()) { }
-    Buffer(const Ice::Byte* beg, const Ice::Byte* end) : b(beg, end), i(b.begin()) { }
-    Buffer(const std::vector<Ice::Byte>& v) : b(v), i(b.begin()) { }
-    Buffer(Buffer& o, bool adopt) : b(o.b, adopt), i(b.begin()) { }
-
-    void swapBuffer(Buffer&);
-
-    class ICE_API Container : private IceUtil::noncopyable
+    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()) {}
 
-        //
-        // Standard vector-like operations.
-        //
-
-        typedef Ice::Byte value_type;
-        typedef Ice::Byte* iterator;
-        typedef const Ice::Byte* const_iterator;
-        typedef Ice::Byte& reference;
-        typedef const Ice::Byte& const_reference;
-        typedef Ice::Byte* pointer;
-        typedef size_t size_type;
+        Buffer(Buffer&& other) noexcept : b(std::move(other.b)), i(other.i) { other.i = other.b.begin(); }
 
-        Container();
-        Container(const_iterator, const_iterator);
-        Container(const std::vector<value_type>&);
-        Container(Container&, bool);
-
-        ~Container();
-
-        iterator begin()
+        Buffer& operator=(Buffer&& other) noexcept
         {
-            return _buf;
+            if (this != &other)
+            {
+                b = std::move(other.b);
+                i = other.i;
+                other.i = other.b.begin();
+            }
+            return *this;
         }
 
-        const_iterator begin() const
-        {
-            return _buf;
-        }
+        Buffer(const Buffer&) = delete;
+        Buffer& operator=(const Buffer&) = delete;
 
-        iterator end()
+        void swapBuffer(Buffer& other) noexcept
         {
-            return _buf + _size;
+            b.swap(other.b);
+            std::swap(i, other.i);
         }
 
-        const_iterator end() const
+        class ICE_API Container
         {
-            return _buf + _size;
-        }
+        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;
 
-        size_type size() const
-        {
-            return _size;
-        }
+            Container() noexcept;
+            Container(const_iterator, const_iterator) noexcept;
+            Container(const std::vector<value_type>&) noexcept;
+            Container(Container&, bool) noexcept;
 
-        bool empty() const
-        {
-            return !_size;
-        }
+            Container(Container&&) noexcept;
+            Container& operator=(Container&&) noexcept;
 
-        void swap(Container&);
+            Container(const Container&) = delete;
+            Container& operator=(const Container&) = delete;
 
-        void clear();
+            ~Container();
 
-        void resize(size_type n) // Inlined for performance reasons.
-        {
-            if(n == 0)
-            {
-                clear();
-            }
-            else if(n > _capacity)
+            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.
             {
-                reserve(n);
+                if (n == 0)
+                {
+                    clear();
+                }
+                else if (n > _capacity)
+                {
+                    reserve(n);
+                }
+                _size = n;
             }
-            _size = n;
-        }
 
-        void reset()
-        {
-            if(_size > 0 && _size * 2 < _capacity)
+            void reset()
             {
-                //
-                // 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)
+                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
                 {
-                    reserve(_size);
                     _shrinkCounter = 0;
                 }
+                _size = 0;
             }
-            else
+
+            void push_back(value_type v)
             {
-                _shrinkCounter = 0;
+                resize(_size + 1);
+                _buf[_size - 1] = v;
             }
-            _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];
-        }
+            reference operator[](size_type n)
+            {
+                assert(n < _size);
+                return _buf[n];
+            }
 
-        const_reference operator[](size_type n) const
-        {
-            assert(n < _size);
-            return _buf[n];
-        }
+            const_reference operator[](size_type n) const
+            {
+                assert(n < _size);
+                return _buf[n];
+            }
 
-    private:
+        private:
+            void reserve(size_type);
 
-        Container(const Container&);
-        void operator=(const Container&);
-        void reserve(size_type);
+            pointer _buf;
+            size_type _size;
+            size_type _capacity;
+            int _shrinkCounter;
+            bool _owned;
+        };
 
-        pointer _buf;
-        size_type _size;
-        size_type _capacity;
-        int _shrinkCounter;
-        bool _owned;
+        Container b;
+        Container::iterator i;
     };
-
-    Container b;
-    Container::iterator i;
-};
-
 }
 
 #endif