1 files changed, 52 insertions, 226 deletions

diff --git a/cpp/src/Ice/UdpEndpointI.cpp b/cpp/src/Ice/UdpEndpointI.cpp
index 18ad812b644..2df35fff2e0 100644
--- a/cpp/src/Ice/UdpEndpointI.cpp
+++ b/cpp/src/Ice/UdpEndpointI.cpp
@@ -23,17 +23,14 @@ using namespace Ice;
 using namespace IceInternal;
 
 IceInternal::UdpEndpointI::UdpEndpointI(const InstancePtr& instance, const string& ho, Int po, const string& mif, 
-                                        Int mttl, Ice::Byte pma, Ice::Byte pmi, Ice::Byte ema, Ice::Byte emi,
-                                        bool conn, const string& conId, bool co) :
+                                        Int mttl, const Ice::ProtocolVersion& protocol, 
+                                        const Ice::EncodingVersion& encoding, bool conn, const string& conId, bool co) :
+    EndpointI(protocol, encoding),
     _instance(instance),
     _host(ho),
     _port(po),
     _mcastInterface(mif),
     _mcastTtl(mttl),
-    _protocolMajor(pma),
-    _protocolMinor(pmi),
-    _encodingMajor(ema),
-    _encodingMinor(emi),
     _connect(conn),
     _connectionId(conId),
     _compress(co)
@@ -44,10 +41,6 @@ IceInternal::UdpEndpointI::UdpEndpointI(const InstancePtr& instance, const strin
     _instance(instance),
     _port(0),
     _mcastTtl(-1),
-    _protocolMajor(protocolMajor),
-    _protocolMinor(protocolMinor),
-    _encodingMajor(encodingMajor),
-    _encodingMinor(encodingMinor),
     _connect(false),
     _compress(false)
 {
@@ -112,114 +105,7 @@ IceInternal::UdpEndpointI::UdpEndpointI(const InstancePtr& instance, const strin
             }
         }
 
-        if(option == "-v")
-        {
-            if(argument.empty())
-            {
-                EndpointParseException ex(__FILE__, __LINE__);
-                ex.str = "no argument provided for -v option in endpoint `udp " + str + "'";
-                throw ex;
-            }
-
-            string::size_type pos = argument.find('.');
-            if(pos == string::npos)
-            {
-                EndpointParseException ex(__FILE__, __LINE__);
-                ex.str = "malformed protocol version `" + argument + "' in endpoint `udp " + str + "'";
-                throw ex;
-            }
-            string majorStr = argument.substr(0, pos);
-            string minorStr = argument.substr(pos + 1, string::npos);
-
-            istringstream majStr(majorStr);
-            Int majVersion;
-            if(!(majStr >> majVersion) || !majStr.eof())
-            {
-                EndpointParseException ex(__FILE__, __LINE__);
-                ex.str = "invalid protocol major version `" + argument + "' in endpoint `udp " + str + "'";
-                throw ex;
-            }
-
-            istringstream minStr(minorStr);
-            Int minVersion;
-            if(!(minStr >> minVersion) || !minStr.eof())
-            {
-                EndpointParseException ex(__FILE__, __LINE__);
-                ex.str = "invalid protocol minor version `" + argument + "' in endpoint `udp " + str + "'";
-                throw ex;
-            }
-
-            if(majVersion < 1 || majVersion > 255 || minVersion < 0 || minVersion > 255)
-            {
-                EndpointParseException ex(__FILE__, __LINE__);
-                ex.str = "range error in protocol version `" + argument + "' in endpoint `udp " + str + "'";
-                throw ex;
-            }
-
-            if(majVersion != protocolMajor)
-            {
-                UnsupportedProtocolException ex(__FILE__, __LINE__);
-                ex.badMajor = majVersion;
-                ex.badMinor = minVersion;
-                ex.major = static_cast<unsigned char>(protocolMajor);
-                ex.minor = static_cast<unsigned char>(protocolMinor);
-                throw ex;
-            }
-
-            const_cast<Byte&>(_protocolMajor) = majVersion;
-            const_cast<Byte&>(_protocolMinor) = minVersion;
-        }
-        else if(option == "-e")
-        {
-            if(argument.empty())
-            {
-                EndpointParseException ex(__FILE__, __LINE__);
-                ex.str = "no argument provided for -e option in endpoint `udp " + str + "'";
-                throw ex;
-            }
-            string::size_type pos = argument.find('.');
-            string majorStr = argument.substr(0, pos);
-            string minorStr = argument.substr(pos + 1, string::npos);
-
-            istringstream majStr(majorStr);
-            Int majVersion;
-            if(!(majStr >> majVersion) || !majStr.eof())
-            {
-                EndpointParseException ex(__FILE__, __LINE__);
-                ex.str = "invalid encoding major version `" + argument + "' in endpoint `udp " + str + "'";
-                throw ex;
-            }
-
-            istringstream minStr(minorStr);
-            Int minVersion;
-            if(!(minStr >> minVersion) || !minStr.eof())
-            {
-                EndpointParseException ex(__FILE__, __LINE__);
-                ex.str = "invalid encoding minor version `" + argument + "' in endpoint `udp " + str + "'";
-                throw ex;
-            }
-
-            if(majVersion < 1 || majVersion > 255 || minVersion < 0 || minVersion > 255)
-            {
-                EndpointParseException ex(__FILE__, __LINE__);
-                ex.str = "range error in encoding version `" + argument + "' in endpoint `udp " + str + "'";
-                throw ex;
-            }
-
-            if(majVersion != static_cast<unsigned char>(encodingMajor))
-            {
-                UnsupportedEncodingException ex(__FILE__, __LINE__);
-                ex.badMajor = majVersion;
-                ex.badMinor = minVersion;
-                ex.major = static_cast<unsigned char>(encodingMajor);
-                ex.minor = static_cast<unsigned char>(encodingMinor);
-                throw ex;
-            }
-
-            const_cast<Byte&>(_encodingMajor) = majVersion;
-            const_cast<Byte&>(_encodingMinor) = minVersion;
-        }
-        else if(option == "-h")
+        if(option == "-h")
         {
             if(argument.empty())
             {
@@ -299,9 +185,7 @@ IceInternal::UdpEndpointI::UdpEndpointI(const InstancePtr& instance, const strin
         }
         else
         {
-            EndpointParseException ex(__FILE__, __LINE__);
-            ex.str = "unknown option `" + option + "' in `udp " + str + "'";
-            throw ex;
+            parseOption(option, argument, "udp", str);
         }
     }
 
@@ -328,38 +212,16 @@ IceInternal::UdpEndpointI::UdpEndpointI(BasicStream* s) :
     _instance(s->instance()),
     _port(0),
     _mcastTtl(-1),
-    _protocolMajor(protocolMajor),
-    _protocolMinor(protocolMinor),
-    _encodingMajor(encodingMajor),
-    _encodingMinor(encodingMinor),
     _connect(false),
     _compress(false)
 {
     s->startReadEncaps();
     s->read(const_cast<string&>(_host), false);
     s->read(const_cast<Int&>(_port));
-    s->read(const_cast<Byte&>(_protocolMajor));
-    s->read(const_cast<Byte&>(_protocolMinor));
-    s->read(const_cast<Byte&>(_encodingMajor));
-    s->read(const_cast<Byte&>(_encodingMinor));
-    if(_protocolMajor != protocolMajor)
-    {
-        UnsupportedProtocolException ex(__FILE__, __LINE__);
-        ex.badMajor = _protocolMajor;
-        ex.badMinor = _protocolMinor;
-        ex.major = static_cast<unsigned char>(protocolMajor);
-        ex.minor = static_cast<unsigned char>(protocolMinor);
-        throw ex;
-    }
-    if(_encodingMajor != encodingMajor)
-    {
-        UnsupportedEncodingException ex(__FILE__, __LINE__);
-        ex.badMajor = _encodingMajor;
-        ex.badMinor = _encodingMinor;
-        ex.major = static_cast<unsigned char>(encodingMajor);
-        ex.minor = static_cast<unsigned char>(encodingMinor);
-        throw ex;
-    }
+    s->read(const_cast<Byte&>(_protocol.major));
+    s->read(const_cast<Byte&>(_protocol.minor));
+    s->read(const_cast<Byte&>(_encoding.major));
+    s->read(const_cast<Byte&>(_encoding.minor));
     // Not transmitted.
     //s->read(const_cast<bool&>(_connect));
     s->read(const_cast<bool&>(_compress));
@@ -373,10 +235,10 @@ IceInternal::UdpEndpointI::streamWrite(BasicStream* s) const
     s->startWriteEncaps();
     s->write(_host, false);
     s->write(_port);
-    s->write(_protocolMajor);
-    s->write(_protocolMinor);
-    s->write(_encodingMajor);
-    s->write(_encodingMinor);
+    s->write(_protocol.major);
+    s->write(_protocol.minor);
+    s->write(_encoding.major);
+    s->write(_encoding.minor);
     // Not transmitted.
     //s->write(_connect);
     s->write(_compress);
@@ -397,18 +259,14 @@ IceInternal::UdpEndpointI::toString() const
 
     s << "udp";
 
-    if(_protocolMajor != Byte(1) || _protocolMinor != Byte(0))
+    if(_protocol != Ice::Protocol_1_0)
     {
-        s << " -v "
-          << static_cast<unsigned>(static_cast<unsigned char>(_protocolMajor)) << "."
-          << static_cast<unsigned>(static_cast<unsigned char>(_protocolMinor));
+        s << " -v " << _protocol;
     }
 
-    if(_encodingMajor != Byte(1) || _encodingMinor != Byte(0))
+    if(_encoding != Ice::Encoding_1_0)
     {
-        s << " -e "
-          << static_cast<unsigned>(static_cast<unsigned char>(_encodingMajor)) << "."
-          << static_cast<unsigned>(static_cast<unsigned char>(_encodingMinor));
+        s << " -e " << _encoding;
     }
 
     if(!_host.empty())
@@ -458,10 +316,9 @@ IceInternal::UdpEndpointI::getInfo() const
     {
     public:
 
-        InfoI(bool comp, const string& host, Ice::Int port, Ice::Byte protocolMajor, Ice::Byte protocolMinor, 
-              Ice::Byte encodingMajor, Ice::Byte encodingMinor, const std::string& mcastInterface, Ice::Int mcastTtl) :
-            UDPEndpointInfo(-1, comp, host, port, protocolMajor, protocolMinor, encodingMajor, encodingMinor,
-                            mcastInterface, mcastTtl)
+        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)
         {
         }
 
@@ -484,8 +341,7 @@ IceInternal::UdpEndpointI::getInfo() const
         }
     };
 
-    return new InfoI(_compress, _host, _port, _protocolMajor, _protocolMinor, _encodingMajor, _encodingMinor, 
-                     _mcastInterface, _mcastTtl);
+    return new InfoI(_protocol, _encoding, _compress, _host, _port, _mcastInterface, _mcastTtl);
 }
 
 Short
@@ -515,8 +371,8 @@ IceInternal::UdpEndpointI::connectionId(const string& connectionId) const
     }
     else
     {
-        return new UdpEndpointI(_instance, _host, _port, _mcastInterface, _mcastTtl, _protocolMajor, _protocolMinor,
-                                _encodingMajor, _encodingMinor, _connect, connectionId, _compress);
+        return new UdpEndpointI(_instance, _host, _port, _mcastInterface, _mcastTtl, _protocol, _encoding, _connect, 
+                                connectionId, _compress);
     }
 }
 
@@ -535,8 +391,8 @@ IceInternal::UdpEndpointI::compress(bool compress) const
     }
     else
     {
-        return new UdpEndpointI(_instance, _host, _port, _mcastInterface, _mcastTtl, _protocolMajor, _protocolMinor,
-                                _encodingMajor, _encodingMinor, _connect, _connectionId, compress);
+        return new UdpEndpointI(_instance, _host, _port, _mcastInterface, _mcastTtl, _protocol, _encoding, _connect, 
+                                _connectionId, compress);
     }
 }
 
@@ -556,9 +412,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, _protocolMajor,
-                            _protocolMinor, _encodingMajor, _encodingMinor, _connect, _connectionId,
-                            _compress);
+    endp = new UdpEndpointI(_instance, _host, p->effectivePort(), _mcastInterface, _mcastTtl, _protocol, _encoding,
+                            _connect, _connectionId, _compress);
     return p;
 }
 
@@ -594,9 +449,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, _protocolMajor,
-                                             _protocolMinor, _encodingMajor, _encodingMinor, _connect,
-                                             _connectionId, _compress));
+            endps.push_back(new UdpEndpointI(_instance, *p, _port, _mcastInterface, _mcastTtl, _protocol, _encoding,
+                                             _connect, _connectionId, _compress));
         }
     }
     return endps;
@@ -627,47 +481,37 @@ IceInternal::UdpEndpointI::operator==(const LocalObject& r) const
         return true;
     }
 
-    if(_host != p->_host)
+    if(_protocol != p->_protocol)
     {
         return false;
     }
 
-    if(_port != p->_port)
+    if(_encoding != p->_encoding) 
     {
         return false;
     }
 
-    if(_compress != p->_compress)
-    {
-        return false;
-    }
-
-    if(_connectionId != p->_connectionId)
-    {
-        return false;
-    }
-
-    if(_connect != p->_connect)
+    if(_host != p->_host)
     {
         return false;
     }
 
-    if(_protocolMajor != p->_protocolMajor)
+    if(_port != p->_port)
     {
         return false;
     }
 
-    if(_protocolMinor != p->_protocolMinor)
+    if(_compress != p->_compress)
     {
         return false;
     }
 
-    if(_encodingMajor != p->_encodingMajor)
+    if(_connectionId != p->_connectionId)
     {
         return false;
     }
 
-    if(_encodingMinor != p->_encodingMinor)
+    if(_connect != p->_connect)
     {
         return false;
     }
@@ -704,83 +548,65 @@ IceInternal::UdpEndpointI::operator<(const LocalObject& r) const
         return false;
     }
 
-    if(_host < p->_host)
+    if(_protocol < p->_protocol)
     {
         return true;
     }
-    else if (p->_host < _host)
+    else if(p->_protocol < _protocol) 
     {
         return false;
     }
 
-    if(_port < p->_port)
+    if(_encoding < p->_encoding) 
     {
         return true;
     }
-    else if(p->_port < _port)
+    else if(p->_encoding < _encoding) 
     {
         return false;
     }
 
-    if(_connectionId < p->_connectionId)
-    {
-        return true;
-    }
-    else if(p->_connectionId < _connectionId)
-    {
-        return false;
-    }
-
-    if(!_compress && p->_compress)
-    {
-        return true;
-    }
-    else if(p->_compress < _compress)
-    {
-        return false;
-    }
-
-    if(!_connect && p->_connect)
+    if(_host < p->_host)
     {
         return true;
     }
-    else if(!p->_connect && _connect)
+    else if (p->_host < _host)
     {
         return false;
     }
 
-    if(_protocolMajor < p->_protocolMajor)
+    if(_port < p->_port)
     {
         return true;
     }
-    else if(p->_protocolMajor < _protocolMajor)
+    else if(p->_port < _port)
     {
         return false;
     }
 
-    if(_protocolMinor < p->_protocolMinor)
+    if(_connectionId < p->_connectionId)
     {
         return true;
     }
-    else if(p->_protocolMinor < _protocolMinor)
+    else if(p->_connectionId < _connectionId)
     {
         return false;
     }
 
-    if(_encodingMajor < p->_encodingMajor)
+    if(!_compress && p->_compress)
     {
         return true;
     }
-    else if(p->_encodingMajor < _encodingMajor)
+    else if(p->_compress < _compress)
     {
         return false;
     }
 
-    if(_encodingMinor < p->_encodingMinor)
+    if(!_connect && p->_connect)
     {
         return true;
     }
-    else if(p->_encodingMinor < _encodingMinor)
+    else if(!p->_connect && _connect)
     {
         return false;
     }
@@ -826,8 +652,8 @@ IceInternal::UdpEndpointI::connectors(const vector<struct sockaddr_storage>& add
     vector<ConnectorPtr> connectors;
     for(unsigned int i = 0; i < addresses.size(); ++i)
     {
-        connectors.push_back(new UdpConnector(_instance, addresses[i], _mcastInterface, _mcastTtl, _protocolMajor,
-                                              _protocolMinor, _encodingMajor, _encodingMinor, _connectionId));
+        connectors.push_back(new UdpConnector(_instance, addresses[i], _mcastInterface, _mcastTtl, _protocol, _encoding,
+                                              _connectionId));
     }
     return connectors;
 }