zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,105 +1,96 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <Ice/Communicator.h>
-#include <Ice/ReferenceFactory.h>
-#include <Ice/ProxyFactory.h>
-#include <Ice/LocalException.h>
-#include <Ice/Instance.h>
-#include <Ice/EndpointI.h>
-#include <Ice/ConnectionI.h>
-#include <Ice/EndpointFactoryManager.h>
-#include <Ice/RouterInfo.h>
-#include <Ice/Router.h>
-#include <Ice/LocatorInfo.h>
-#include <Ice/Locator.h>
-#include <Ice/LoggerUtil.h>
-#include <Ice/InputStream.h>
-#include <Ice/Properties.h>
-#include <Ice/DefaultsAndOverrides.h>
-#include <Ice/PropertyNames.h>
-#include <Ice/StringUtil.h>
+// Copyright (c) ZeroC, Inc.
+
+#include "ReferenceFactory.h"
+#include "ConnectionI.h"
+#include "DefaultsAndOverrides.h"
+#include "EndpointFactoryManager.h"
+#include "EndpointI.h"
+#include "Ice/Communicator.h"
+#include "Ice/InputStream.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/Locator.h"
+#include "Ice/LoggerUtil.h"
+#include "Ice/Properties.h"
+#include "Ice/ProxyFunctions.h"
+#include "Ice/Router.h"
+#include "Ice/StringUtil.h"
+#include "Instance.h"
+#include "LocatorInfo.h"
+#include "PropertyNames.h"
+#include "PropertyUtil.h"
+#include "RouterInfo.h"
+
+#include <chrono>
+#include <stdexcept>
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-IceUtil::Shared* IceInternal::upCast(::IceInternal::ReferenceFactory* p) { return p; }
-
 ReferencePtr
-IceInternal::ReferenceFactory::copy(const Reference* r) const
+IceInternal::ReferenceFactory::create(
+    Identity ident,
+    string facet,
+    const ReferencePtr& tmpl,
+    vector<EndpointIPtr> endpoints)
 {
-    const Ice::Identity& ident = r->getIdentity();
-    if(ident.name.empty() && ident.category.empty())
-    {
-        return 0;
-    }
-
-    return r->clone();
+    assert(!ident.name.empty());
+
+    return create(
+        std::move(ident),
+        std::move(facet),
+        tmpl->getMode(),
+        tmpl->getProtocol(),
+        tmpl->getEncoding(),
+        std::move(endpoints),
+        "",
+        "");
 }
 
 ReferencePtr
-IceInternal::ReferenceFactory::create(const Identity& ident,
-                                      const string& facet,
-                                      const ReferencePtr& tmpl,
-                                      const vector<EndpointIPtr>& endpoints)
+IceInternal::ReferenceFactory::create(Identity ident, string facet, const ReferencePtr& tmpl, string adapterId)
 {
-    if(ident.name.empty() && ident.category.empty())
-    {
-        return 0;
-    }
-
-    return create(ident, facet, tmpl->getMode(), tmpl->getSecure(), tmpl->getProtocol(), tmpl->getEncoding(),
-                  endpoints, "", "");
+    assert(!ident.name.empty());
+
+    return create(
+        std::move(ident),
+        std::move(facet),
+        tmpl->getMode(),
+        tmpl->getProtocol(),
+        tmpl->getEncoding(),
+        vector<EndpointIPtr>(),
+        std::move(adapterId),
+        "");
 }
 
 ReferencePtr
-IceInternal::ReferenceFactory::create(const Identity& ident,
-                                      const string& facet,
-                                      const ReferencePtr& tmpl,
-                                      const string& adapterId)
+IceInternal::ReferenceFactory::create(Identity ident, Ice::ConnectionIPtr connection)
 {
-    if(ident.name.empty() && ident.category.empty())
-    {
-        return 0;
-    }
+    assert(!ident.name.empty());
 
-    return create(ident, facet, tmpl->getMode(), tmpl->getSecure(), tmpl->getProtocol(), tmpl->getEncoding(),
-                  vector<EndpointIPtr>(), adapterId, "");
-}
+    Reference::Mode mode = connection->endpoint()->datagram() ? Reference::ModeDatagram : Reference::ModeTwoway;
 
-ReferencePtr
-IceInternal::ReferenceFactory::create(const Identity& ident, const Ice::ConnectionIPtr& connection)
-{
-    if(ident.name.empty() && ident.category.empty())
-    {
-        return 0;
-    }
-
-    //
     // Create new reference
-    //
-    return new FixedReference(_instance,
-                              _communicator,
-                              ident,
-                              "",  // Facet
-                              connection->endpoint()->datagram() ? Reference::ModeDatagram : Reference::ModeTwoway,
-                              connection->endpoint()->secure(),
-                              Ice::Protocol_1_0,
-                              _instance->defaultsAndOverrides()->defaultEncoding,
-                              connection,
-                              -1,
-                              Ice::Context(),
-                              IceUtil::Optional<bool>());
+    return make_shared<FixedReference>(
+        _instance,
+        _communicator,
+        std::move(ident),
+        "", // Facet
+        mode,
+        nullopt,
+        Protocol_1_0,
+        _instance->defaultsAndOverrides()->defaultEncoding,
+        std::move(connection),
+        -1ms,
+        Ice::Context());
 }
 
 ReferencePtr
-IceInternal::ReferenceFactory::create(const string& str, const string& propertyPrefix)
+IceInternal::ReferenceFactory::create(string_view str, const string& propertyPrefix)
 {
-    if(str.empty())
+    if (str.empty())
     {
-        return 0;
+        return nullptr;
     }
 
     const string delim = " \t\r\n";
@@ -109,9 +100,9 @@ IceInternal::ReferenceFactory::create(const string& str, const string& propertyP
     string::size_type end = 0;
 
     beg = s.find_first_not_of(delim, end);
-    if(beg == string::npos)
+    if (beg == string::npos)
     {
-        throw ProxyParseException(__FILE__, __LINE__, "no non-whitespace characters found in `" + s + "'");
+        throw ParseException(__FILE__, __LINE__, "no non-whitespace characters found in proxy string '" + s + "'");
     }
 
     //
@@ -119,15 +110,15 @@ IceInternal::ReferenceFactory::create(const string& str, const string& propertyP
     // or double quotation marks.
     //
     string idstr;
-    end = IceUtilInternal::checkQuote(s, beg);
-    if(end == string::npos)
+    end = IceInternal::checkQuote(s, beg);
+    if (end == string::npos)
     {
-        throw ProxyParseException(__FILE__, __LINE__, "mismatched quotes around identity in `" + s + "'");
+        throw ParseException(__FILE__, __LINE__, "mismatched quotes around identity in proxy string '" + s + "'");
     }
-    else if(end == 0)
+    else if (end == 0)
     {
         end = s.find_first_of(delim + ":@", beg);
-        if(end == string::npos)
+        if (end == string::npos)
         {
             end = s.size();
         }
@@ -140,78 +131,71 @@ IceInternal::ReferenceFactory::create(const string& str, const string& propertyP
         end++; // Skip trailing quote
     }
 
-    if(beg == end)
+    if (beg == end)
     {
-        throw ProxyParseException(__FILE__, __LINE__, "no identity in `" + s + "'");
+        throw ParseException(__FILE__, __LINE__, "no identity in proxy string '" + s + "'");
     }
 
-    //
-    // Parsing the identity may raise IdentityParseException.
-    //
-    Identity ident = Ice::stringToIdentity(idstr);
-
-    if(ident.name.empty())
+    if (idstr.empty())
     {
-        //
-        // An identity with an empty name and a non-empty
-        // category is illegal.
-        //
-        if(!ident.category.empty())
-        {
-            throw IllegalIdentityException(__FILE__, __LINE__, ident);
-        }
         //
         // Treat a stringified proxy containing two double
         // quotes ("") the same as an empty string, i.e.,
         // a null proxy, but only if nothing follows the
         // quotes.
         //
-        else if(s.find_first_not_of(delim, end) != string::npos)
+        if (s.find_first_not_of(delim, end) != string::npos)
         {
-            throw ProxyParseException(__FILE__, __LINE__, "invalid characters after identity in `" + s + "'");
+            throw ParseException(__FILE__, __LINE__, "invalid characters after identity in proxy string '" + s + "'");
         }
         else
         {
-            return 0;
+            return nullptr;
         }
     }
 
+    //
+    // Parsing the identity may raise ParseException.
+    //
+    Identity ident = Ice::stringToIdentity(idstr);
+
     string facet;
     Reference::Mode mode = Reference::ModeTwoway;
-    bool secure = false;
     Ice::EncodingVersion encoding = _instance->defaultsAndOverrides()->defaultEncoding;
     Ice::ProtocolVersion protocol = Protocol_1_0;
     string adapter;
 
-    while(true)
+    while (true)
     {
         beg = s.find_first_not_of(delim, end);
-        if(beg == string::npos)
+        if (beg == string::npos)
         {
             break;
         }
 
-        if(s[beg] == ':' || s[beg] == '@')
+        if (s[beg] == ':' || s[beg] == '@')
         {
             break;
         }
 
         end = s.find_first_of(delim + ":@", beg);
-        if(end == string::npos)
+        if (end == string::npos)
         {
             end = s.length();
         }
 
-        if(beg == end)
+        if (beg == end)
         {
             break;
         }
 
         string option = s.substr(beg, end - beg);
-        if(option.length() != 2 || option[0] != '-')
+        if (option.length() != 2 || option[0] != '-')
         {
-            throw ProxyParseException(__FILE__, __LINE__, "expected a proxy option but found `" + option + "' in `" +
-                                      s + "'");
+            throw ParseException(
+                __FILE__,
+                __LINE__,
+                "expected a proxy option but found '" + option + "' in proxy string '" + s + "'");
         }
 
         //
@@ -221,21 +205,23 @@ IceInternal::ReferenceFactory::create(const string& str, const string& propertyP
         //
         string argument;
         string::size_type argumentBeg = s.find_first_not_of(delim, end);
-        if(argumentBeg != string::npos)
+        if (argumentBeg != string::npos)
         {
-            if(s[argumentBeg] != '@' && s[argumentBeg] != ':' && s[argumentBeg] != '-')
+            if (s[argumentBeg] != '@' && s[argumentBeg] != ':' && s[argumentBeg] != '-')
             {
                 beg = argumentBeg;
-                end = IceUtilInternal::checkQuote(s, beg);
-                if(end == string::npos)
+                end = IceInternal::checkQuote(s, beg);
+                if (end == string::npos)
                 {
-                    throw ProxyParseException(__FILE__, __LINE__, "mismatched quotes around value for " + option +
-                                              " option in `" + s + "'");
+                    throw ParseException(
+                        __FILE__,
+                        __LINE__,
+                        "mismatched quotes around value for " + option + " option in proxy string '" + s + "'");
                 }
-                else if(end == 0)
+                else if (end == 0)
                 {
                     end = s.find_first_of(delim + ":@", beg);
-                    if(end == string::npos)
+                    if (end == string::npos)
                     {
                         end = s.size();
                     }
@@ -254,22 +240,25 @@ IceInternal::ReferenceFactory::create(const string& str, const string& propertyP
         // If any new options are added here,
         // IceInternal::Reference::toString() and its derived classes must be updated as well.
         //
-        switch(option[1])
+        switch (option[1])
         {
             case 'f':
             {
-                if(argument.empty())
+                if (argument.empty())
                 {
-                    throw ProxyParseException(__FILE__, __LINE__, "no argument provided for -f option in `" + s + "'");
+                    throw ParseException(
+                        __FILE__,
+                        __LINE__,
+                        "no argument provided for -f option in proxy string '" + s + "'");
                 }
 
                 try
                 {
                     facet = unescapeString(argument, 0, argument.size(), "");
                 }
-                catch(const IceUtil::IllegalArgumentException& ex)
+                catch (const invalid_argument& ex)
                 {
-                    throw ProxyParseException(__FILE__, __LINE__, "invalid facet in `" + s + "': " + ex.reason());
+                    throw ParseException(__FILE__, __LINE__, "invalid facet in proxy string '" + s + "': " + ex.what());
                 }
 
                 break;
@@ -277,10 +266,12 @@ IceInternal::ReferenceFactory::create(const string& str, const string& propertyP
 
             case 't':
             {
-                if(!argument.empty())
+                if (!argument.empty())
                 {
-                    throw ProxyParseException(__FILE__, __LINE__, "unexpected argument `" + argument +
-                                              "' provided for -t option in `" + s + "'");
+                    throw ParseException(
+                        __FILE__,
+                        __LINE__,
+                        "unexpected argument '" + argument + "' provided for -t option in proxy string '" + s + "'");
                 }
                 mode = Reference::ModeTwoway;
                 break;
@@ -288,10 +279,12 @@ IceInternal::ReferenceFactory::create(const string& str, const string& propertyP
 
             case 'o':
             {
-                if(!argument.empty())
+                if (!argument.empty())
                 {
-                    throw ProxyParseException(__FILE__, __LINE__, "unexpected argument `" + argument +
-                                              "' provided for -o option in `" + s + "'");
+                    throw ParseException(
+                        __FILE__,
+                        __LINE__,
+                        "unexpected argument '" + argument + "' provided for -o option in proxy string '" + s + "'");
                 }
                 mode = Reference::ModeOneway;
                 break;
@@ -299,10 +292,12 @@ IceInternal::ReferenceFactory::create(const string& str, const string& propertyP
 
             case 'O':
             {
-                if(!argument.empty())
+                if (!argument.empty())
                 {
-                    throw ProxyParseException(__FILE__, __LINE__, "unexpected argument `" + argument +
-                                              "' provided for -O option in `" + s + "'");
+                    throw ParseException(
+                        __FILE__,
+                        __LINE__,
+                        "unexpected argument '" + argument + "' provided for -O option in proxy string '" + s + "'");
                 }
                 mode = Reference::ModeBatchOneway;
                 break;
@@ -310,10 +305,12 @@ IceInternal::ReferenceFactory::create(const string& str, const string& propertyP
 
             case 'd':
             {
-                if(!argument.empty())
+                if (!argument.empty())
                 {
-                    throw ProxyParseException(__FILE__, __LINE__, "unexpected argument `" + argument +
-                                              "' provided for -d option in `" + s + "'");
+                    throw ParseException(
+                        __FILE__,
+                        __LINE__,
+                        "unexpected argument '" + argument + "' provided for -d option in proxy string '" + s + "'");
                 }
                 mode = Reference::ModeDatagram;
                 break;
@@ -321,10 +318,12 @@ IceInternal::ReferenceFactory::create(const string& str, const string& propertyP
 
             case 'D':
             {
-                if(!argument.empty())
+                if (!argument.empty())
                 {
-                    throw ProxyParseException(__FILE__, __LINE__, "unexpected argument `" + argument +
-                                              "' provided for -D option in `" + s + "'");
+                    throw ParseException(
+                        __FILE__,
+                        __LINE__,
+                        "unexpected argument '" + argument + "' provided for -D option in proxy string '" + s + "'");
                 }
                 mode = Reference::ModeBatchDatagram;
                 break;
@@ -332,82 +331,94 @@ IceInternal::ReferenceFactory::create(const string& str, const string& propertyP
 
             case 's':
             {
-                if(!argument.empty())
+                if (!argument.empty())
                 {
-                    throw ProxyParseException(__FILE__, __LINE__, "unexpected argument `" + argument +
-                                              "' provided for -s option in `" + s + "'");
+                    throw ParseException(
+                        __FILE__,
+                        __LINE__,
+                        "unexpected argument '" + argument + "' provided for -s option in proxy string '" + s + "'");
                 }
-                secure = true;
+                // Ignored. Kept for backwards compatibility.
                 break;
             }
 
             case 'e':
             {
-                if(argument.empty())
+                if (argument.empty())
                 {
-                    throw ProxyParseException(__FILE__, __LINE__, "no argument provided for -e option in `" + s + "'");
+                    throw ParseException(
+                        __FILE__,
+                        __LINE__,
+                        "no argument provided for -e option in proxy string '" + s + "'");
                 }
 
                 try
                 {
-                    encoding = Ice::stringToEncodingVersion(argument);
+                    encoding = stringToEncodingVersion(argument);
                 }
-                catch(const Ice::VersionParseException& ex)
+                catch (const Ice::ParseException& ex)
                 {
-                    throw ProxyParseException(__FILE__, __LINE__, "invalid encoding version `" + argument + "' in `" +
-                                              s + "':\n" + ex.str);
+                    throw ParseException(
+                        __FILE__,
+                        __LINE__,
+                        "invalid encoding version '" + argument + "' in proxy string '" + s + "':\n" + ex.what());
                 }
                 break;
             }
 
             case 'p':
             {
-                if(argument.empty())
+                if (argument.empty())
                 {
-                    throw ProxyParseException(__FILE__, __LINE__, "no argument provided for -p option in `" + s + "'");
+                    throw ParseException(
+                        __FILE__,
+                        __LINE__,
+                        "no argument provided for -p option in proxy string '" + s + "'");
                 }
 
                 try
                 {
-                    protocol = Ice::stringToProtocolVersion(argument);
+                    protocol = stringToProtocolVersion(argument);
                 }
-                catch(const Ice::VersionParseException& ex)
+                catch (const Ice::ParseException& ex)
                 {
-                    throw ProxyParseException(__FILE__, __LINE__, "invalid protocol version `" + argument + "' in `" +
-                                              s + "':\n" + ex.str);
+                    throw ParseException(
+                        __FILE__,
+                        __LINE__,
+                        "invalid protocol version '" + argument + "' in proxy string '" + s + "':\n" + ex.what());
                 }
                 break;
             }
 
             default:
             {
-                throw ProxyParseException(__FILE__, __LINE__, "unknown option `" + option + "' in `" + s + "'");
+                throw ParseException(__FILE__, __LINE__, "unknown option '" + option + "' in proxy string '" + s + "'");
             }
         }
     }
 
-    if(beg == string::npos)
+    if (beg == string::npos)
     {
-        return create(ident, facet, mode, secure, protocol, encoding, vector<EndpointIPtr>(), "", propertyPrefix);
+        return create(ident, facet, mode, protocol, encoding, vector<EndpointIPtr>(), "", propertyPrefix);
     }
 
     vector<EndpointIPtr> endpoints;
-    switch(s[beg])
+    switch (s[beg])
     {
         case ':':
         {
             vector<string> unknownEndpoints;
             end = beg;
 
-            while(end < s.length() && s[end] == ':')
+            while (end < s.length() && s[end] == ':')
             {
                 beg = end + 1;
 
                 end = beg;
-                while(true)
+                while (true)
                 {
                     end = s.find(':', end);
-                    if(end == string::npos)
+                    if (end == string::npos)
                     {
                         end = s.length();
                         break;
@@ -416,21 +427,21 @@ IceInternal::ReferenceFactory::create(const string& str, const string& propertyP
                     {
                         bool quoted = false;
                         string::size_type quote = beg;
-                        while(true)
+                        while (true)
                         {
                             quote = s.find('\"', quote);
-                            if(quote == string::npos || end < quote)
+                            if (quote == string::npos || end < quote)
                             {
                                 break;
                             }
                             else
                             {
                                 quote = s.find('\"', ++quote);
-                                if(quote == string::npos)
+                                if (quote == string::npos)
                                 {
                                     break;
                                 }
-                                else if(end < quote)
+                                else if (end < quote)
                                 {
                                     quoted = true;
                                     break;
@@ -438,7 +449,7 @@ IceInternal::ReferenceFactory::create(const string& str, const string& propertyP
                                 ++quote;
                             }
                         }
-                        if(!quoted)
+                        if (!quoted)
                         {
                             break;
                         }
@@ -448,7 +459,7 @@ IceInternal::ReferenceFactory::create(const string& str, const string& propertyP
 
                 string es = s.substr(beg, end - beg);
                 EndpointIPtr endp = _instance->endpointFactoryManager()->create(es, false);
-                if(endp != ICE_NULLPTR)
+                if (endp != nullptr)
                 {
                     endpoints.push_back(endp);
                 }
@@ -457,45 +468,50 @@ IceInternal::ReferenceFactory::create(const string& str, const string& propertyP
                     unknownEndpoints.push_back(es);
                 }
             }
-            if(endpoints.size() == 0)
+            if (endpoints.size() == 0)
             {
                 assert(!unknownEndpoints.empty());
-                throw EndpointParseException(__FILE__, __LINE__, "invalid endpoint `" + unknownEndpoints.front() +
-                                             "' in `" + s + "'");
+                throw ParseException(
+                    __FILE__,
+                    __LINE__,
+                    "invalid endpoint '" + unknownEndpoints.front() + "' in proxy string '" + s + "'");
             }
-            else if(unknownEndpoints.size() != 0 &&
-                    _instance->initializationData().properties->
-                                getPropertyAsIntWithDefault("Ice.Warn.Endpoints", 1) > 0)
+            else if (
+                unknownEndpoints.size() != 0 &&
+                _instance->initializationData().properties->getIcePropertyAsInt("Ice.Warn.Endpoints") > 0)
             {
                 Warning out(_instance->initializationData().logger);
                 out << "Proxy contains unknown endpoints:";
-                for(unsigned int idx = 0; idx < unknownEndpoints.size(); ++idx)
+                for (const auto& unknownEndpoint : unknownEndpoints)
                 {
-                    out << " `" << unknownEndpoints[idx] << "'";
+                    out << " '" << unknownEndpoint << "'";
                 }
             }
 
-            return create(ident, facet, mode, secure, protocol, encoding, endpoints, "", propertyPrefix);
+            return create(ident, facet, mode, protocol, encoding, endpoints, "", propertyPrefix);
             break;
         }
         case '@':
         {
             beg = s.find_first_not_of(delim, beg + 1);
-            if(beg == string::npos)
+            if (beg == string::npos)
             {
-                throw ProxyParseException(__FILE__, __LINE__, "missing adapter id in `" + s + "'");
+                throw ParseException(__FILE__, __LINE__, "missing adapter id in proxy string '" + s + "'");
             }
 
             string adapterstr;
-            end = IceUtilInternal::checkQuote(s, beg);
-            if(end == string::npos)
+            end = IceInternal::checkQuote(s, beg);
+            if (end == string::npos)
             {
-                throw ProxyParseException(__FILE__, __LINE__, "mismatched quotes around adapter id in `" + s + "'");
+                throw ParseException(
+                    __FILE__,
+                    __LINE__,
+                    "mismatched quotes around adapter id in proxy string '" + s + "'");
             }
-            else if(end == 0)
+            else if (end == 0)
             {
                 end = s.find_first_of(delim, beg);
-                if(end == string::npos)
+                if (end == string::npos)
                 {
                     end = s.size();
                 }
@@ -509,47 +525,48 @@ IceInternal::ReferenceFactory::create(const string& str, const string& propertyP
             }
 
             // Check for trailing whitespace.
-            if(end != string::npos && s.find_first_not_of(delim, end) != string::npos)
+            if (end != string::npos && s.find_first_not_of(delim, end) != string::npos)
             {
-                throw ProxyParseException(__FILE__, __LINE__, "invalid trailing characters after `" +
-                                          s.substr(0, end + 1) + "' in `" + s + "'");
+                throw ParseException(
+                    __FILE__,
+                    __LINE__,
+                    "invalid trailing characters after '" + s.substr(0, end + 1) + "' in proxy string '" + s + "'");
             }
 
             try
             {
                 adapter = unescapeString(adapterstr, 0, adapterstr.size(), "");
             }
-            catch(const IceUtil::IllegalArgumentException& ex)
+            catch (const invalid_argument& ex)
             {
-                throw ProxyParseException(__FILE__, __LINE__, "invalid adapter id in `" + s + "': " + ex.reason());
+                throw ParseException(
+                    __FILE__,
+                    __LINE__,
+                    "invalid adapter id in proxy string '" + s + "': " + ex.what());
             }
-            if(adapter.size() == 0)
+            if (adapter.size() == 0)
             {
-                throw ProxyParseException(__FILE__, __LINE__, "empty adapter id in `" + s + "'");
+                throw ParseException(__FILE__, __LINE__, "empty adapter id in proxy string '" + s + "'");
             }
 
-            return create(ident, facet, mode, secure, protocol, encoding, endpoints, adapter, propertyPrefix);
+            return create(ident, facet, mode, protocol, encoding, endpoints, adapter, propertyPrefix);
             break;
         }
         default:
         {
-            throw ProxyParseException(__FILE__, __LINE__, "malformed proxy `" + s + "'");
+            throw ParseException(__FILE__, __LINE__, "malformed proxy '" + s + "'");
         }
     }
 }
 
 ReferencePtr
-IceInternal::ReferenceFactory::create(const Identity& ident, InputStream* s)
+IceInternal::ReferenceFactory::create(Identity ident, InputStream* s)
 {
     //
     // Don't read the identity here. Operations calling this
     // constructor read the identity, and pass it as a parameter.
     //
-
-    if(ident.name.empty() && ident.category.empty())
-    {
-        return 0;
-    }
+    assert(!ident.name.empty());
 
     //
     // For compatibility with the old FacetPath.
@@ -557,48 +574,48 @@ IceInternal::ReferenceFactory::create(const Identity& ident, InputStream* s)
     vector<string> facetPath;
     s->read(facetPath);
     string facet;
-    if(!facetPath.empty())
+    if (!facetPath.empty())
     {
-        if(facetPath.size() > 1)
+        if (facetPath.size() > 1)
         {
-            throw ProxyUnmarshalException(__FILE__, __LINE__);
+            throw MarshalException{__FILE__, __LINE__, "received facet path with more than one element"};
         }
         facet.swap(facetPath[0]);
     }
 
-    Byte modeAsByte;
+    uint8_t modeAsByte;
     s->read(modeAsByte);
-    Reference::Mode mode = static_cast<Reference::Mode>(modeAsByte);
-    if(mode < 0 || mode > Reference::ModeLast)
+    auto mode = static_cast<Reference::Mode>(modeAsByte);
+    if (mode < 0 || mode > Reference::ModeLast)
     {
-        throw ProxyUnmarshalException(__FILE__, __LINE__);
+        throw MarshalException{__FILE__, __LINE__, "received proxy with invalid mode " + to_string(mode)};
     }
 
-    bool secure;
-    s->read(secure);
+    [[maybe_unused]] bool secure;
+    s->read(secure); // and ignored
 
     Ice::ProtocolVersion protocol;
     Ice::EncodingVersion encoding;
-    if(s->getEncoding() != Ice::Encoding_1_0)
+    if (s->getEncoding() != Ice::Encoding_1_0)
     {
         s->read(protocol);
         s->read(encoding);
     }
     else
     {
-        protocol = Ice::Protocol_1_0;
+        protocol = Protocol_1_0;
         encoding = Ice::Encoding_1_0;
     }
 
     vector<EndpointIPtr> endpoints;
     string adapterId;
 
-    Ice::Int sz = s->readSize();
+    int32_t sz = s->readSize();
 
-    if(sz > 0)
+    if (sz > 0)
     {
         endpoints.reserve(static_cast<size_t>(sz));
-        while(sz--)
+        while (sz--)
         {
             EndpointIPtr endpoint = _instance->endpointFactoryManager()->read(s);
             endpoints.push_back(endpoint);
@@ -609,124 +626,73 @@ IceInternal::ReferenceFactory::create(const Identity& ident, InputStream* s)
         s->read(adapterId);
     }
 
-    return create(ident, facet, mode, secure, protocol, encoding, endpoints, adapterId, "");
+    return create(
+        std::move(ident),
+        std::move(facet),
+        mode,
+        protocol,
+        encoding,
+        std::move(endpoints),
+        std::move(adapterId),
+        "");
 }
 
 ReferenceFactoryPtr
-IceInternal::ReferenceFactory::setDefaultRouter(const RouterPrxPtr& defaultRouter)
+IceInternal::ReferenceFactory::setDefaultRouter(optional<RouterPrx> defaultRouter)
 {
-    if(defaultRouter == _defaultRouter)
+    if (defaultRouter == _defaultRouter)
     {
-        return this;
+        return shared_from_this();
     }
 
-    ReferenceFactoryPtr factory = new ReferenceFactory(_instance, _communicator);
+    ReferenceFactoryPtr factory = make_shared<ReferenceFactory>(_instance, _communicator);
     factory->_defaultLocator = _defaultLocator;
-    factory->_defaultRouter = defaultRouter;
+    factory->_defaultRouter = std::move(defaultRouter);
     return factory;
 }
 
-RouterPrxPtr
+std::optional<RouterPrx>
 IceInternal::ReferenceFactory::getDefaultRouter() const
 {
     return _defaultRouter;
 }
 
 ReferenceFactoryPtr
-IceInternal::ReferenceFactory::setDefaultLocator(const LocatorPrxPtr& defaultLocator)
+IceInternal::ReferenceFactory::setDefaultLocator(std::optional<LocatorPrx> defaultLocator)
 {
-    if(defaultLocator == _defaultLocator)
+    if (defaultLocator == _defaultLocator)
     {
-        return this;
+        return shared_from_this();
     }
 
-    ReferenceFactoryPtr factory = new ReferenceFactory(_instance, _communicator);
+    ReferenceFactoryPtr factory = make_shared<ReferenceFactory>(_instance, _communicator);
     factory->_defaultRouter = _defaultRouter;
-    factory->_defaultLocator = defaultLocator;
+    factory->_defaultLocator = std::move(defaultLocator);
     return factory;
 }
 
-LocatorPrxPtr
+std::optional<LocatorPrx>
 IceInternal::ReferenceFactory::getDefaultLocator() const
 {
     return _defaultLocator;
 }
 
-IceInternal::ReferenceFactory::ReferenceFactory(const InstancePtr& instance, const CommunicatorPtr& communicator) :
-    _instance(instance),
-    _communicator(communicator)
+IceInternal::ReferenceFactory::ReferenceFactory(InstancePtr instance, CommunicatorPtr communicator)
+    : _instance(std::move(instance)),
+      _communicator(std::move(communicator))
 {
 }
 
-void
-IceInternal::ReferenceFactory::checkForUnknownProperties(const string& prefix)
-{
-    static const string suffixes[] =
-    {
-        "EndpointSelection",
-        "ConnectionCached",
-        "PreferSecure",
-        "LocatorCacheTimeout",
-        "InvocationTimeout",
-        "Locator",
-        "Router",
-        "CollocationOptimized",
-        "Context.*"
-    };
-
-    //
-    // Do not warn about unknown properties list if Ice prefix, ie Ice, Glacier2, etc
-    //
-    for(const char** i = IceInternal::PropertyNames::clPropNames; *i != 0; ++i)
-    {
-        if(prefix.find(*i) == 0)
-        {
-            return;
-        }
-    }
-
-    StringSeq unknownProps;
-    PropertyDict props = _instance->initializationData().properties->getPropertiesForPrefix(prefix + ".");
-    for(PropertyDict::const_iterator p = props.begin(); p != props.end(); ++p)
-    {
-        bool valid = false;
-        for(unsigned int i = 0; i < sizeof(suffixes)/sizeof(*suffixes); ++i)
-        {
-            string prop = prefix + "." + suffixes[i];
-            if(IceUtilInternal::match(p->first, prop))
-            {
-                valid = true;
-                break;
-            }
-        }
-
-        if(!valid)
-        {
-            unknownProps.push_back(p->first);
-        }
-    }
-
-    if(unknownProps.size())
-    {
-        Warning out(_instance->initializationData().logger);
-        out << "found unknown properties for proxy '" << prefix << "':";
-        for(unsigned int i = 0; i < unknownProps.size(); ++i)
-        {
-            out << "\n    " << unknownProps[i];
-        }
-    }
-}
-
 RoutableReferencePtr
-IceInternal::ReferenceFactory::create(const Identity& ident,
-                                      const string& facet,
-                                      Reference::Mode mode,
-                                      bool secure,
-                                      const Ice::ProtocolVersion& protocol,
-                                      const Ice::EncodingVersion& encoding,
-                                      const vector<EndpointIPtr>& endpoints,
-                                      const string& adapterId,
-                                      const string& propertyPrefix)
+IceInternal::ReferenceFactory::create(
+    Identity ident,
+    string facet,
+    Reference::Mode mode,
+    Ice::ProtocolVersion protocol,
+    Ice::EncodingVersion encoding,
+    vector<EndpointIPtr> endpoints,
+    string adapterId,
+    const string& propertyPrefix)
 {
     DefaultsAndOverridesPtr defaultsAndOverrides = _instance->defaultsAndOverrides();
 
@@ -734,66 +700,65 @@ IceInternal::ReferenceFactory::create(const Identity& ident,
     // Default local proxy options.
     //
     LocatorInfoPtr locatorInfo;
-    if(_defaultLocator)
+    if (_defaultLocator)
     {
-        if(_defaultLocator->ice_getEncodingVersion() != encoding)
+        if (_defaultLocator->ice_getEncodingVersion() != encoding)
         {
             locatorInfo = _instance->locatorManager()->get(_defaultLocator->ice_encodingVersion(encoding));
         }
         else
         {
-            locatorInfo = _instance->locatorManager()->get(_defaultLocator);
+            locatorInfo = _instance->locatorManager()->get(_defaultLocator.value());
         }
     }
-    RouterInfoPtr routerInfo = _instance->routerManager()->get(_defaultRouter);
+    RouterInfoPtr routerInfo = _defaultRouter ? _instance->routerManager()->get(_defaultRouter.value()) : nullptr;
     bool collocationOptimized = defaultsAndOverrides->defaultCollocationOptimization;
     bool cacheConnection = true;
-    bool preferSecure = defaultsAndOverrides->defaultPreferSecure;
     Ice::EndpointSelectionType endpointSelection = defaultsAndOverrides->defaultEndpointSelection;
-    int locatorCacheTimeout = defaultsAndOverrides->defaultLocatorCacheTimeout;
-    int invocationTimeout = defaultsAndOverrides->defaultInvocationTimeout;
+    chrono::seconds locatorCacheTimeout = defaultsAndOverrides->defaultLocatorCacheTimeout;
+    chrono::milliseconds invocationTimeout = defaultsAndOverrides->defaultInvocationTimeout;
     Ice::Context ctx;
 
     //
     // Override the defaults with the proxy properties if a property prefix is defined.
     //
-    if(!propertyPrefix.empty())
+    if (!propertyPrefix.empty())
     {
         PropertiesPtr properties = _instance->initializationData().properties;
-        if(properties->getPropertyAsIntWithDefault("Ice.Warn.UnknownProperties", 1) > 0)
-        {
-            checkForUnknownProperties(propertyPrefix);
-        }
+        validatePropertiesWithPrefix(
+            propertyPrefix,
+            _instance->initializationData().properties,
+            &IceInternal::PropertyNames::ProxyProps);
 
         string property;
 
         property = propertyPrefix + ".Locator";
-        LocatorPrxPtr locator = ICE_UNCHECKED_CAST(LocatorPrx, _communicator->propertyToProxy(property));
-        if(locator)
+        auto locator = _communicator->propertyToProxy<LocatorPrx>(property);
+        if (locator)
         {
-            if(locator->ice_getEncodingVersion() != encoding)
+            if (locator->ice_getEncodingVersion() != encoding)
             {
                 locatorInfo = _instance->locatorManager()->get(locator->ice_encodingVersion(encoding));
             }
             else
             {
-                locatorInfo = _instance->locatorManager()->get(locator);
+                locatorInfo = _instance->locatorManager()->get(locator.value());
             }
         }
 
         property = propertyPrefix + ".Router";
-        RouterPrxPtr router = ICE_UNCHECKED_CAST(RouterPrx, _communicator->propertyToProxy(property));
-        if(router)
+        auto router = _communicator->propertyToProxy<RouterPrx>(property);
+        if (router)
         {
-            if(propertyPrefix.size() > 7 && propertyPrefix.substr(propertyPrefix.size() - 7, 7) == ".Router")
+            if (propertyPrefix.size() > 7 && propertyPrefix.substr(propertyPrefix.size() - 7, 7) == ".Router")
             {
                 Warning out(_instance->initializationData().logger);
-                out << "`" << property << "=" << properties->getProperty(property)
+                out << "'" << property << "=" << properties->getProperty(property)
                     << "': cannot set a router on a router; setting ignored";
             }
             else
             {
-                routerInfo = _instance->routerManager()->get(router);
+                routerInfo = _instance->routerManager()->get(router.value());
             }
         }
 
@@ -803,86 +768,63 @@ IceInternal::ReferenceFactory::create(const Identity& ident,
         property = propertyPrefix + ".ConnectionCached";
         cacheConnection = properties->getPropertyAsIntWithDefault(property, cacheConnection) > 0;
 
-        property = propertyPrefix + ".PreferSecure";
-        preferSecure = properties->getPropertyAsIntWithDefault(property, preferSecure) > 0;
-
         property = propertyPrefix + ".EndpointSelection";
-        if(!properties->getProperty(property).empty())
+        if (!properties->getProperty(property).empty())
         {
             string type = properties->getProperty(property);
-            if(type == "Random")
+            if (type == "Random")
             {
-                endpointSelection = ICE_ENUM(EndpointSelectionType, Random);
+                endpointSelection = EndpointSelectionType::Random;
             }
-            else if(type == "Ordered")
+            else if (type == "Ordered")
             {
-                endpointSelection = ICE_ENUM(EndpointSelectionType, Ordered);
+                endpointSelection = EndpointSelectionType::Ordered;
             }
             else
             {
-                throw EndpointSelectionTypeParseException(__FILE__, __LINE__, "illegal value `" + type +
-                                                          "'; expected `Random' or `Ordered'");
+                throw ParseException(
+                    __FILE__,
+                    __LINE__,
+                    "illegal value '" + type + "' for property " + property + "; expected 'Random' or 'Ordered'");
             }
         }
 
         property = propertyPrefix + ".LocatorCacheTimeout";
-        string value = properties->getProperty(property);
-        if(!value.empty())
-        {
-            locatorCacheTimeout = properties->getPropertyAsIntWithDefault(property, locatorCacheTimeout);
-            if(locatorCacheTimeout < -1)
-            {
-                locatorCacheTimeout = -1;
-
-                Warning out(_instance->initializationData().logger);
-                out << "invalid value for " << property << "`" << properties->getProperty(property) << "'"
-                    << ": defaulting to -1";
-            }
-        }
+        locatorCacheTimeout = chrono::seconds(
+            properties->getPropertyAsIntWithDefault(property, static_cast<int32_t>(locatorCacheTimeout.count())));
 
         property = propertyPrefix + ".InvocationTimeout";
-        value = properties->getProperty(property);
-        if(!value.empty())
-        {
-            invocationTimeout = properties->getPropertyAsIntWithDefault(property, invocationTimeout);
-            if(invocationTimeout < 1 && invocationTimeout != -1)
-            {
-                invocationTimeout = -1;
-
-                Warning out(_instance->initializationData().logger);
-                out << "invalid value for " << property << "`" << properties->getProperty(property) << "'"
-                    << ": defaulting to -1";
-            }
-        }
+        invocationTimeout = chrono::milliseconds(
+            properties->getPropertyAsIntWithDefault(property, static_cast<int32_t>(invocationTimeout.count())));
 
         property = propertyPrefix + ".Context.";
         PropertyDict contexts = properties->getPropertiesForPrefix(property);
-        for(PropertyDict::const_iterator p = contexts.begin(); p != contexts.end(); ++p)
+        for (const auto& context : contexts)
         {
-            ctx.insert(make_pair(p->first.substr(property.length()), p->second));
+            ctx.insert(make_pair(context.first.substr(property.length()), context.second));
         }
     }
 
     //
     // Create new reference
     //
-    return new RoutableReference(_instance,
-                                 _communicator,
-                                 ident,
-                                 facet,
-                                 mode,
-                                 secure,
-                                 protocol,
-                                 encoding,
-                                 endpoints,
-                                 adapterId,
-                                 locatorInfo,
-                                 routerInfo,
-                                 collocationOptimized,
-                                 cacheConnection,
-                                 preferSecure,
-                                 endpointSelection,
-                                 locatorCacheTimeout,
-                                 invocationTimeout,
-                                 ctx);
+    return make_shared<RoutableReference>(
+        _instance,
+        _communicator,
+        std::move(ident),
+        std::move(facet),
+        mode,
+        nullopt,
+        protocol,
+        encoding,
+        std::move(endpoints),
+        std::move(adapterId),
+        std::move(locatorInfo),
+        std::move(routerInfo),
+        collocationOptimized,
+        cacheConnection,
+        endpointSelection,
+        locatorCacheTimeout,
+        invocationTimeout,
+        std::move(ctx));
 }