zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,323 +1,339 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_REFERENCE_H
 #define ICE_REFERENCE_H
 
-#include <IceUtil/Shared.h>
-#include <Ice/ReferenceF.h>
-#include <Ice/ReferenceFactoryF.h>
-#include <Ice/EndpointIF.h>
-#include <Ice/InstanceF.h>
-#include <Ice/RouterF.h>
-#include <Ice/LocatorF.h>
-#include <Ice/RouterInfoF.h>
-#include <Ice/LocatorInfoF.h>
-#include <Ice/ConnectionIF.h>
-#include <Ice/RequestHandlerF.h>
-#include <Ice/BatchRequestQueue.h>
-#include <Ice/SharedContext.h>
-#include <Ice/Identity.h>
-#include <Ice/Protocol.h>
-#include <Ice/Properties.h>
+#include "BatchRequestQueue.h"
+#include "EndpointIF.h"
+#include "Ice/ConnectionIF.h"
+#include "Ice/Identity.h"
+#include "Ice/InstanceF.h"
+#include "Ice/Locator.h"
+#include "Ice/Properties.h"
+#include "Ice/ReferenceF.h"
+#include "Ice/RequestHandlerF.h"
+#include "Ice/Router.h"
+#include "LocatorInfoF.h"
+#include "ReferenceFactoryF.h"
+#include "RouterInfoF.h"
+#include "SharedContext.h"
+
+#include <mutex>
 
 namespace Ice
 {
-
-class OutputStream;
-
+    class OutputStream;
 }
 
 namespace IceInternal
 {
-
-class Reference : public IceUtil::Shared
-{
-public:
-
-    class GetConnectionCallback
-#ifndef ICE_CPP11_MAPPING
-        : public virtual IceUtil::Shared
-#endif
+    class Reference : public std::enable_shared_from_this<Reference>
     {
     public:
-
-        virtual void setConnection(const Ice::ConnectionIPtr&, bool) = 0;
-        virtual void setException(const Ice::LocalException&) = 0;
+        virtual ~Reference() = default;
+
+        enum Mode
+        {
+            ModeTwoway = 0,
+            ModeOneway = 1,
+            ModeBatchOneway = 2,
+            ModeDatagram = 3,
+            ModeBatchDatagram = 4,
+            ModeLast = ModeBatchDatagram
+        };
+
+        [[nodiscard]] Mode getMode() const noexcept { return _mode; }
+        [[nodiscard]] bool isBatch() const noexcept { return _mode == ModeBatchOneway || _mode == ModeBatchDatagram; }
+        [[nodiscard]] bool isTwoway() const noexcept { return _mode == ModeTwoway; }
+        [[nodiscard]] const Ice::ProtocolVersion& getProtocol() const noexcept { return _protocol; }
+        [[nodiscard]] const Ice::EncodingVersion& getEncoding() const noexcept { return _encoding; }
+        [[nodiscard]] const Ice::Identity& getIdentity() const noexcept { return _identity; }
+        [[nodiscard]] const std::string& getFacet() const noexcept { return _facet; }
+        [[nodiscard]] const InstancePtr& getInstance() const noexcept { return _instance; }
+        [[nodiscard]] const SharedContextPtr& getContext() const noexcept { return _context; }
+        [[nodiscard]] std::chrono::milliseconds getInvocationTimeout() const noexcept { return _invocationTimeout; }
+        [[nodiscard]] std::optional<bool> getCompress() const noexcept { return _compress; }
+
+        [[nodiscard]] Ice::CommunicatorPtr getCommunicator() const noexcept;
+
+        [[nodiscard]] virtual std::vector<EndpointIPtr> getEndpoints() const = 0;
+        [[nodiscard]] virtual std::string getAdapterId() const = 0;
+        [[nodiscard]] virtual LocatorInfoPtr getLocatorInfo() const noexcept { return nullptr; }
+        [[nodiscard]] virtual RouterInfoPtr getRouterInfo() const noexcept { return nullptr; }
+        [[nodiscard]] virtual bool getCollocationOptimized() const noexcept = 0;
+        [[nodiscard]] virtual bool getCacheConnection() const noexcept = 0;
+        [[nodiscard]] virtual Ice::EndpointSelectionType getEndpointSelection() const noexcept = 0;
+        [[nodiscard]] virtual std::chrono::milliseconds getLocatorCacheTimeout() const noexcept = 0;
+        [[nodiscard]] virtual std::string getConnectionId() const = 0;
+
+        //
+        // The change* methods (here and in derived classes) create
+        // a new reference based on the existing one, with the
+        // corresponding value changed.
+        //
+        [[nodiscard]] ReferencePtr changeContext(Ice::Context) const;
+        [[nodiscard]] ReferencePtr changeIdentity(Ice::Identity) const;
+        [[nodiscard]] ReferencePtr changeFacet(std::string) const;
+        [[nodiscard]] ReferencePtr changeInvocationTimeout(std::chrono::milliseconds) const;
+
+        [[nodiscard]] virtual ReferencePtr changeEncoding(Ice::EncodingVersion) const;
+        [[nodiscard]] virtual ReferencePtr changeCompress(bool) const;
+        [[nodiscard]] virtual ReferencePtr changeMode(Mode) const;
+        [[nodiscard]] virtual ReferencePtr changeEndpoints(std::vector<EndpointIPtr>) const = 0;
+        [[nodiscard]] virtual ReferencePtr changeAdapterId(std::string) const = 0;
+        [[nodiscard]] virtual ReferencePtr changeLocator(std::optional<Ice::LocatorPrx>) const = 0;
+        [[nodiscard]] virtual ReferencePtr changeRouter(std::optional<Ice::RouterPrx>) const = 0;
+        [[nodiscard]] virtual ReferencePtr changeCollocationOptimized(bool) const = 0;
+        [[nodiscard]] virtual ReferencePtr changeLocatorCacheTimeout(std::chrono::milliseconds) const = 0;
+        [[nodiscard]] virtual ReferencePtr changeCacheConnection(bool) const = 0;
+        [[nodiscard]] virtual ReferencePtr changeEndpointSelection(Ice::EndpointSelectionType) const = 0;
+
+        [[nodiscard]] virtual ReferencePtr changeConnectionId(std::string) const = 0;
+        [[nodiscard]] virtual ReferencePtr changeConnection(Ice::ConnectionIPtr) const = 0;
+
+        [[nodiscard]] virtual std::size_t hash() const noexcept;
+
+        // Gets the effective compression setting, taking into account the override.
+        [[nodiscard]] std::optional<bool> getCompressOverride() const noexcept;
+
+        //
+        // Utility methods.
+        //
+        [[nodiscard]] virtual bool isIndirect() const noexcept = 0;
+        [[nodiscard]] virtual bool isWellKnown() const noexcept = 0;
+
+        //
+        // Marshal the reference.
+        //
+        virtual void streamWrite(Ice::OutputStream*) const;
+
+        //
+        // Convert the reference to its string form.
+        //
+        [[nodiscard]] virtual std::string toString() const;
+
+        //
+        // Convert the reference to its property form.
+        //
+        [[nodiscard]] virtual Ice::PropertyDict toProperty(std::string) const = 0;
+
+        //
+        // Get a suitable connection for this reference.
+        //
+        [[nodiscard]] virtual RequestHandlerPtr getRequestHandler() const = 0;
+
+        //
+        // Get batch request queue.
+        //
+        [[nodiscard]] virtual const BatchRequestQueuePtr& getBatchRequestQueue() const noexcept = 0;
+
+        virtual bool operator==(const Reference&) const noexcept;
+        virtual bool operator<(const Reference&) const noexcept;
+
+        [[nodiscard]] virtual ReferencePtr clone() const = 0;
+
+    protected:
+        Reference(
+            InstancePtr,
+            Ice::CommunicatorPtr,
+            Ice::Identity,
+            std::string,
+            Mode,
+            std::optional<bool>,
+            Ice::ProtocolVersion,
+            Ice::EncodingVersion,
+            std::chrono::milliseconds,
+            Ice::Context ctx);
+
+        Reference(const Reference&);
+
+        const InstancePtr _instance;
+
+    private:
+        const Ice::CommunicatorPtr _communicator;
+
+        Mode _mode;
+        std::optional<bool> _compress;
+        Ice::Identity _identity;
+        SharedContextPtr _context;
+        std::string _facet;
+        Ice::ProtocolVersion _protocol;
+        Ice::EncodingVersion _encoding;
+        std::chrono::milliseconds _invocationTimeout;
     };
-    ICE_DEFINE_PTR(GetConnectionCallbackPtr, GetConnectionCallback);
 
-    enum Mode
+    class FixedReference final : public Reference
     {
-        ModeTwoway,
-        ModeOneway,
-        ModeBatchOneway,
-        ModeDatagram,
-        ModeBatchDatagram,
-        ModeLast = ModeBatchDatagram
+    public:
+        FixedReference(
+            InstancePtr,
+            Ice::CommunicatorPtr,
+            Ice::Identity,
+            std::string,
+            Mode,
+            std::optional<bool>,
+            Ice::ProtocolVersion,
+            Ice::EncodingVersion,
+            Ice::ConnectionIPtr,
+            std::chrono::milliseconds,
+            Ice::Context);
+
+        FixedReference(const FixedReference&) = default;
+
+        [[nodiscard]] std::vector<EndpointIPtr> getEndpoints() const final;
+        [[nodiscard]] std::string getAdapterId() const final;
+        [[nodiscard]] bool getCollocationOptimized() const noexcept final;
+        [[nodiscard]] bool getCacheConnection() const noexcept final;
+        [[nodiscard]] Ice::EndpointSelectionType getEndpointSelection() const noexcept final;
+        [[nodiscard]] std::chrono::milliseconds getLocatorCacheTimeout() const noexcept final;
+        [[nodiscard]] std::string getConnectionId() const final;
+
+        [[nodiscard]] ReferencePtr changeEndpoints(std::vector<EndpointIPtr>) const final;
+        [[nodiscard]] ReferencePtr changeAdapterId(std::string) const final;
+        [[nodiscard]] ReferencePtr changeLocator(std::optional<Ice::LocatorPrx>) const final;
+        [[nodiscard]] ReferencePtr changeRouter(std::optional<Ice::RouterPrx>) const final;
+        [[nodiscard]] ReferencePtr changeCollocationOptimized(bool) const final;
+        [[nodiscard]] ReferencePtr changeCacheConnection(bool) const final;
+        [[nodiscard]] ReferencePtr changeEndpointSelection(Ice::EndpointSelectionType) const final;
+        [[nodiscard]] ReferencePtr changeLocatorCacheTimeout(std::chrono::milliseconds) const final;
+
+        [[nodiscard]] ReferencePtr changeConnectionId(std::string) const final;
+        [[nodiscard]] ReferencePtr changeConnection(Ice::ConnectionIPtr) const final;
+
+        [[nodiscard]] bool isIndirect() const noexcept final;
+        [[nodiscard]] bool isWellKnown() const noexcept final;
+
+        void streamWrite(Ice::OutputStream*) const final;
+        [[nodiscard]] Ice::PropertyDict toProperty(std::string) const final;
+
+        [[nodiscard]] RequestHandlerPtr getRequestHandler() const final;
+        [[nodiscard]] const BatchRequestQueuePtr& getBatchRequestQueue() const noexcept final;
+
+        bool operator==(const Reference&) const noexcept final;
+        bool operator<(const Reference&) const noexcept final;
+
+        [[nodiscard]] ReferencePtr clone() const final;
+
+    private:
+        Ice::ConnectionIPtr _fixedConnection;
     };
 
-    Mode getMode() const { return _mode; }
-    bool getSecure() const { return _secure; }
-    const Ice::ProtocolVersion& getProtocol() const { return _protocol; }
-    const Ice::EncodingVersion& getEncoding() const { return _encoding; }
-    const Ice::Identity& getIdentity() const { return _identity; }
-    const std::string& getFacet() const { return _facet; }
-    const InstancePtr& getInstance() const { return _instance; }
-    const SharedContextPtr& getContext() const { return _context; }
-    int getInvocationTimeout() const { return _invocationTimeout; }
-    IceUtil::Optional<bool> getCompress() const
-    {
-        return _overrideCompress ? IceUtil::Optional<bool>(_compress) : IceUtil::None;
-    }
-
-    Ice::CommunicatorPtr getCommunicator() const;
-
-    virtual std::vector<EndpointIPtr> getEndpoints() const = 0;
-    virtual std::string getAdapterId() const = 0;
-    virtual LocatorInfoPtr getLocatorInfo() const { return 0; }
-    virtual RouterInfoPtr getRouterInfo() const { return 0; }
-    virtual bool getCollocationOptimized() const = 0;
-    virtual bool getCacheConnection() const = 0;
-    virtual bool getPreferSecure() const = 0;
-    virtual Ice::EndpointSelectionType getEndpointSelection() const = 0;
-    virtual int getLocatorCacheTimeout() const = 0;
-    virtual std::string getConnectionId() const = 0;
-    virtual IceUtil::Optional<int> getTimeout() const = 0;
-
-    //
-    // The change* methods (here and in derived classes) create
-    // a new reference based on the existing one, with the
-    // corresponding value changed.
-    //
-    ReferencePtr changeContext(const Ice::Context&) const;
-    ReferencePtr changeMode(Mode) const;
-    ReferencePtr changeSecure(bool) const;
-    ReferencePtr changeIdentity(const Ice::Identity&) const;
-    ReferencePtr changeFacet(const std::string&) const;
-    ReferencePtr changeInvocationTimeout(int) const;
-    virtual ReferencePtr changeEncoding(const Ice::EncodingVersion&) const;
-    virtual ReferencePtr changeCompress(bool) const;
-
-    virtual ReferencePtr changeEndpoints(const std::vector<EndpointIPtr>&) const = 0;
-    virtual ReferencePtr changeAdapterId(const std::string&) const = 0;
-    virtual ReferencePtr changeLocator(const Ice::LocatorPrxPtr&) const = 0;
-    virtual ReferencePtr changeRouter(const Ice::RouterPrxPtr&) const = 0;
-    virtual ReferencePtr changeCollocationOptimized(bool) const = 0;
-    virtual ReferencePtr changeLocatorCacheTimeout(int) const = 0;
-    virtual ReferencePtr changeCacheConnection(bool) const = 0;
-    virtual ReferencePtr changePreferSecure(bool) const = 0;
-    virtual ReferencePtr changeEndpointSelection(Ice::EndpointSelectionType) const = 0;
-
-    virtual ReferencePtr changeTimeout(int) const = 0;
-    virtual ReferencePtr changeConnectionId(const std::string&) const = 0;
-    virtual ReferencePtr changeConnection(const Ice::ConnectionIPtr&) const = 0;
-
-    int hash() const; // Conceptually const.
-
-    bool getCompressOverride(bool&) const;
-
-    //
-    // Utility methods.
-    //
-    virtual bool isIndirect() const = 0;
-    virtual bool isWellKnown() const = 0;
-
-    //
-    // Marshal the reference.
-    //
-    virtual void streamWrite(Ice::OutputStream*) const;
-
-    //
-    // Convert the reference to its string form.
-    //
-    virtual std::string toString() const;
-
-    //
-    // Convert the refernce to its property form.
-    //
-    virtual Ice::PropertyDict toProperty(const std::string&) const = 0;
-
-    //
-    // Get a suitable connection for this reference.
-    //
-    virtual RequestHandlerPtr getRequestHandler(const Ice::ObjectPrxPtr&) const = 0;
-    virtual BatchRequestQueuePtr getBatchRequestQueue() const = 0;
-
-    virtual bool operator==(const Reference&) const;
-    virtual bool operator<(const Reference&) const;
-
-    virtual ReferencePtr clone() const = 0;
-
-protected:
-
-    Reference(const InstancePtr&, const Ice::CommunicatorPtr&, const Ice::Identity&, const std::string&, Mode, bool,
-              const Ice::ProtocolVersion&, const Ice::EncodingVersion&, int, const Ice::Context& ctx);
-    Reference(const Reference&);
-
-    virtual Ice::Int hashInit() const;
-
-    mutable Ice::Int _hashValue;
-    mutable bool _hashInitialized;
-
-private:
-
-    const InstancePtr _instance;
-    const Ice::CommunicatorPtr _communicator;
-
-    Mode _mode;
-    bool _secure;
-    Ice::Identity _identity;
-    SharedContextPtr _context;
-    std::string _facet;
-    Ice::ProtocolVersion _protocol;
-    Ice::EncodingVersion _encoding;
-    int _invocationTimeout;
-
-protected:
-
-    bool _overrideCompress;
-    bool _compress; // Only used if _overrideCompress == true
-};
-
-class FixedReference : public Reference
-{
-public:
-
-    FixedReference(const InstancePtr&, const Ice::CommunicatorPtr&, const Ice::Identity&, const std::string&, Mode,
-                   bool, const Ice::ProtocolVersion&, const Ice::EncodingVersion&, const Ice::ConnectionIPtr&,
-                   int, const Ice::Context&, const IceUtil::Optional<bool>&);
-
-    virtual std::vector<EndpointIPtr> getEndpoints() const;
-    virtual std::string getAdapterId() const;
-    virtual bool getCollocationOptimized() const;
-    virtual bool getCacheConnection() const;
-    virtual bool getPreferSecure() const;
-    virtual Ice::EndpointSelectionType getEndpointSelection() const;
-    virtual int getLocatorCacheTimeout() const;
-    virtual std::string getConnectionId() const;
-    virtual IceUtil::Optional<int> getTimeout() const;
+    using FixedReferencePtr = std::shared_ptr<FixedReference>;
 
-    virtual ReferencePtr changeEndpoints(const std::vector<EndpointIPtr>&) const;
-    virtual ReferencePtr changeAdapterId(const std::string&) const;
-    virtual ReferencePtr changeLocator(const Ice::LocatorPrxPtr&) const;
-    virtual ReferencePtr changeRouter(const Ice::RouterPrxPtr&) const;
-    virtual ReferencePtr changeCollocationOptimized(bool) const;
-    virtual ReferencePtr changeCacheConnection(bool) const;
-    virtual ReferencePtr changePreferSecure(bool) const;
-    virtual ReferencePtr changeEndpointSelection(Ice::EndpointSelectionType) const;
-    virtual ReferencePtr changeLocatorCacheTimeout(int) const;
-
-    virtual ReferencePtr changeTimeout(int) const;
-    virtual ReferencePtr changeConnectionId(const std::string&) const;
-    virtual ReferencePtr changeConnection(const Ice::ConnectionIPtr&) const;
-
-    virtual bool isIndirect() const;
-    virtual bool isWellKnown() const;
-
-    virtual void streamWrite(Ice::OutputStream*) const;
-    virtual Ice::PropertyDict toProperty(const std::string&) const;
-
-    virtual RequestHandlerPtr getRequestHandler(const Ice::ObjectPrxPtr&) const;
-    virtual BatchRequestQueuePtr getBatchRequestQueue() const;
-
-    virtual bool operator==(const Reference&) const;
-    virtual bool operator<(const Reference&) const;
-
-    virtual ReferencePtr clone() const;
-
-private:
-
-    FixedReference(const FixedReference&);
+    class RoutableReference final : public Reference
+    {
+    public:
+        RoutableReference(
+            InstancePtr,
+            Ice::CommunicatorPtr,
+            Ice::Identity,
+            std::string,
+            Mode,
+            std::optional<bool>,
+            Ice::ProtocolVersion,
+            Ice::EncodingVersion,
+            std::vector<EndpointIPtr>,
+            std::string,
+            LocatorInfoPtr,
+            RouterInfoPtr,
+            bool,
+            bool,
+            Ice::EndpointSelectionType,
+            std::chrono::milliseconds,
+            std::chrono::milliseconds,
+            Ice::Context);
+
+        RoutableReference(const RoutableReference&);
+
+        [[nodiscard]] std::vector<EndpointIPtr> getEndpoints() const final;
+        [[nodiscard]] std::string getAdapterId() const final;
+        [[nodiscard]] LocatorInfoPtr getLocatorInfo() const noexcept final;
+        [[nodiscard]] RouterInfoPtr getRouterInfo() const noexcept final;
+        [[nodiscard]] bool getCollocationOptimized() const noexcept final;
+        [[nodiscard]] bool getCacheConnection() const noexcept final;
+        [[nodiscard]] Ice::EndpointSelectionType getEndpointSelection() const noexcept final;
+        [[nodiscard]] std::chrono::milliseconds getLocatorCacheTimeout() const noexcept final;
+        [[nodiscard]] std::string getConnectionId() const final;
+
+        [[nodiscard]] ReferencePtr changeEncoding(Ice::EncodingVersion) const final;
+        [[nodiscard]] ReferencePtr changeCompress(bool) const final;
+        [[nodiscard]] ReferencePtr changeMode(Mode) const final;
+        [[nodiscard]] ReferencePtr changeEndpoints(std::vector<EndpointIPtr>) const final;
+        [[nodiscard]] ReferencePtr changeAdapterId(std::string) const final;
+        [[nodiscard]] ReferencePtr changeLocator(std::optional<Ice::LocatorPrx>) const final;
+        [[nodiscard]] ReferencePtr changeRouter(std::optional<Ice::RouterPrx>) const final;
+        [[nodiscard]] ReferencePtr changeCollocationOptimized(bool) const final;
+        [[nodiscard]] ReferencePtr changeCacheConnection(bool) const final;
+        [[nodiscard]] ReferencePtr changeEndpointSelection(Ice::EndpointSelectionType) const final;
+        [[nodiscard]] ReferencePtr changeLocatorCacheTimeout(std::chrono::milliseconds) const final;
+
+        [[nodiscard]] ReferencePtr changeConnectionId(std::string) const final;
+        [[nodiscard]] ReferencePtr changeConnection(Ice::ConnectionIPtr) const final;
+
+        [[nodiscard]] bool isIndirect() const noexcept final;
+        [[nodiscard]] bool isWellKnown() const noexcept final;
+
+        void streamWrite(Ice::OutputStream*) const final;
+        [[nodiscard]] std::string toString() const final;
+        [[nodiscard]] Ice::PropertyDict toProperty(std::string) const final;
+
+        bool operator==(const Reference&) const noexcept final;
+        bool operator<(const Reference&) const noexcept final;
+
+        [[nodiscard]] std::size_t hash() const noexcept final;
+
+        [[nodiscard]] ReferencePtr clone() const final;
+
+        [[nodiscard]] RequestHandlerPtr getRequestHandler() const final;
+        [[nodiscard]] const BatchRequestQueuePtr& getBatchRequestQueue() const noexcept final;
+
+        void getConnectionAsync(
+            std::function<void(Ice::ConnectionIPtr, bool)> response,
+            std::function<void(std::exception_ptr)> exception) const;
+
+        void applyOverrides(std::vector<EndpointIPtr>&) const;
+
+    protected:
+        [[nodiscard]] std::vector<EndpointIPtr> filterEndpoints(const std::vector<EndpointIPtr>&) const;
+
+    private:
+        void createConnectionAsync(
+            const std::vector<EndpointIPtr>&,
+            std::function<void(Ice::ConnectionIPtr, bool)> response,
+            std::function<void(std::exception_ptr)> exception) const;
+
+        void getConnectionNoRouterInfoAsync(
+            std::function<void(Ice::ConnectionIPtr, bool)> response,
+            std::function<void(std::exception_ptr)> exception) const;
+
+        // Sets or resets _batchRequestQueue based on _mode.
+        void setBatchRequestQueue();
+
+        BatchRequestQueuePtr _batchRequestQueue;
+
+        std::vector<EndpointIPtr> _endpoints; // Empty if indirect proxy.
+        std::string _adapterId;               // Empty if direct proxy.
+
+        LocatorInfoPtr _locatorInfo; // Null if no locator is used.
+        RouterInfoPtr _routerInfo;   // Null if no router is used.
+        bool _collocationOptimized;
+        bool _cacheConnection;
+        Ice::EndpointSelectionType _endpointSelection;
+        std::chrono::milliseconds _locatorCacheTimeout;
+
+        std::string _connectionId;
+    };
 
-    Ice::ConnectionIPtr _fixedConnection;
-};
+    using RoutableReferencePtr = std::shared_ptr<RoutableReference>;
+}
 
-class RoutableReference : public Reference
+namespace std
 {
-public:
-
-    RoutableReference(const InstancePtr&, const Ice::CommunicatorPtr&, const Ice::Identity&, const std::string&, Mode,
-                      bool, const Ice::ProtocolVersion&, const Ice::EncodingVersion&, const std::vector<EndpointIPtr>&,
-                      const std::string&, const LocatorInfoPtr&, const RouterInfoPtr&, bool, bool, bool,
-                      Ice::EndpointSelectionType, int, int, const Ice::Context&);
-
-    virtual std::vector<EndpointIPtr> getEndpoints() const;
-    virtual std::string getAdapterId() const;
-    virtual LocatorInfoPtr getLocatorInfo() const;
-    virtual RouterInfoPtr getRouterInfo() const;
-    virtual bool getCollocationOptimized() const;
-    virtual bool getCacheConnection() const;
-    virtual bool getPreferSecure() const;
-    virtual Ice::EndpointSelectionType getEndpointSelection() const;
-    virtual int getLocatorCacheTimeout() const;
-    virtual std::string getConnectionId() const;
-    virtual IceUtil::Optional<int> getTimeout() const;
-
-    virtual ReferencePtr changeEncoding(const Ice::EncodingVersion&) const;
-    virtual ReferencePtr changeCompress(bool) const;
-    virtual ReferencePtr changeEndpoints(const std::vector<EndpointIPtr>&) const;
-    virtual ReferencePtr changeAdapterId(const std::string&) const;
-    virtual ReferencePtr changeLocator(const Ice::LocatorPrxPtr&) const;
-    virtual ReferencePtr changeRouter(const Ice::RouterPrxPtr&) const;
-    virtual ReferencePtr changeCollocationOptimized(bool) const;
-    virtual ReferencePtr changeCacheConnection(bool) const;
-    virtual ReferencePtr changePreferSecure(bool) const;
-    virtual ReferencePtr changeEndpointSelection(Ice::EndpointSelectionType) const;
-    virtual ReferencePtr changeLocatorCacheTimeout(int) const;
-
-    virtual ReferencePtr changeTimeout(int) const;
-    virtual ReferencePtr changeConnectionId(const std::string&) const;
-    virtual ReferencePtr changeConnection(const Ice::ConnectionIPtr&) const;
-
-    virtual bool isIndirect() const;
-    virtual bool isWellKnown() const;
-
-    virtual void streamWrite(Ice::OutputStream*) const;
-    virtual std::string toString() const;
-    virtual Ice::PropertyDict toProperty(const std::string&) const;
-
-    virtual bool operator==(const Reference&) const;
-    virtual bool operator<(const Reference&) const;
-
-    virtual ReferencePtr clone() const;
-
-    virtual RequestHandlerPtr getRequestHandler(const Ice::ObjectPrxPtr&) const;
-    virtual BatchRequestQueuePtr getBatchRequestQueue() const;
-
-    void getConnection(const GetConnectionCallbackPtr&) const;
-    void getConnectionNoRouterInfo(const GetConnectionCallbackPtr&) const;
-
-    void createConnection(const std::vector<EndpointIPtr>&, const GetConnectionCallbackPtr&) const;
-    void applyOverrides(std::vector<EndpointIPtr>&) const;
-
-protected:
-
-    RoutableReference(const RoutableReference&);
-
-    std::vector<EndpointIPtr> filterEndpoints(const std::vector<EndpointIPtr>&) const;
-
-    virtual int hashInit() const;
-
-private:
-
-    std::vector<EndpointIPtr> _endpoints; // Empty if indirect proxy.
-    std::string _adapterId; // Empty if direct proxy.
-
-    LocatorInfoPtr _locatorInfo; // Null if no locator is used.
-    RouterInfoPtr _routerInfo; // Null if no router is used.
-    bool _collocationOptimized;
-    bool _cacheConnection;
-    bool _preferSecure;
-    Ice::EndpointSelectionType _endpointSelection;
-    int _locatorCacheTimeout;
-
-    bool _overrideTimeout;
-    int _timeout; // Only used if _overrideTimeout == true
-    std::string _connectionId;
-};
-
+    // Specialization of std::hash for Reference.
+    template<> struct hash<IceInternal::Reference>
+    {
+        std::size_t operator()(const IceInternal::Reference& r) const { return r.hash(); }
+    };
 }
 
 #endif