zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,15 +1,14 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <Ice/OpaqueEndpointI.h>
-#include <Ice/OutputStream.h>
-#include <Ice/InputStream.h>
-#include <Ice/Exception.h>
-#include <Ice/DefaultsAndOverrides.h>
-#include <Ice/Base64.h>
-#include <Ice/HashUtil.h>
-#include <Ice/LocalException.h>
+// Copyright (c) ZeroC, Inc.
+
+#include "OpaqueEndpointI.h"
+#include "Base64.h"
+#include "DefaultsAndOverrides.h"
+#include "HashUtil.h"
+#include "Ice/InputStream.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/OutputStream.h"
+
+#include <sstream>
 
 using namespace std;
 using namespace Ice;
@@ -17,92 +16,46 @@ using namespace IceInternal;
 
 namespace
 {
-
-static string opaqueEndpointProtocol = "opaque";
-static string opaqueEndpointConnectionId;
-
+    static string opaqueEndpointProtocol = "opaque"; // NOLINT(cert-err58-cpp)
+    static string opaqueEndpointConnectionId;
 }
 
-IceInternal::OpaqueEndpointI::OpaqueEndpointI(vector<string>& args) :
-    _type(-1), _rawEncoding(Encoding_1_0)
+IceInternal::OpaqueEndpointI::OpaqueEndpointI(vector<string>& args) : _type(-1), _rawEncoding(Encoding_1_0)
 {
     initWithOptions(args);
 
-    if(_type < 0)
+    if (_type < 0)
     {
-        throw EndpointParseException(__FILE__, __LINE__, "no -t option in endpoint " + toString());
+        throw ParseException(__FILE__, __LINE__, "no -t option in endpoint '" + toString() + "'");
     }
-    if(_rawBytes.empty())
+    if (_rawBytes.empty())
     {
-        throw EndpointParseException(__FILE__, __LINE__, "no -v option in endpoint " + toString());
+        throw ParseException(__FILE__, __LINE__, "no -v option in endpoint '" + toString() + "'");
     }
 }
 
-IceInternal::OpaqueEndpointI::OpaqueEndpointI(Short type, InputStream* s) : _type(type)
+IceInternal::OpaqueEndpointI::OpaqueEndpointI(int16_t type, InputStream* s) : _type(type)
 {
     _rawEncoding = s->getEncoding();
-    Int sz = s->getEncapsulationSize();
-    s->readBlob(const_cast<vector<Byte>&>(_rawBytes), sz);
-}
-
-namespace
-{
-
-class OpaqueEndpointInfoI : public Ice::OpaqueEndpointInfo
-{
-public:
-
-    OpaqueEndpointInfoI(Ice::Short type, const Ice::EncodingVersion& rawEncoding, const Ice::ByteSeq& rawBytes);
-
-    virtual Ice::Short
-    type() const ICE_NOEXCEPT
-    {
-        return _type;
-    }
-
-    virtual bool
-    datagram() const ICE_NOEXCEPT
-    {
-        return false;
-    }
-
-    virtual bool
-    secure() const ICE_NOEXCEPT
-    {
-        return false;
-    }
-
-private:
-
-    Ice::Short _type;
-};
-
-}
-//
-// COMPILERFIX: inlining this constructor causes crashes with gcc 4.0.1.
-//
-OpaqueEndpointInfoI::OpaqueEndpointInfoI(Ice::Short type, const Ice::EncodingVersion& rawEncodingP,
-                                         const Ice::ByteSeq& rawBytesP) :
-    Ice::OpaqueEndpointInfo(ICE_NULLPTR, -1, false, rawEncodingP, rawBytesP),
-    _type(type)
-{
+    int32_t sz = s->getEncapsulationSize();
+    s->readBlob(const_cast<vector<byte>&>(_rawBytes), sz);
 }
 
 void
 IceInternal::OpaqueEndpointI::streamWrite(OutputStream* s) const
 {
-    s->startEncapsulation(_rawEncoding, ICE_ENUM(FormatType, DefaultFormat));
+    s->startEncapsulation(_rawEncoding, nullopt);
     s->writeBlob(_rawBytes);
     s->endEncapsulation();
 }
 
 Ice::EndpointInfoPtr
-IceInternal::OpaqueEndpointI::getInfo() const ICE_NOEXCEPT
+IceInternal::OpaqueEndpointI::getInfo() const noexcept
 {
-    return ICE_MAKE_SHARED(OpaqueEndpointInfoI, _type, _rawEncoding, _rawBytes);
+    return make_shared<OpaqueEndpointInfo>(_type, _rawEncoding, _rawBytes);
 }
 
-Short
+int16_t
 IceInternal::OpaqueEndpointI::type() const
 {
     return _type;
@@ -114,16 +67,16 @@ IceInternal::OpaqueEndpointI::protocol() const
     return opaqueEndpointProtocol;
 }
 
-Int
+int32_t
 IceInternal::OpaqueEndpointI::timeout() const
 {
     return -1;
 }
 
 EndpointIPtr
-IceInternal::OpaqueEndpointI::timeout(Int) const
+IceInternal::OpaqueEndpointI::timeout(int32_t) const
 {
-    return ICE_SHARED_FROM_CONST_THIS(OpaqueEndpointI);
+    return const_cast<OpaqueEndpointI*>(this)->shared_from_this();
 }
 
 const string&
@@ -135,7 +88,7 @@ IceInternal::OpaqueEndpointI::connectionId() const
 EndpointIPtr
 IceInternal::OpaqueEndpointI::connectionId(const string&) const
 {
-    return ICE_SHARED_FROM_CONST_THIS(OpaqueEndpointI);
+    return const_cast<OpaqueEndpointI*>(this)->shared_from_this();
 }
 
 bool
@@ -147,7 +100,7 @@ IceInternal::OpaqueEndpointI::compress() const
 EndpointIPtr
 IceInternal::OpaqueEndpointI::compress(bool) const
 {
-    return ICE_SHARED_FROM_CONST_THIS(OpaqueEndpointI);
+    return const_cast<OpaqueEndpointI*>(this)->shared_from_this();
 }
 
 bool
@@ -165,35 +118,39 @@ IceInternal::OpaqueEndpointI::secure() const
 TransceiverPtr
 IceInternal::OpaqueEndpointI::transceiver() const
 {
-    return ICE_NULLPTR;
+    return nullptr;
 }
 
 void
-IceInternal::OpaqueEndpointI::connectors_async(Ice::EndpointSelectionType, const EndpointI_connectorsPtr& cb) const
+IceInternal::OpaqueEndpointI::connectorsAsync(
+    function<void(vector<IceInternal::ConnectorPtr>)> response,
+    function<void(exception_ptr)>) const
 {
-    cb->connectors(vector<ConnectorPtr>());
+    response(vector<ConnectorPtr>());
 }
 
 AcceptorPtr
-IceInternal::OpaqueEndpointI::acceptor(const string&) const
+IceInternal::OpaqueEndpointI::acceptor(const string&, const optional<Ice::SSL::ServerAuthenticationOptions>&) const
 {
-    return ICE_NULLPTR;
+    return nullptr;
 }
 
 vector<EndpointIPtr>
-IceInternal::OpaqueEndpointI::expandIfWildcard() const
+IceInternal::OpaqueEndpointI::expandHost() const
 {
-    vector<EndpointIPtr> endps;
-    endps.push_back(ICE_SHARED_FROM_CONST_THIS(OpaqueEndpointI));
-    return endps;
+    return {const_cast<OpaqueEndpointI*>(this)->shared_from_this()};
 }
 
-vector<EndpointIPtr>
-IceInternal::OpaqueEndpointI::expandHost(EndpointIPtr&) const
+bool
+IceInternal::OpaqueEndpointI::isLoopbackOrMulticast() const
 {
-    vector<EndpointIPtr> endps;
-    endps.push_back(ICE_SHARED_FROM_CONST_THIS(OpaqueEndpointI));
-    return endps;
+    return false;
+}
+
+shared_ptr<EndpointI>
+IceInternal::OpaqueEndpointI::toPublishedEndpoint(string) const
+{
+    return const_cast<OpaqueEndpointI*>(this)->shared_from_this();
 }
 
 bool
@@ -202,13 +159,11 @@ IceInternal::OpaqueEndpointI::equivalent(const EndpointIPtr&) const
     return false;
 }
 
-Int
-IceInternal::OpaqueEndpointI::hash() const
+size_t
+IceInternal::OpaqueEndpointI::hash() const noexcept
 {
-    Int h = 5381;
-    hashAdd(h, type());
-    hashAdd(h, _rawEncoding.major);
-    hashAdd(h, _rawEncoding.minor);
+    size_t h = 5381;
+    hashAdd(h, _type);
     hashAdd(h, _rawBytes);
     return h;
 }
@@ -217,12 +172,12 @@ string
 IceInternal::OpaqueEndpointI::options() const
 {
     ostringstream s;
-    if(_type > -1)
+    if (_type > -1)
     {
         s << " -t " << _type;
     }
     s << " -e " << _rawEncoding;
-    if(!_rawBytes.empty())
+    if (!_rawBytes.empty())
     {
         s << " -v " << Base64::encode(_rawBytes);
     }
@@ -230,34 +185,30 @@ IceInternal::OpaqueEndpointI::options() const
 }
 
 bool
-#ifdef ICE_CPP11_MAPPING
 IceInternal::OpaqueEndpointI::operator==(const Endpoint& r) const
-#else
-IceInternal::OpaqueEndpointI::operator==(const LocalObject& r) const
-#endif
 {
-    const OpaqueEndpointI* p = dynamic_cast<const OpaqueEndpointI*>(&r);
-    if(!p)
+    const auto* p = dynamic_cast<const OpaqueEndpointI*>(&r);
+    if (!p)
     {
         return false;
     }
 
-    if(this == p)
+    if (this == p)
     {
         return true;
     }
 
-    if(_type != p->_type)
+    if (_type != p->_type)
     {
         return false;
     }
 
-    if(_rawEncoding != p->_rawEncoding)
+    if (_rawEncoding != p->_rawEncoding)
     {
         return false;
     }
 
-    if(_rawBytes != p->_rawBytes)
+    if (_rawBytes != p->_rawBytes)
     {
         return false;
     }
@@ -266,51 +217,47 @@ IceInternal::OpaqueEndpointI::operator==(const LocalObject& r) const
 }
 
 bool
-#ifdef ICE_CPP11_MAPPING
 IceInternal::OpaqueEndpointI::operator<(const Endpoint& r) const
-#else
-IceInternal::OpaqueEndpointI::operator<(const LocalObject& r) const
-#endif
 {
-    const OpaqueEndpointI* p = dynamic_cast<const OpaqueEndpointI*>(&r);
-    if(!p)
+    const auto* p = dynamic_cast<const OpaqueEndpointI*>(&r);
+    if (!p)
     {
-        const EndpointI* e = dynamic_cast<const EndpointI*>(&r);
-        if(!e)
+        const auto* e = dynamic_cast<const EndpointI*>(&r);
+        if (!e)
         {
             return false;
         }
         return type() < e->type();
     }
 
-    if(this == p)
+    if (this == p)
     {
         return false;
     }
 
-    if(_type < p->_type)
+    if (_type < p->_type)
     {
         return true;
     }
-    else if(p->_type < _type)
+    else if (p->_type < _type)
     {
         return false;
     }
 
-    if(_rawEncoding < p->_rawEncoding)
+    if (_rawEncoding < p->_rawEncoding)
     {
         return true;
     }
-    else if(p->_rawEncoding < _rawEncoding)
+    else if (p->_rawEncoding < _rawEncoding)
     {
         return false;
     }
 
-    if(_rawBytes < p->_rawBytes)
+    if (_rawBytes < p->_rawBytes)
     {
         return true;
     }
-    else if(p->_rawBytes < _rawBytes)
+    else if (p->_rawBytes < _rawBytes)
     {
         return false;
     }
@@ -327,82 +274,95 @@ IceInternal::OpaqueEndpointI::streamWriteImpl(Ice::OutputStream*) const
 bool
 IceInternal::OpaqueEndpointI::checkOption(const string& option, const string& argument, const string& endpoint)
 {
-    switch(option[1])
+    switch (option[1])
     {
-    case 't':
-    {
-        if(_type > -1)
-        {
-            throw EndpointParseException(__FILE__, __LINE__, "multiple -t options in endpoint " + endpoint);
-        }
-        if(argument.empty())
-        {
-            throw EndpointParseException(__FILE__, __LINE__, "no argument provided for -t option in endpoint " +
-                                         endpoint);
-        }
-        istringstream p(argument);
-        Ice::Int t;
-        if(!(p >> t) || !p.eof())
-        {
-            throw EndpointParseException(__FILE__, __LINE__, "invalid type value `" + argument + "' in endpoint " +
-                                         endpoint);
-        }
-        else if(t < 0 || t > 65535)
+        case 't':
         {
-            throw EndpointParseException(__FILE__, __LINE__, "type value `" + argument + "' out of range in endpoint " +
-                                         endpoint);
+            if (_type > -1)
+            {
+                throw ParseException(__FILE__, __LINE__, "multiple -t options in endpoint '" + endpoint + "'");
+            }
+            if (argument.empty())
+            {
+                throw ParseException(
+                    __FILE__,
+                    __LINE__,
+                    "no argument provided for -t option in endpoint '" + endpoint + "'");
+            }
+            istringstream p(argument);
+            int32_t t;
+            if (!(p >> t) || !p.eof())
+            {
+                throw ParseException(
+                    __FILE__,
+                    __LINE__,
+                    "invalid type value '" + argument + "' in endpoint '" + endpoint + "'");
+            }
+            else if (t < 0 || t > 65535)
+            {
+                throw ParseException(
+                    __FILE__,
+                    __LINE__,
+                    "type value '" + argument + "' out of range in endpoint '" + endpoint + "'");
+            }
+            _type = static_cast<int16_t>(t);
+            return true;
         }
-        _type = static_cast<Ice::Short>(t);
-        return true;
-    }
 
-    case 'v':
-    {
-        if(!_rawBytes.empty())
-        {
-            throw EndpointParseException(__FILE__, __LINE__, "multiple -v options in endpoint " + endpoint);
-        }
-        if(argument.empty())
-        {
-            throw EndpointParseException(__FILE__, __LINE__, "no argument provided for -v option in endpoint " + endpoint);
-        }
-        for(string::size_type i = 0; i < argument.size(); ++i)
+        case 'v':
         {
-            if(!Base64::isBase64(argument[i]))
+            if (!_rawBytes.empty())
+            {
+                throw ParseException(__FILE__, __LINE__, "multiple -v options in endpoint '" + endpoint + "'");
+            }
+            if (argument.empty())
+            {
+                throw ParseException(
+                    __FILE__,
+                    __LINE__,
+                    "no argument provided for -v option in endpoint '" + endpoint + "'");
+            }
+            for (char i : argument)
             {
-                ostringstream os;
-                os << "invalid base64 character `" << argument[i] << "' (ordinal " << static_cast<int>(argument[i])
-                   << ") in endpoint " << endpoint;
-                throw EndpointParseException(__FILE__, __LINE__, os.str());
+                if (!Base64::isBase64(i))
+                {
+                    ostringstream os;
+                    os << "invalid base64 character '" << i << "' (ordinal " << static_cast<int>(i) << ") in endpoint '"
+                       << endpoint << "'";
+                    throw ParseException(__FILE__, __LINE__, os.str());
+                }
             }
+            const_cast<vector<byte>&>(_rawBytes) = Base64::decode(argument);
+            return true;
         }
-        const_cast<vector<Byte>&>(_rawBytes) = Base64::decode(argument);
-        return true;
-    }
 
-    case 'e':
-    {
-        if(argument.empty())
+        case 'e':
         {
-            throw Ice::EndpointParseException(__FILE__, __LINE__, "no argument provided for -e option in endpoint " +
-                                              endpoint);
-        }
+            if (argument.empty())
+            {
+                throw Ice::ParseException(
+                    __FILE__,
+                    __LINE__,
+                    "no argument provided for -e option in endpoint '" + endpoint + "'");
+            }
 
-        try
-        {
-            _rawEncoding = Ice::stringToEncodingVersion(argument);
+            try
+            {
+                _rawEncoding = stringToEncodingVersion(argument);
+            }
+            catch (const Ice::ParseException& ex)
+            {
+                throw Ice::ParseException(
+                    __FILE__,
+                    __LINE__,
+                    "invalid encoding version '" + argument + "' in endpoint '" + endpoint + "':\n" + ex.what());
+            }
+            return true;
         }
-        catch(const Ice::VersionParseException& ex)
+
+        default:
         {
-            throw Ice::EndpointParseException(__FILE__, __LINE__, "invalid encoding version `" + argument +
-                                              "' in endpoint " + endpoint + ":\n" + ex.str);
+            return false;
         }
-        return true;
-    }
-
-    default:
-    {
-        return false;
-    }
     }
 }

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

@@ -1,74 +1,66 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_UNKNOWN_ENDPOINT_I_H
 #define ICE_UNKNOWN_ENDPOINT_I_H
 
-#include <Ice/EndpointI.h>
-#include <Ice/EndpointFactory.h>
+#include "EndpointFactory.h"
+#include "EndpointI.h"
+#include "Ice/SSL/ServerAuthenticationOptions.h"
 
-namespace IceInternal
-{
+#include <optional>
 
-class OpaqueEndpointI : public EndpointI
-#ifdef ICE_CPP11_MAPPING
-                      , public std::enable_shared_from_this<OpaqueEndpointI>
-#endif
+namespace IceInternal
 {
-public:
-
-    OpaqueEndpointI(std::vector<std::string>&);
-    OpaqueEndpointI(Ice::Short, Ice::InputStream*);
-
-    virtual void streamWrite(Ice::OutputStream*) const;
-    virtual Ice::EndpointInfoPtr getInfo() const ICE_NOEXCEPT;
-    virtual Ice::Short type() const;
-    virtual const std::string& protocol() const;
-
-    virtual Ice::Int timeout() const;
-    virtual EndpointIPtr timeout(Ice::Int) const;
-    virtual const std::string& connectionId() const;
-    virtual EndpointIPtr connectionId(const ::std::string&) const;
-    virtual bool compress() const;
-    virtual EndpointIPtr compress(bool) const;
-    virtual bool datagram() const;
-    virtual bool secure() const;
-
-    virtual TransceiverPtr transceiver() const;
-    virtual void connectors_async(Ice::EndpointSelectionType, const EndpointI_connectorsPtr&) const;
-    virtual AcceptorPtr acceptor(const std::string&) const;
-    virtual std::vector<EndpointIPtr> expandIfWildcard() const;
-    virtual std::vector<EndpointIPtr> expandHost(EndpointIPtr&) const;
-    virtual bool equivalent(const EndpointIPtr&) const;
-    virtual Ice::Int hash() const;
-    virtual std::string options() const;
-
-#ifdef ICE_CPP11_MAPPING
-    virtual bool operator==(const Ice::Endpoint&) const;
-    virtual bool operator<(const Ice::Endpoint&) const;
-#else
-    virtual bool operator==(const Ice::LocalObject&) const;
-    virtual bool operator<(const Ice::LocalObject&) const;
-#endif
-
-    using EndpointI::connectionId;
-
-protected:
-
-    virtual void streamWriteImpl(Ice::OutputStream*) const;
-    virtual bool checkOption(const std::string&, const std::string&, const std::string&);
-
-private:
-
-    //
-    // All members are const, because endpoints are immutable.
-    //
-    Ice::Short _type;
-    Ice::EncodingVersion _rawEncoding; // The encoding used for _rawBytes
-    const std::vector<Ice::Byte> _rawBytes;
-};
-
+    class OpaqueEndpointI final : public EndpointI, public std::enable_shared_from_this<OpaqueEndpointI>
+    {
+    public:
+        OpaqueEndpointI(std::vector<std::string>&);
+        OpaqueEndpointI(std::int16_t, Ice::InputStream*);
+
+        void streamWrite(Ice::OutputStream*) const final;
+        [[nodiscard]] Ice::EndpointInfoPtr getInfo() const noexcept final;
+        [[nodiscard]] std::int16_t type() const final;
+        [[nodiscard]] const std::string& protocol() const final;
+
+        [[nodiscard]] std::int32_t timeout() const final;
+        [[nodiscard]] EndpointIPtr timeout(std::int32_t) const final;
+        [[nodiscard]] const std::string& connectionId() const final;
+        [[nodiscard]] EndpointIPtr connectionId(const std::string&) const final;
+        [[nodiscard]] bool compress() const final;
+        [[nodiscard]] EndpointIPtr compress(bool) const final;
+        [[nodiscard]] bool datagram() const final;
+        [[nodiscard]] bool secure() const final;
+
+        [[nodiscard]] TransceiverPtr transceiver() const final;
+        void connectorsAsync(
+            std::function<void(std::vector<IceInternal::ConnectorPtr>)>,
+            std::function<void(std::exception_ptr)>) const final;
+        [[nodiscard]] AcceptorPtr
+        acceptor(const std::string&, const std::optional<Ice::SSL::ServerAuthenticationOptions>&) const final;
+        [[nodiscard]] std::vector<EndpointIPtr> expandHost() const final;
+        [[nodiscard]] bool isLoopbackOrMulticast() const final;
+        [[nodiscard]] std::shared_ptr<EndpointI> toPublishedEndpoint(std::string publishedHost) const final;
+        [[nodiscard]] bool equivalent(const EndpointIPtr&) const final;
+        [[nodiscard]] std::size_t hash() const noexcept final;
+        [[nodiscard]] std::string options() const final;
+
+        bool operator==(const Ice::Endpoint&) const final;
+        bool operator<(const Ice::Endpoint&) const final;
+
+        using EndpointI::connectionId;
+
+    protected:
+        void streamWriteImpl(Ice::OutputStream*) const final;
+        bool checkOption(const std::string&, const std::string&, const std::string&) final;
+
+    private:
+        //
+        // All members are const, because endpoints are immutable.
+        //
+        std::int16_t _type;
+        Ice::EncodingVersion _rawEncoding; // The encoding used for _rawBytes
+        const std::vector<std::byte> _rawBytes;
+    };
 }
 
 #endif