zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,218 +1,150 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_ENDPOINT_I_H
 #define ICE_ENDPOINT_I_H
 
-#include <Ice/EndpointIF.h>
-#include <Ice/Endpoint.h>
-#include <Ice/EndpointTypes.h>
-#include <Ice/TransceiverF.h>
-#include <Ice/ConnectorF.h>
-#include <Ice/AcceptorF.h>
+#include "AcceptorF.h"
+#include "ConnectorF.h"
+#include "EndpointIF.h"
+#include "Ice/Endpoint.h"
+#include "Ice/EndpointSelectionType.h"
+#include "Ice/SSL/ServerAuthenticationOptions.h"
+#include "TransceiverF.h"
+
+#include <optional>
 
 namespace Ice
 {
-
-class OutputStream;
-class InputStream;
-
+    class OutputStream;
+    class InputStream;
 }
 
 namespace IceInternal
 {
-
-class ICE_API EndpointI_connectors
-#ifndef ICE_CPP11_MAPPING
-    : public virtual IceUtil::Shared
-#endif
-{
-public:
-
-    virtual ~EndpointI_connectors();
-
-    virtual void connectors(const std::vector<ConnectorPtr>&) = 0;
-    virtual void exception(const Ice::LocalException&) = 0;
-};
-
-class ICE_API EndpointI : public Ice::Endpoint
-{
-public:
-
-    //
-    // Marshal the endpoint.
-    //
-    virtual void streamWrite(Ice::OutputStream*) const;
-    virtual void streamWriteImpl(Ice::OutputStream*) const = 0;
-
-    //
-    // Return the endpoint type.
-    //
-    virtual Ice::Short type() const = 0;
-
-    //
-    // Return the protocol name
-    //
-    virtual const std::string& protocol() const = 0;
-
-    //
-    // Return the timeout for the endpoint in milliseconds. 0 means
-    // non-blocking, -1 means no timeout.
-    //
-    virtual Ice::Int timeout() const = 0;
-
-    //
-    // Return a new endpoint with a different timeout value, provided
-    // that timeouts are supported by the endpoint. Otherwise the same
-    // endpoint is returned.
-    //
-    virtual EndpointIPtr timeout(Ice::Int) const = 0;
-
-    //
-    // Returns the endpoint connection id.
-    //
-    virtual const std::string& connectionId() const = 0;
-
-    //
-    // Return a new endpoint with a different connection id.
-    //
-    virtual EndpointIPtr connectionId(const ::std::string&) const = 0;
-
-    //
-    // Return true if the endpoints support bzip2 compress, or false
-    // otherwise.
-    //
-    virtual bool compress() const = 0;
-
-    //
-    // Return a new endpoint with a different compression value,
-    // provided that compression is supported by the
-    // endpoint. Otherwise the same endpoint is returned.
-    //
-    virtual EndpointIPtr compress(bool) const = 0;
-
-    //
-    // Return true if the endpoint is datagram-based.
-    //
-    virtual bool datagram() const = 0;
-
-    //
-    // Return true if the endpoint is secure.
-    //
-    virtual bool secure() const = 0;
-
-    //
-    // Return a server side transceiver for this endpoint, or null if a
-    // transceiver can only be created by an acceptor.
-    //
-    virtual TransceiverPtr transceiver() const = 0;
-
-    //
-    // Return connectors for this endpoint, or empty vector if no
-    // connector is available. Implementation is responsible for
-    // returning connectors sorted according to the endpoint selection
-    // type.
-    //
-    virtual void connectors_async(Ice::EndpointSelectionType, const EndpointI_connectorsPtr&) const = 0;
-
-    //
-    // Return an acceptor for this endpoint, or null if no acceptors
-    // is available.
-    //
-    virtual AcceptorPtr acceptor(const std::string&) const = 0;
-
-    //
-    // Expand endpoint out into separate endpoints for each local
-    // host if listening on INADDR_ANY on server side.
-    //
-    virtual std::vector<EndpointIPtr> expandIfWildcard() const = 0;
-
-    //
-    // Expand endpoint out into separate endpoints for each IP
-    // address returned by the DNS resolver. Also returns the
-    // endpoint which can be used to connect to the returned
-    // endpoints or null if no specific endpoint can be used to
-    // connect to these endpoints (e.g.: with the IP endpoint,
-    // it returns this endpoint if it uses a fixed port, null
-    // otherwise).
-    //
-    virtual std::vector<EndpointIPtr> expandHost(IceInternal::EndpointIPtr&) const = 0;
-
-    //
-    // Check whether the endpoint is equivalent to another one.
-    //
-    virtual bool equivalent(const EndpointIPtr&) const = 0;
-
-    //
-    // Compare endpoints for sorting purposes.
-    //
-#ifndef ICE_CPP11_MAPPING
-    virtual bool operator==(const Ice::LocalObject&) const = 0;
-    virtual bool operator<(const Ice::LocalObject&) const = 0;
-#endif
-
-    virtual ::Ice::Int hash() const = 0;
-
-    //
-    // Returns the stringified options
-    //
-    virtual std::string options() const = 0;
-
-    virtual std::string toString() const ICE_NOEXCEPT;
-    void initWithOptions(std::vector<std::string>&);
-
-protected:
-
-    virtual bool checkOption(const std::string&, const std::string&, const std::string&);
-
-};
-
-#ifndef ICE_CPP11_MAPPING
-inline bool operator==(const EndpointI& l, const EndpointI& r)
-{
-    return static_cast<const ::Ice::LocalObject&>(l) == static_cast<const ::Ice::LocalObject&>(r);
-}
-
-inline bool operator<(const EndpointI& l, const EndpointI& r)
-{
-    return static_cast<const ::Ice::LocalObject&>(l) < static_cast<const ::Ice::LocalObject&>(r);
+    class ICE_API EndpointI : public Ice::Endpoint
+    {
+    public:
+        //
+        // Marshal the endpoint.
+        //
+        virtual void streamWrite(Ice::OutputStream*) const;
+        virtual void streamWriteImpl(Ice::OutputStream*) const = 0;
+
+        //
+        // Return the endpoint type.
+        //
+        [[nodiscard]] virtual std::int16_t type() const = 0;
+
+        //
+        // Return the protocol name
+        //
+        [[nodiscard]] virtual const std::string& protocol() const = 0;
+
+        //
+        // Return the timeout for the endpoint in milliseconds. 0 means
+        // non-blocking, -1 means no timeout.
+        //
+        [[nodiscard]] virtual std::int32_t timeout() const = 0;
+
+        //
+        // Return a new endpoint with a different timeout value, provided
+        // that timeouts are supported by the endpoint. Otherwise the same
+        // endpoint is returned.
+        //
+        [[nodiscard]] virtual EndpointIPtr timeout(std::int32_t) const = 0;
+
+        //
+        // Returns the endpoint connection id.
+        //
+        [[nodiscard]] virtual const std::string& connectionId() const = 0;
+
+        //
+        // Return a new endpoint with a different connection id.
+        //
+        [[nodiscard]] virtual EndpointIPtr connectionId(const std::string&) const = 0;
+
+        //
+        // Return true if the endpoints support bzip2 compress, or false
+        // otherwise.
+        //
+        [[nodiscard]] virtual bool compress() const = 0;
+
+        //
+        // Return a new endpoint with a different compression value,
+        // provided that compression is supported by the
+        // endpoint. Otherwise the same endpoint is returned.
+        //
+        [[nodiscard]] virtual EndpointIPtr compress(bool) const = 0;
+
+        //
+        // Return true if the endpoint is datagram-based.
+        //
+        [[nodiscard]] virtual bool datagram() const = 0;
+
+        //
+        // Return true if the endpoint is secure.
+        //
+        [[nodiscard]] virtual bool secure() const = 0;
+
+        //
+        // Return a server side transceiver for this endpoint, or null if a
+        // transceiver can only be created by an acceptor.
+        //
+        [[nodiscard]] virtual TransceiverPtr transceiver() const = 0;
+
+        //
+        // Return connectors for this endpoint, or empty vector if no
+        // connector is available.
+        //
+        virtual void connectorsAsync(
+            std::function<void(std::vector<ConnectorPtr>)>,
+            std::function<void(std::exception_ptr)>) const = 0;
+
+        //
+        // Return an acceptor for this endpoint, or null if no acceptors
+        // is available.
+        //
+        [[nodiscard]] virtual AcceptorPtr
+        acceptor(const std::string&, const std::optional<Ice::SSL::ServerAuthenticationOptions>&) const = 0;
+
+        // Expand endpoint into separate endpoints for each IP address returned by the DNS resolver.
+        // Used only for server endpoints.
+        [[nodiscard]] virtual std::vector<EndpointIPtr> expandHost() const = 0;
+
+        // Returns true when the most underlying endpoint is an IP endpoint with a loopback or multicast address.
+        [[nodiscard]] virtual bool isLoopbackOrMulticast() const = 0;
+
+        // Returns a new endpoint with the specified host (if not empty) and all local options cleared. May return
+        // shared_from_this().
+        [[nodiscard]] virtual std::shared_ptr<EndpointI> toPublishedEndpoint(std::string publishedHost) const = 0;
+
+        //
+        // Check whether the endpoint is equivalent to another one.
+        //
+        [[nodiscard]] virtual bool equivalent(const EndpointIPtr&) const = 0;
+
+        [[nodiscard]] virtual std::size_t hash() const noexcept = 0;
+
+        //
+        // Returns the stringified options
+        //
+        [[nodiscard]] virtual std::string options() const = 0;
+
+        [[nodiscard]] std::string toString() const noexcept override;
+        void initWithOptions(std::vector<std::string>&);
+
+    protected:
+        virtual bool checkOption(const std::string&, const std::string&, const std::string&);
+    };
 }
-#endif
 
-template<typename T> class InfoI : public T
+namespace std
 {
-public:
-
-    InfoI(const EndpointIPtr& endpoint) : _endpoint(endpoint)
+    /// Specialization of std::hash for EndpointI.
+    template<> struct hash<IceInternal::EndpointI>
     {
-        T::compress = _endpoint->compress();
-        T::timeout = _endpoint->timeout();
-    }
-
-    virtual Ice::Short
-    type() const ICE_NOEXCEPT
-    {
-        return _endpoint->type();
-    }
-
-    virtual bool
-    datagram() const ICE_NOEXCEPT
-    {
-        return _endpoint->datagram();
-    }
-
-    virtual bool
-    secure() const ICE_NOEXCEPT
-    {
-        return _endpoint->secure();
-    }
-
-private:
-
-    const EndpointIPtr _endpoint;
-};
-
+        std::size_t operator()(const IceInternal::EndpointI& endpoint) const noexcept { return endpoint.hash(); }
+    };
 }
 
 #endif

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

@@ -1,49 +1,21 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_ENDPOINT_I_F_H
 #define ICE_ENDPOINT_I_F_H
 
-#include <IceUtil/Shared.h>
-#include <Ice/Handle.h>
+#include <memory>
 
 namespace IceInternal
 {
-
-class EndpointI;
-class TcpEndpointI;
-class UdpEndpointI;
-class WSEndpoint;
-class EndpointI_connectors;
-
-#ifdef ICE_CPP11_MAPPING // C++11 mapping
-
-using EndpointIPtr = ::std::shared_ptr<EndpointI>;
-using TcpEndpointIPtr = ::std::shared_ptr<TcpEndpointI>;
-using UdpEndpointIPtr = ::std::shared_ptr<UdpEndpointI>;
-using WSEndpointPtr = ::std::shared_ptr<WSEndpoint>;
-using EndpointI_connectorsPtr = ::std::shared_ptr<EndpointI_connectors>;
-
-#else // C++98 mapping
-
-ICE_API IceUtil::Shared* upCast(EndpointI*);
-typedef Handle<EndpointI> EndpointIPtr;
-
-ICE_API IceUtil::Shared* upCast(TcpEndpointI*);
-typedef Handle<TcpEndpointI> TcpEndpointIPtr;
-
-ICE_API IceUtil::Shared* upCast(UdpEndpointI*);
-typedef Handle<UdpEndpointI> UdpEndpointIPtr;
-
-ICE_API IceUtil::Shared* upCast(WSEndpoint*);
-typedef Handle<WSEndpoint> WSEndpointPtr;
-
-ICE_API IceUtil::Shared* upCast(EndpointI_connectors*);
-typedef Handle<EndpointI_connectors> EndpointI_connectorsPtr;
-
-#endif
-
+    class EndpointI;
+    class TcpEndpointI;
+    class UdpEndpointI;
+    class WSEndpoint;
+
+    using EndpointIPtr = std::shared_ptr<EndpointI>;
+    using TcpEndpointIPtr = std::shared_ptr<TcpEndpointI>;
+    using UdpEndpointIPtr = std::shared_ptr<UdpEndpointI>;
+    using WSEndpointPtr = std::shared_ptr<WSEndpoint>;
 }
 
 #endif

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

@@ -1,32 +1,9 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <Ice/EventHandler.h>
-#include <Ice/Instance.h>
+#include "EventHandler.h"
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-#ifndef ICE_CPP11_MAPPING
-IceUtil::Shared* IceInternal::upCast(EventHandler* p) { return p; }
-#endif
-
-IceInternal::EventHandler::EventHandler() :
-#if defined(ICE_USE_IOCP)
-    _pending(SocketOperationNone),
-    _started(SocketOperationNone),
-    _completed(SocketOperationNone),
-    _finish(false),
-#else
-    _disabled(SocketOperationNone),
-#endif
-    _ready(SocketOperationNone),
-    _registered(SocketOperationNone)
-{
-}
-
-IceInternal::EventHandler::~EventHandler()
-{
-}
+IceInternal::EventHandler::~EventHandler() = default;

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

@@ -1,81 +1,71 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_EVENT_HANDLER_H
 #define ICE_EVENT_HANDLER_H
 
-#include <IceUtil/Shared.h>
-#include <Ice/EventHandlerF.h>
-#include <Ice/InstanceF.h>
-#include <Ice/ThreadPoolF.h>
-#include <Ice/Network.h>
-#include <Ice/VirtualShared.h>
+#include "EventHandlerF.h"
+#include "Ice/InstanceF.h"
+#include "Network.h"
+#include "ThreadPoolF.h"
 
-namespace IceInternal
-{
+#include <memory>
 
-class ICE_API EventHandler :
-#ifdef ICE_CPP11_MAPPING
-        public EnableSharedFromThis<EventHandler>
-#else
-        public virtual Ice::LocalObject
-#endif
+namespace IceInternal
 {
-public:
+    class ThreadPoolCurrent;
 
+    class EventHandler : public std::enable_shared_from_this<EventHandler>
+    {
+    public:
 #if defined(ICE_USE_IOCP)
-    //
-    // Called to start a new asynchronous read or write operation.
-    //
-    virtual bool startAsync(SocketOperation) = 0;
-    virtual bool finishAsync(SocketOperation) = 0;
+        //
+        // Called to start a new asynchronous read or write operation.
+        //
+        virtual bool startAsync(SocketOperation) = 0;
+        virtual bool finishAsync(SocketOperation) = 0;
 #endif
 
-    //
-    // Called when there's a message ready to be processed.
-    //
-    virtual void message(ThreadPoolCurrent&) = 0;
-
-    //
-    // Called when the event handler is unregistered.
-    //
-    virtual void finished(ThreadPoolCurrent&, bool) = 0;
+        //
+        // Called when there's a message ready to be processed.
+        //
+        virtual void message(ThreadPoolCurrent&) = 0;
 
-    //
-    // Get a textual representation of the event handler.
-    //
-    virtual std::string toString() const = 0;
+        //
+        // Called when the event handler is unregistered.
+        //
+        virtual void finished(ThreadPoolCurrent&, bool) = 0;
 
-    //
-    // Get the native information of the handler, this is used by the selector.
-    //
-    virtual NativeInfoPtr getNativeInfo() = 0;
+        //
+        // Get a textual representation of the event handler.
+        //
+        [[nodiscard]] virtual std::string toString() const = 0;
 
-protected:
+        //
+        // Get the native information of the handler, this is used by the selector.
+        //
+        virtual NativeInfoPtr getNativeInfo() = 0;
 
-    EventHandler();
-    virtual ~EventHandler();
+    protected:
+        virtual ~EventHandler();
 
 #if defined(ICE_USE_IOCP)
-    SocketOperation _pending;
-    SocketOperation _started;
-    SocketOperation _completed;
-    bool _finish;
+        SocketOperation _pending{SocketOperationNone};
+        SocketOperation _started{SocketOperationNone};
+        SocketOperation _completed{SocketOperationNone};
+        bool _finish{false};
 #else
-    SocketOperation _disabled;
+        SocketOperation _disabled{SocketOperationNone};
 #endif
-    SocketOperation _ready;
-    SocketOperation _registered;
+        SocketOperation _ready{SocketOperationNone};
+        SocketOperation _registered{SocketOperationNone};
 
-    friend class ThreadPool;
-    friend class ThreadPoolCurrent;
-    friend class Selector;
+        friend class ThreadPool;
+        friend class ThreadPoolCurrent;
+        friend class Selector;
 #ifdef ICE_USE_CFSTREAM
-    friend class EventHandlerWrapper;
+        friend class EventHandlerWrapper;
 #endif
-};
-
+    };
 }
 
 #endif

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

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