zeroc-ice 3.8.1 → 3.8.3

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

@@ -68,6 +68,10 @@ Ice::OutputStream::OutputStream(
       _format(format),
       _currentEncaps(nullptr)
 {
+    if (!_wstringConverter)
+    {
+        _wstringConverter = getProcessWstringConverter();
+    }
 }
 
 Ice::OutputStream::OutputStream(
@@ -85,6 +89,11 @@ Ice::OutputStream::OutputStream(
       _currentEncaps(nullptr)
 {
     b.reset();
+
+    if (!_wstringConverter)
+    {
+        _wstringConverter = getProcessWstringConverter();
+    }
 }
 
 Ice::OutputStream::OutputStream(const CommunicatorPtr& communicator, EncodingVersion encoding)
@@ -104,6 +113,7 @@ Ice::OutputStream::OutputStream(Instance* instance, EncodingVersion encoding)
           instance->getStringConverter(),
           instance->getWstringConverter())
 {
+    assert(_wstringConverter);
 }
 
 Ice::OutputStream::OutputStream(OutputStream&& other) noexcept
@@ -116,6 +126,7 @@ Ice::OutputStream::OutputStream(OutputStream&& other) noexcept
       _currentEncaps(other._currentEncaps)
 {
     // Reset other to its default state.
+    other._wstringConverter = getProcessWstringConverter();
     other._closure = nullptr;
     other._encoding = Encoding_1_1;
     other._format = FormatType::CompactFormat;
@@ -140,6 +151,7 @@ Ice::OutputStream::operator=(OutputStream&& other) noexcept
         _currentEncaps = other._currentEncaps;
 
         // Reset other to its default state.
+        other._wstringConverter = getProcessWstringConverter();
         other._closure = nullptr;
         other._encoding = Encoding_1_1;
         other._format = FormatType::CompactFormat;
@@ -294,7 +306,7 @@ Ice::OutputStream::writeEncapsulation(const byte* v, int32_t sz)
 
     Container::size_type position = b.size();
     resize(position + static_cast<size_t>(sz));
-    memcpy(&b[position], &v[0], static_cast<size_t>(sz));
+    memcpy(&b[position], v, static_cast<size_t>(sz));
 }
 
 void
@@ -326,7 +338,7 @@ Ice::OutputStream::writeBlob(const vector<byte>& v)
     {
         Container::size_type pos = b.size();
         resize(pos + v.size());
-        memcpy(&b[pos], &v[0], v.size());
+        memcpy(&b[pos], v.data(), v.size());
     }
 }
 
@@ -703,13 +715,7 @@ Ice::OutputStream::write(const char*)
 void
 Ice::OutputStream::writeConverted(const char* vdata, size_t vsize)
 {
-    StringConverterPtr stringConverter = _stringConverter;
-    if (!stringConverter)
-    {
-        stringConverter = getProcessStringConverter();
-    }
-
-    if (!stringConverter)
+    if (!_stringConverter)
     {
         // No converter installed; write the string as-is (assumed to be UTF-8 already).
         writeSize(static_cast<int32_t>(vsize));
@@ -735,7 +741,7 @@ Ice::OutputStream::writeConverted(const char* vdata, size_t vsize)
             auto sizePos = startOneByteSize();
 
             StreamUTF8BufferI buffer(*this);
-            byte* lastByte = stringConverter->toUTF8(vdata, vdata + vsize, buffer);
+            byte* lastByte = _stringConverter->toUTF8(vdata, vdata + vsize, buffer);
             if (lastByte != b.end())
             {
                 resize(static_cast<size_t>(lastByte - b.begin()));
@@ -750,7 +756,7 @@ Ice::OutputStream::writeConverted(const char* vdata, size_t vsize)
             auto sizePos = startSize();
 
             StreamUTF8BufferI buffer(*this);
-            byte* lastByte = stringConverter->toUTF8(vdata, vdata + vsize, buffer);
+            byte* lastByte = _stringConverter->toUTF8(vdata, vdata + vsize, buffer);
             if (lastByte != b.end())
             {
                 resize(static_cast<size_t>(lastByte - b.begin()));
@@ -788,68 +794,47 @@ Ice::OutputStream::write(wstring_view v)
         return;
     }
 
-    //
-    // What is the size of the resulting UTF-8 encoded string?
-    // Impossible to tell, so we guess. If we don't guess correctly,
-    // we'll have to fix the mistake afterwards
-    //
+    assert(_wstringConverter);
+
+    // The worst-case expansion for converting a wide string to UTF-8 is 3x or 4x depending on the platform.
+    const size_t factor = sizeof(wchar_t) == 2 ? 3 : 4;
+
     try
     {
-        auto guessedSize = static_cast<int32_t>(v.size());
-        writeSize(guessedSize); // writeSize() only writes the size; it does not reserve any buffer space.
-
-        size_t firstIndex = b.size();
-        StreamUTF8BufferI buffer(*this);
+        // (252 / 3 = 84, 252 / 4 = 63)
+        if (v.size() <= 252 / factor)
+        {
+            // The maximum UTF-8 size is v.size() * factor <= 252, which fits in a 1-byte size encoding.
+            // We use this upper bound to decide the size encoding:
+            //  - If v.size() <= 252 / factor, the converted string is at most 252 bytes, which always fits in a 1-byte
+            //   size.
+            //  - Otherwise, we use the 5-byte size encoding to avoid guessing and memmove fixups.
+            auto sizePos = startOneByteSize();
 
-        byte* lastByte = nullptr;
+            StreamUTF8BufferI buffer(*this);
+            byte* lastByte = _wstringConverter->toUTF8(v.data(), v.data() + v.size(), buffer);
+            if (lastByte != b.end())
+            {
+                resize(static_cast<size_t>(lastByte - b.begin()));
+            }
 
-        WstringConverterPtr wstringConverter = _wstringConverter;
-        if (!wstringConverter)
-        {
-            wstringConverter = getProcessWstringConverter();
+            endOneByteSize(sizePos);
+            return;
         }
-        assert(wstringConverter); // never null
-        lastByte = wstringConverter->toUTF8(v.data(), v.data() + v.size(), buffer);
-
-        if (lastByte != b.end())
+        else
         {
-            resize(static_cast<size_t>(lastByte - b.begin()));
-        }
-        size_t lastIndex = b.size();
-
-        auto actualSize = static_cast<int32_t>(lastIndex - firstIndex);
+            // Write the first byte of the 5-byte size encoding, followed by a 4-byte size placeholder.
+            write(uint8_t(255));
+            auto sizePos = startSize();
 
-        //
-        // Check against the guess
-        //
-        if (guessedSize != actualSize)
-        {
-            if (guessedSize <= 254 && actualSize > 254)
-            {
-                //
-                // Move the UTF-8 sequence 4 bytes further
-                // Use memmove instead of memcpy since the source and destination typically overlap.
-                //
-                resize(b.size() + 4);
-                memmove(b.begin() + firstIndex + 4, b.begin() + firstIndex, static_cast<size_t>(actualSize));
-            }
-            else if (guessedSize > 254 && actualSize <= 254)
+            StreamUTF8BufferI buffer(*this);
+            byte* lastByte = _wstringConverter->toUTF8(v.data(), v.data() + v.size(), buffer);
+            if (lastByte != b.end())
             {
-                //
-                // Move the UTF-8 sequence 4 bytes back
-                //
-                memmove(b.begin() + firstIndex - 4, b.begin() + firstIndex, static_cast<size_t>(actualSize));
-                resize(b.size() - 4);
+                resize(static_cast<size_t>(lastByte - b.begin()));
             }
 
-            if (guessedSize <= 254)
-            {
-                rewriteSize(actualSize, b.begin() + firstIndex - 1);
-            }
-            else
-            {
-                rewriteSize(actualSize, b.begin() + firstIndex - 1 - 4);
-            }
+            endSize(sizePos);
         }
     }
     catch (const Ice::IllegalConversionException& ex)
@@ -1021,7 +1006,7 @@ void
 Ice::OutputStream::EncapsEncoder10::write(const UserException& v)
 {
     //
-    // User exception with the 1.0 encoding start with a boolean
+    // User exceptions with the 1.0 encoding start with a boolean
     // flag that indicates whether or not the exception uses
     // classes.
     //
@@ -1413,7 +1398,7 @@ Ice::OutputStream::EncapsEncoder11::writeInstance(const shared_ptr<Value>& v)
     assert(v);
 
     //
-    // If the instance was already marshaled, just write it's ID.
+    // If the instance was already marshaled, just write its ID.
     //
     auto q = _marshaledMap.find(v);
     if (q != _marshaledMap.end())

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

@@ -279,7 +279,13 @@ Ice::PluginManagerI::loadPlugin(PluginFactoryFunc factoryFunc, const string& nam
                 "invalid arguments for plug-in '" + name + "':\n" + string{ex.what()});
         }
 
-        assert(!args.empty());
+        if (args.empty())
+        {
+            throw PluginInitializationException(
+                __FILE__,
+                __LINE__,
+                "no entry point specified for plug-in '" + name + "'");
+        }
 
         //
         // Shift the arguments.

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

@@ -315,6 +315,7 @@ Ice::Properties::getPropertyAsListWithDefault(string_view key, const StringSeq&
         {
             Warning out(getProcessLogger());
             out << "mismatched quotes in property " << key << "'s value, returning default value";
+            return value;
         }
         if (result.size() == 0)
         {
@@ -359,27 +360,28 @@ Ice::Properties::setProperty(string_view key, string_view value)
     }
 
     // Check if the property is in an Ice property prefix. If so, check that it's a valid property.
-    if (auto propertyArray = findIcePropertyArray(key))
+    if (auto propertyArray = findIcePropertyArray(currentKey))
     {
         if (propertyArray->isOptIn &&
             find(_optInPrefixes.begin(), _optInPrefixes.end(), propertyArray->name) == _optInPrefixes.end())
         {
             ostringstream os;
-            os << "unable to set '" << key << "': property prefix '" << propertyArray->name
+            os << "unable to set '" << currentKey << "': property prefix '" << propertyArray->name
                << "' is opt-in and must be explicitly enabled.";
             throw PropertyException{__FILE__, __LINE__, os.str()};
         }
         string propertyPrefix{propertyArray->name};
-        auto prop = IceInternal::findProperty(key.substr(propertyPrefix.length() + 1), propertyArray);
+        auto prop =
+            IceInternal::findProperty(string_view{currentKey}.substr(propertyPrefix.length() + 1), propertyArray);
         if (!prop)
         {
-            throw PropertyException{__FILE__, __LINE__, "unknown Ice property: " + string{key}};
+            throw PropertyException{__FILE__, __LINE__, "unknown Ice property: " + currentKey};
         }
 
         // If the property is deprecated, log a warning.
         if (prop->deprecated)
         {
-            getProcessLogger()->warning("setting deprecated property: " + string{key});
+            getProcessLogger()->warning("setting deprecated property: " + currentKey);
         }
     }
 
@@ -495,7 +497,15 @@ Ice::Properties::load(string_view file)
                 DWORD keyType;
                 DWORD nameBufSize = static_cast<DWORD>(nameBuf.size());
                 DWORD dataBufSize = static_cast<DWORD>(dataBuf.size());
-                err = RegEnumValueW(iceKey, i, &nameBuf[0], &nameBufSize, nullptr, &keyType, &dataBuf[0], &dataBufSize);
+                err = RegEnumValueW(
+                    iceKey,
+                    i,
+                    nameBuf.data(),
+                    &nameBufSize,
+                    nullptr,
+                    &keyType,
+                    dataBuf.data(),
+                    &dataBufSize);
                 if (err != ERROR_SUCCESS || nameBufSize == 0)
                 {
                     ostringstream os;
@@ -503,7 +513,7 @@ Ice::Properties::load(string_view file)
                        << ":\n";
                     if (nameBufSize == 0)
                     {
-                        os << "property name can't be the empty string";
+                        os << "property name cannot be the empty string";
                     }
                     else
                     {
@@ -512,8 +522,7 @@ Ice::Properties::load(string_view file)
                     getProcessLogger()->warning(os.str());
                     continue;
                 }
-                string name =
-                    wstringToString(wstring(reinterpret_cast<wchar_t*>(&nameBuf[0]), nameBufSize), stringConverter);
+                string name = wstringToString(wstring(nameBuf.data(), nameBufSize), stringConverter);
                 if (keyType != REG_SZ && keyType != REG_EXPAND_SZ)
                 {
                     ostringstream os;
@@ -523,7 +532,8 @@ Ice::Properties::load(string_view file)
                 }
 
                 string value;
-                wstring valueW = wstring(reinterpret_cast<wchar_t*>(&dataBuf[0]), (dataBufSize / sizeof(wchar_t)) - 1);
+                wstring valueW =
+                    wstring(reinterpret_cast<wchar_t*>(dataBuf.data()), (dataBufSize / sizeof(wchar_t)) - 1);
                 if (keyType == REG_SZ)
                 {
                     value = wstringToString(valueW, stringConverter);
@@ -533,14 +543,14 @@ Ice::Properties::load(string_view file)
                     vector<wchar_t> expandedValue(1024);
                     DWORD sz = ExpandEnvironmentStringsW(
                         valueW.c_str(),
-                        &expandedValue[0],
+                        expandedValue.data(),
                         static_cast<DWORD>(expandedValue.size()));
                     if (sz >= expandedValue.size())
                     {
                         expandedValue.resize(sz + 1);
                         if (ExpandEnvironmentStringsW(
                                 valueW.c_str(),
-                                &expandedValue[0],
+                                expandedValue.data(),
                                 static_cast<DWORD>(expandedValue.size())) == 0)
                         {
                             ostringstream os;
@@ -551,7 +561,7 @@ Ice::Properties::load(string_view file)
                             continue;
                         }
                     }
-                    value = wstringToString(wstring(&expandedValue[0], sz - 1), stringConverter);
+                    value = wstringToString(wstring(expandedValue.data(), sz - 1), stringConverter);
                 }
                 setProperty(name, value);
             }
@@ -893,15 +903,15 @@ Ice::Properties::loadConfig()
     {
 #ifdef _WIN32
         vector<wchar_t> v(256);
-        DWORD ret = GetEnvironmentVariableW(L"ICE_CONFIG", &v[0], static_cast<DWORD>(v.size()));
+        DWORD ret = GetEnvironmentVariableW(L"ICE_CONFIG", v.data(), static_cast<DWORD>(v.size()));
         if (ret >= v.size())
         {
             v.resize(ret + 1);
-            ret = GetEnvironmentVariableW(L"ICE_CONFIG", &v[0], static_cast<DWORD>(v.size()));
+            ret = GetEnvironmentVariableW(L"ICE_CONFIG", v.data(), static_cast<DWORD>(v.size()));
         }
         if (ret > 0)
         {
-            value = wstringToString(wstring(&v[0], ret), getProcessStringConverter());
+            value = wstringToString(wstring(v.data(), ret), getProcessStringConverter());
         }
         else
         {

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

@@ -70,6 +70,7 @@ const PropertyArray PropertyNames::ThreadPoolProps
 const Property ObjectAdapterPropsData[] =
 {
     Property{"AdapterId", "", false, false, nullptr},
+    Property{"AllowedOrigins", "", false, false, nullptr},
     Property{"Connection", "", false, false, &PropertyNames::ConnectionProps},
     Property{"Endpoints", "", false, false, nullptr},
     Property{"Locator", "", false, false, &PropertyNames::ProxyProps},
@@ -89,7 +90,7 @@ const PropertyArray PropertyNames::ObjectAdapterProps
     .prefixOnly=true,
     .isOptIn=false,
     .properties=ObjectAdapterPropsData,
-    .length=12
+    .length=13
 };
 
 const Property IcePropsData[] =

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

@@ -82,7 +82,7 @@ IceInternal::validatePropertiesWithPrefix(
     PropertyDict props = properties->getPropertiesForPrefix(string{prefix} + ".");
     for (const auto& p : props)
     {
-        // Plus one to include the dot.
+        // Plus one to skip the dot.
         if (!findProperty(p.first.substr(prefix.size() + 1), propertyArray))
         {
             unknownProps.push_back(p.first);

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

@@ -136,17 +136,6 @@ IceInternal::ProtocolInstance::defaultSourceAddress() const
     return instance->defaultsAndOverrides()->defaultSourceAddress;
 }
 
-const EncodingVersion&
-IceInternal::ProtocolInstance::defaultEncoding() const
-{
-    InstancePtr instance = _instance.lock();
-    if (!instance)
-    {
-        throw CommunicatorDestroyedException{__FILE__, __LINE__};
-    }
-    return instance->defaultsAndOverrides()->defaultEncoding;
-}
-
 NetworkProxyPtr
 IceInternal::ProtocolInstance::networkProxy() const
 {

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

@@ -45,7 +45,6 @@ namespace IceInternal
         [[nodiscard]] ProtocolSupport protocolSupport() const;
         [[nodiscard]] const std::string& defaultHost() const;
         [[nodiscard]] const Address& defaultSourceAddress() const;
-        [[nodiscard]] const Ice::EncodingVersion& defaultEncoding() const;
         [[nodiscard]] NetworkProxyPtr networkProxy() const;
         [[nodiscard]] std::int32_t messageSizeMax() const;
 
@@ -60,7 +59,7 @@ namespace IceInternal
         ProtocolInstance(const InstancePtr&, std::int16_t, std::string, bool);
         friend class Instance;
         // Use a weak pointer to avoid circular references. The communicator owns the endpoint factory, which in
-        // turn own this protocol instance.
+        // turn owns this protocol instance.
         const std::weak_ptr<Instance> _instance;
         const int _traceLevel;
         const std::string _traceCategory;

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

@@ -207,7 +207,15 @@ Ice::ObjectPrx::ice_isFixed() const noexcept
 ConnectionPtr
 Ice::ObjectPrx::ice_getCachedConnection() const noexcept
 {
-    return _requestHandlerCache->getCachedConnection();
+    // A fixed proxy is bound to a single connection: return this connection as is, whatever its state.
+    if (auto fixedReference = dynamic_pointer_cast<FixedReference>(_reference))
+    {
+        return fixedReference->fixedConnection();
+    }
+    else
+    {
+        return _requestHandlerCache->getCachedConnection();
+    }
 }
 
 CommunicatorPtr

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

@@ -6,10 +6,15 @@
 #include "CollocatedRequestHandler.h"
 #include "ConnectionI.h"
 #include "Ice/InputStream.h"
+#include "Ice/LoggerUtil.h"
 #include "Ice/OutgoingAsync.h"
 #include "Ice/OutputStream.h"
 #include "Ice/Proxy.h"
+#include "Instance.h"
+#include "Reference.h"
 #include "ReferenceFactory.h"
+#include "RequestHandler.h"
+#include "ThreadPool.h"
 
 using namespace std;
 using namespace Ice;
@@ -77,7 +82,20 @@ namespace IceInternal
             : ProxyGetConnection(std::move(proxy)),
               LambdaInvoke(std::move(ex), std::move(sent))
         {
-            _response = [&, response = std::move(response)](bool) { response(getConnection()); };
+            _response = [this, response = std::move(response)](bool)
+            {
+                if (response)
+                {
+                    try
+                    {
+                        response(getConnection());
+                    }
+                    catch (...)
+                    {
+                        warning("response", std::current_exception());
+                    }
+                }
+            };
         }
     };
 
@@ -172,13 +190,14 @@ namespace IceInternal
             {
                 _response = [this, response = std::move(response)](bool ok)
                 {
-                    if (this->_is.b.empty())
+                    R v = this->_is.b.empty() ? R{ok, {}} : this->_read(ok, &this->_is);
+                    try
                     {
-                        response(R{ok, {}});
+                        response(std::move(v));
                     }
-                    else
+                    catch (...)
                     {
-                        response(this->_read(ok, &this->_is));
+                        this->warning("response", std::current_exception());
                     }
                 };
             }
@@ -282,6 +301,18 @@ ProxyGetConnection::ProxyGetConnection(ObjectPrx proxy) : ProxyOutgoingAsyncBase
 AsyncStatus
 ProxyGetConnection::invokeRemote(const ConnectionIPtr& connection, bool, bool)
 {
+    // A fixed proxy never reaches the invocation machinery: invoke returns its bound connection directly.
+    assert(!_proxy.ice_isFixed());
+    try
+    {
+        connection->throwException();
+    }
+    catch (const Ice::LocalException&)
+    {
+        // The connection is closed: throw RetryException so that the caller clears the cached request handler
+        // and calls invokeRemote again with a new connection.
+        throw RetryException(current_exception());
+    }
     _cachedConnection = connection;
     if (responseImpl(true, true))
     {
@@ -602,7 +633,15 @@ Ice::ObjectPrx::ice_invokeAsync(
 Ice::ConnectionPtr
 Ice::ObjectPrx::ice_getConnection() const
 {
-    return ice_getConnectionAsync().get();
+    // A fixed proxy is bound to a single connection: return this connection as is, whatever its state.
+    if (auto fixedReference = dynamic_pointer_cast<FixedReference>(_reference))
+    {
+        return fixedReference->fixedConnection();
+    }
+    else
+    {
+        return ice_getConnectionAsync().get();
+    }
 }
 
 std::function<void()>
@@ -611,18 +650,76 @@ Ice::ObjectPrx::ice_getConnectionAsync(
     std::function<void(std::exception_ptr)> ex,
     std::function<void(bool)> sent) const
 {
-    using LambdaOutgoing = ProxyGetConnectionLambda;
-    auto outAsync = std::make_shared<LambdaOutgoing>(*this, std::move(response), std::move(ex), std::move(sent));
-    _iceI_getConnection(outAsync);
-    return [outAsync]() { outAsync->cancel(); };
+    // A fixed proxy is bound to a single connection: return this connection as is, whatever its state. The response
+    // callback is executed from the thread pool that services this connection (or by the executor, if set). Like for
+    // the response callback of a lambda invocation, an exception thrown by the callback is logged as an
+    // Ice.Warn.AMICallback warning.
+    if (auto fixedReference = dynamic_pointer_cast<FixedReference>(_reference))
+    {
+        if (response)
+        {
+            InstancePtr instance = fixedReference->getInstance();
+            ConnectionIPtr connection = fixedReference->fixedConnection();
+            connection->getThreadPool()->execute(
+                [response = std::move(response), connection, instance = std::move(instance)]()
+                {
+                    try
+                    {
+                        response(connection);
+                    }
+                    catch (...)
+                    {
+                        if (instance->initializationData().properties->getIcePropertyAsInt("Ice.Warn.AMICallback") > 0)
+                        {
+                            Warning out(instance->initializationData().logger);
+                            try
+                            {
+                                throw;
+                            }
+                            catch (const Ice::Exception& e)
+                            {
+                                out << "Ice::Exception raised by response callback:\n" << e;
+                            }
+                            catch (const std::exception& e)
+                            {
+                                out << "std::exception raised by response callback:\n" << e.what();
+                            }
+                            catch (...)
+                            {
+                                out << "unknown exception raised by response callback";
+                            }
+                        }
+                    }
+                },
+                connection);
+        }
+        return [] {};
+    }
+    else
+    {
+        using LambdaOutgoing = ProxyGetConnectionLambda;
+        auto outAsync = std::make_shared<LambdaOutgoing>(*this, std::move(response), std::move(ex), std::move(sent));
+        _iceI_getConnection(outAsync);
+        return [outAsync]() { outAsync->cancel(); };
+    }
 }
 
 std::future<Ice::ConnectionPtr>
 Ice::ObjectPrx::ice_getConnectionAsync() const
 {
-    auto outAsync = std::make_shared<ProxyGetConnectionPromise>(*this);
-    _iceI_getConnection(outAsync);
-    return outAsync->getFuture();
+    // A fixed proxy is bound to a single connection: return this connection as is, whatever its state.
+    if (auto fixedReference = dynamic_pointer_cast<FixedReference>(_reference))
+    {
+        promise<Ice::ConnectionPtr> p;
+        p.set_value(fixedReference->fixedConnection());
+        return p.get_future();
+    }
+    else
+    {
+        auto outAsync = std::make_shared<ProxyGetConnectionPromise>(*this);
+        _iceI_getConnection(outAsync);
+        return outAsync->getFuture();
+    }
 }
 
 void

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

@@ -53,8 +53,8 @@ Ice::proxyIdentityAndFacetLess(const optional<ObjectPrx>& lhs, const optional<Ob
 {
     if (lhs && rhs)
     {
-        Identity lhsIdentity = lhs->ice_getIdentity();
-        Identity rhsIdentity = rhs->ice_getIdentity();
+        const Identity& lhsIdentity = lhs->ice_getIdentity();
+        const Identity& rhsIdentity = rhs->ice_getIdentity();
 
         if (lhsIdentity < rhsIdentity)
         {
@@ -65,8 +65,8 @@ Ice::proxyIdentityAndFacetLess(const optional<ObjectPrx>& lhs, const optional<Ob
             return false;
         }
 
-        string lhsFacet = lhs->ice_getFacet();
-        string rhsFacet = rhs->ice_getFacet();
+        const string& lhsFacet = lhs->ice_getFacet();
+        const string& rhsFacet = rhs->ice_getFacet();
 
         return lhsFacet < rhsFacet;
     }