porting C++ transport changes to Java

1 files changed, 122 insertions, 364 deletions

diff --git a/java/src/IceInternal/TcpEndpointI.java b/java/src/IceInternal/TcpEndpointI.java
index 9e6594b20ad..6fb7a7e9ce1 100644
--- a/java/src/IceInternal/TcpEndpointI.java
+++ b/java/src/IceInternal/TcpEndpointI.java
@@ -9,284 +9,61 @@
 
 package IceInternal;
 
-final class TcpEndpointI extends EndpointI
+final class TcpEndpointI extends IPEndpointI
 {
-    public
-    TcpEndpointI(Instance instance, String ho, int po, int ti, String conId, boolean co)
+    public TcpEndpointI(ProtocolInstance instance, String ho, int po, int ti, String conId, boolean co)
     {
-        super(conId);
-        _instance = instance;
-        _host = ho;
-        _port = po;
+        super(instance, ho, po, conId);
         _timeout = ti;
         _compress = co;
-        calcHashValue();
     }
 
-    public
-    TcpEndpointI(Instance instance, String str, boolean oaEndpoint)
+    public TcpEndpointI(ProtocolInstance instance)
     {
-        super("");
-        _instance = instance;
-        _host = null;
-        _port = 0;
+        super(instance);
         _timeout = -1;
         _compress = false;
-
-        String[] arr = str.split("[ \t\n\r]+");
-
-        int i = 0;
-        while(i < arr.length)
-        {
-            if(arr[i].length() == 0)
-            {
-                i++;
-                continue;
-            }
-
-            String option = arr[i++];
-            if(option.length() != 2 || option.charAt(0) != '-')
-            {
-                throw new Ice.EndpointParseException("expected an endpoint option but found `" + option +
-                                                     "' in endpoint `tcp " + str + "'");
-            }
-
-            String argument = null;
-            if(i < arr.length && arr[i].charAt(0) != '-')
-            {
-                argument = arr[i++];
-                if(argument.charAt(0) == '\"' && argument.charAt(argument.length() - 1) == '\"')
-                {
-                    argument = argument.substring(1, argument.length() - 1);
-                }
-            }
-
-            switch(option.charAt(1))
-            {
-                case 'h':
-                {
-                    if(argument == null)
-                    {
-                        throw new Ice.EndpointParseException("no argument provided for -h option in endpoint `tcp "
-                                                             + str + "'");
-                    }
-
-                    _host = argument;
-                    break;
-                }
-
-                case 'p':
-                {
-                    if(argument == null)
-                    {
-                        throw new Ice.EndpointParseException("no argument provided for -p option in endpoint `tcp "
-                                                             + str + "'");
-                    }
-
-                    try
-                    {
-                        _port = Integer.parseInt(argument);
-                    }
-                    catch(NumberFormatException ex)
-                    {
-                        throw new Ice.EndpointParseException("invalid port value `" + argument +
-                                                             "' in endpoint `tcp " + str + "'");
-                    }
-
-                    if(_port < 0 || _port > 65535)
-                    {
-                        throw new Ice.EndpointParseException("port value `" + argument +
-                                                             "' out of range in endpoint `tcp " + str + "'");
-                    }
-
-                    break;
-                }
-
-                case 't':
-                {
-                    if(argument == null)
-                    {
-                        throw new Ice.EndpointParseException("no argument provided for -t option in endpoint `tcp "
-                                                             + str + "'");
-                    }
-
-                    try
-                    {
-                        _timeout = Integer.parseInt(argument);
-                    }
-                    catch(NumberFormatException ex)
-                    {
-                        throw new Ice.EndpointParseException("invalid timeout value `" + argument +
-                                                             "' in endpoint `tcp " + str + "'");
-                    }
-
-                    break;
-                }
-
-                case 'z':
-                {
-                    if(argument != null)
-                    {
-                        throw new Ice.EndpointParseException("unexpected argument `" + argument +
-                                                             "' provided for -z option in `tcp " + str + "'");
-                    }
-
-                    _compress = true;
-                    break;
-                }
-
-                default:
-                {
-                    throw new Ice.EndpointParseException("unknown option `" + option + "' in `tcp " + str + "'");
-                }
-            }
-        }
-
-        if(_host == null)
-        {
-            _host = _instance.defaultsAndOverrides().defaultHost;
-        }
-        else if(_host.equals("*"))
-        {
-            if(oaEndpoint)
-            {
-                _host = null;
-            }
-            else
-            {
-                throw new Ice.EndpointParseException("`-h *' not valid for proxy endpoint `tcp " + str + "'");
-            }
-        }
-
-        if(_host == null)
-        {
-            _host = "";
-        }
-
-        calcHashValue();
     }
 
-    public
-    TcpEndpointI(BasicStream s)
+    public TcpEndpointI(ProtocolInstance instance, BasicStream s)
     {
-        super("");
-        _instance = s.instance();
-        s.startReadEncaps();
-        _host = s.readString();
-        _port = s.readInt();
+        super(instance, s);
         _timeout = s.readInt();
         _compress = s.readBool();
-        s.endReadEncaps();
-        calcHashValue();
-    }
-
-    //
-    // Marshal the endpoint
-    //
-    public void
-    streamWrite(BasicStream s)
-    {
-        s.writeShort(Ice.TCPEndpointType.value);
-        s.startWriteEncaps();
-        s.writeString(_host);
-        s.writeInt(_port);
-        s.writeInt(_timeout);
-        s.writeBool(_compress);
-        s.endWriteEncaps();
-    }
-
-    //
-    // Convert the endpoint to its string form
-    //
-    public String
-    _toString()
-    {
-        //
-        // WARNING: Certain features, such as proxy validation in Glacier2,
-        // depend on the format of proxy strings. Changes to toString() and
-        // methods called to generate parts of the reference string could break
-        // these features. Please review for all features that depend on the
-        // format of proxyToString() before changing this and related code.
-        //
-        String s = "tcp";
-
-        if(_host != null && _host.length() > 0)
-        {
-            s += " -h ";
-            boolean addQuote = _host.indexOf(':') != -1;
-            if(addQuote)
-            {
-                s += "\"";
-            }
-            s += _host; 
-            if(addQuote)
-            {
-                s += "\"";
-            }
-        }
-
-        s += " -p " + _port;
-
-        if(_timeout != -1)
-        {
-            s += " -t " + _timeout;
-        }
-        if(_compress)
-        {
-            s += " -z";
-        }
-        return s;
     }
 
     //
     // Return the endpoint information.
     //
-    public Ice.EndpointInfo
-    getInfo()
+    public Ice.EndpointInfo getInfo()
     {
-        return new Ice.TCPEndpointInfo(_timeout, _compress, _host, _port)
+        Ice.TCPEndpointInfo info = new Ice.TCPEndpointInfo()
             {
                 public short type()
                 {
-                    return Ice.TCPEndpointType.value;
+                    return TcpEndpointI.this.type();
                 }
-                
+
                 public boolean datagram()
                 {
-                    return false;
+                    return TcpEndpointI.this.datagram();
                 }
-                
+
                 public boolean secure()
                 {
-                    return false;
+                    return TcpEndpointI.this.secure();
                 }
-        };
-    }
-
-    //
-    // Return the endpoint type
-    //
-    public short
-    type()
-    {
-        return Ice.TCPEndpointType.value;
-    }
+            };
 
-    //
-    // Return the protocol name
-    //
-    public String
-    protocol()
-    {
-        return "tcp";
+        fillEndpointInfo(info);
+        return info;
     }
 
     //
     // Return the timeout for the endpoint in milliseconds. 0 means
     // non-blocking, -1 means no timeout.
     //
-    public int
-    timeout()
+    public int timeout()
     {
         return _timeout;
     }
@@ -296,8 +73,7 @@ final class TcpEndpointI extends EndpointI
     // that timeouts are supported by the endpoint. Otherwise the same
     // endpoint is returned.
     //
-    public EndpointI
-    timeout(int timeout)
+    public EndpointI timeout(int timeout)
     {
         if(timeout == _timeout)
         {
@@ -310,27 +86,10 @@ final class TcpEndpointI extends EndpointI
     }
 
     //
-    // Return a new endpoint with a different connection id.
-    //
-    public EndpointI
-    connectionId(String connectionId)
-    {
-        if(connectionId.equals(_connectionId))
-        {
-            return this;
-        }
-        else
-        {
-            return new TcpEndpointI(_instance, _host, _port, _timeout, connectionId, _compress);
-        }
-    }
-
-    //
     // Return true if the endpoints support bzip2 compress, or false
     // otherwise.
     //
-    public boolean
-    compress()
+    public boolean compress()
     {
         return _compress;
     }
@@ -340,8 +99,7 @@ final class TcpEndpointI extends EndpointI
     // provided that compression is supported by the
     // endpoint. Otherwise the same endpoint is returned.
     //
-    public EndpointI
-    compress(boolean compress)
+    public EndpointI compress(boolean compress)
     {
         if(compress == _compress)
         {
@@ -356,8 +114,7 @@ final class TcpEndpointI extends EndpointI
     //
     // Return true if the endpoint is datagram-based.
     //
-    public boolean
-    datagram()
+    public boolean datagram()
     {
         return false;
     }
@@ -365,8 +122,7 @@ final class TcpEndpointI extends EndpointI
     //
     // Return true if the endpoint is secure.
     //
-    public boolean
-    secure()
+    public boolean secure()
     {
         return false;
     }
@@ -378,103 +134,54 @@ final class TcpEndpointI extends EndpointI
     // "effective" endpoint, which might differ from this endpoint,
     // for example, if a dynamic port number is assigned.
     //
-    public Transceiver
-    transceiver(EndpointIHolder endpoint)
+    public Transceiver transceiver(EndpointIHolder endpoint)
     {
         endpoint.value = this;
         return null;
     }
 
     //
-    // Return connectors for this endpoint, or empty list if no connector
-    // is available.
-    //
-    public java.util.List<Connector>
-    connectors(Ice.EndpointSelectionType selType)
-    {
-        return _instance.endpointHostResolver().resolve(_host, _port, selType, this);
-    }
-
-    public void
-    connectors_async(Ice.EndpointSelectionType selType, EndpointI_connectors callback)
-    {
-        _instance.endpointHostResolver().resolve(_host, _port, selType, this, callback);
-    }
-
-    //
     // Return an acceptor for this endpoint, or null if no acceptors
     // is available. In case an acceptor is created, this operation
     // also returns a new "effective" endpoint, which might differ
     // from this endpoint, for example, if a dynamic port number is
     // assigned.
     //
-    public Acceptor
-    acceptor(EndpointIHolder endpoint, String adapterName)
+    public Acceptor acceptor(EndpointIHolder endpoint, String adapterName)
     {
         TcpAcceptor p = new TcpAcceptor(_instance, _host, _port);
-        endpoint.value = new TcpEndpointI(_instance, _host, p.effectivePort(), _timeout, _connectionId, _compress);
+        endpoint.value = createEndpoint(_host, p.effectivePort(), _connectionId);
         return p;
     }
 
-    //
-    // Expand endpoint out in to separate endpoints for each local
-    // host if listening on INADDR_ANY.
-    //
-    public java.util.List<EndpointI>
-    expand()
+    public String options()
     {
-        java.util.List<EndpointI> endps = new java.util.ArrayList<EndpointI>();
-        java.util.List<String> hosts = Network.getHostsForEndpointExpand(_host, _instance.protocolSupport(), false);
-        if(hosts == null || hosts.isEmpty())
-        {
-            endps.add(this);
-        }
-        else
-        {
-            for(String h : hosts)
-            {
-                endps.add(new TcpEndpointI(_instance, h, _port, _timeout, _connectionId, _compress));
-            }
-        }
-        return endps;
-    }
+        //
+        // WARNING: Certain features, such as proxy validation in Glacier2,
+        // depend on the format of proxy strings. Changes to toString() and
+        // methods called to generate parts of the reference string could break
+        // these features. Please review for all features that depend on the
+        // format of proxyToString() before changing this and related code.
+        //
+        String s = super.options();
 
-    //
-    // Check whether the endpoint is equivalent to another one.
-    //
-    public boolean
-    equivalent(EndpointI endpoint)
-    {
-        if(!(endpoint instanceof TcpEndpointI))
+        if(_timeout != -1)
         {
-            return false;
+            s += " -t " + _timeout;
         }
-        TcpEndpointI tcpEndpointI = (TcpEndpointI)endpoint;
-        return tcpEndpointI._host.equals(_host) && tcpEndpointI._port == _port;
-    }
 
-    public java.util.List<Connector>
-    connectors(java.util.List<java.net.InetSocketAddress> addresses, NetworkProxy proxy)
-    {
-        java.util.List<Connector> connectors = new java.util.ArrayList<Connector>();
-        for(java.net.InetSocketAddress p : addresses)
+        if(_compress)
         {
-            connectors.add(new TcpConnector(_instance, p, proxy, _timeout, _connectionId));
+            s += " -z";
         }
-        return connectors;
-    }
 
-    public int
-    hashCode()
-    {
-        return _hashCode;
+        return s;
     }
 
     //
     // Compare endpoints for sorting purposes
     //
-    public int
-    compareTo(EndpointI obj) // From java.lang.Comparable
+    public int compareTo(EndpointI obj) // From java.lang.Comparable
     {
         if(!(obj instanceof TcpEndpointI))
         {
@@ -486,23 +193,6 @@ final class TcpEndpointI extends EndpointI
         {
             return 0;
         }
-        else
-        {
-            int r = super.compareTo(p);
-            if(r != 0)
-            {
-                return r;
-            }
-        }
-
-        if(_port < p._port)
-        {
-            return -1;
-        }
-        else if(p._port < _port)
-        {
-            return 1;
-        }
 
         if(_timeout < p._timeout)
         {
@@ -522,26 +212,94 @@ final class TcpEndpointI extends EndpointI
             return 1;
         }
 
-        return _host.compareTo(p._host);
+        return super.compareTo(obj);
     }
 
-    private void
-    calcHashValue()
+    protected void streamWriteImpl(BasicStream s)
     {
-        int h = 5381;
-        h = IceInternal.HashUtil.hashAdd(h, Ice.TCPEndpointType.value);
-        h = IceInternal.HashUtil.hashAdd(h, _host);
-        h = IceInternal.HashUtil.hashAdd(h, _port);
+        super.streamWriteImpl(s);
+        s.writeInt(_timeout);
+        s.writeBool(_compress);
+    }
+
+    protected int hashInit(int h)
+    {
+        h = super.hashInit(h);
         h = IceInternal.HashUtil.hashAdd(h, _timeout);
-        h = IceInternal.HashUtil.hashAdd(h, _connectionId);
         h = IceInternal.HashUtil.hashAdd(h, _compress);
-        _hashCode = h;
+        return h;
+    }
+
+    protected void fillEndpointInfo(Ice.IPEndpointInfo info)
+    {
+        super.fillEndpointInfo(info);
+        if(info instanceof Ice.TCPEndpointInfo)
+        {
+            Ice.TCPEndpointInfo tcpInfo = (Ice.TCPEndpointInfo)info;
+            tcpInfo.timeout = _timeout;
+            tcpInfo.compress = _compress;
+        }
+    }
+
+    protected boolean checkOption(String option, String argument, String endpoint)
+    {
+        if(super.checkOption(option, argument, endpoint))
+        {
+            return true;
+        }
+
+        switch(option.charAt(1))
+        {
+            case 't':
+            {
+                if(argument == null)
+                {
+                    throw new Ice.EndpointParseException("no argument provided for -t option in endpoint " + endpoint);
+                }
+
+                try
+                {
+                    _timeout = Integer.parseInt(argument);
+                }
+                catch(NumberFormatException ex)
+                {
+                    throw new Ice.EndpointParseException("invalid timeout value `" + argument +
+                                                         "' in endpoint " + endpoint);
+                }
+
+                return true;
+            }
+
+            case 'z':
+            {
+                if(argument != null)
+                {
+                    throw new Ice.EndpointParseException("unexpected argument `" + argument +
+                                                         "' provided for -z option in " + endpoint);
+                }
+
+                _compress = true;
+
+                return true;
+            }
+
+            default:
+            {
+                return false;
+            }
+        }
+    }
+
+    protected Connector createConnector(java.net.InetSocketAddress addr, NetworkProxy proxy)
+    {
+        return new TcpConnector(_instance, addr, proxy, _timeout, _connectionId);
+    }
+
+    protected IPEndpointI createEndpoint(String host, int port, String connectionId)
+    {
+        return new TcpEndpointI(_instance, host, port, _timeout, connectionId, _compress);
     }
 
-    private Instance _instance;
-    private String _host;
-    private int _port;
     private int _timeout;
     private boolean _compress;
-    private int _hashCode;
 }