zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/src/Ice/BatchRequestQueue.cpp

@@ -1,83 +1,61 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <Ice/BatchRequestQueue.h>
-#include <Ice/Instance.h>
-#include <Ice/Properties.h>
-#include <Ice/Reference.h>
+#include "BatchRequestQueue.h"
+#include "Ice/Properties.h"
+#include "Ice/Proxy.h"
+#include "Instance.h"
+#include "Reference.h"
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-IceUtil::Shared* IceInternal::upCast(BatchRequestQueue* p) { return p; }
-
 namespace
 {
+    const int udpOverhead = 20 + 8;
 
-const int udpOverhead = 20 + 8;
-
-class BatchRequestI : public Ice::BatchRequest
-{
-public:
-
-    BatchRequestI(BatchRequestQueue& queue, const Ice::ObjectPrxPtr& proxy, const string& operation, int size) :
-        _queue(queue), _proxy(proxy), _operation(operation), _size(size)
-    {
-    }
-
-    virtual void
-    enqueue() const
+    class BatchRequestI final : public Ice::BatchRequest
     {
-        _queue.enqueueBatchRequest(_proxy);
-    }
-
-    virtual int
-    getSize() const
-    {
-        return _size;
-    }
+    public:
+        BatchRequestI(BatchRequestQueue& queue, const Ice::ObjectPrx& proxy, string_view operation, int size)
+            : _queue(queue),
+              _proxy(proxy),
+              _operation(operation),
+              _size(size)
+        {
+        }
 
-    virtual const std::string&
-    getOperation() const
-    {
-        return _operation;
-    }
+        void enqueue() const final { _queue.enqueueBatchRequest(_proxy); }
 
-    virtual const Ice::ObjectPrxPtr&
-    getProxy() const
-    {
-        return _proxy;
-    }
+        [[nodiscard]] int getSize() const final { return _size; }
 
-private:
+        [[nodiscard]] string_view getOperation() const override { return _operation; }
 
-    BatchRequestQueue& _queue;
-    const Ice::ObjectPrxPtr& _proxy;
-    const std::string& _operation;
-    const int _size;
-};
+        [[nodiscard]] const Ice::ObjectPrx& getProxy() const final { return _proxy; }
 
+    private:
+        BatchRequestQueue& _queue;
+        const Ice::ObjectPrx& _proxy;
+        const string_view _operation;
+        const int _size;
+    };
 }
 
-BatchRequestQueue::BatchRequestQueue(const InstancePtr& instance, bool datagram) :
-    _interceptor(instance->initializationData().batchRequestInterceptor),
-    _batchStream(instance.get(), Ice::currentProtocolEncoding),
-    _batchStreamInUse(false),
-    _batchStreamCanFlush(false),
-    _batchCompress(false),
-    _batchRequestNum(0)
+BatchRequest::~BatchRequest() = default; // avoid weak vtable
+
+BatchRequestQueue::BatchRequestQueue(const InstancePtr& instance, bool datagram)
+    : _interceptor(instance->initializationData().batchRequestInterceptor),
+      _batchStream(instance.get(), currentProtocolEncoding)
 {
     _batchStream.writeBlob(requestBatchHdr, sizeof(requestBatchHdr));
     _batchMarker = _batchStream.b.size();
 
     _maxSize = instance->batchAutoFlushSize();
-    if(_maxSize > 0 && datagram)
+    if (_maxSize > 0 && datagram)
     {
         const Ice::InitializationData& initData = instance->initializationData();
-        size_t udpSndSize = static_cast<size_t>(initData.properties->getPropertyAsIntWithDefault("Ice.UDP.SndSize", 65535 - udpOverhead));
-        if(udpSndSize < _maxSize)
+        int32_t udpSndSize = initData.properties->getPropertyAsIntWithDefault("Ice.UDP.SndSize", 65535 - udpOverhead);
+        if (udpSndSize < _maxSize)
         {
             _maxSize = udpSndSize;
         }
@@ -87,20 +65,19 @@ BatchRequestQueue::BatchRequestQueue(const InstancePtr& instance, bool datagram)
 void
 BatchRequestQueue::prepareBatchRequest(OutputStream* os)
 {
-    Lock sync(*this);
-    if(_exception)
+    unique_lock lock(_mutex);
+    if (_exception)
     {
-        _exception->ice_throw();
+        rethrow_exception(_exception);
     }
-    waitStreamInUse(false);
+    _conditionVariable.wait(lock, [this] { return !_batchStreamInUse; });
+
     _batchStreamInUse = true;
     _batchStream.swap(*os);
 }
 
 void
-BatchRequestQueue::finishBatchRequest(OutputStream* os,
-                                      const Ice::ObjectPrxPtr& proxy,
-                                      const std::string& operation)
+BatchRequestQueue::finishBatchRequest(OutputStream* os, const Ice::ObjectPrx& proxy, string_view operation)
 {
     //
     // No need for synchronization, no other threads are supposed
@@ -113,49 +90,41 @@ BatchRequestQueue::finishBatchRequest(OutputStream* os,
     {
         _batchStreamCanFlush = true; // Allow flush to proceed even if the stream is marked in use.
 
-        if(_maxSize > 0 && _batchStream.b.size() >= _maxSize)
+        if (_maxSize > 0 && _batchStream.b.size() >= static_cast<size_t>(_maxSize))
         {
-#ifdef ICE_CPP11_MAPPING
-            proxy->ice_flushBatchRequestsAsync();
-#else
-            proxy->begin_ice_flushBatchRequests();
-#endif
+            proxy->ice_flushBatchRequestsAsync(nullptr); // auto-flush, don't wait for response
         }
 
         assert(_batchMarker < _batchStream.b.size());
-        if(_interceptor)
+        if (_interceptor)
         {
             BatchRequestI request(*this, proxy, operation, static_cast<int>(_batchStream.b.size() - _batchMarker));
-#ifdef ICE_CPP11_MAPPING
             _interceptor(request, _batchRequestNum, static_cast<int>(_batchMarker));
-#else
-            _interceptor->enqueue(request, _batchRequestNum, static_cast<int>(_batchMarker));
-#endif
         }
         else
         {
-            bool compress;
-            if(proxy->_getReference()->getCompressOverride(compress))
+            optional<bool> compress = proxy->_getReference()->getCompressOverride();
+            if (compress.has_value())
             {
-                _batchCompress |= compress;
+                _batchCompress |= *compress;
             }
             _batchMarker = _batchStream.b.size();
             ++_batchRequestNum;
         }
 
-        Lock sync(*this);
+        lock_guard lock(_mutex);
         _batchStream.resize(_batchMarker);
         _batchStreamInUse = false;
         _batchStreamCanFlush = false;
-        notifyAll();
+        _conditionVariable.notify_all();
     }
-    catch(const std::exception&)
+    catch (const std::exception&)
     {
-        Lock sync(*this);
+        lock_guard lock(_mutex);
         _batchStream.resize(_batchMarker);
         _batchStreamInUse = false;
         _batchStreamCanFlush = false;
-        notifyAll();
+        _conditionVariable.notify_all();
         throw;
     }
 }
@@ -163,31 +132,31 @@ BatchRequestQueue::finishBatchRequest(OutputStream* os,
 void
 BatchRequestQueue::abortBatchRequest(OutputStream* os)
 {
-    Lock sync(*this);
-    if(_batchStreamInUse)
+    lock_guard lock(_mutex);
+    if (_batchStreamInUse)
     {
         _batchStream.swap(*os);
         _batchStream.resize(_batchMarker);
         _batchStreamInUse = false;
-        notifyAll();
+        _conditionVariable.notify_all();
     }
 }
 
 int
-BatchRequestQueue::swap(OutputStream* os, bool& compress)
+BatchRequestQueue::swap(OutputStream* os, bool& compress) noexcept
 {
-    Lock sync(*this);
-    if(_batchRequestNum == 0)
+    unique_lock lock(_mutex);
+    if (_batchRequestNum == 0)
     {
         return 0;
     }
 
-    waitStreamInUse(true);
+    _conditionVariable.wait(lock, [this] { return !_batchStreamInUse || _batchStreamCanFlush; });
 
-    vector<Ice::Byte> lastRequest;
-    if(_batchMarker < _batchStream.b.size())
+    vector<byte> lastRequest;
+    if (_batchMarker < _batchStream.b.size())
     {
-        vector<Ice::Byte>(_batchStream.b.begin() + _batchMarker, _batchStream.b.end()).swap(lastRequest);
+        vector<byte>(_batchStream.b.begin() + _batchMarker, _batchStream.b.end()).swap(lastRequest);
         _batchStream.b.resize(_batchMarker);
     }
 
@@ -202,48 +171,28 @@ BatchRequestQueue::swap(OutputStream* os, bool& compress)
     _batchCompress = false;
     _batchStream.writeBlob(requestBatchHdr, sizeof(requestBatchHdr));
     _batchMarker = _batchStream.b.size();
-    if(!lastRequest.empty())
+    if (!lastRequest.empty())
     {
-        _batchStream.writeBlob(&lastRequest[0], lastRequest.size());
+        _batchStream.writeBlob(lastRequest.data(), lastRequest.size());
     }
     return requestNum;
 }
 
 void
-BatchRequestQueue::destroy(const Ice::LocalException& ex)
-{
-    Lock sync(*this);
-#ifdef ICE_CPP11_MAPPING
-    _exception = ex.ice_clone();
-#else
-    _exception.reset(ex.ice_clone());
-#endif
-}
-
-bool
-BatchRequestQueue::isEmpty()
-{
-    Lock sync(*this);
-    return _batchStream.b.size() == sizeof(requestBatchHdr);
-}
-
-void
-BatchRequestQueue::waitStreamInUse(bool flush)
+BatchRequestQueue::destroy(std::exception_ptr ex)
 {
-    while(_batchStreamInUse && !(flush && _batchStreamCanFlush))
-    {
-        wait();
-    }
+    lock_guard lock(_mutex);
+    _exception = ex;
 }
 
 void
-BatchRequestQueue::enqueueBatchRequest(const Ice::ObjectPrxPtr& proxy)
+BatchRequestQueue::enqueueBatchRequest(const Ice::ObjectPrx& proxy)
 {
     assert(_batchMarker < _batchStream.b.size());
-    bool compress;
-    if(proxy->_getReference()->getCompressOverride(compress))
+    optional<bool> compress = proxy->_getReference()->getCompressOverride();
+    if (compress.has_value())
     {
-        _batchCompress |= compress;
+        _batchCompress |= *compress;
     }
     _batchMarker = _batchStream.b.size();
     ++_batchRequestNum;

data/dist/ice/cpp/src/Ice/BatchRequestQueue.h

@@ -1,58 +1,48 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_BATCH_REQUEST_QUEUE_H
 #define ICE_BATCH_REQUEST_QUEUE_H
 
-#include <IceUtil/Shared.h>
-#include <IceUtil/Mutex.h>
-#include <IceUtil/Monitor.h>
-#include <Ice/UniquePtr.h>
+#include "Ice/BatchRequest.h"
+#include "Ice/BatchRequestQueueF.h"
+#include "Ice/InstanceF.h"
+#include "Ice/OutputStream.h"
 
-#include <Ice/BatchRequestInterceptor.h>
-#include <Ice/BatchRequestQueueF.h>
-#include <Ice/InstanceF.h>
-#include <Ice/OutputStream.h>
+#include <condition_variable>
+#include <functional>
+#include <mutex>
 
 namespace IceInternal
 {
-
-class BatchRequestQueue : public IceUtil::Shared, private IceUtil::Monitor<IceUtil::Mutex>
-{
-public:
-
-    BatchRequestQueue(const InstancePtr&, bool);
-
-    void prepareBatchRequest(Ice::OutputStream*);
-    void finishBatchRequest(Ice::OutputStream*, const Ice::ObjectPrxPtr&, const std::string&);
-    void abortBatchRequest(Ice::OutputStream*);
-
-    int swap(Ice::OutputStream*, bool&);
-
-    void destroy(const Ice::LocalException&);
-    bool isEmpty();
-
-    void enqueueBatchRequest(const Ice::ObjectPrxPtr&);
-
-private:
-
-    void waitStreamInUse(bool);
-
-#ifdef ICE_CPP11_MAPPING
-    std::function<void(const Ice::BatchRequest&, int, int)> _interceptor;
-#else
-    Ice::BatchRequestInterceptorPtr _interceptor;
-#endif
-    Ice::OutputStream _batchStream;
-    bool _batchStreamInUse;
-    bool _batchStreamCanFlush;
-    bool _batchCompress;
-    int _batchRequestNum;
-    size_t _batchMarker;
-    IceInternal::UniquePtr<Ice::LocalException> _exception;
-    size_t _maxSize;
-};
+    class BatchRequestQueue
+    {
+    public:
+        BatchRequestQueue(const InstancePtr&, bool);
+
+        void prepareBatchRequest(Ice::OutputStream*);
+        void finishBatchRequest(Ice::OutputStream*, const Ice::ObjectPrx&, std::string_view);
+        void abortBatchRequest(Ice::OutputStream*);
+
+        int swap(Ice::OutputStream*, bool&) noexcept;
+
+        void destroy(std::exception_ptr);
+
+        void enqueueBatchRequest(const Ice::ObjectPrx&);
+
+    private:
+        std::function<void(const Ice::BatchRequest&, int, int)> _interceptor;
+        Ice::OutputStream _batchStream;
+        bool _batchStreamInUse{false};
+        bool _batchStreamCanFlush{false};
+        bool _batchCompress{false};
+        int _batchRequestNum{0};
+        size_t _batchMarker;
+        std::exception_ptr _exception;
+        std::int32_t _maxSize;
+
+        std::mutex _mutex;
+        std::condition_variable _conditionVariable;
+    };
 
 };
 

data/dist/ice/cpp/src/Ice/Buffer.cpp

@@ -1,45 +1,36 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <Ice/Buffer.h>
-#include <Ice/LocalException.h>
+#include "Ice/Buffer.h"
+
+#include <cstdlib>
+#include <cstring>
 
 using namespace std;
-using namespace Ice;
 using namespace IceInternal;
 
-void
-IceInternal::Buffer::swapBuffer(Buffer& other)
+IceInternal::Buffer::Container::Container() noexcept
+    : _buf(nullptr),
+      _size(0),
+      _capacity(0),
+      _shrinkCounter(0),
+      _owned(true)
 {
-    b.swap(other.b);
-    std::swap(i, other.i);
 }
 
-IceInternal::Buffer::Container::Container() :
-    _buf(0),
-    _size(0),
-    _capacity(0),
-    _shrinkCounter(0),
-    _owned(true)
+IceInternal::Buffer::Container::Container(const_iterator beg, const_iterator end) noexcept
+    : _buf(const_cast<iterator>(beg)),
+      _size(static_cast<size_t>(end - beg)),
+      _capacity(static_cast<size_t>(end - beg)),
+      _shrinkCounter(0),
+      _owned(false)
 {
 }
 
-IceInternal::Buffer::Container::Container(const_iterator beg, const_iterator end) :
-    _buf(const_cast<iterator>(beg)),
-    _size(static_cast<size_t>(end - beg)),
-    _capacity(static_cast<size_t>(end - beg)),
-    _shrinkCounter(0),
-    _owned(false)
+IceInternal::Buffer::Container::Container(const vector<value_type>& v) noexcept : _shrinkCounter(0)
 {
-}
-
-IceInternal::Buffer::Container::Container(const vector<value_type>& v) :
-    _shrinkCounter(0)
-{
-    if(v.empty())
+    if (v.empty())
     {
-        _buf = 0;
+        _buf = nullptr;
         _size = 0;
         _capacity = 0;
         _owned = true;
@@ -53,9 +44,9 @@ IceInternal::Buffer::Container::Container(const vector<value_type>& v) :
     }
 }
 
-IceInternal::Buffer::Container::Container(Container& other, bool adopt)
+IceInternal::Buffer::Container::Container(Container& other, bool adopt) noexcept
 {
-    if(adopt)
+    if (adopt)
     {
         _buf = other._buf;
         _size = other._size;
@@ -63,7 +54,7 @@ IceInternal::Buffer::Container::Container(Container& other, bool adopt)
         _shrinkCounter = other._shrinkCounter;
         _owned = other._owned;
 
-        other._buf = 0;
+        other._buf = nullptr;
         other._size = 0;
         other._capacity = 0;
         other._shrinkCounter = 0;
@@ -79,16 +70,57 @@ IceInternal::Buffer::Container::Container(Container& other, bool adopt)
     }
 }
 
+IceInternal::Buffer::Container::Container(Container&& other) noexcept
+    : _buf(other._buf),
+      _size(other._size),
+      _capacity(other._capacity),
+      _shrinkCounter(other._shrinkCounter),
+      _owned(other._owned)
+{
+    // Reset other to default state.
+    other._buf = nullptr;
+    other._size = 0;
+    other._capacity = 0;
+    other._shrinkCounter = 0;
+    other._owned = true;
+}
+
+IceInternal::Buffer::Container&
+IceInternal::Buffer::Container::operator=(Container&& other) noexcept
+{
+    if (this != &other)
+    {
+        // If we own the buffer, free it first.
+        if (_owned)
+        {
+            ::free(_buf);
+        }
+        _buf = other._buf;
+        _size = other._size;
+        _capacity = other._capacity;
+        _shrinkCounter = other._shrinkCounter;
+        _owned = other._owned;
+
+        // Reset other to default state.
+        other._buf = nullptr;
+        other._size = 0;
+        other._capacity = 0;
+        other._shrinkCounter = 0;
+        other._owned = true;
+    }
+    return *this;
+}
+
 IceInternal::Buffer::Container::~Container()
 {
-    if(_buf && _owned)
+    if (_owned)
     {
         ::free(_buf);
     }
 }
 
 void
-IceInternal::Buffer::Container::swap(Container& other)
+IceInternal::Buffer::Container::swap(Container& other) noexcept
 {
     std::swap(_buf, other._buf);
     std::swap(_size, other._size);
@@ -100,12 +132,12 @@ IceInternal::Buffer::Container::swap(Container& other)
 void
 IceInternal::Buffer::Container::clear()
 {
-    if(_buf && _owned)
+    if (_owned)
     {
         ::free(_buf);
     }
 
-    _buf = 0;
+    _buf = nullptr;
     _size = 0;
     _capacity = 0;
     _shrinkCounter = 0;
@@ -116,12 +148,12 @@ void
 IceInternal::Buffer::Container::reserve(size_type n)
 {
     size_type c = _capacity;
-    if(n > _capacity)
+    if (n > _capacity)
     {
         _capacity = std::max<size_type>(n, 2 * _capacity);
         _capacity = std::max<size_type>(static_cast<size_type>(240), _capacity);
     }
-    else if(n < _capacity)
+    else if (n < _capacity)
     {
         _capacity = n;
     }
@@ -131,21 +163,21 @@ IceInternal::Buffer::Container::reserve(size_type n)
     }
 
     pointer p;
-    if(_owned)
+    if (_owned)
     {
         p = reinterpret_cast<pointer>(::realloc(_buf, _capacity));
     }
     else
     {
         p = reinterpret_cast<pointer>(::malloc(_capacity));
-        if(p)
+        if (p)
         {
             ::memcpy(p, _buf, _size);
             _owned = true;
         }
     }
 
-    if(!p)
+    if (!p)
     {
         _capacity = c; // Restore the previous capacity.
         throw std::bad_alloc();

data/dist/ice/cpp/src/Ice/CheckIdentity.h

@@ -0,0 +1,21 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "Ice/Identity.h"
+#include "Ice/LocalExceptions.h"
+
+#include <sstream>
+
+namespace Ice
+{
+    // An identity with an empty name is illegal for all Ice APIs: no Ice API returns such an identity, and no Ice API
+    // accepts such an identity argument.
+    inline void checkIdentity(const Identity& identity, const char* file, int line)
+    {
+        if (identity.name.empty())
+        {
+            std::ostringstream os;
+            os << file << ':' << line << ": the name component of an Ice identity cannot be empty";
+            throw std::invalid_argument(os.str());
+        }
+    }
+}