Fixed ICE-4927: fixed proxy encoding to marshal protocol/encoding version instead of encoding it in endpoints

author: Benoit Foucher <benoit@zeroc.com> 2012-11-13 10:17:27 +0100
committer: Benoit Foucher <benoit@zeroc.com> 2012-11-13 10:17:27 +0100
commit: 99b44d083eeee5583adfe642081a827224fa1309 (patch)
tree: 46bb3af634cbd5d90b9e5d46099f4e0e85f70ec6 /cpp/src
parent: Cosmetic updates to IceGrid Admin connection wizard (diff)
download: ice-99b44d083eeee5583adfe642081a827224fa1309.tar.bz2
ice-99b44d083eeee5583adfe642081a827224fa1309.tar.xz
ice-99b44d083eeee5583adfe642081a827224fa1309.zip
29 files changed, 259 insertions, 533 deletions
diff --git a/cpp/src/Ice/EndpointI.cpp b/cpp/src/Ice/EndpointI.cpp
index e9762fe2eec..0115a5f31cc 100644
--- a/cpp/src/Ice/EndpointI.cpp
+++ b/cpp/src/Ice/EndpointI.cpp
@@ -46,18 +46,6 @@ Init init;
 Ice::LocalObject* IceInternal::upCast(EndpointI* p) { return p; }
 IceUtil::Shared* IceInternal::upCast(EndpointHostResolver* p) { return p; }
 
-const Ice::EncodingVersion&
-IceInternal::EndpointI::encodingVersion() const
-{
-    return _encoding;
-}
-
-const Ice::ProtocolVersion&
-IceInternal::EndpointI::protocolVersion() const
-{
-    return _protocol;
-}
-
 const string&
 IceInternal::EndpointI::connectionId() const
 {
@@ -86,74 +74,17 @@ IceInternal::EndpointI::connectors(const vector<Address>& addrs) const
     return vector<ConnectorPtr>();
 }
 
-IceInternal::EndpointI::EndpointI(const Ice::ProtocolVersion& protocol, 
-                                  const Ice::EncodingVersion& encoding, 
-                                  const std::string& connectionId) : 
-    _protocol(protocol),
-    _encoding(encoding), 
+IceInternal::EndpointI::EndpointI(const std::string& connectionId) : 
     _connectionId(connectionId),
     _hashInitialized(false)
 {
 }
 
 IceInternal::EndpointI::EndpointI() : 
-    _protocol(Ice::currentProtocol),
-    _encoding(Ice::currentEncoding), 
     _hashInitialized(false) 
 {
 }
 
-void
-IceInternal::EndpointI::parseOption(const string& option, const string& arg, const string& desc, const string& str)
-{
-    if(option == "-v")
-    {
-        if(arg.empty())
-        {
-            Ice::EndpointParseException ex(__FILE__, __LINE__);
-            ex.str = "no argument provided for -v option in endpoint `" + desc + " " + str + "'";
-            throw ex;
-        }
-
-        try 
-        {
-            const_cast<Ice::ProtocolVersion&>(_protocol) = Ice::stringToProtocolVersion(arg);
-        }
-        catch(const Ice::VersionParseException& e)
-        {
-            Ice::EndpointParseException ex(__FILE__, __LINE__);
-            ex.str = "invalid protocol version `" + arg + "' in endpoint `" + desc + " " + str + "':\n" + e.str;
-            throw ex;
-        }
-    }
-    else if(option == "-e")
-    {
-        if(arg.empty())
-        {
-            Ice::EndpointParseException ex(__FILE__, __LINE__);
-            ex.str = "no argument provided for -e option in endpoint `" + desc + " " + str + "'";
-            throw ex;
-        }
-
-        try 
-        {
-            const_cast<Ice::EncodingVersion&>(_encoding) = Ice::stringToEncodingVersion(arg);
-        }
-        catch(const Ice::VersionParseException& e)
-        {
-            Ice::EndpointParseException ex(__FILE__, __LINE__);
-            ex.str = "invalid encoding version `" + arg + "' in endpoint `" + desc + " " + str + "':\n" + e.str;
-            throw ex;
-        }
-    }
-    else 
-    {
-        Ice::EndpointParseException ex(__FILE__, __LINE__);
-        ex.str = "unknown option `" + option + "' in `" + desc + " " + str + "'";
-        throw ex;
-    }
-}
-
 #ifndef ICE_OS_WINRT
 
 IceInternal::EndpointHostResolver::EndpointHostResolver(const InstancePtr& instance) :
diff --git a/cpp/src/Ice/EndpointI.h b/cpp/src/Ice/EndpointI.h
index 17f079d1c1e..e7e1a208f19 100644
--- a/cpp/src/Ice/EndpointI.h
+++ b/cpp/src/Ice/EndpointI.h
@@ -105,16 +105,6 @@ public:
     virtual bool secure() const = 0;
 
     //
-    // Returns the encoding version supported by this endpoint.
-    //
-    const ::Ice::EncodingVersion& encodingVersion() const;
-
-    //
-    // Returns the encoding version supported by this endpoint.
-    //
-    const ::Ice::ProtocolVersion& protocolVersion() const;
-
-    //
     // Return a server side transceiver for this endpoint, or null if a
     // transceiver can only be created by an acceptor. In case a
     // transceiver is created, this operation also returns a new
@@ -165,15 +155,11 @@ protected:
     virtual std::vector<ConnectorPtr> connectors(const std::vector<Address>&) const;
     friend class EndpointHostResolver;
 
-    EndpointI(const Ice::ProtocolVersion&, const Ice::EncodingVersion&, const std::string&);
+    EndpointI(const std::string&);
     EndpointI();
 
-    void parseOption(const std::string&, const std::string&, const std::string&, const std::string&);
-
     virtual ::Ice::Int hashInit() const = 0;
 
-    const Ice::ProtocolVersion _protocol;
-    const Ice::EncodingVersion _encoding;
     const std::string _connectionId;
 
 private:
diff --git a/cpp/src/Ice/InstrumentationI.h b/cpp/src/Ice/InstrumentationI.h
index d8f9641c76c..035aed387cc 100644
--- a/cpp/src/Ice/InstrumentationI.h
+++ b/cpp/src/Ice/InstrumentationI.h
@@ -24,8 +24,6 @@ void addEndpointAttributes(typename Helper::Attributes& attrs)
     attrs.add("endpointType", &Helper::getEndpointInfo, &Ice::EndpointInfo::type);
     attrs.add("endpointIsDatagram", &Helper::getEndpointInfo, &Ice::EndpointInfo::datagram);
     attrs.add("endpointIsSecure", &Helper::getEndpointInfo, &Ice::EndpointInfo::secure);
-    attrs.add("endpointProtocolVersion", &Helper::getEndpointInfo, &Ice::EndpointInfo::protocol);
-    attrs.add("endpointEncodingVersion", &Helper::getEndpointInfo, &Ice::EndpointInfo::encoding);
     attrs.add("endpointTimeout", &Helper::getEndpointInfo, &Ice::EndpointInfo::timeout);
     attrs.add("endpointCompress", &Helper::getEndpointInfo, &Ice::EndpointInfo::compress);
     
diff --git a/cpp/src/Ice/LocatorInfo.cpp b/cpp/src/Ice/LocatorInfo.cpp
index ac693041b2e..0acf9db3f90 100644
--- a/cpp/src/Ice/LocatorInfo.cpp
+++ b/cpp/src/Ice/LocatorInfo.cpp
@@ -156,16 +156,17 @@ IceInternal::LocatorManager::get(const LocatorPrx& loc)
         // have only one table per locator (not one per locator
         // proxy).
         //
-        map<Identity, LocatorTablePtr>::iterator t = _locatorTables.find(locator->ice_getIdentity());
+        pair<Identity, EncodingVersion> locatorKey(locator->ice_getIdentity(), locator->ice_getEncodingVersion());
+        map<pair<Identity, EncodingVersion>, LocatorTablePtr>::iterator t = _locatorTables.find(locatorKey);
         if(t == _locatorTables.end())
         {
             t = _locatorTables.insert(_locatorTables.begin(),
-                                      pair<const Identity, LocatorTablePtr>(locator->ice_getIdentity(), 
-                                                                            new LocatorTable()));
+                                      pair<const pair<Identity, EncodingVersion>, LocatorTablePtr>(
+                                          locatorKey, new LocatorTable()));
         }
 
-        _tableHint = _table.insert(_tableHint, 
-                                   pair<const LocatorPrx, LocatorInfoPtr>(locator, 
+        _tableHint = _table.insert(_tableHint,
+                                   pair<const LocatorPrx, LocatorInfoPtr>(locator,
                                                                           new LocatorInfo(locator, t->second,
                                                                                           _background)));
     }
@@ -536,15 +537,6 @@ IceInternal::LocatorInfo::operator<(const LocatorInfo& rhs) const
     return _locator < rhs._locator;
 }
 
-LocatorPrx
-IceInternal::LocatorInfo::getLocator() const
-{
-    //
-    // No mutex lock necessary, _locator is immutable.
-    //
-    return _locator;
-}
-
 LocatorRegistryPrx
 IceInternal::LocatorInfo::getLocatorRegistry()
 {
diff --git a/cpp/src/Ice/LocatorInfo.h b/cpp/src/Ice/LocatorInfo.h
index 9a863107e38..15d4ad3075a 100644
--- a/cpp/src/Ice/LocatorInfo.h
+++ b/cpp/src/Ice/LocatorInfo.h
@@ -20,6 +20,7 @@
 #include <Ice/Identity.h>
 #include <Ice/EndpointIF.h>
 #include <Ice/PropertiesF.h>
+#include <Ice/Version.h>
 
 #include <IceUtil/UniquePtr.h>
 
@@ -47,7 +48,7 @@ private:
     std::map<Ice::LocatorPrx, LocatorInfoPtr> _table;
     std::map<Ice::LocatorPrx, LocatorInfoPtr>::iterator _tableHint;
 
-    std::map<Ice::Identity, LocatorTablePtr> _locatorTables;
+    std::map<std::pair<Ice::Identity, Ice::EncodingVersion>, LocatorTablePtr> _locatorTables;
 };
 
 class LocatorTable : public IceUtil::Shared, public IceUtil::Mutex
@@ -143,7 +144,13 @@ public:
     bool operator!=(const LocatorInfo&) const;
     bool operator<(const LocatorInfo&) const;
 
-    Ice::LocatorPrx getLocator() const;
+    const Ice::LocatorPrx& getLocator() const
+    {
+        //
+        // No mutex lock necessary, _locator is immutable.
+        //
+        return _locator;
+    }
     Ice::LocatorRegistryPrx getLocatorRegistry();
 
     std::vector<EndpointIPtr> getEndpoints(const ReferencePtr& ref, int ttl, bool& cached)
diff --git a/cpp/src/Ice/OpaqueEndpointI.cpp b/cpp/src/Ice/OpaqueEndpointI.cpp
index 5b3bedbaedd..10b16984b56 100644
--- a/cpp/src/Ice/OpaqueEndpointI.cpp
+++ b/cpp/src/Ice/OpaqueEndpointI.cpp
@@ -25,7 +25,7 @@ const Ice::EncodingVersion Encoding_0_0 = { 0, 0 };
 }
 
 IceInternal::OpaqueEndpointI::OpaqueEndpointI(const string& str) : 
-    EndpointI(Protocol_0_0, Encoding_0_0, ""),
+    EndpointI(""),
     _rawEncoding(Ice::currentEncoding)
 {
     const string delim = " \t\n\r";
@@ -183,7 +183,7 @@ IceInternal::OpaqueEndpointI::OpaqueEndpointI(const string& str) :
 }
 
 IceInternal::OpaqueEndpointI::OpaqueEndpointI(Short type, BasicStream* s) :
-    EndpointI(Protocol_0_0, Encoding_0_0, ""),
+    EndpointI(""),
     _type(type)
 {
     _rawEncoding = s->startReadEncaps();
@@ -247,7 +247,7 @@ private:
 // COMPILERFIX: inlining this constructor causes crashes with gcc 4.0.1.
 //
 InfoI::InfoI(Ice::Short type, const Ice::EncodingVersion& rawEncoding, const Ice::ByteSeq& rawBytes) : 
-    Ice::OpaqueEndpointInfo(Protocol_0_0, Encoding_0_0, -1, false, rawEncoding, rawBytes), 
+    Ice::OpaqueEndpointInfo(-1, false, rawEncoding, rawBytes), 
     _type(type)
 {
 }
diff --git a/cpp/src/Ice/Outgoing.cpp b/cpp/src/Ice/Outgoing.cpp
index c46b95bad14..85e15a53509 100644
--- a/cpp/src/Ice/Outgoing.cpp
+++ b/cpp/src/Ice/Outgoing.cpp
@@ -92,6 +92,8 @@ IceInternal::Outgoing::Outgoing(RequestHandler* handler, const string& operation
     _os(handler->getReference()->getInstance().get(), Ice::currentProtocolEncoding),
     _sent(false)
 { 
+    checkSupportedProtocol(handler->getReference()->getProtocol());
+
     switch(_handler->getReference()->getMode())
     {
         case Reference::ModeTwoway:
@@ -561,6 +563,7 @@ IceInternal::BatchOutgoing::BatchOutgoing(RequestHandler* handler, InvocationObs
     _os(handler->getReference()->getInstance().get(), Ice::currentProtocolEncoding),
     _observer(observer)
 {
+    checkSupportedProtocol(handler->getReference()->getProtocol());
 }
 
 IceInternal::BatchOutgoing::BatchOutgoing(ConnectionI* connection, Instance* instance, InvocationObserver& observer) :
diff --git a/cpp/src/Ice/OutgoingAsync.cpp b/cpp/src/Ice/OutgoingAsync.cpp
index 5dd2238944f..33ac9dee0f5 100644
--- a/cpp/src/Ice/OutgoingAsync.cpp
+++ b/cpp/src/Ice/OutgoingAsync.cpp
@@ -438,6 +438,8 @@ IceInternal::OutgoingAsync::__prepare(const std::string& operation, OperationMod
     _mode = mode;
     _sentSynchronously = false;
 
+    checkSupportedProtocol(_proxy->__reference()->getProtocol());
+
     _observer.attach(_proxy.get(), operation, context);
 
     //
@@ -935,6 +937,8 @@ IceInternal::ProxyBatchOutgoingAsync::ProxyBatchOutgoingAsync(const Ice::ObjectP
 void
 IceInternal::ProxyBatchOutgoingAsync::__send()
 {
+    checkSupportedProtocol(_proxy->__reference()->getProtocol());
+
     //
     // We don't automatically retry if ice_flushBatchRequests fails. Otherwise, if some batch
     // requests were queued with the connection, they would be lost without being noticed.
diff --git a/cpp/src/Ice/PropertyNames.cpp b/cpp/src/Ice/PropertyNames.cpp
index e9e05239474..62d94b80fa7 100644
--- a/cpp/src/Ice/PropertyNames.cpp
+++ b/cpp/src/Ice/PropertyNames.cpp
@@ -8,7 +8,7 @@
 // **********************************************************************
 
 //
-// Generated by makeprops.py from file ../config/PropertyNames.xml, Mon Oct 22 18:48:40 2012
+// Generated by makeprops.py from file ./config/PropertyNames.xml, Mon Nov 12 21:17:34 2012
 
 // IMPORTANT: Do not edit this file -- any edits made here will be lost!
 
@@ -27,7 +27,6 @@ const IceInternal::Property IcePropsData[] =
     IceInternal::Property("Ice.Admin.Locator.LocatorCacheTimeout", false, 0),
     IceInternal::Property("Ice.Admin.Locator.Locator", false, 0),
     IceInternal::Property("Ice.Admin.Locator.Router", false, 0),
-    IceInternal::Property("Ice.Admin.Locator.EncodingVersion", false, 0),
     IceInternal::Property("Ice.Admin.Locator.CollocationOptimized", false, 0),
     IceInternal::Property("Ice.Admin.Locator", false, 0),
     IceInternal::Property("Ice.Admin.PublishedEndpoints", false, 0),
@@ -38,7 +37,6 @@ const IceInternal::Property IcePropsData[] =
     IceInternal::Property("Ice.Admin.Router.LocatorCacheTimeout", false, 0),
     IceInternal::Property("Ice.Admin.Router.Locator", false, 0),
     IceInternal::Property("Ice.Admin.Router.Router", false, 0),
-    IceInternal::Property("Ice.Admin.Router.EncodingVersion", false, 0),
     IceInternal::Property("Ice.Admin.Router.CollocationOptimized", false, 0),
     IceInternal::Property("Ice.Admin.Router", false, 0),
     IceInternal::Property("Ice.Admin.ProxyOptions", false, 0),
@@ -69,7 +67,6 @@ const IceInternal::Property IcePropsData[] =
     IceInternal::Property("Ice.Default.Locator.LocatorCacheTimeout", false, 0),
     IceInternal::Property("Ice.Default.Locator.Locator", false, 0),
     IceInternal::Property("Ice.Default.Locator.Router", false, 0),
-    IceInternal::Property("Ice.Default.Locator.EncodingVersion", false, 0),
     IceInternal::Property("Ice.Default.Locator.CollocationOptimized", false, 0),
     IceInternal::Property("Ice.Default.Locator", false, 0),
     IceInternal::Property("Ice.Default.LocatorCacheTimeout", false, 0),
@@ -82,7 +79,6 @@ const IceInternal::Property IcePropsData[] =
     IceInternal::Property("Ice.Default.Router.LocatorCacheTimeout", false, 0),
     IceInternal::Property("Ice.Default.Router.Locator", false, 0),
     IceInternal::Property("Ice.Default.Router.Router", false, 0),
-    IceInternal::Property("Ice.Default.Router.EncodingVersion", false, 0),
     IceInternal::Property("Ice.Default.Router.CollocationOptimized", false, 0),
     IceInternal::Property("Ice.Default.Router", false, 0),
     IceInternal::Property("Ice.Default.SlicedFormat", false, 0),
@@ -188,7 +184,6 @@ const IceInternal::Property IceBoxPropsData[] =
     IceInternal::Property("IceBox.ServiceManager.Locator.LocatorCacheTimeout", false, 0),
     IceInternal::Property("IceBox.ServiceManager.Locator.Locator", false, 0),
     IceInternal::Property("IceBox.ServiceManager.Locator.Router", false, 0),
-    IceInternal::Property("IceBox.ServiceManager.Locator.EncodingVersion", false, 0),
     IceInternal::Property("IceBox.ServiceManager.Locator.CollocationOptimized", false, 0),
     IceInternal::Property("IceBox.ServiceManager.Locator", false, 0),
     IceInternal::Property("IceBox.ServiceManager.PublishedEndpoints", false, 0),
@@ -199,7 +194,6 @@ const IceInternal::Property IceBoxPropsData[] =
     IceInternal::Property("IceBox.ServiceManager.Router.LocatorCacheTimeout", false, 0),
     IceInternal::Property("IceBox.ServiceManager.Router.Locator", false, 0),
     IceInternal::Property("IceBox.ServiceManager.Router.Router", false, 0),
-    IceInternal::Property("IceBox.ServiceManager.Router.EncodingVersion", false, 0),
     IceInternal::Property("IceBox.ServiceManager.Router.CollocationOptimized", false, 0),
     IceInternal::Property("IceBox.ServiceManager.Router", false, 0),
     IceInternal::Property("IceBox.ServiceManager.ProxyOptions", false, 0),
@@ -226,7 +220,6 @@ const IceInternal::Property IceBoxAdminPropsData[] =
     IceInternal::Property("IceBoxAdmin.ServiceManager.Proxy.LocatorCacheTimeout", false, 0),
     IceInternal::Property("IceBoxAdmin.ServiceManager.Proxy.Locator", false, 0),
     IceInternal::Property("IceBoxAdmin.ServiceManager.Proxy.Router", false, 0),
-    IceInternal::Property("IceBoxAdmin.ServiceManager.Proxy.EncodingVersion", false, 0),
     IceInternal::Property("IceBoxAdmin.ServiceManager.Proxy.CollocationOptimized", false, 0),
     IceInternal::Property("IceBoxAdmin.ServiceManager.Proxy", false, 0),
 };
@@ -261,7 +254,6 @@ const IceInternal::Property IceGridPropsData[] =
     IceInternal::Property("IceGrid.Node.Locator.LocatorCacheTimeout", false, 0),
     IceInternal::Property("IceGrid.Node.Locator.Locator", false, 0),
     IceInternal::Property("IceGrid.Node.Locator.Router", false, 0),
-    IceInternal::Property("IceGrid.Node.Locator.EncodingVersion", false, 0),
     IceInternal::Property("IceGrid.Node.Locator.CollocationOptimized", false, 0),
     IceInternal::Property("IceGrid.Node.Locator", false, 0),
     IceInternal::Property("IceGrid.Node.PublishedEndpoints", false, 0),
@@ -272,7 +264,6 @@ const IceInternal::Property IceGridPropsData[] =
     IceInternal::Property("IceGrid.Node.Router.LocatorCacheTimeout", false, 0),
     IceInternal::Property("IceGrid.Node.Router.Locator", false, 0),
     IceInternal::Property("IceGrid.Node.Router.Router", false, 0),
-    IceInternal::Property("IceGrid.Node.Router.EncodingVersion", false, 0),
     IceInternal::Property("IceGrid.Node.Router.CollocationOptimized", false, 0),
     IceInternal::Property("IceGrid.Node.Router", false, 0),
     IceInternal::Property("IceGrid.Node.ProxyOptions", false, 0),
@@ -306,7 +297,6 @@ const IceInternal::Property IceGridPropsData[] =
     IceInternal::Property("IceGrid.Node.UserAccountMapper.LocatorCacheTimeout", false, 0),
     IceInternal::Property("IceGrid.Node.UserAccountMapper.Locator", false, 0),
     IceInternal::Property("IceGrid.Node.UserAccountMapper.Router", false, 0),
-    IceInternal::Property("IceGrid.Node.UserAccountMapper.EncodingVersion", false, 0),
     IceInternal::Property("IceGrid.Node.UserAccountMapper.CollocationOptimized", false, 0),
     IceInternal::Property("IceGrid.Node.UserAccountMapper", false, 0),
     IceInternal::Property("IceGrid.Node.WaitTime", false, 0),
@@ -317,7 +307,6 @@ const IceInternal::Property IceGridPropsData[] =
     IceInternal::Property("IceGrid.Registry.AdminPermissionsVerifier.LocatorCacheTimeout", false, 0),
     IceInternal::Property("IceGrid.Registry.AdminPermissionsVerifier.Locator", false, 0),
     IceInternal::Property("IceGrid.Registry.AdminPermissionsVerifier.Router", false, 0),
-    IceInternal::Property("IceGrid.Registry.AdminPermissionsVerifier.EncodingVersion", false, 0),
     IceInternal::Property("IceGrid.Registry.AdminPermissionsVerifier.CollocationOptimized", false, 0),
     IceInternal::Property("IceGrid.Registry.AdminPermissionsVerifier", false, 0),
     IceInternal::Property("IceGrid.Registry.AdminSessionFilters", false, 0),
@@ -330,7 +319,6 @@ const IceInternal::Property IceGridPropsData[] =
     IceInternal::Property("IceGrid.Registry.AdminSessionManager.Locator.LocatorCacheTimeout", false, 0),
     IceInternal::Property("IceGrid.Registry.AdminSessionManager.Locator.Locator", false, 0),
     IceInternal::Property("IceGrid.Registry.AdminSessionManager.Locator.Router", false, 0),
-    IceInternal::Property("IceGrid.Registry.AdminSessionManager.Locator.EncodingVersion", false, 0),
     IceInternal::Property("IceGrid.Registry.AdminSessionManager.Locator.CollocationOptimized", false, 0),
     IceInternal::Property("IceGrid.Registry.AdminSessionManager.Locator", false, 0),
     IceInternal::Property("IceGrid.Registry.AdminSessionManager.PublishedEndpoints", false, 0),
@@ -341,7 +329,6 @@ const IceInternal::Property IceGridPropsData[] =
     IceInternal::Property("IceGrid.Registry.AdminSessionManager.Router.LocatorCacheTimeout", false, 0),
     IceInternal::Property("IceGrid.Registry.AdminSessionManager.Router.Locator", false, 0),
     IceInternal::Property("IceGrid.Registry.AdminSessionManager.Router.Router", false, 0),
-    IceInternal::Property("IceGrid.Registry.AdminSessionManager.Router.EncodingVersion", false, 0),
     IceInternal::Property("IceGrid.Registry.AdminSessionManager.Router.CollocationOptimized", false, 0),
     IceInternal::Property("IceGrid.Registry.AdminSessionManager.Router", false, 0),
     IceInternal::Property("IceGrid.Registry.AdminSessionManager.ProxyOptions", false, 0),
@@ -358,7 +345,6 @@ const IceInternal::Property IceGridPropsData[] =
     IceInternal::Property("IceGrid.Registry.AdminSSLPermissionsVerifier.LocatorCacheTimeout", false, 0),
     IceInternal::Property("IceGrid.Registry.AdminSSLPermissionsVerifier.Locator", false, 0),
     IceInternal::Property("IceGrid.Registry.AdminSSLPermissionsVerifier.Router", false, 0),
-    IceInternal::Property("IceGrid.Registry.AdminSSLPermissionsVerifier.EncodingVersion", false, 0),
     IceInternal::Property("IceGrid.Registry.AdminSSLPermissionsVerifier.CollocationOptimized", false, 0),
     IceInternal::Property("IceGrid.Registry.AdminSSLPermissionsVerifier", false, 0),
     IceInternal::Property("IceGrid.Registry.Client.ACM", false, 0),
@@ -370,7 +356,6 @@ const IceInternal::Property IceGridPropsData[] =
     IceInternal::Property("IceGrid.Registry.Client.Locator.LocatorCacheTimeout", false, 0),
     IceInternal::Property("IceGrid.Registry.Client.Locator.Locator", false, 0),
     IceInternal::Property("IceGrid.Registry.Client.Locator.Router", false, 0),
-    IceInternal::Property("IceGrid.Registry.Client.Locator.EncodingVersion", false, 0),
     IceInternal::Property("IceGrid.Registry.Client.Locator.CollocationOptimized", false, 0),
     IceInternal::Property("IceGrid.Registry.Client.Locator", false, 0),
     IceInternal::Property("IceGrid.Registry.Client.PublishedEndpoints", false, 0),
@@ -381,7 +366,6 @@ const IceInternal::Property IceGridPropsData[] =
     IceInternal::Property("IceGrid.Registry.Client.Router.LocatorCacheTimeout", false, 0),
     IceInternal::Property("IceGrid.Registry.Client.Router.Locator", false, 0),
     IceInternal::Property("IceGrid.Registry.Client.Router.Router", false, 0),
-    IceInternal::Property("IceGrid.Registry.Client.Router.EncodingVersion", false, 0),
     IceInternal::Property("IceGrid.Registry.Client.Router.CollocationOptimized", false, 0),
     IceInternal::Property("IceGrid.Registry.Client.Router", false, 0),
     IceInternal::Property("IceGrid.Registry.Client.ProxyOptions", false, 0),
@@ -405,7 +389,6 @@ const IceInternal::Property IceGridPropsData[] =
     IceInternal::Property("IceGrid.Registry.Internal.Locator.LocatorCacheTimeout", false, 0),
     IceInternal::Property("IceGrid.Registry.Internal.Locator.Locator", false, 0),
     IceInternal::Property("IceGrid.Registry.Internal.Locator.Router", false, 0),
-    IceInternal::Property("IceGrid.Registry.Internal.Locator.EncodingVersion", false, 0),
     IceInternal::Property("IceGrid.Registry.Internal.Locator.CollocationOptimized", false, 0),
     IceInternal::Property("IceGrid.Registry.Internal.Locator", false, 0),
     IceInternal::Property("IceGrid.Registry.Internal.PublishedEndpoints", false, 0),
@@ -416,7 +399,6 @@ const IceInternal::Property IceGridPropsData[] =
     IceInternal::Property("IceGrid.Registry.Internal.Router.LocatorCacheTimeout", false, 0),
     IceInternal::Property("IceGrid.Registry.Internal.Router.Locator", false, 0),
     IceInternal::Property("IceGrid.Registry.Internal.Router.Router", false, 0),
-    IceInternal::Property("IceGrid.Registry.Internal.Router.EncodingVersion", false, 0),
     IceInternal::Property("IceGrid.Registry.Internal.Router.CollocationOptimized", false, 0),
     IceInternal::Property("IceGrid.Registry.Internal.Router", false, 0),
     IceInternal::Property("IceGrid.Registry.Internal.ProxyOptions", false, 0),
@@ -434,7 +416,6 @@ const IceInternal::Property IceGridPropsData[] =
     IceInternal::Property("IceGrid.Registry.PermissionsVerifier.LocatorCacheTimeout", false, 0),
     IceInternal::Property("IceGrid.Registry.PermissionsVerifier.Locator", false, 0),
     IceInternal::Property("IceGrid.Registry.PermissionsVerifier.Router", false, 0),
-    IceInternal::Property("IceGrid.Registry.PermissionsVerifier.EncodingVersion", false, 0),
     IceInternal::Property("IceGrid.Registry.PermissionsVerifier.CollocationOptimized", false, 0),
     IceInternal::Property("IceGrid.Registry.PermissionsVerifier", false, 0),
     IceInternal::Property("IceGrid.Registry.ReplicaName", false, 0),
@@ -450,7 +431,6 @@ const IceInternal::Property IceGridPropsData[] =
     IceInternal::Property("IceGrid.Registry.Server.Locator.LocatorCacheTimeout", false, 0),
     IceInternal::Property("IceGrid.Registry.Server.Locator.Locator", false, 0),
     IceInternal::Property("IceGrid.Registry.Server.Locator.Router", false, 0),
-    IceInternal::Property("IceGrid.Registry.Server.Locator.EncodingVersion", false, 0),
     IceInternal::Property("IceGrid.Registry.Server.Locator.CollocationOptimized", false, 0),
     IceInternal::Property("IceGrid.Registry.Server.Locator", false, 0),
     IceInternal::Property("IceGrid.Registry.Server.PublishedEndpoints", false, 0),
@@ -461,7 +441,6 @@ const IceInternal::Property IceGridPropsData[] =
     IceInternal::Property("IceGrid.Registry.Server.Router.LocatorCacheTimeout", false, 0),
     IceInternal::Property("IceGrid.Registry.Server.Router.Locator", false, 0),
     IceInternal::Property("IceGrid.Registry.Server.Router.Router", false, 0),
-    IceInternal::Property("IceGrid.Registry.Server.Router.EncodingVersion", false, 0),
     IceInternal::Property("IceGrid.Registry.Server.Router.CollocationOptimized", false, 0),
     IceInternal::Property("IceGrid.Registry.Server.Router", false, 0),
     IceInternal::Property("IceGrid.Registry.Server.ProxyOptions", false, 0),
@@ -482,7 +461,6 @@ const IceInternal::Property IceGridPropsData[] =
     IceInternal::Property("IceGrid.Registry.SessionManager.Locator.LocatorCacheTimeout", false, 0),
     IceInternal::Property("IceGrid.Registry.SessionManager.Locator.Locator", false, 0),
     IceInternal::Property("IceGrid.Registry.SessionManager.Locator.Router", false, 0),
-    IceInternal::Property("IceGrid.Registry.SessionManager.Locator.EncodingVersion", false, 0),
     IceInternal::Property("IceGrid.Registry.SessionManager.Locator.CollocationOptimized", false, 0),
     IceInternal::Property("IceGrid.Registry.SessionManager.Locator", false, 0),
     IceInternal::Property("IceGrid.Registry.SessionManager.PublishedEndpoints", false, 0),
@@ -493,7 +471,6 @@ const IceInternal::Property IceGridPropsData[] =
     IceInternal::Property("IceGrid.Registry.SessionManager.Router.LocatorCacheTimeout", false, 0),
     IceInternal::Property("IceGrid.Registry.SessionManager.Router.Locator", false, 0),
     IceInternal::Property("IceGrid.Registry.SessionManager.Router.Router", false, 0),
-    IceInternal::Property("IceGrid.Registry.SessionManager.Router.EncodingVersion", false, 0),
     IceInternal::Property("IceGrid.Registry.SessionManager.Router.CollocationOptimized", false, 0),
     IceInternal::Property("IceGrid.Registry.SessionManager.Router", false, 0),
     IceInternal::Property("IceGrid.Registry.SessionManager.ProxyOptions", false, 0),
@@ -511,7 +488,6 @@ const IceInternal::Property IceGridPropsData[] =
     IceInternal::Property("IceGrid.Registry.SSLPermissionsVerifier.LocatorCacheTimeout", false, 0),
     IceInternal::Property("IceGrid.Registry.SSLPermissionsVerifier.Locator", false, 0),
     IceInternal::Property("IceGrid.Registry.SSLPermissionsVerifier.Router", false, 0),
-    IceInternal::Property("IceGrid.Registry.SSLPermissionsVerifier.EncodingVersion", false, 0),
     IceInternal::Property("IceGrid.Registry.SSLPermissionsVerifier.CollocationOptimized", false, 0),
     IceInternal::Property("IceGrid.Registry.SSLPermissionsVerifier", false, 0),
     IceInternal::Property("IceGrid.Registry.Trace.Application", false, 0),
@@ -551,7 +527,6 @@ const IceInternal::Property IcePatch2PropsData[] =
     IceInternal::Property("IcePatch2.Locator.LocatorCacheTimeout", false, 0),
     IceInternal::Property("IcePatch2.Locator.Locator", false, 0),
     IceInternal::Property("IcePatch2.Locator.Router", false, 0),
-    IceInternal::Property("IcePatch2.Locator.EncodingVersion", false, 0),
     IceInternal::Property("IcePatch2.Locator.CollocationOptimized", false, 0),
     IceInternal::Property("IcePatch2.Locator", false, 0),
     IceInternal::Property("IcePatch2.PublishedEndpoints", false, 0),
@@ -562,7 +537,6 @@ const IceInternal::Property IcePatch2PropsData[] =
     IceInternal::Property("IcePatch2.Router.LocatorCacheTimeout", false, 0),
     IceInternal::Property("IcePatch2.Router.Locator", false, 0),
     IceInternal::Property("IcePatch2.Router.Router", false, 0),
-    IceInternal::Property("IcePatch2.Router.EncodingVersion", false, 0),
     IceInternal::Property("IcePatch2.Router.CollocationOptimized", false, 0),
     IceInternal::Property("IcePatch2.Router", false, 0),
     IceInternal::Property("IcePatch2.ProxyOptions", false, 0),
@@ -658,7 +632,6 @@ const IceInternal::Property Glacier2PropsData[] =
     IceInternal::Property("Glacier2.Client.Locator.LocatorCacheTimeout", false, 0),
     IceInternal::Property("Glacier2.Client.Locator.Locator", false, 0),
     IceInternal::Property("Glacier2.Client.Locator.Router", false, 0),
-    IceInternal::Property("Glacier2.Client.Locator.EncodingVersion", false, 0),
     IceInternal::Property("Glacier2.Client.Locator.CollocationOptimized", false, 0),
     IceInternal::Property("Glacier2.Client.Locator", false, 0),
     IceInternal::Property("Glacier2.Client.PublishedEndpoints", false, 0),
@@ -669,7 +642,6 @@ const IceInternal::Property Glacier2PropsData[] =
     IceInternal::Property("Glacier2.Client.Router.LocatorCacheTimeout", false, 0),
     IceInternal::Property("Glacier2.Client.Router.Locator", false, 0),
     IceInternal::Property("Glacier2.Client.Router.Router", false, 0),
-    IceInternal::Property("Glacier2.Client.Router.EncodingVersion", false, 0),
     IceInternal::Property("Glacier2.Client.Router.CollocationOptimized", false, 0),
     IceInternal::Property("Glacier2.Client.Router", false, 0),
     IceInternal::Property("Glacier2.Client.ProxyOptions", false, 0),
@@ -702,7 +674,6 @@ const IceInternal::Property Glacier2PropsData[] =
     IceInternal::Property("Glacier2.PermissionsVerifier.LocatorCacheTimeout", false, 0),
     IceInternal::Property("Glacier2.PermissionsVerifier.Locator", false, 0),
     IceInternal::Property("Glacier2.PermissionsVerifier.Router", false, 0),
-    IceInternal::Property("Glacier2.PermissionsVerifier.EncodingVersion", false, 0),
     IceInternal::Property("Glacier2.PermissionsVerifier.CollocationOptimized", false, 0),
     IceInternal::Property("Glacier2.PermissionsVerifier", false, 0),
     IceInternal::Property("Glacier2.ReturnClientProxy", false, 0),
@@ -712,7 +683,6 @@ const IceInternal::Property Glacier2PropsData[] =
     IceInternal::Property("Glacier2.SSLPermissionsVerifier.LocatorCacheTimeout", false, 0),
     IceInternal::Property("Glacier2.SSLPermissionsVerifier.Locator", false, 0),
     IceInternal::Property("Glacier2.SSLPermissionsVerifier.Router", false, 0),
-    IceInternal::Property("Glacier2.SSLPermissionsVerifier.EncodingVersion", false, 0),
     IceInternal::Property("Glacier2.SSLPermissionsVerifier.CollocationOptimized", false, 0),
     IceInternal::Property("Glacier2.SSLPermissionsVerifier", false, 0),
     IceInternal::Property("Glacier2.RoutingTable.MaxSize", false, 0),
@@ -725,7 +695,6 @@ const IceInternal::Property Glacier2PropsData[] =
     IceInternal::Property("Glacier2.Server.Locator.LocatorCacheTimeout", false, 0),
     IceInternal::Property("Glacier2.Server.Locator.Locator", false, 0),
     IceInternal::Property("Glacier2.Server.Locator.Router", false, 0),
-    IceInternal::Property("Glacier2.Server.Locator.EncodingVersion", false, 0),
     IceInternal::Property("Glacier2.Server.Locator.CollocationOptimized", false, 0),
     IceInternal::Property("Glacier2.Server.Locator", false, 0),
     IceInternal::Property("Glacier2.Server.PublishedEndpoints", false, 0),
@@ -736,7 +705,6 @@ const IceInternal::Property Glacier2PropsData[] =
     IceInternal::Property("Glacier2.Server.Router.LocatorCacheTimeout", false, 0),
     IceInternal::Property("Glacier2.Server.Router.Locator", false, 0),
     IceInternal::Property("Glacier2.Server.Router.Router", false, 0),
-    IceInternal::Property("Glacier2.Server.Router.EncodingVersion", false, 0),
     IceInternal::Property("Glacier2.Server.Router.CollocationOptimized", false, 0),
     IceInternal::Property("Glacier2.Server.Router", false, 0),
     IceInternal::Property("Glacier2.Server.ProxyOptions", false, 0),
@@ -759,7 +727,6 @@ const IceInternal::Property Glacier2PropsData[] =
     IceInternal::Property("Glacier2.SessionManager.LocatorCacheTimeout", false, 0),
     IceInternal::Property("Glacier2.SessionManager.Locator", false, 0),
     IceInternal::Property("Glacier2.SessionManager.Router", false, 0),
-    IceInternal::Property("Glacier2.SessionManager.EncodingVersion", false, 0),
     IceInternal::Property("Glacier2.SessionManager.CollocationOptimized", false, 0),
     IceInternal::Property("Glacier2.SessionManager", false, 0),
     IceInternal::Property("Glacier2.SSLSessionManager.EndpointSelection", false, 0),
@@ -768,7 +735,6 @@ const IceInternal::Property Glacier2PropsData[] =
     IceInternal::Property("Glacier2.SSLSessionManager.LocatorCacheTimeout", false, 0),
     IceInternal::Property("Glacier2.SSLSessionManager.Locator", false, 0),
     IceInternal::Property("Glacier2.SSLSessionManager.Router", false, 0),
-    IceInternal::Property("Glacier2.SSLSessionManager.EncodingVersion", false, 0),
     IceInternal::Property("Glacier2.SSLSessionManager.CollocationOptimized", false, 0),
     IceInternal::Property("Glacier2.SSLSessionManager", false, 0),
     IceInternal::Property("Glacier2.SessionTimeout", false, 0),
diff --git a/cpp/src/Ice/PropertyNames.h b/cpp/src/Ice/PropertyNames.h
index f8f09b5a81c..f460865f279 100644
--- a/cpp/src/Ice/PropertyNames.h
+++ b/cpp/src/Ice/PropertyNames.h
@@ -8,7 +8,7 @@
 // **********************************************************************
 
 //
-// Generated by makeprops.py from file ../config/PropertyNames.xml, Mon Oct 22 18:48:40 2012
+// Generated by makeprops.py from file ./config/PropertyNames.xml, Mon Nov 12 21:17:34 2012
 
 // IMPORTANT: Do not edit this file -- any edits made here will be lost!
 
@@ -27,9 +27,9 @@ struct Property
     const char* deprecatedBy;
 
     Property(const char* n, bool d, const char* b) :
-        pattern(n),
-        deprecated(d),
-        deprecatedBy(b)
+	pattern(n),
+	deprecated(d),
+	deprecatedBy(b)
     {
     }
 
diff --git a/cpp/src/Ice/Proxy.cpp b/cpp/src/Ice/Proxy.cpp
index 8f519f5ca55..7b5b6781867 100644
--- a/cpp/src/Ice/Proxy.cpp
+++ b/cpp/src/Ice/Proxy.cpp
@@ -870,7 +870,6 @@ IceProxy::Ice::Object::ice_encodingVersion(const ::Ice::EncodingVersion& encodin
     }
     else
     {
-        checkSupportedEncoding(encoding);
         ObjectPrx proxy = __newInstance();
         proxy->setup(_reference->changeEncoding(encoding));
         return proxy;
diff --git a/cpp/src/Ice/Reference.cpp b/cpp/src/Ice/Reference.cpp
index dadbdf8af0d..a3d9f9478ca 100644
--- a/cpp/src/Ice/Reference.cpp
+++ b/cpp/src/Ice/Reference.cpp
@@ -143,7 +143,7 @@ IceInternal::Reference::changeEncoding(const Ice::EncodingVersion& encoding) con
     r->_encoding = encoding;
     return r;
 }
-
+ 
 ReferencePtr
 IceInternal::Reference::changeCompress(bool newCompress) const
 {
@@ -193,6 +193,12 @@ IceInternal::Reference::streamWrite(BasicStream* s) const
 
     s->write(_secure);
 
+    if(s->getWriteEncoding() != Ice::Encoding_1_0)
+    {
+        s->write(_protocol);
+        s->write(_encoding);
+    }
+
     // Derived class writes the remainder of the reference.
 }
 
@@ -282,6 +288,16 @@ IceInternal::Reference::toString() const
         s << " -s";
     }
 
+    if(_protocol != Ice::Protocol_1_0)
+    {
+        s << " -p " << _protocol;
+    }
+
+    if(_encoding != Ice::Encoding_1_0)
+    {
+        s << " -e " << _encoding;
+    }
+
     return s.str();
 
     // Derived class writes the remainder of the string.
@@ -324,7 +340,12 @@ IceInternal::Reference::operator==(const Reference& r) const
         return false;
     }
 
-    if(_encoding != r._encoding)
+    if(_protocol != r._protocol)
+    {
+        return false;
+    }
+
+    if(_encoding != r._encoding) 
     {
         return false;
     }
@@ -410,11 +431,20 @@ IceInternal::Reference::operator<(const Reference& r) const
         return false;
     }
 
-    if(_encoding < r._encoding)
+    if(_protocol < r._protocol)
     {
         return true;
-    } 
-    else if(r._encoding > _encoding)
+    }
+    else if(r._protocol < _protocol) 
+    {
+        return false;
+    }
+
+    if(_encoding < r._encoding) 
+    {
+        return true;
+    }
+    else if(r._encoding < _encoding) 
     {
         return false;
     }
@@ -450,6 +480,7 @@ IceInternal::Reference::Reference(const InstancePtr& instance,
                                   const string& facet, 
                                   Mode mode,
                                   bool secure,
+                                  const ProtocolVersion& protocol,
                                   const EncodingVersion& encoding) :
     _hashInitialized(false),
     _instance(instance),
@@ -459,6 +490,7 @@ IceInternal::Reference::Reference(const InstancePtr& instance,
     _identity(id),
     _context(new SharedContext),
     _facet(facet),
+    _protocol(protocol),
     _encoding(encoding),
     _overrideCompress(false),
     _compress(false)
@@ -474,6 +506,7 @@ IceInternal::Reference::Reference(const Reference& r) :
     _identity(r._identity),
     _context(r._context),
     _facet(r._facet),
+    _protocol(r._protocol),
     _encoding(r._encoding),
     _overrideCompress(r._overrideCompress),
     _compress(r._compress)
@@ -495,6 +528,8 @@ IceInternal::Reference::hashInit() const
     {
         hashAdd(h, _compress);
     }
+    hashAdd(h, _protocol.major);
+    hashAdd(h, _protocol.minor);
     hashAdd(h, _encoding.major);
     hashAdd(h, _encoding.minor);
     return h;
@@ -510,7 +545,7 @@ IceInternal::FixedReference::FixedReference(const InstancePtr& instance,
                                             bool secure,
                                             const EncodingVersion& encoding,
                                             const ConnectionIPtr& fixedConnection) :
-    Reference(instance, communicator, id, facet, mode, secure, encoding),
+    Reference(instance, communicator, id, facet, mode, secure, Ice::Protocol_1_0, encoding),
     _fixedConnection(fixedConnection)
 {
 }
@@ -820,7 +855,8 @@ IceInternal::RoutableReference::RoutableReference(const InstancePtr& instance,
                                                   const string& facet,
                                                   Mode mode, 
                                                   bool secure, 
-                                                  const EncodingVersion& version,
+                                                  const ProtocolVersion& protocol,
+                                                  const EncodingVersion& encoding,
                                                   const vector<EndpointIPtr>& endpoints,
                                                   const string& adapterId,
                                                   const LocatorInfoPtr& locatorInfo,
@@ -830,7 +866,7 @@ IceInternal::RoutableReference::RoutableReference(const InstancePtr& instance,
                                                   bool preferSecure, 
                                                   EndpointSelectionType endpointSelection,
                                                   int locatorCacheTimeout) :
-    Reference(instance, communicator, id, facet, mode, secure, version),
+    Reference(instance, communicator, id, facet, mode, secure, protocol, encoding),
     _endpoints(endpoints),
     _adapterId(adapterId),
     _locatorInfo(locatorInfo),
@@ -907,6 +943,21 @@ IceInternal::RoutableReference::getConnectionId() const
 }
 
 ReferencePtr
+IceInternal::RoutableReference::changeEncoding(const Ice::EncodingVersion& encoding) const
+{
+    ReferencePtr r = Reference::changeEncoding(encoding);
+    if(r.get() != const_cast<RoutableReference*>(this))
+    {
+        LocatorInfoPtr& locInfo = RoutableReferencePtr::dynamicCast(r)->_locatorInfo;
+        if(locInfo && locInfo->getLocator()->ice_getEncodingVersion() != encoding)
+        {
+            locInfo = getInstance()->locatorManager()->get(locInfo->getLocator()->ice_encodingVersion(encoding));
+        }
+    }
+    return r;
+}
+
+ReferencePtr
 IceInternal::RoutableReference::changeCompress(bool newCompress) const
 {
     ReferencePtr r = Reference::changeCompress(newCompress);
@@ -1175,7 +1226,6 @@ IceInternal::RoutableReference::toProperty(const string& prefix) const
     properties[prefix + ".ConnectionCached"] = _cacheConnection ? "1" : "0";
     properties[prefix + ".PreferSecure"] = _preferSecure ? "1" : "0";
     properties[prefix + ".EndpointSelection"] = _endpointSelection == Random ? "Random" : "Ordered";
-    properties[prefix + ".EncodingVersion"] = versionToString(getEncoding());
 
     ostringstream s;
     s << _locatorCacheTimeout;
@@ -1888,20 +1938,14 @@ IceInternal::RoutableReference::RoutableReference(const RoutableReference& r) :
 namespace
 {
 
-struct EndpointIsIncompatible : public unary_function<EndpointIPtr, bool>
+struct EndpointIsOpaque : public unary_function<EndpointIPtr, bool>
 {
-    const Reference* _reference;
-
-    EndpointIsIncompatible(const Reference* reference) : _reference(reference)
-    {
-    }
+public:
 
     bool
-    operator()(const EndpointIPtr& p) const
+    operator()(EndpointIPtr p) const
     {
-        // If the enpoint doesn't support the proxy encoding or protocol, it's incompatible.
-        return !(isSupported(_reference->getEncoding(), p->encodingVersion()) && 
-                 isSupported(currentProtocol, p->protocolVersion()));
+        return dynamic_cast<OpaqueEndpointI*>(p.get()) != 0;
     }
 };
 
@@ -1913,10 +1957,9 @@ IceInternal::RoutableReference::filterEndpoints(const vector<EndpointIPtr>& allE
     vector<EndpointIPtr> endpoints = allEndpoints;
 
     //
-    // Filter out incompatible endpoints (whose encoding/protocol
-    // versions aren't supported by this runtime, or are opaque).
+    // Filter out unknown endpoints.
     //
-    endpoints.erase(remove_if(endpoints.begin(), endpoints.end(), EndpointIsIncompatible(this)), endpoints.end());
+    endpoints.erase(remove_if(endpoints.begin(), endpoints.end(), EndpointIsOpaque()), endpoints.end());
 
     //
     // Filter out endpoints according to the mode of the reference.
diff --git a/cpp/src/Ice/Reference.h b/cpp/src/Ice/Reference.h
index 4fad67eab08..ceff28a7c01 100644
--- a/cpp/src/Ice/Reference.h
+++ b/cpp/src/Ice/Reference.h
@@ -55,6 +55,7 @@ public:
 
     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; }
@@ -85,7 +86,7 @@ public:
     ReferencePtr changeSecure(bool) const;
     ReferencePtr changeIdentity(const Ice::Identity&) const;
     ReferencePtr changeFacet(const std::string&) const;
-    ReferencePtr changeEncoding(const Ice::EncodingVersion&) const;
+    virtual ReferencePtr changeEncoding(const Ice::EncodingVersion&) const;
     virtual ReferencePtr changeCompress(bool) const;
 
     virtual ReferencePtr changeEndpoints(const std::vector<EndpointIPtr>&) const = 0;
@@ -139,7 +140,7 @@ public:
 protected:
 
     Reference(const InstancePtr&, const Ice::CommunicatorPtr&, const Ice::Identity&, const std::string&, Mode, bool,
-              const Ice::EncodingVersion&);
+              const Ice::ProtocolVersion&, const Ice::EncodingVersion&);
     Reference(const Reference&);
 
     virtual Ice::Int hashInit() const;
@@ -157,6 +158,7 @@ private:
     Ice::Identity _identity;
     SharedContextPtr _context;
     std::string _facet;
+    Ice::ProtocolVersion _protocol;
     Ice::EncodingVersion _encoding;
 
 protected:
@@ -222,8 +224,9 @@ class RoutableReference : public Reference
 public:
 
     RoutableReference(const InstancePtr&, const Ice::CommunicatorPtr&, const Ice::Identity&, const std::string&, Mode,
-                      bool, const Ice::EncodingVersion&, const std::vector<EndpointIPtr>&, const std::string&, 
-                      const LocatorInfoPtr&, const RouterInfoPtr&, bool, bool, bool, Ice::EndpointSelectionType, int);
+                      bool, const Ice::ProtocolVersion&, const Ice::EncodingVersion&, const std::vector<EndpointIPtr>&,
+                      const std::string&, const LocatorInfoPtr&, const RouterInfoPtr&, bool, bool, bool, 
+                      Ice::EndpointSelectionType, int);
 
     virtual std::vector<EndpointIPtr> getEndpoints() const;
     virtual std::string getAdapterId() const;
@@ -236,6 +239,7 @@ public:
     virtual int getLocatorCacheTimeout() const;
     virtual std::string getConnectionId() 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;
diff --git a/cpp/src/Ice/ReferenceFactory.cpp b/cpp/src/Ice/ReferenceFactory.cpp
index 37ccafa1976..b4193f3a374 100644
--- a/cpp/src/Ice/ReferenceFactory.cpp
+++ b/cpp/src/Ice/ReferenceFactory.cpp
@@ -55,7 +55,8 @@ IceInternal::ReferenceFactory::create(const Identity& ident,
         return 0;
     }
 
-    return create(ident, facet, tmpl->getMode(), tmpl->getSecure(), endpoints, "", "");
+    return create(ident, facet, tmpl->getMode(), tmpl->getSecure(), tmpl->getProtocol(), tmpl->getEncoding(), 
+                  endpoints, "", "");
 }
 
 ReferencePtr
@@ -69,7 +70,8 @@ IceInternal::ReferenceFactory::create(const Identity& ident,
         return 0;
     }
 
-    return create(ident, facet, tmpl->getMode(), tmpl->getSecure(), vector<EndpointIPtr>(), adapterId, "");
+    return create(ident, facet, tmpl->getMode(), tmpl->getSecure(), tmpl->getProtocol(), tmpl->getEncoding(), 
+                  vector<EndpointIPtr>(), adapterId, "");
 }
 
 ReferencePtr
@@ -80,8 +82,6 @@ IceInternal::ReferenceFactory::create(const Identity& ident, const Ice::Connecti
         return 0;
     }
 
-    DefaultsAndOverridesPtr defaultsAndOverrides = _instance->defaultsAndOverrides();
-
     //
     // Create new reference
     //
@@ -91,7 +91,7 @@ IceInternal::ReferenceFactory::create(const Identity& ident, const Ice::Connecti
                               "",  // Facet
                               connection->endpoint()->datagram() ? Reference::ModeDatagram : Reference::ModeTwoway,
                               connection->endpoint()->secure(),
-                              defaultsAndOverrides->defaultEncoding,
+                              _instance->defaultsAndOverrides()->defaultEncoding,
                               connection);
 }
 
@@ -189,6 +189,7 @@ IceInternal::ReferenceFactory::create(const string& str, const string& propertyP
     string facet;
     Reference::Mode mode = Reference::ModeTwoway;
     bool secure = false;
+    Ice::EncodingVersion encoding = _instance->defaultsAndOverrides()->defaultEncoding;
     string adapter;
 
     while(true)
@@ -362,6 +363,28 @@ IceInternal::ReferenceFactory::create(const string& str, const string& propertyP
                 break;
             }
 
+            case 'e':
+            {
+                if(argument.empty())
+                {
+                    Ice::ProxyParseException ex(__FILE__, __LINE__);
+                    ex.str = "no argument provided for -e option in `" + s + "'";
+                    throw ex;
+                }
+                
+                try 
+                {
+                    encoding = Ice::stringToEncodingVersion(argument);
+                }
+                catch(const Ice::VersionParseException& e)
+                {
+                    Ice::ProxyParseException ex(__FILE__, __LINE__);
+                    ex.str = "invalid encoding version `" + argument + "' in `" + s + "':\n" + e.str;
+                    throw ex;
+                }
+                break;
+            }
+
             default:
             {
                 ProxyParseException ex(__FILE__, __LINE__);
@@ -371,14 +394,12 @@ IceInternal::ReferenceFactory::create(const string& str, const string& propertyP
         }
     }
 
-
     if(beg == string::npos)
     {
-        return create(ident, facet, mode, secure, vector<EndpointIPtr>(), "", propertyPrefix);
+        return create(ident, facet, mode, secure, Protocol_1_0, encoding, vector<EndpointIPtr>(), "", propertyPrefix);
     }
 
     vector<EndpointIPtr> endpoints;
-
     switch(s[beg])
     {
         case ':':
@@ -463,7 +484,7 @@ IceInternal::ReferenceFactory::create(const string& str, const string& propertyP
                 }
             }
 
-            return create(ident, facet, mode, secure, endpoints, "", propertyPrefix);
+            return create(ident, facet, mode, secure, Protocol_1_0, encoding, endpoints, "", propertyPrefix);
             break;
         }
         case '@':
@@ -527,7 +548,7 @@ IceInternal::ReferenceFactory::create(const string& str, const string& propertyP
 
             adapter = Ice::UTF8ToNative(_instance->initializationData().stringConverter, adapter);
 
-            return create(ident, facet, mode, secure, vector<EndpointIPtr>(), adapter, propertyPrefix);
+            return create(ident, facet, mode, secure, Protocol_1_0, encoding, endpoints, adapter, propertyPrefix);
             break;
         }
         default:
@@ -580,6 +601,19 @@ IceInternal::ReferenceFactory::create(const Identity& ident, BasicStream* s)
     bool secure;
     s->read(secure);
 
+    Ice::ProtocolVersion protocol;
+    Ice::EncodingVersion encoding;
+    if(s->getReadEncoding() != Ice::Encoding_1_0)
+    {
+        s->read(protocol);
+        s->read(encoding);
+    }
+    else
+    {
+        protocol = Ice::Protocol_1_0;
+        encoding = Ice::Encoding_1_0;
+    }
+
     vector<EndpointIPtr> endpoints;
     string adapterId;
 
@@ -599,7 +633,7 @@ IceInternal::ReferenceFactory::create(const Identity& ident, BasicStream* s)
         s->read(adapterId);
     }
 
-    return create(ident, facet, mode, secure, endpoints, adapterId, "");
+    return create(ident, facet, mode, secure, protocol, encoding, endpoints, adapterId, "");
 }
 
 ReferenceFactoryPtr
@@ -656,7 +690,6 @@ IceInternal::ReferenceFactory::checkForUnknownProperties(const string& prefix)
         "EndpointSelection",
         "ConnectionCached",
         "PreferSecure",
-        "EncodingVersion",
         "LocatorCacheTimeout",
         "Locator",
         "Router",
@@ -711,6 +744,8 @@ 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)
@@ -720,12 +755,22 @@ IceInternal::ReferenceFactory::create(const Identity& ident,
     //
     // Default local proxy options.
     //
-    LocatorInfoPtr locatorInfo = _instance->locatorManager()->get(_defaultLocator);
+    LocatorInfoPtr locatorInfo;
+    if(_defaultLocator)
+    {
+        if(_defaultLocator->ice_getEncodingVersion() != encoding)
+        {
+            locatorInfo = _instance->locatorManager()->get(_defaultLocator->ice_encodingVersion(encoding));
+        }
+        else
+        {
+            locatorInfo = _instance->locatorManager()->get(_defaultLocator);
+        }
+    }
     RouterInfoPtr routerInfo = _instance->routerManager()->get(_defaultRouter);
     bool collocationOptimized = defaultsAndOverrides->defaultCollocationOptimization;
     bool cacheConnection = true;
     bool preferSecure = defaultsAndOverrides->defaultPreferSecure;
-    EncodingVersion encoding = defaultsAndOverrides->defaultEncoding;
     Ice::EndpointSelectionType endpointSelection = defaultsAndOverrides->defaultEndpointSelection;
     int locatorCacheTimeout = defaultsAndOverrides->defaultLocatorCacheTimeout;
 
@@ -746,7 +791,14 @@ IceInternal::ReferenceFactory::create(const Identity& ident,
         LocatorPrx locator = LocatorPrx::uncheckedCast(_communicator->propertyToProxy(property));
         if(locator)
         {
-            locatorInfo = _instance->locatorManager()->get(locator);
+            if(locator->ice_getEncodingVersion() != encoding)
+            {
+                locatorInfo = _instance->locatorManager()->get(locator->ice_encodingVersion(encoding));
+            }
+            else
+            {
+                locatorInfo = _instance->locatorManager()->get(locator);
+            }
         }
 
         property = propertyPrefix + ".Router";
@@ -774,14 +826,6 @@ IceInternal::ReferenceFactory::create(const Identity& ident,
         property = propertyPrefix + ".PreferSecure";
         preferSecure = properties->getPropertyAsIntWithDefault(property, preferSecure) > 0;
 
-        property = propertyPrefix + ".EncodingVersion";
-        string encodingStr = properties->getProperty(property);
-        if(!encodingStr.empty())
-        {
-            encoding = stringToEncodingVersion(encodingStr);
-            checkSupportedEncoding(encoding);
-        }
-
         property = propertyPrefix + ".EndpointSelection";
         if(!properties->getProperty(property).empty())
         {
@@ -815,6 +859,7 @@ IceInternal::ReferenceFactory::create(const Identity& ident,
                                  facet,
                                  mode,
                                  secure,
+                                 protocol,
                                  encoding,
                                  endpoints,
                                  adapterId,
diff --git a/cpp/src/Ice/ReferenceFactory.h b/cpp/src/Ice/ReferenceFactory.h
index dd1982f96de..6542b062887 100644
--- a/cpp/src/Ice/ReferenceFactory.h
+++ b/cpp/src/Ice/ReferenceFactory.h
@@ -67,6 +67,7 @@ private:
 
     void checkForUnknownProperties(const std::string&);
     RoutableReferencePtr create(const ::Ice::Identity&, const ::std::string&, Reference::Mode, bool, 
+                                const Ice::ProtocolVersion&, const Ice::EncodingVersion&,
                                 const std::vector<EndpointIPtr>&, const std::string&, const std::string&);
 
     const InstancePtr _instance;
diff --git a/cpp/src/Ice/RouterInfo.cpp b/cpp/src/Ice/RouterInfo.cpp
index 291e0ec03d9..84feadb9869 100644
--- a/cpp/src/Ice/RouterInfo.cpp
+++ b/cpp/src/Ice/RouterInfo.cpp
@@ -142,15 +142,6 @@ IceInternal::RouterInfo::operator<(const RouterInfo& rhs) const
     return _router < rhs._router;
 }
 
-RouterPrx
-IceInternal::RouterInfo::getRouter() const
-{
-    //
-    // No mutex lock necessary, _router is immutable.
-    //
-    return _router;
-}
-
 vector<EndpointIPtr>
 IceInternal::RouterInfo::getClientEndpoints()
 {
diff --git a/cpp/src/Ice/RouterInfo.h b/cpp/src/Ice/RouterInfo.h
index c1b1077a73b..7caaafc97cf 100644
--- a/cpp/src/Ice/RouterInfo.h
+++ b/cpp/src/Ice/RouterInfo.h
@@ -76,7 +76,13 @@ public:
     bool operator!=(const RouterInfo&) const;
     bool operator<(const RouterInfo&) const;
 
-    Ice::RouterPrx getRouter() const;
+    const Ice::RouterPrx& getRouter() const
+    {
+        //
+        // No mutex lock necessary, _router is immutable.
+        //
+        return _router;
+    }
     void getClientProxyResponse(const Ice::ObjectPrx&, const GetClientEndpointsCallbackPtr&);
     void getClientProxyException(const Ice::Exception&, const GetClientEndpointsCallbackPtr&);
     std::vector<EndpointIPtr> getClientEndpoints();
diff --git a/cpp/src/Ice/TcpConnector.cpp b/cpp/src/Ice/TcpConnector.cpp
index a3211c28eb7..7c4dedb9cf2 100644
--- a/cpp/src/Ice/TcpConnector.cpp
+++ b/cpp/src/Ice/TcpConnector.cpp
@@ -77,16 +77,6 @@ IceInternal::TcpConnector::operator==(const Connector& r) const
         return false;
     }
 
-    if(_protocol != p->_protocol)
-    {
-        return false;
-    }
-
-    if(_encoding != p->_encoding)
-    {
-        return false;
-    }
-
     if(_connectionId != p->_connectionId)
     {
         return false;
@@ -119,24 +109,6 @@ IceInternal::TcpConnector::operator<(const Connector& r) const
         return false;
     }
 
-    if(_protocol < p->_protocol)
-    {
-        return true;
-    }
-    else if(p->_protocol < _protocol)
-    {
-        return false;
-    }
-
-    if(_encoding < p->_encoding)
-    {
-        return true;
-    }
-    else if(p->_encoding < _encoding)
-    {
-        return false;
-    }
-
     if(_connectionId < p->_connectionId)
     {
         return true;
@@ -149,15 +121,12 @@ IceInternal::TcpConnector::operator<(const Connector& r) const
 }
 
 IceInternal::TcpConnector::TcpConnector(const InstancePtr& instance, const Address& addr,
-                                        Ice::Int timeout, const Ice::ProtocolVersion& protocol, 
-                                        const Ice::EncodingVersion& encoding, const string& connectionId) :
+                                        Ice::Int timeout, const string& connectionId) :
     _instance(instance),
     _traceLevels(instance->traceLevels()),
     _logger(instance->initializationData().logger),
     _addr(addr),
     _timeout(timeout),
-    _protocol(protocol),
-    _encoding(encoding),
     _connectionId(connectionId)
 {
 }
diff --git a/cpp/src/Ice/TcpConnector.h b/cpp/src/Ice/TcpConnector.h
index 341696087ef..6a1d5fdab50 100644
--- a/cpp/src/Ice/TcpConnector.h
+++ b/cpp/src/Ice/TcpConnector.h
@@ -36,8 +36,7 @@ public:
 
 private:
     
-    TcpConnector(const InstancePtr&, const Address&, Ice::Int, const Ice::ProtocolVersion&, 
-                 const Ice::EncodingVersion&, const std::string&);
+    TcpConnector(const InstancePtr&, const Address&, Ice::Int, const std::string&);
     virtual ~TcpConnector();
     friend class TcpEndpointI;
 
@@ -46,8 +45,6 @@ private:
     const ::Ice::LoggerPtr _logger;
     const Address _addr;
     const Ice::Int _timeout;
-    const Ice::ProtocolVersion _protocol;
-    const Ice::EncodingVersion _encoding;
     const std::string _connectionId;
 };
 
diff --git a/cpp/src/Ice/TcpEndpointI.cpp b/cpp/src/Ice/TcpEndpointI.cpp
index 1eac94a8988..f69cfb1094b 100644
--- a/cpp/src/Ice/TcpEndpointI.cpp
+++ b/cpp/src/Ice/TcpEndpointI.cpp
@@ -23,9 +23,8 @@ using namespace Ice;
 using namespace IceInternal;
 
 IceInternal::TcpEndpointI::TcpEndpointI(const InstancePtr& instance, const string& ho, Int po, Int ti,
-                                        const Ice::ProtocolVersion& protocol, const Ice::EncodingVersion& encoding,
                                         const string& conId, bool co) :
-    EndpointI(protocol, encoding, conId),
+    EndpointI(conId),
     _instance(instance),
     _host(ho),
     _port(po),
@@ -35,7 +34,7 @@ IceInternal::TcpEndpointI::TcpEndpointI(const InstancePtr& instance, const strin
 }
 
 IceInternal::TcpEndpointI::TcpEndpointI(const InstancePtr& instance, const string& str, bool oaEndpoint) :
-    EndpointI(Ice::currentProtocol, instance->defaultsAndOverrides()->defaultEncoding, ""),
+    EndpointI(""),
     _instance(instance),
     _port(0),
     _timeout(-1),
@@ -155,7 +154,9 @@ IceInternal::TcpEndpointI::TcpEndpointI(const InstancePtr& instance, const strin
 
             default:
             {
-                parseOption(option, argument, "tcp", str);
+                Ice::EndpointParseException ex(__FILE__, __LINE__);
+                ex.str = "unknown option `" + option + "' in endpoint `tcp " + str + "'";
+                throw ex;
             }
         }
     }
@@ -190,16 +191,6 @@ IceInternal::TcpEndpointI::TcpEndpointI(BasicStream* s) :
     s->read(const_cast<Int&>(_port));
     s->read(const_cast<Int&>(_timeout));
     s->read(const_cast<bool&>(_compress));
-    if(s->getReadEncoding() > Ice::Encoding_1_0)
-    {
-        s->read(const_cast<Ice::ProtocolVersion&>(_protocol));
-        s->read(const_cast<Ice::EncodingVersion&>(_encoding));
-    }
-    else
-    {
-        const_cast<ProtocolVersion&>(_protocol) = Ice::Protocol_1_0;
-        const_cast<EncodingVersion&>(_encoding) = Ice::Encoding_1_0;
-    }
     s->endReadEncaps();
 }
 
@@ -212,11 +203,6 @@ IceInternal::TcpEndpointI::streamWrite(BasicStream* s) const
     s->write(_port);
     s->write(_timeout);
     s->write(_compress);
-    if(s->getWriteEncoding() > Ice::Encoding_1_0)
-    {
-        s->write(_protocol);
-        s->write(_encoding);
-    }
     s->endWriteEncaps();
 }
 
@@ -233,16 +219,6 @@ IceInternal::TcpEndpointI::toString() const
     ostringstream s;
     s << "tcp";
 
-    if(_protocol != Ice::Protocol_1_0)
-    {
-        s << " -v " << _protocol;
-    }
-
-    if(_encoding != Ice::Encoding_1_0)
-    {
-        s << " -e " << _encoding;
-    }
-
     if(!_host.empty())
     {
         s << " -h ";
@@ -277,9 +253,8 @@ IceInternal::TcpEndpointI::getInfo() const
     {
     public:
 
-        InfoI(const ProtocolVersion& pv, const EncodingVersion& ev, Ice::Int to, bool comp, const string& host, 
-              Ice::Int port) :
-            TCPEndpointInfo(pv, ev, to, comp, host, port)
+        InfoI(Ice::Int to, bool comp, const string& host, Ice::Int port) :
+            TCPEndpointInfo(to, comp, host, port)
         {
         }
 
@@ -302,7 +277,7 @@ IceInternal::TcpEndpointI::getInfo() const
         }
     };
 
-    return new InfoI(_protocol, _encoding, _timeout, _compress, _host, _port);
+    return new InfoI(_timeout, _compress, _host, _port);
 }
 
 Short
@@ -332,7 +307,7 @@ IceInternal::TcpEndpointI::timeout(Int timeout) const
     }
     else
     {
-        return new TcpEndpointI(_instance, _host, _port, timeout, _protocol, _encoding, _connectionId, _compress);
+        return new TcpEndpointI(_instance, _host, _port, timeout, _connectionId, _compress);
     }
 }
 
@@ -345,7 +320,7 @@ IceInternal::TcpEndpointI::connectionId(const string& connectionId) const
     }
     else
     {
-        return new TcpEndpointI(_instance, _host, _port, _timeout, _protocol, _encoding, connectionId, _compress);
+        return new TcpEndpointI(_instance, _host, _port, _timeout, connectionId, _compress);
     }
 }
 
@@ -364,7 +339,7 @@ IceInternal::TcpEndpointI::compress(bool compress) const
     }
     else
     {
-        return new TcpEndpointI(_instance, _host, _port, _timeout, _protocol, _encoding, _connectionId, compress);
+        return new TcpEndpointI(_instance, _host, _port, _timeout, _connectionId, compress);
     }
 }
 
@@ -403,8 +378,8 @@ AcceptorPtr
 IceInternal::TcpEndpointI::acceptor(EndpointIPtr& endp, const string&) const
 {
     TcpAcceptor* p = new TcpAcceptor(_instance, _host, _port, _instance->protocolSupport());
-    endp = new TcpEndpointI(_instance, _host, p->effectivePort(), _timeout, _protocol, _encoding, _connectionId, 
-                            _compress);
+
+    endp = new TcpEndpointI(_instance, _host, p->effectivePort(), _timeout, _connectionId, _compress);
     return p;
 }
 
@@ -422,8 +397,7 @@ IceInternal::TcpEndpointI::expand() const
     {
         for(vector<string>::const_iterator p = hosts.begin(); p != hosts.end(); ++p)
         {
-            endps.push_back(new TcpEndpointI(_instance, *p, _port, _timeout, _protocol, _encoding, _connectionId, 
-                                             _compress));
+            endps.push_back(new TcpEndpointI(_instance, *p, _port, _timeout, _connectionId, _compress));
         }
     }
     return endps;
@@ -454,16 +428,6 @@ IceInternal::TcpEndpointI::operator==(const LocalObject& r) const
         return true;
     }
 
-    if(_protocol != p->_protocol)
-    {
-        return false;
-    }
-
-    if(_encoding != p->_encoding) 
-    {
-        return false;
-    }
-
     if(_host != p->_host)
     {
         return false;
@@ -511,24 +475,6 @@ IceInternal::TcpEndpointI::operator<(const LocalObject& r) const
         return false;
     }
 
-    if(_protocol < p->_protocol)
-    {
-        return true;
-    }
-    else if(p->_protocol < _protocol) 
-    {
-        return false;
-    }
-
-    if(_encoding < p->_encoding) 
-    {
-        return true;
-    }
-    else if(p->_encoding < _encoding) 
-    {
-        return false;
-    }
-
     if(_host < p->_host)
     {
         return true;
@@ -585,10 +531,6 @@ IceInternal::TcpEndpointI::hashInit() const
     hashAdd(h, _host);
     hashAdd(h, _port);
     hashAdd(h, _timeout);
-    hashAdd(h, _protocol.major);
-    hashAdd(h, _protocol.minor);
-    hashAdd(h, _encoding.major);
-    hashAdd(h, _encoding.minor);
     hashAdd(h, _connectionId);
     hashAdd(h, _compress);
     return h;
@@ -600,7 +542,7 @@ IceInternal::TcpEndpointI::connectors(const vector<Address>& addresses) const
     vector<ConnectorPtr> connectors;
     for(unsigned int i = 0; i < addresses.size(); ++i)
     {
-        connectors.push_back(new TcpConnector(_instance, addresses[i], _timeout, _protocol, _encoding, _connectionId));
+        connectors.push_back(new TcpConnector(_instance, addresses[i], _timeout, _connectionId));
     }
     return connectors;
 }
diff --git a/cpp/src/Ice/TcpEndpointI.h b/cpp/src/Ice/TcpEndpointI.h
index feaba9879a2..c1d410ebacd 100644
--- a/cpp/src/Ice/TcpEndpointI.h
+++ b/cpp/src/Ice/TcpEndpointI.h
@@ -22,8 +22,7 @@ class TcpEndpointI : public EndpointI
 {
 public:
 
-    TcpEndpointI(const InstancePtr&, const std::string&, Ice::Int, Ice::Int, const Ice::ProtocolVersion&, 
-                 const Ice::EncodingVersion&, const std::string&, bool);
+    TcpEndpointI(const InstancePtr&, const std::string&, Ice::Int, Ice::Int, const std::string&, bool);
     TcpEndpointI(const InstancePtr&, const std::string&, bool);
     TcpEndpointI(BasicStream*);
 
diff --git a/cpp/src/Ice/UdpConnector.cpp b/cpp/src/Ice/UdpConnector.cpp
index 29782122b53..b52c5a44bd6 100644
--- a/cpp/src/Ice/UdpConnector.cpp
+++ b/cpp/src/Ice/UdpConnector.cpp
@@ -48,16 +48,6 @@ IceInternal::UdpConnector::operator==(const Connector& r) const
         return false;
     }
 
-    if(_protocol != p->_protocol)
-    {
-        return false;
-    }
-
-    if(_encoding != p->_encoding)
-    {
-        return false;
-    }
-
     if(_connectionId != p->_connectionId)
     {
         return false;
@@ -91,24 +81,6 @@ IceInternal::UdpConnector::operator<(const Connector& r) const
         return type() < r.type();
     }
 
-    if(_protocol < p->_protocol)
-    {
-        return true;
-    }
-    else if(p->_protocol < _protocol)
-    {
-        return false;
-    }
-
-    if(_encoding < p->_encoding)
-    {
-        return true;
-    }
-    else if(p->_encoding < _encoding)
-    {
-        return false;
-    }
-
     if(_connectionId < p->_connectionId)
     {
         return true;
@@ -139,15 +111,11 @@ IceInternal::UdpConnector::operator<(const Connector& r) const
 }
 
 IceInternal::UdpConnector::UdpConnector(const InstancePtr& instance, const Address& addr, 
-                                        const string& mcastInterface, int mcastTtl, 
-                                        const Ice::ProtocolVersion& protocol, const Ice::EncodingVersion& encoding, 
-                                        const std::string& connectionId) :
+                                        const string& mcastInterface, int mcastTtl, const std::string& connectionId) :
     _instance(instance),
     _addr(addr),
     _mcastInterface(mcastInterface),
     _mcastTtl(mcastTtl),
-    _protocol(protocol),
-    _encoding(encoding),
     _connectionId(connectionId)
 {
 }
diff --git a/cpp/src/Ice/UdpConnector.h b/cpp/src/Ice/UdpConnector.h
index 148c767407b..e325e5007b6 100644
--- a/cpp/src/Ice/UdpConnector.h
+++ b/cpp/src/Ice/UdpConnector.h
@@ -34,8 +34,7 @@ public:
 
 private:
     
-    UdpConnector(const InstancePtr&, const Address&, const std::string&, int, 
-                 const Ice::ProtocolVersion&, const Ice::EncodingVersion&, const std::string&);
+    UdpConnector(const InstancePtr&, const Address&, const std::string&, int, const std::string&);
 
     virtual ~UdpConnector();
     friend class UdpEndpointI;
@@ -44,8 +43,6 @@ private:
     const Address _addr;
     const std::string _mcastInterface;
     const int _mcastTtl;
-    const Ice::ProtocolVersion _protocol;
-    const Ice::EncodingVersion _encoding;
     const std::string _connectionId;
 };
 
diff --git a/cpp/src/Ice/UdpEndpointI.cpp b/cpp/src/Ice/UdpEndpointI.cpp
index 8f508a98c0d..8d812e591dc 100644
--- a/cpp/src/Ice/UdpEndpointI.cpp
+++ b/cpp/src/Ice/UdpEndpointI.cpp
@@ -17,15 +17,15 @@
 #include <Ice/DefaultsAndOverrides.h>
 #include <Ice/Protocol.h>
 #include <Ice/HashUtil.h>
+#include <Ice/Logger.h>
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
 IceInternal::UdpEndpointI::UdpEndpointI(const InstancePtr& instance, const string& ho, Int po, const string& mif, 
-                                        Int mttl, const Ice::ProtocolVersion& protocol, 
-                                        const Ice::EncodingVersion& encoding, bool conn, const string& conId, bool co) :
-    EndpointI(protocol, encoding, conId),
+                                        Int mttl, bool conn, const string& conId, bool co) :
+    EndpointI(conId),
     _instance(instance),
     _host(ho),
     _port(po),
@@ -37,7 +37,7 @@ IceInternal::UdpEndpointI::UdpEndpointI(const InstancePtr& instance, const strin
 }
 
 IceInternal::UdpEndpointI::UdpEndpointI(const InstancePtr& instance, const string& str, bool oaEndpoint) :
-    EndpointI(Ice::currentProtocol, instance->defaultsAndOverrides()->defaultEncoding, ""),
+    EndpointI(""),
     _instance(instance),
     _port(0),
     _mcastTtl(-1),
@@ -157,6 +157,14 @@ IceInternal::UdpEndpointI::UdpEndpointI(const InstancePtr& instance, const strin
             }
             const_cast<bool&>(_compress) = true;
         }
+        else if(option == "-v")
+        {
+            _instance->initializationData().logger->warning("deprecated udp endpoint option: -v");
+        }
+        else if(option == "-e")
+        {
+            _instance->initializationData().logger->warning("deprecated udp endpoint option: -e");
+        }
         else if(option == "--interface")
         {
             if(argument.empty())
@@ -185,7 +193,9 @@ IceInternal::UdpEndpointI::UdpEndpointI(const InstancePtr& instance, const strin
         }
         else
         {
-            parseOption(option, argument, "udp", str);
+            Ice::EndpointParseException ex(__FILE__, __LINE__);
+            ex.str = "unknown option `" + option + "' in endpoint `udp " + str + "'";
+            throw ex;
         }
     }
 
@@ -218,8 +228,14 @@ IceInternal::UdpEndpointI::UdpEndpointI(BasicStream* s) :
     s->startReadEncaps();
     s->read(const_cast<string&>(_host), false);
     s->read(const_cast<Int&>(_port));
-    s->read(const_cast<Ice::ProtocolVersion&>(_protocol));
-    s->read(const_cast<Ice::EncodingVersion&>(_encoding));
+    if(s->getReadEncoding() == Ice::Encoding_1_0)
+    {
+        Ice::Byte b;
+        s->read(b);
+        s->read(b);
+        s->read(b);
+        s->read(b);
+    }
     // Not transmitted.
     //s->read(const_cast<bool&>(_connect));
     s->read(const_cast<bool&>(_compress));
@@ -233,8 +249,11 @@ IceInternal::UdpEndpointI::streamWrite(BasicStream* s) const
     s->startWriteEncaps();
     s->write(_host, false);
     s->write(_port);
-    s->write(_protocol);
-    s->write(_encoding);
+    if(s->getWriteEncoding() == Ice::Encoding_1_0)
+    {
+        s->write(Ice::Protocol_1_0);
+        s->write(Ice::Encoding_1_0);
+    }
     // Not transmitted.
     //s->write(_connect);
     s->write(_compress);
@@ -255,16 +274,6 @@ IceInternal::UdpEndpointI::toString() const
 
     s << "udp";
 
-    if(_protocol != Ice::Protocol_1_0)
-    {
-        s << " -v " << _protocol;
-    }
-
-    if(_encoding != Ice::Encoding_1_0)
-    {
-        s << " -e " << _encoding;
-    }
-
     if(!_host.empty())
     {
         s << " -h ";
@@ -312,9 +321,8 @@ IceInternal::UdpEndpointI::getInfo() const
     {
     public:
 
-        InfoI(const ProtocolVersion& pv, const EncodingVersion& ev, bool comp, const string& host, Ice::Int port, 
-              const std::string& mcastInterface, Ice::Int mcastTtl) :
-            UDPEndpointInfo(pv, ev, -1, comp, host, port, mcastInterface, mcastTtl)
+        InfoI(bool comp, const string& host, Ice::Int port, const std::string& mcastInterface, Ice::Int mcastTtl) :
+            UDPEndpointInfo(-1, comp, host, port, mcastInterface, mcastTtl)
         {
         }
 
@@ -337,7 +345,7 @@ IceInternal::UdpEndpointI::getInfo() const
         }
     };
 
-    return new InfoI(_protocol, _encoding, _compress, _host, _port, _mcastInterface, _mcastTtl);
+    return new InfoI(_compress, _host, _port, _mcastInterface, _mcastTtl);
 }
 
 Short
@@ -373,8 +381,7 @@ IceInternal::UdpEndpointI::connectionId(const string& connectionId) const
     }
     else
     {
-        return new UdpEndpointI(_instance, _host, _port, _mcastInterface, _mcastTtl, _protocol, _encoding, _connect, 
-                                connectionId, _compress);
+        return new UdpEndpointI(_instance, _host, _port, _mcastInterface, _mcastTtl, _connect, connectionId, _compress);
     }
 }
 
@@ -393,8 +400,7 @@ IceInternal::UdpEndpointI::compress(bool compress) const
     }
     else
     {
-        return new UdpEndpointI(_instance, _host, _port, _mcastInterface, _mcastTtl, _protocol, _encoding, _connect, 
-                                _connectionId, compress);
+        return new UdpEndpointI(_instance, _host, _port, _mcastInterface, _mcastTtl, _connect, _connectionId, compress);
     }
 }
 
@@ -414,8 +420,8 @@ TransceiverPtr
 IceInternal::UdpEndpointI::transceiver(EndpointIPtr& endp) const
 {
     UdpTransceiver* p = new UdpTransceiver(_instance, _host, _port, _mcastInterface, _connect);
-    endp = new UdpEndpointI(_instance, _host, p->effectivePort(), _mcastInterface, _mcastTtl, _protocol, _encoding,
-                            _connect, _connectionId, _compress);
+    endp = new UdpEndpointI(_instance, _host, p->effectivePort(), _mcastInterface, _mcastTtl, _connect, _connectionId, 
+                            _compress);
     return p;
 }
 
@@ -451,8 +457,8 @@ IceInternal::UdpEndpointI::expand() const
     {
         for(vector<string>::const_iterator p = hosts.begin(); p != hosts.end(); ++p)
         {
-            endps.push_back(new UdpEndpointI(_instance, *p, _port, _mcastInterface, _mcastTtl, _protocol, _encoding,
-                                             _connect, _connectionId, _compress));
+            endps.push_back(new UdpEndpointI(_instance, *p, _port, _mcastInterface, _mcastTtl, _connect, _connectionId,
+                                             _compress));
         }
     }
     return endps;
@@ -483,16 +489,6 @@ IceInternal::UdpEndpointI::operator==(const LocalObject& r) const
         return true;
     }
 
-    if(_protocol != p->_protocol)
-    {
-        return false;
-    }
-
-    if(_encoding != p->_encoding) 
-    {
-        return false;
-    }
-
     if(_host != p->_host)
     {
         return false;
@@ -550,24 +546,6 @@ IceInternal::UdpEndpointI::operator<(const LocalObject& r) const
         return false;
     }
 
-    if(_protocol < p->_protocol)
-    {
-        return true;
-    }
-    else if(p->_protocol < _protocol) 
-    {
-        return false;
-    }
-
-    if(_encoding < p->_encoding) 
-    {
-        return true;
-    }
-    else if(p->_encoding < _encoding) 
-    {
-        return false;
-    }
-
     if(_host < p->_host)
     {
         return true;
@@ -644,10 +622,6 @@ IceInternal::UdpEndpointI::hashInit() const
     hashAdd(h, _mcastInterface);
     hashAdd(h, _mcastTtl);
     hashAdd(h, _connect);
-    hashAdd(h, _protocol.major);
-    hashAdd(h, _protocol.minor);
-    hashAdd(h, _encoding.major);
-    hashAdd(h, _encoding.minor);
     hashAdd(h, _connectionId);
     hashAdd(h, _compress);
     return h;
@@ -659,8 +633,7 @@ IceInternal::UdpEndpointI::connectors(const vector<Address>& addresses) const
     vector<ConnectorPtr> connectors;
     for(unsigned int i = 0; i < addresses.size(); ++i)
     {
-        connectors.push_back(new UdpConnector(_instance, addresses[i], _mcastInterface, _mcastTtl, _protocol, _encoding,
-                                              _connectionId));
+        connectors.push_back(new UdpConnector(_instance, addresses[i], _mcastInterface, _mcastTtl, _connectionId));
     }
     return connectors;
 }
diff --git a/cpp/src/Ice/UdpEndpointI.h b/cpp/src/Ice/UdpEndpointI.h
index dccdf28e796..765396cc436 100644
--- a/cpp/src/Ice/UdpEndpointI.h
+++ b/cpp/src/Ice/UdpEndpointI.h
@@ -22,8 +22,8 @@ class UdpEndpointI : public EndpointI
 {
 public:
 
-    UdpEndpointI(const InstancePtr&, const std::string&, Ice::Int, const std::string&, Ice::Int, 
-                 const Ice::ProtocolVersion&, const Ice::EncodingVersion&, bool, const std::string&, bool);
+    UdpEndpointI(const InstancePtr&, const std::string&, Ice::Int, const std::string&, Ice::Int, bool, 
+                 const std::string&, bool);
     UdpEndpointI(const InstancePtr&, const std::string&, bool);
     UdpEndpointI(BasicStream*);
 
diff --git a/cpp/src/IceSSL/ConnectorI.cpp b/cpp/src/IceSSL/ConnectorI.cpp
index 8c9857880fa..c881e5574f6 100644
--- a/cpp/src/IceSSL/ConnectorI.cpp
+++ b/cpp/src/IceSSL/ConnectorI.cpp
@@ -86,16 +86,6 @@ IceSSL::ConnectorI::operator==(const IceInternal::Connector& r) const
         return false;
     }
 
-    if(_protocol != p->_protocol)
-    {
-        return false;
-    }
-
-    if(_encoding != p->_encoding)
-    {
-        return false;
-    }
-
     if(_connectionId != p->_connectionId)
     {
         return false;
@@ -128,24 +118,6 @@ IceSSL::ConnectorI::operator<(const IceInternal::Connector& r) const
         return false;
     }
 
-    if(_protocol < p->_protocol)
-    {
-        return true;
-    }
-    else if(p->_protocol < _protocol)
-    {
-        return false;
-    }
-
-    if(_encoding < p->_encoding)
-    {
-        return true;
-    }
-    else if(p->_encoding < _encoding)
-    {
-        return false;
-    }
-
     if(_connectionId < p->_connectionId)
     {
         return true;
@@ -159,15 +131,12 @@ IceSSL::ConnectorI::operator<(const IceInternal::Connector& r) const
 }
 
 IceSSL::ConnectorI::ConnectorI(const InstancePtr& instance, const string& host, const struct sockaddr_storage& addr,
-                               Ice::Int timeout, const Ice::ProtocolVersion& protocol, 
-                               const Ice::EncodingVersion& encoding, const string& connectionId) :
+                               Ice::Int timeout, const string& connectionId) :
     _instance(instance),
     _logger(instance->communicator()->getLogger()),
     _host(host),
     _addr(addr),
     _timeout(timeout),
-    _protocol(protocol),
-    _encoding(encoding),
     _connectionId(connectionId)
 {
 }
diff --git a/cpp/src/IceSSL/ConnectorI.h b/cpp/src/IceSSL/ConnectorI.h
index 5e00e714678..8a32689aeb7 100644
--- a/cpp/src/IceSSL/ConnectorI.h
+++ b/cpp/src/IceSSL/ConnectorI.h
@@ -42,8 +42,7 @@ public:
 
 private:
     
-    ConnectorI(const InstancePtr&, const std::string&, const struct sockaddr_storage&, Ice::Int, 
-               const Ice::ProtocolVersion&, const Ice::EncodingVersion&, const std::string&);
+    ConnectorI(const InstancePtr&, const std::string&, const struct sockaddr_storage&, Ice::Int, const std::string&);
     virtual ~ConnectorI();
     friend class EndpointI;
 
@@ -52,8 +51,6 @@ private:
     const std::string _host;
     struct sockaddr_storage _addr;
     const Ice::Int _timeout;
-    const Ice::ProtocolVersion _protocol;
-    const Ice::EncodingVersion _encoding;
     const std::string _connectionId;
 };
 
diff --git a/cpp/src/IceSSL/EndpointI.cpp b/cpp/src/IceSSL/EndpointI.cpp
index 5c15d89fdd3..a433b3259d1 100644
--- a/cpp/src/IceSSL/EndpointI.cpp
+++ b/cpp/src/IceSSL/EndpointI.cpp
@@ -23,10 +23,9 @@ using namespace std;
 using namespace Ice;
 using namespace IceSSL;
 
-IceSSL::EndpointI::EndpointI(const InstancePtr& instance, const string& ho, Int po, Int ti, 
-                             const Ice::ProtocolVersion& protocol, const Ice::EncodingVersion& encoding, 
-                             const string& conId, bool co) :
-    IceInternal::EndpointI(protocol, encoding, conId),
+IceSSL::EndpointI::EndpointI(const InstancePtr& instance, const string& ho, Int po, Int ti, const string& conId, 
+                             bool co) :
+    IceInternal::EndpointI(conId),
     _instance(instance),
     _host(ho),
     _port(po),
@@ -36,7 +35,7 @@ IceSSL::EndpointI::EndpointI(const InstancePtr& instance, const string& ho, Int
 }
 
 IceSSL::EndpointI::EndpointI(const InstancePtr& instance, const string& str, bool oaEndpoint) :
-    IceInternal::EndpointI(Ice::currentProtocol, instance->defaultEncoding(), ""),
+    IceInternal::EndpointI(""),
     _instance(instance),
     _port(0),
     _timeout(-1),
@@ -156,7 +155,9 @@ IceSSL::EndpointI::EndpointI(const InstancePtr& instance, const string& str, boo
 
             default:
             {
-                parseOption(option, argument, "ssl", str);
+                Ice::EndpointParseException ex(__FILE__, __LINE__);
+                ex.str = "unknown option `" + option + "' in endpoint `ssl " + str + "'";
+                throw ex;
             }
         }
     }
@@ -191,16 +192,6 @@ IceSSL::EndpointI::EndpointI(const InstancePtr& instance, IceInternal::BasicStre
     s->read(const_cast<Int&>(_port));
     s->read(const_cast<Int&>(_timeout));
     s->read(const_cast<bool&>(_compress));
-    if(s->getReadEncoding() > Ice::Encoding_1_0)
-    {
-        s->read(const_cast<Ice::ProtocolVersion&>(_protocol));
-        s->read(const_cast<Ice::EncodingVersion&>(_encoding));
-    }
-    else
-    {
-        const_cast<ProtocolVersion&>(_protocol) = Ice::Protocol_1_0;
-        const_cast<EncodingVersion&>(_encoding) = Ice::Encoding_1_0;
-    }
     s->endReadEncaps();
 }
 
@@ -213,11 +204,6 @@ IceSSL::EndpointI::streamWrite(IceInternal::BasicStream* s) const
     s->write(_port);
     s->write(_timeout);
     s->write(_compress);
-    if(s->getWriteEncoding() > Ice::Encoding_1_0)
-    {
-        s->write(_protocol);
-        s->write(_encoding);
-    }
     s->endWriteEncaps();
 }
 
@@ -234,16 +220,6 @@ IceSSL::EndpointI::toString() const
     ostringstream s;
     s << "ssl";
 
-    if(_protocol != Ice::Protocol_1_0)
-    {
-        s << " -v " << _protocol;
-    }
-
-    if(_encoding != Ice::Encoding_1_0)
-    {
-        s << " -e " << _encoding;
-    }
-
     if(!_host.empty())
     {
         s << " -h ";
@@ -278,8 +254,7 @@ IceSSL::EndpointI::getInfo() const
     {
     public:
 
-        InfoI(const ProtocolVersion& pv, const EncodingVersion& ev, Int to, bool comp, const string& host, Int port) :
-            IceSSL::EndpointInfo(pv, ev, to, comp, host, port)
+        InfoI(Int to, bool comp, const string& host, Int port) : IceSSL::EndpointInfo(to, comp, host, port)
         {
         }
 
@@ -301,7 +276,7 @@ IceSSL::EndpointI::getInfo() const
             return true;
         }
     };
-    return new InfoI(_protocol, _encoding, _timeout, _compress, _host, _port);
+    return new InfoI(_timeout, _compress, _host, _port);
 }
 
 Short
@@ -331,7 +306,7 @@ IceSSL::EndpointI::timeout(Int timeout) const
     }
     else
     {
-        return new EndpointI(_instance, _host, _port, timeout, _protocol, _encoding, _connectionId, _compress);
+        return new EndpointI(_instance, _host, _port, timeout, _connectionId, _compress);
     }
 }
 
@@ -344,7 +319,7 @@ IceSSL::EndpointI::connectionId(const string& connectionId) const
     }
     else
     {
-        return new EndpointI(_instance, _host, _port, _timeout, _protocol, _encoding, connectionId, _compress);
+        return new EndpointI(_instance, _host, _port, _timeout, connectionId, _compress);
     }
 }
 
@@ -363,7 +338,7 @@ IceSSL::EndpointI::compress(bool compress) const
     }
     else
     {
-        return new EndpointI(_instance, _host, _port, _timeout, _protocol, _encoding, _connectionId, compress);
+        return new EndpointI(_instance, _host, _port, _timeout, _connectionId, compress);
     }
 }
 
@@ -402,8 +377,7 @@ IceInternal::AcceptorPtr
 IceSSL::EndpointI::acceptor(IceInternal::EndpointIPtr& endp, const string& adapterName) const
 {
     AcceptorI* p = new AcceptorI(_instance, adapterName, _host, _port);
-    endp = new EndpointI(_instance, _host, p->effectivePort(), _timeout, _protocol, _encoding, _connectionId, 
-                         _compress);
+    endp = new EndpointI(_instance, _host, p->effectivePort(), _timeout, _connectionId, _compress);
     return p;
 }
 
@@ -420,8 +394,7 @@ IceSSL::EndpointI::expand() const
     {
         for(vector<string>::const_iterator p = hosts.begin(); p != hosts.end(); ++p)
         {
-            endps.push_back(new EndpointI(_instance, *p, _port, _timeout, _protocol, _encoding, _connectionId, 
-                                          _compress));
+            endps.push_back(new EndpointI(_instance, *p, _port, _timeout, _connectionId, _compress));
         }
     }
     return endps;
@@ -452,16 +425,6 @@ IceSSL::EndpointI::operator==(const Ice::LocalObject& r) const
         return true;
     }
 
-    if(_protocol != p->_protocol)
-    {
-        return false;
-    }
-
-    if(_encoding != p->_encoding) 
-    {
-        return false;
-    }
-
     if(_host != p->_host)
     {
         return false;
@@ -509,24 +472,6 @@ IceSSL::EndpointI::operator<(const Ice::LocalObject& r) const
         return false;
     }
 
-    if(_protocol < p->_protocol)
-    {
-        return true;
-    }
-    else if(p->_protocol < _protocol) 
-    {
-        return false;
-    }
-
-    if(_encoding < p->_encoding) 
-    {
-        return true;
-    }
-    else if(p->_encoding < _encoding) 
-    {
-        return false;
-    }
-
     if(_host < p->_host)
     {
         return true;
@@ -583,10 +528,6 @@ IceSSL::EndpointI::hashInit() const
     IceInternal::hashAdd(h, _host);
     IceInternal::hashAdd(h, _port);
     IceInternal::hashAdd(h, _timeout);
-    IceInternal::hashAdd(h, _protocol.major);
-    IceInternal::hashAdd(h, _protocol.minor);
-    IceInternal::hashAdd(h, _encoding.major);
-    IceInternal::hashAdd(h, _encoding.minor);
     IceInternal::hashAdd(h, _connectionId);
     IceInternal::hashAdd(h, _compress);
     return h;
@@ -598,8 +539,7 @@ IceSSL::EndpointI::connectors(const vector<struct sockaddr_storage>& addresses)
     vector<IceInternal::ConnectorPtr> connectors;
     for(unsigned int i = 0; i < addresses.size(); ++i)
     {
-        connectors.push_back(new ConnectorI(_instance, _host, addresses[i], _timeout, _protocol, _encoding, 
-                                            _connectionId));
+        connectors.push_back(new ConnectorI(_instance, _host, addresses[i], _timeout, _connectionId));
     }
     return connectors;
 }
diff --git a/cpp/src/IceSSL/EndpointI.h b/cpp/src/IceSSL/EndpointI.h
index 4eec180dfa8..14787ae1b0a 100644
--- a/cpp/src/IceSSL/EndpointI.h
+++ b/cpp/src/IceSSL/EndpointI.h
@@ -22,8 +22,7 @@ class EndpointI : public IceInternal::EndpointI
 {
 public:
 
-    EndpointI(const InstancePtr&, const std::string&, Ice::Int, Ice::Int, const Ice::ProtocolVersion&, 
-              const Ice::EncodingVersion&, const std::string&, bool);
+    EndpointI(const InstancePtr&, const std::string&, Ice::Int, Ice::Int, const std::string&, bool);
     EndpointI(const InstancePtr&, const std::string&, bool);
     EndpointI(const InstancePtr&, IceInternal::BasicStream*);
author	Benoit Foucher <benoit@zeroc.com>	2012-11-13 10:17:27 +0100
committer	Benoit Foucher <benoit@zeroc.com>	2012-11-13 10:17:27 +0100
commit	99b44d083eeee5583adfe642081a827224fa1309 (patch)
tree	46bb3af634cbd5d90b9e5d46099f4e0e85f70ec6 /cpp/src
parent	Cosmetic updates to IceGrid Admin connection wizard (diff)
download	ice-99b44d083eeee5583adfe642081a827224fa1309.tar.bz2 ice-99b44d083eeee5583adfe642081a827224fa1309.tar.xz ice-99b44d083eeee5583adfe642081a827224fa1309.zip