zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,96 +1,90 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_UDP_TRANSCEIVER_H
 #define ICE_UDP_TRANSCEIVER_H
 
-#include <IceUtil/Mutex.h>
-
-#include <Ice/ProtocolInstanceF.h>
-#include <Ice/Transceiver.h>
-#include <Ice/Network.h>
+#include "Network.h"
+#include "ProtocolInstanceF.h"
+#include "Transceiver.h"
 
 namespace IceInternal
 {
+    class UdpEndpoint;
 
-class UdpEndpoint;
-
-class UdpTransceiver : public Transceiver, public NativeInfo
-{
-    enum State
+    class UdpTransceiver final : public Transceiver,
+                                 public NativeInfo,
+                                 public std::enable_shared_from_this<UdpTransceiver>
     {
-        StateNeedConnect,
-        StateConnectPending,
-        StateConnected,
-        StateNotConnected
-    };
+        enum State
+        {
+            StateNeedConnect,
+            StateConnectPending,
+            StateConnected,
+            StateNotConnected
+        };
 
-public:
+    public:
+        UdpTransceiver(ProtocolInstancePtr, const Address&, const Address&, const std::string&, int);
+        UdpTransceiver(UdpEndpointIPtr, const ProtocolInstancePtr&, const std::string&, int, std::string);
 
-    virtual NativeInfoPtr getNativeInfo();
+        ~UdpTransceiver() final;
+
+        NativeInfoPtr getNativeInfo() final;
 #if defined(ICE_USE_IOCP)
-    virtual AsyncInfo* getAsyncInfo(SocketOperation);
+        AsyncInfo* getAsyncInfo(SocketOperation) final;
 #endif
 
-    virtual SocketOperation initialize(Buffer&, Buffer&);
-    virtual SocketOperation closing(bool, const Ice::LocalException&);
-    virtual void close();
-    virtual EndpointIPtr bind();
-    virtual SocketOperation write(Buffer&);
-    virtual SocketOperation read(Buffer&);
+        SocketOperation initialize(Buffer&, Buffer&) final;
+        SocketOperation closing(bool, std::exception_ptr) final;
+        void close() final;
+        EndpointIPtr bind() final;
+        SocketOperation write(Buffer&) final;
+        SocketOperation read(Buffer&) final;
 #if defined(ICE_USE_IOCP)
-    virtual bool startWrite(Buffer&);
-    virtual void finishWrite(Buffer&);
-    virtual void startRead(Buffer&);
-    virtual void finishRead(Buffer&);
+        bool startWrite(Buffer&) final;
+        void finishWrite(Buffer&) final;
+        void startRead(Buffer&) final;
+        void finishRead(Buffer&) final;
+#endif
+        [[nodiscard]] std::string protocol() const final;
+        [[nodiscard]] std::string toString() const final;
+        [[nodiscard]] std::string toDetailedString() const final;
+        [[nodiscard]] Ice::ConnectionInfoPtr
+        getInfo(bool incoming, std::string adapterName, std::string connectionId) const final;
+        void checkSendSize(const Buffer&) final;
+        void setBufferSize(int rcvSize, int sndSize) final;
+
+        [[nodiscard]] int effectivePort() const;
+
+    private:
+        void setBufSize(int, int);
+
+        UdpEndpointIPtr _endpoint;
+        const ProtocolInstancePtr _instance;
+        const bool _incoming;
+        bool _bound;
+
+        const Address _addr;
+        Address _mcastAddr;
+        const std::string _mcastInterface;
+        Address _peerAddr;
+
+#if defined(_WIN32)
+        int _port;
 #endif
-    virtual std::string protocol() const;
-    virtual std::string toString() const;
-    virtual std::string toDetailedString() const;
-    virtual Ice::ConnectionInfoPtr getInfo() const;
-    virtual void checkSendSize(const Buffer&);
-    virtual void setBufferSize(int rcvSize, int sndSize);
-
-    int effectivePort() const;
-
-private:
-
-    UdpTransceiver(const ProtocolInstancePtr&, const Address&, const Address&, const std::string&, int);
-    UdpTransceiver(const UdpEndpointIPtr&, const ProtocolInstancePtr&, const std::string&, int, const std::string&,
-                   bool);
-
-    virtual ~UdpTransceiver();
-
-    void setBufSize(int, int);
-
-    friend class UdpEndpointI;
-    friend class UdpConnector;
-
-    UdpEndpointIPtr _endpoint;
-    const ProtocolInstancePtr _instance;
-    const bool _incoming;
-    bool _bound;
-
-    const Address _addr;
-    Address _mcastAddr;
-    const std::string _mcastInterface;
-    Address _peerAddr;
-    int _port;
 
-    State _state;
-    int _rcvSize;
-    int _sndSize;
-    static const int _udpOverhead;
-    static const int _maxPacketSize;
+        State _state;
+        int _rcvSize;
+        int _sndSize;
+        static const int _udpOverhead;
+        static const int _maxPacketSize;
 
 #if defined(ICE_USE_IOCP)
-    AsyncInfo _read;
-    AsyncInfo _write;
-    Address _readAddr;
-    socklen_t _readAddrLen;
+        AsyncInfo _read;
+        AsyncInfo _write;
+        Address _readAddr;
+        socklen_t _readAddrLen;
 #endif
-};
-
+    };
 }
 #endif

data/dist/ice/cpp/{include/IceUtil → src/Ice}/UndefSysMacros.h

@@ -1,13 +1,14 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#ifndef ICE_UTIL_UNDEF_SYS_MACROS_H
-#define ICE_UTIL_UNDEF_SYS_MACROS_H
+/*! \file
+    \hideincludedbygraph
+*/
+
+#ifndef ICE_UNDEF_SYS_MACROS_H
+#define ICE_UNDEF_SYS_MACROS_H
 
-//
 // This header includes macros that can end up being dragged into
-// the generated code from system headers, such as major() or NDEBUG.
+// the generated code from system headers, such as major().
 // If a Slice symbol has the same name as a macro, the generated
 // code most likely won't compile (but, depending how the macro is
 // defined, may even compile).
@@ -16,22 +17,21 @@
 //
 // The #ifdef ... #endif protection is necessary to prevent
 // warnings on some platforms.
-//
 
 #ifdef major
-#undef major
+#    undef major
 #endif
 
 #ifdef minor
-#undef minor
+#    undef minor
 #endif
 
 #ifdef min
-#undef min
+#    undef min
 #endif
 
 #ifdef max
-#undef max
+#    undef max
 #endif
 
 #endif

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

@@ -0,0 +1,77 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_UNIQUE_REF_H
+#define ICE_UNIQUE_REF_H
+
+#include <cassert>
+
+#ifdef __APPLE__
+
+#    include <CoreFoundation/CoreFoundation.h>
+
+namespace IceInternal
+{
+    //
+    // UniqueRef helper class for CoreFoundation classes, comparable to std::unique_ptr
+    //
+    template<typename R> class UniqueRef
+    {
+    public:
+        explicit UniqueRef(R ref = nullptr) : _ref(ref) {}
+
+        ~UniqueRef()
+        {
+            if (_ref != nullptr)
+            {
+                CFRelease(_ref);
+            }
+        }
+
+        UniqueRef(UniqueRef&) = delete;
+        UniqueRef& operator=(UniqueRef&) = delete;
+
+        R release()
+        {
+            R r = _ref;
+            _ref = nullptr;
+            return r;
+        }
+
+        void reset(R ref = nullptr)
+        {
+            //
+            // Support "self-reset" for CF objects. This is useful if CF allocation methods return
+            // the same object with an increased reference count.
+            //
+            // assert(ref == nullptr || ref != _ref);
+
+            if (_ref != nullptr)
+            {
+                CFRelease(_ref);
+            }
+            _ref = ref;
+        }
+
+        void retain(R ref) { reset(ref ? (R)CFRetain(ref) : ref); }
+
+        R& get() { return _ref; }
+
+        [[nodiscard]] R get() const { return _ref; }
+
+        operator bool() const { return _ref != nullptr; }
+
+        void swap(UniqueRef& a) noexcept
+        {
+            R tmp = a._ref;
+            a._ref = _ref;
+            _ref = tmp;
+        }
+
+    private:
+        R _ref;
+    };
+}
+
+#endif
+
+#endif

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

@@ -0,0 +1,58 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "Ice/UserException.h"
+#include "Ice/Demangle.h"
+#include "Ice/InputStream.h"
+#include "Ice/OutputStream.h"
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+
+const char*
+Ice::UserException::what() const noexcept
+{
+    return ice_id();
+}
+
+void
+Ice::UserException::ice_print(ostream& os) const
+{
+    string className{demangle(typeid(*this).name())};
+    // On Windows, the class name is prefixed with "class "; we removed it.
+    if (className.compare(0, 6, "class ") == 0)
+    {
+        className.erase(0, 6);
+    }
+
+    os << className << '{';
+    ice_printFields(os);
+    os << '}';
+}
+
+void
+Ice::UserException::ice_printFields(ostream&) const
+{
+}
+
+void
+Ice::UserException::_write(OutputStream* os) const
+{
+    os->startException();
+    _writeImpl(os);
+    os->endException();
+}
+
+void
+Ice::UserException::_read(InputStream* is)
+{
+    is->startException();
+    _readImpl(is);
+    is->endException();
+}
+
+bool
+Ice::UserException::_usesClasses() const
+{
+    return false;
+}

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

@@ -1,32 +1,113 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <Ice/Value.h>
-#include <Ice/LocalException.h>
-#include <Ice/OutputStream.h>
-#include <Ice/InputStream.h>
+#include "Ice/Value.h"
+#include "Ice/Demangle.h"
+#include "Ice/InputStream.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/OutputStream.h"
+#include "Ice/SlicedData.h"
 
-#ifdef ICE_CPP11_MAPPING
+#include <algorithm>
+#include <deque>
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
+namespace
+{
+    // RAII helper class that detects cycles when printing class instances.
+    class CycleChecker final
+    {
+    public:
+        CycleChecker(const Value* value, ostream& os) : _os(os)
+        {
+            // Retrieve current stack, if any.
+            void*& currentVoidStar = _os.pword(_cycleCheckIndex);
+            if (currentVoidStar)
+            {
+                auto* currentStack = static_cast<deque<const Value*>*>(currentVoidStar);
+                if (find(currentStack->begin(), currentStack->end(), value) == currentStack->end())
+                {
+                    // No cycle detected.
+                    _currentStack = currentStack;
+                }
+                // else _currentStack remains null and CycleChecker doesn't do anything.
+            }
+            else // new stack
+            {
+                _currentStack = &_localStack;
+                currentVoidStar = _currentStack;
+            }
+
+            if (_currentStack)
+            {
+                _currentStack->push_front(value);
+            }
+        }
+
+        ~CycleChecker()
+        {
+            if (_currentStack)
+            {
+                _currentStack->pop_front();
+
+                if (_currentStack == &_localStack)
+                {
+                    // Clear value in os.
+                    _os.pword(_cycleCheckIndex) = nullptr;
+                }
+            }
+            assert(_localStack.size() == 0);
+        }
+
+        [[nodiscard]] bool good() const noexcept { return _currentStack; }
+
+    private:
+        ostream& _os;
+        deque<const Value*> _localStack;
+        deque<const Value*>* _currentStack{nullptr}; // may or may not point to _localStack
+
+        static const int _cycleCheckIndex;
+    };
+
+    const int CycleChecker::_cycleCheckIndex = ios_base::xalloc(); // NOLINT(cert-err58-cpp)
+}
+
+Ice::Value::~Value() = default;
+
 void
-Ice::Value::ice_preMarshal()
+Ice::Value::ice_print(ostream& os) const
 {
+    string className{demangle(typeid(*this).name())};
+    // On Windows, the class name is prefixed with "class "; we removed it.
+    if (className.compare(0, 6, "class ") == 0)
+    {
+        className.erase(0, 6);
+    }
+
+    os << className << '{';
+    const CycleChecker cycleChecker{this, os};
+    if (cycleChecker.good())
+    {
+        ice_printFields(os);
+    }
+    else
+    {
+        os << "...already printed...";
+    }
+    os << '}';
 }
 
 void
-Ice::Value::ice_postUnmarshal()
+Ice::Value::ice_printFields(ostream&) const
 {
 }
 
 void
 Ice::Value::_iceWrite(Ice::OutputStream* os) const
 {
-    os->startValue(0);
+    os->startValue(_slicedData);
     _iceWriteImpl(os);
     os->endValue();
 }
@@ -34,43 +115,31 @@ Ice::Value::_iceWrite(Ice::OutputStream* os) const
 void
 Ice::Value::_iceRead(Ice::InputStream* is)
 {
-   is->startValue();
-   _iceReadImpl(is);
-   is->endValue(false);
+    is->startValue();
+    _iceReadImpl(is);
+    _slicedData = is->endValue();
 }
 
-namespace
-{
-
-const string object_ids[] =
+const char*
+Ice::Value::ice_id() const noexcept
 {
-    "::Ice::Object"
-};
-
+    return ice_staticId();
 }
 
-string
-Ice::Value::ice_id() const
+const char*
+Ice::Value::ice_staticId() noexcept
 {
-    return object_ids[0];
+    return "::Ice::Object";
 }
 
-const string&
-Ice::Value::ice_staticId()
-{
-    return object_ids[0];
-}
-
-shared_ptr<Value>
-Ice::Value::ice_clone() const
+SlicedDataPtr
+Ice::Value::ice_getSlicedData() const
 {
-    return _iceCloneImpl();
+    return _slicedData;
 }
 
-shared_ptr<SlicedData>
-Ice::Value::ice_getSlicedData() const
+Ice::ValuePtr
+Ice::Value::_iceCloneImpl() const
 {
-    return nullptr;
+    throw std::logic_error("clone is not implemented for this class");
 }
-
-#endif

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

@@ -1,10 +1,8 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <Ice/WSAcceptor.h>
-#include <Ice/WSTransceiver.h>
-#include <Ice/WSEndpoint.h>
+#include "WSAcceptor.h"
+#include "WSEndpoint.h"
+#include "WSTransceiver.h"
 
 using namespace std;
 using namespace Ice;
@@ -58,7 +56,7 @@ IceInternal::WSAcceptor::accept()
     // WebSocket handshaking is performed in TransceiverI::initialize, since
     // accept must not block.
     //
-    return new WSTransceiver(_instance, _delegate->accept());
+    return make_shared<WSTransceiver>(_instance, _delegate->accept());
 }
 
 string
@@ -79,14 +77,11 @@ IceInternal::WSAcceptor::toDetailedString() const
     return _delegate->toDetailedString();
 }
 
-IceInternal::WSAcceptor::WSAcceptor(const WSEndpointPtr& endpoint, const ProtocolInstancePtr& instance,
-                                    const AcceptorPtr& del) :
-    _endpoint(endpoint),
-    _instance(instance),
-    _delegate(del)
+IceInternal::WSAcceptor::WSAcceptor(WSEndpointPtr endpoint, ProtocolInstancePtr instance, AcceptorPtr del)
+    : _endpoint(std::move(endpoint)),
+      _instance(std::move(instance)),
+      _delegate(std::move(del))
 {
 }
 
-IceInternal::WSAcceptor::~WSAcceptor()
-{
-}
+IceInternal::WSAcceptor::~WSAcceptor() = default;

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

@@ -1,52 +1,46 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_WS_ACCEPTOR_I_H
 #define ICE_WS_ACCEPTOR_I_H
 
-#include <Ice/LoggerF.h>
-#include <Ice/TransceiverF.h>
-#include <Ice/Acceptor.h>
-#include <Ice/Network.h>
-#include <Ice/ProtocolInstance.h>
+#include "Acceptor.h"
+#include "Ice/Logger.h"
+#include "Network.h"
+#include "ProtocolInstance.h"
+#include "TransceiverF.h"
 
 namespace IceInternal
 {
-
-class WSEndpoint;
-
-class WSAcceptor : public Acceptor, public NativeInfo
-{
-public:
-
-    virtual NativeInfoPtr getNativeInfo();
+    class WSEndpoint;
+
+    class WSAcceptor final : public Acceptor, public NativeInfo
+    {
+    public:
+        WSAcceptor(WSEndpointPtr, ProtocolInstancePtr, AcceptorPtr);
+        ~WSAcceptor() override;
+        NativeInfoPtr getNativeInfo() final;
 #if defined(ICE_USE_IOCP)
-    virtual AsyncInfo* getAsyncInfo(SocketOperation);
+        AsyncInfo* getAsyncInfo(SocketOperation) final;
 #endif
 
-    virtual void close();
-    virtual EndpointIPtr listen();
+        void close() final;
+        EndpointIPtr listen() final;
 #if defined(ICE_USE_IOCP)
-    virtual void startAccept();
-    virtual void finishAccept();
+        void startAccept() final;
+        void finishAccept() final;
 #endif
-    virtual TransceiverPtr accept();
-    virtual std::string protocol() const;
-    virtual std::string toString() const;
-    virtual std::string toDetailedString() const;
-
-private:
-
-    WSAcceptor(const WSEndpointPtr&, const ProtocolInstancePtr&, const AcceptorPtr&);
-    virtual ~WSAcceptor();
-    friend class WSEndpoint;
-
-    WSEndpointPtr _endpoint;
-    const ProtocolInstancePtr _instance;
-    const AcceptorPtr _delegate;
-};
-
+        TransceiverPtr accept() final;
+        [[nodiscard]] std::string protocol() const final;
+        [[nodiscard]] std::string toString() const final;
+        [[nodiscard]] std::string toDetailedString() const final;
+
+    private:
+        friend class WSEndpoint;
+
+        WSEndpointPtr _endpoint;
+        const ProtocolInstancePtr _instance;
+        const AcceptorPtr _delegate;
+    };
 }
 
 #endif