Expanded tabs into spaces

1 files changed, 453 insertions, 453 deletions

diff --git a/java/src/IceInternal/OutgoingConnectionFactory.java b/java/src/IceInternal/OutgoingConnectionFactory.java
index bad0c4edba8..d44b99cdabe 100644
--- a/java/src/IceInternal/OutgoingConnectionFactory.java
+++ b/java/src/IceInternal/OutgoingConnectionFactory.java
@@ -22,15 +22,15 @@ public final class OutgoingConnectionFactory
         java.util.Iterator p = _connections.values().iterator();
         while(p.hasNext())
         {
-	    java.util.LinkedList connectionList = (java.util.LinkedList)p.next();
-		
-	    java.util.Iterator q = connectionList.iterator();
-	    while(q.hasNext())
-	    {
-		Ice.ConnectionI connection = (Ice.ConnectionI)q.next();
-		connection.destroy(Ice.ConnectionI.CommunicatorDestroyed);
-	    }
-	}
+            java.util.LinkedList connectionList = (java.util.LinkedList)p.next();
+                
+            java.util.Iterator q = connectionList.iterator();
+            while(q.hasNext())
+            {
+                Ice.ConnectionI connection = (Ice.ConnectionI)q.next();
+                connection.destroy(Ice.ConnectionI.CommunicatorDestroyed);
+            }
+        }
 
         _destroyed = true;
         notifyAll();
@@ -39,72 +39,72 @@ public final class OutgoingConnectionFactory
     public void
     waitUntilFinished()
     {
-	java.util.HashMap connections;
-
-	synchronized(this)
-	{
-	    //
-	    // First we wait until the factory is destroyed. We also
-	    // wait until there are no pending connections
-	    // anymore. Only then we can be sure the _connections
-	    // contains all connections.
-	    //
-	    while(!_destroyed || !_pending.isEmpty())
-	    {
-		try
-		{
-		    wait();
-		}
-		catch(InterruptedException ex)
-		{
-		}
-	    }
-
-	    //
-	    // We want to wait until all connections are finished outside the
-	    // thread synchronization.
-	    //
-	    // For consistency with C#, we set _connections to null rather than to a
-	    // new empty list so that our finalizer does not try to invoke any
-	    // methods on member objects.
-	    //
-	    connections = _connections;
-	    _connections = null;
-	}
-	
-	//
-	// Now we wait for until the destruction of each connection is
-	// finished.
-	//
+        java.util.HashMap connections;
+
+        synchronized(this)
+        {
+            //
+            // First we wait until the factory is destroyed. We also
+            // wait until there are no pending connections
+            // anymore. Only then we can be sure the _connections
+            // contains all connections.
+            //
+            while(!_destroyed || !_pending.isEmpty())
+            {
+                try
+                {
+                    wait();
+                }
+                catch(InterruptedException ex)
+                {
+                }
+            }
+
+            //
+            // We want to wait until all connections are finished outside the
+            // thread synchronization.
+            //
+            // For consistency with C#, we set _connections to null rather than to a
+            // new empty list so that our finalizer does not try to invoke any
+            // methods on member objects.
+            //
+            connections = _connections;
+            _connections = null;
+        }
+        
+        //
+        // Now we wait for until the destruction of each connection is
+        // finished.
+        //
         java.util.Iterator p = connections.values().iterator();
         while(p.hasNext())
         {
-	    java.util.LinkedList connectionList = (java.util.LinkedList)p.next();
-		
-	    java.util.Iterator q = connectionList.iterator();
-	    while(q.hasNext())
-	    {
-		Ice.ConnectionI connection = (Ice.ConnectionI)q.next();
-		connection.waitUntilFinished();
-	    }
+            java.util.LinkedList connectionList = (java.util.LinkedList)p.next();
+                
+            java.util.Iterator q = connectionList.iterator();
+            while(q.hasNext())
+            {
+                Ice.ConnectionI connection = (Ice.ConnectionI)q.next();
+                connection.waitUntilFinished();
+            }
         }
     }
 
     public Ice.ConnectionI
     create(EndpointI[] endpts, boolean hasMore, boolean threadPerConnection, Ice.BooleanHolder compress)
     {
-	assert(endpts.length > 0);
-	EndpointI[] endpoints = new EndpointI[endpts.length];
-	System.arraycopy(endpts, 0, endpoints, 0, endpts.length);
+        assert(endpts.length > 0);
+        EndpointI[] endpoints = new EndpointI[endpts.length];
+        System.arraycopy(endpts, 0, endpoints, 0, endpts.length);
 
         DefaultsAndOverrides defaultsAndOverrides = _instance.defaultsAndOverrides();
 
-	synchronized(this)
-	{
-	    if(_destroyed)
-	    {
-		throw new Ice.CommunicatorDestroyedException();
-	    }
+        synchronized(this)
+        {
+            if(_destroyed)
+            {
+                throw new Ice.CommunicatorDestroyedException();
+            }
 
             //
             // TODO: Remove when we no longer support SSL for JDK 1.4.
@@ -119,296 +119,296 @@ public final class OutgoingConnectionFactory
                 }
             }
 
-	    //
-	    // Reap connections for which destruction has completed.
-	    //
-	    java.util.Iterator p = _connections.values().iterator();
-	    while(p.hasNext())
-	    {
-		java.util.LinkedList connectionList = (java.util.LinkedList)p.next();
-		
-		java.util.Iterator q = connectionList.iterator();
-		while(q.hasNext())
-		{
-		    Ice.ConnectionI con = (Ice.ConnectionI)q.next();
-		    if(con.isFinished())
-		    {
-			q.remove();
-		    }
-		}
-
-		if(connectionList.isEmpty())
-		{
-		    p.remove();
-		}
-	    }
-
-	    //
-	    // Modify endpoints with overrides.
-	    //
-	    for(int i = 0; i < endpoints.length; i++)
-	    {
-		if(defaultsAndOverrides.overrideTimeout)
-		{
-		    endpoints[i] = endpoints[i].timeout(defaultsAndOverrides.overrideTimeoutValue);
-		}
-
-		//
-		// The Connection object does not take the compression flag of
-		// endpoints into account, but instead gets the information
-		// about whether messages should be compressed or not from
-		// other sources. In order to allow connection sharing for
-		// endpoints that differ in the value of the compression flag
-		// only, we always set the compression flag to false here in
-		// this connection factory.
-		//
-		endpoints[i] = endpoints[i].compress(false);
-	    }
-
-	    //
-	    // Search for existing connections.
-	    //
-	    for(int i = 0; i < endpoints.length; i++)
-	    {
-		java.util.LinkedList connectionList = (java.util.LinkedList)_connections.get(endpoints[i]);
-		if(connectionList != null)
-		{
-		    java.util.Iterator q = connectionList.iterator();
-			
-		    while(q.hasNext())
-		    {
-			Ice.ConnectionI connection = (Ice.ConnectionI)q.next();
-			
-			//
-			// Don't return connections for which destruction has
-			// been initiated. The connection must also match the
+            //
+            // Reap connections for which destruction has completed.
+            //
+            java.util.Iterator p = _connections.values().iterator();
+            while(p.hasNext())
+            {
+                java.util.LinkedList connectionList = (java.util.LinkedList)p.next();
+                
+                java.util.Iterator q = connectionList.iterator();
+                while(q.hasNext())
+                {
+                    Ice.ConnectionI con = (Ice.ConnectionI)q.next();
+                    if(con.isFinished())
+                    {
+                        q.remove();
+                    }
+                }
+
+                if(connectionList.isEmpty())
+                {
+                    p.remove();
+                }
+            }
+
+            //
+            // Modify endpoints with overrides.
+            //
+            for(int i = 0; i < endpoints.length; i++)
+            {
+                if(defaultsAndOverrides.overrideTimeout)
+                {
+                    endpoints[i] = endpoints[i].timeout(defaultsAndOverrides.overrideTimeoutValue);
+                }
+
+                //
+                // The Connection object does not take the compression flag of
+                // endpoints into account, but instead gets the information
+                // about whether messages should be compressed or not from
+                // other sources. In order to allow connection sharing for
+                // endpoints that differ in the value of the compression flag
+                // only, we always set the compression flag to false here in
+                // this connection factory.
+                //
+                endpoints[i] = endpoints[i].compress(false);
+            }
+
+            //
+            // Search for existing connections.
+            //
+            for(int i = 0; i < endpoints.length; i++)
+            {
+                java.util.LinkedList connectionList = (java.util.LinkedList)_connections.get(endpoints[i]);
+                if(connectionList != null)
+                {
+                    java.util.Iterator q = connectionList.iterator();
+                        
+                    while(q.hasNext())
+                    {
+                        Ice.ConnectionI connection = (Ice.ConnectionI)q.next();
+                        
+                        //
+                        // Don't return connections for which destruction has
+                        // been initiated. The connection must also match the
                         // requested thread-per-connection setting.
-			//
-			if(!connection.isDestroyed() && connection.threadPerConnection() == threadPerConnection)
-			{
-			    if(defaultsAndOverrides.overrideCompress)
-			    {
-				compress.value = defaultsAndOverrides.overrideCompressValue;
-			    }
-			    else
-			    {
-				compress.value = endpts[i].compress();
-			    }
-
-			    return connection;
-			}
-		    }
-		}
-	    }
-
-	    //
-	    // If some other thread is currently trying to establish a
-	    // connection to any of our endpoints, we wait until this
-	    // thread is finished.
-	    //
-	    boolean searchAgain = false;
-	    while(!_destroyed)
-	    {
-		int i;
-		for(i = 0; i < endpoints.length; i++)
-		{
-		    if(_pending.contains(endpoints[i]))
-		    {
-			break;
-		    }
-		}
-		
-		if(i == endpoints.length)
-		{
-		    break;
-		}
-		
-		searchAgain = true;
-
-		try
-		{
-		    wait();
-		}
-		catch(InterruptedException ex)
-		{
-		}
-	    }
-
-	    if(_destroyed)
-	    {
-		throw new Ice.CommunicatorDestroyedException();
-	    }
-
-	    //
-	    // Search for existing connections again if we waited
-	    // above, as new connections might have been added in the
-	    // meantime.
-	    //
-	    if(searchAgain)
-	    {
-		for(int i = 0; i < endpoints.length; i++)
-		{
-		    java.util.LinkedList connectionList = (java.util.LinkedList)_connections.get(endpoints[i]);
-		    if(connectionList != null)
-		    {
-			java.util.Iterator q = connectionList.iterator();
-			
-			while(q.hasNext())
-			{
-			    Ice.ConnectionI connection = (Ice.ConnectionI)q.next();
-			    
-			    //
-			    // Don't return connections for which destruction has
+                        //
+                        if(!connection.isDestroyed() && connection.threadPerConnection() == threadPerConnection)
+                        {
+                            if(defaultsAndOverrides.overrideCompress)
+                            {
+                                compress.value = defaultsAndOverrides.overrideCompressValue;
+                            }
+                            else
+                            {
+                                compress.value = endpts[i].compress();
+                            }
+
+                            return connection;
+                        }
+                    }
+                }
+            }
+
+            //
+            // If some other thread is currently trying to establish a
+            // connection to any of our endpoints, we wait until this
+            // thread is finished.
+            //
+            boolean searchAgain = false;
+            while(!_destroyed)
+            {
+                int i;
+                for(i = 0; i < endpoints.length; i++)
+                {
+                    if(_pending.contains(endpoints[i]))
+                    {
+                        break;
+                    }
+                }
+                
+                if(i == endpoints.length)
+                {
+                    break;
+                }
+                
+                searchAgain = true;
+
+                try
+                {
+                    wait();
+                }
+                catch(InterruptedException ex)
+                {
+                }
+            }
+
+            if(_destroyed)
+            {
+                throw new Ice.CommunicatorDestroyedException();
+            }
+
+            //
+            // Search for existing connections again if we waited
+            // above, as new connections might have been added in the
+            // meantime.
+            //
+            if(searchAgain)
+            {
+                for(int i = 0; i < endpoints.length; i++)
+                {
+                    java.util.LinkedList connectionList = (java.util.LinkedList)_connections.get(endpoints[i]);
+                    if(connectionList != null)
+                    {
+                        java.util.Iterator q = connectionList.iterator();
+                        
+                        while(q.hasNext())
+                        {
+                            Ice.ConnectionI connection = (Ice.ConnectionI)q.next();
+                            
+                            //
+                            // Don't return connections for which destruction has
                             // been initiated. The connection must also match the
                             // requested thread-per-connection setting.
-			    //
+                            //
                             if(!connection.isDestroyed() && connection.threadPerConnection() == threadPerConnection)
-			    {
-				if(defaultsAndOverrides.overrideCompress)
-				{
-				    compress.value = defaultsAndOverrides.overrideCompressValue;
-				}
-				else
-				{
-				    compress.value = endpts[i].compress();
-				}
-
-				return connection;
-			    }
-			}
-		    }
-		}
-	    }
-
-	    //
-	    // No connection to any of our endpoints exists yet, so we
-	    // will try to create one. To avoid that other threads try
-	    // to create connections to the same endpoints, we add our
-	    // endpoints to _pending.
-	    //
-	    for(int i = 0; i < endpoints.length; i++)
-	    {
-		_pending.add(endpoints[i]);
-	    }
-	}
-
-	Ice.ConnectionI connection = null;
-	Ice.LocalException exception = null;
-
-	for(int i = 0; i < endpoints.length; i++)
-	{
-	    EndpointI endpoint = endpoints[i];
-
-	    try
-	    {
-		Transceiver transceiver = endpoint.clientTransceiver();
-		if(transceiver == null)
-		{
-		    Connector connector = endpoint.connector();
-		    assert(connector != null);
-
-		    int timeout;
-		    if(defaultsAndOverrides.overrideConnectTimeout)
-		    {
-			timeout = defaultsAndOverrides.overrideConnectTimeoutValue;
-		    }
-		    // It is not necessary to check for overrideTimeout,
-		    // the endpoint has already been modified with this
-		    // override, if set.
-		    else
-		    {
-			timeout = endpoint.timeout();
-		    }
-
-		    transceiver = connector.connect(timeout);
-		    assert(transceiver != null);
-		}
-		connection = new Ice.ConnectionI(_instance, transceiver, endpoint, null, threadPerConnection);
-		connection.validate();
-
-		if(defaultsAndOverrides.overrideCompress)
-		{
-		    compress.value = defaultsAndOverrides.overrideCompressValue;
-		}
-		else
-		{
-		    compress.value = endpts[i].compress();
-		}
-		break;
-	    }
-	    catch(Ice.LocalException ex)
-	    {
-		exception = ex;
-
-		//
-		// If a connection object was constructed, then validate()
-		// must have raised the exception.
-		//
-		if(connection != null)
-		{
-		    connection.waitUntilFinished(); // We must call waitUntilFinished() for cleanup.
-		    connection = null;
-		}
-	    }
-	    
-	    TraceLevels traceLevels = _instance.traceLevels();
-	    if(traceLevels.retry >= 2)
-	    {
-		StringBuffer s = new StringBuffer();
-		s.append("connection to endpoint failed");
-		if(hasMore || i < endpoints.length - 1)
-		{
-		    s.append(", trying next endpoint\n");
-		}
-		else
-		{
-		    s.append(" and no more endpoints to try\n");
-		}
-		s.append(exception.toString());
-		_instance.initializationData().logger.trace(traceLevels.retryCat, s.toString());
-	    }
-	}
-	
-	synchronized(this)
-	{
-	    //
-	    // Signal other threads that we are done with trying to
-	    // establish connections to our endpoints.
-	    //
-	    for(int i = 0; i < endpoints.length; i++)
-	    {
-		_pending.remove(endpoints[i]);
-	    }
-	    notifyAll();
-	    
-	    if(connection == null)
-	    {
-		assert(exception != null);
-		throw exception;
-	    }
-	    else
-	    {
-		java.util.LinkedList connectionList = (java.util.LinkedList)_connections.get(connection.endpoint());
-		if(connectionList == null)
-		{
-		    connectionList = new java.util.LinkedList();
-		    _connections.put(connection.endpoint(), connectionList);
-		}
-		connectionList.add(connection);
-
-		if(_destroyed)
-		{
-		    connection.destroy(Ice.ConnectionI.CommunicatorDestroyed);
-		    throw new Ice.CommunicatorDestroyedException();
-		}
-		else
-		{
-		    connection.activate();
-		}
-	    }
-	}
-	
-	assert(connection != null);
+                            {
+                                if(defaultsAndOverrides.overrideCompress)
+                                {
+                                    compress.value = defaultsAndOverrides.overrideCompressValue;
+                                }
+                                else
+                                {
+                                    compress.value = endpts[i].compress();
+                                }
+
+                                return connection;
+                            }
+                        }
+                    }
+                }
+            }
+
+            //
+            // No connection to any of our endpoints exists yet, so we
+            // will try to create one. To avoid that other threads try
+            // to create connections to the same endpoints, we add our
+            // endpoints to _pending.
+            //
+            for(int i = 0; i < endpoints.length; i++)
+            {
+                _pending.add(endpoints[i]);
+            }
+        }
+
+        Ice.ConnectionI connection = null;
+        Ice.LocalException exception = null;
+
+        for(int i = 0; i < endpoints.length; i++)
+        {
+            EndpointI endpoint = endpoints[i];
+
+            try
+            {
+                Transceiver transceiver = endpoint.clientTransceiver();
+                if(transceiver == null)
+                {
+                    Connector connector = endpoint.connector();
+                    assert(connector != null);
+
+                    int timeout;
+                    if(defaultsAndOverrides.overrideConnectTimeout)
+                    {
+                        timeout = defaultsAndOverrides.overrideConnectTimeoutValue;
+                    }
+                    // It is not necessary to check for overrideTimeout,
+                    // the endpoint has already been modified with this
+                    // override, if set.
+                    else
+                    {
+                        timeout = endpoint.timeout();
+                    }
+
+                    transceiver = connector.connect(timeout);
+                    assert(transceiver != null);
+                }
+                connection = new Ice.ConnectionI(_instance, transceiver, endpoint, null, threadPerConnection);
+                connection.validate();
+
+                if(defaultsAndOverrides.overrideCompress)
+                {
+                    compress.value = defaultsAndOverrides.overrideCompressValue;
+                }
+                else
+                {
+                    compress.value = endpts[i].compress();
+                }
+                break;
+            }
+            catch(Ice.LocalException ex)
+            {
+                exception = ex;
+
+                //
+                // If a connection object was constructed, then validate()
+                // must have raised the exception.
+                //
+                if(connection != null)
+                {
+                    connection.waitUntilFinished(); // We must call waitUntilFinished() for cleanup.
+                    connection = null;
+                }
+            }
+            
+            TraceLevels traceLevels = _instance.traceLevels();
+            if(traceLevels.retry >= 2)
+            {
+                StringBuffer s = new StringBuffer();
+                s.append("connection to endpoint failed");
+                if(hasMore || i < endpoints.length - 1)
+                {
+                    s.append(", trying next endpoint\n");
+                }
+                else
+                {
+                    s.append(" and no more endpoints to try\n");
+                }
+                s.append(exception.toString());
+                _instance.initializationData().logger.trace(traceLevels.retryCat, s.toString());
+            }
+        }
+        
+        synchronized(this)
+        {
+            //
+            // Signal other threads that we are done with trying to
+            // establish connections to our endpoints.
+            //
+            for(int i = 0; i < endpoints.length; i++)
+            {
+                _pending.remove(endpoints[i]);
+            }
+            notifyAll();
+            
+            if(connection == null)
+            {
+                assert(exception != null);
+                throw exception;
+            }
+            else
+            {
+                java.util.LinkedList connectionList = (java.util.LinkedList)_connections.get(connection.endpoint());
+                if(connectionList == null)
+                {
+                    connectionList = new java.util.LinkedList();
+                    _connections.put(connection.endpoint(), connectionList);
+                }
+                connectionList.add(connection);
+
+                if(_destroyed)
+                {
+                    connection.destroy(Ice.ConnectionI.CommunicatorDestroyed);
+                    throw new Ice.CommunicatorDestroyedException();
+                }
+                else
+                {
+                    connection.activate();
+                }
+            }
+        }
+        
+        assert(connection != null);
         return connection;
     }
 
@@ -422,59 +422,59 @@ public final class OutgoingConnectionFactory
 
         assert(routerInfo != null);
 
-	//
-	// Search for connections to the router's client proxy
-	// endpoints, and update the object adapter for such
-	// connections, so that callbacks from the router can be
-	// received over such connections.
-	//
-	Ice.ObjectAdapter adapter = routerInfo.getAdapter();
-	DefaultsAndOverrides defaultsAndOverrides = _instance.defaultsAndOverrides();
-	EndpointI[] endpoints = routerInfo.getClientEndpoints();
-	for(int i = 0; i < endpoints.length; i++)
-	{
-	    EndpointI endpoint = endpoints[i];
-
-	    //
-	    // Modify endpoints with overrides.
-	    //
-	    if(defaultsAndOverrides.overrideTimeout)
-	    {
-		endpoint = endpoint.timeout(defaultsAndOverrides.overrideTimeoutValue);
-	    }
-
-	    //
-	    // The Connection object does not take the compression flag of
-	    // endpoints into account, but instead gets the information
-	    // about whether messages should be compressed or not from
-	    // other sources. In order to allow connection sharing for
-	    // endpoints that differ in the value of the compression flag
-	    // only, we always set the compression flag to false here in
-	    // this connection factory.
-	    //
-	    endpoint = endpoint.compress(false);
-
-	    java.util.LinkedList connectionList = (java.util.LinkedList)_connections.get(endpoints[i]);
-	    if(connectionList != null)
-	    {
-		java.util.Iterator p = connectionList.iterator();
-
-		while(p.hasNext())
-		{
-		    Ice.ConnectionI connection = (Ice.ConnectionI)p.next();
-		    try
-		    {
-			connection.setAdapter(adapter);
-		    }
-		    catch(Ice.LocalException ex)
-		    {
-			//
-			// Ignore, the connection is being closed or closed.
-			//
-		    }
-		}
-	    }
-	}
+        //
+        // Search for connections to the router's client proxy
+        // endpoints, and update the object adapter for such
+        // connections, so that callbacks from the router can be
+        // received over such connections.
+        //
+        Ice.ObjectAdapter adapter = routerInfo.getAdapter();
+        DefaultsAndOverrides defaultsAndOverrides = _instance.defaultsAndOverrides();
+        EndpointI[] endpoints = routerInfo.getClientEndpoints();
+        for(int i = 0; i < endpoints.length; i++)
+        {
+            EndpointI endpoint = endpoints[i];
+
+            //
+            // Modify endpoints with overrides.
+            //
+            if(defaultsAndOverrides.overrideTimeout)
+            {
+                endpoint = endpoint.timeout(defaultsAndOverrides.overrideTimeoutValue);
+            }
+
+            //
+            // The Connection object does not take the compression flag of
+            // endpoints into account, but instead gets the information
+            // about whether messages should be compressed or not from
+            // other sources. In order to allow connection sharing for
+            // endpoints that differ in the value of the compression flag
+            // only, we always set the compression flag to false here in
+            // this connection factory.
+            //
+            endpoint = endpoint.compress(false);
+
+            java.util.LinkedList connectionList = (java.util.LinkedList)_connections.get(endpoints[i]);
+            if(connectionList != null)
+            {
+                java.util.Iterator p = connectionList.iterator();
+
+                while(p.hasNext())
+                {
+                    Ice.ConnectionI connection = (Ice.ConnectionI)p.next();
+                    try
+                    {
+                        connection.setAdapter(adapter);
+                    }
+                    catch(Ice.LocalException ex)
+                    {
+                        //
+                        // Ignore, the connection is being closed or closed.
+                        //
+                    }
+                }
+            }
+        }
     }
 
     public synchronized void
@@ -488,61 +488,61 @@ public final class OutgoingConnectionFactory
         java.util.Iterator p = _connections.values().iterator();
         while(p.hasNext())
         {
-	    java.util.LinkedList connectionList = (java.util.LinkedList)p.next();
-		
-	    java.util.Iterator q = connectionList.iterator();
-	    while(q.hasNext())
-	    {
-		Ice.ConnectionI connection = (Ice.ConnectionI)q.next();
-		if(connection.getAdapter() == adapter)
-		{
-		    try
-		    {
-			connection.setAdapter(null);
-		    }
-		    catch(Ice.LocalException ex)
-		    {
-			//
-			// Ignore, the connection is being closed or closed.
-			//
-		    }
-		}
-	    }
-	}
+            java.util.LinkedList connectionList = (java.util.LinkedList)p.next();
+                
+            java.util.Iterator q = connectionList.iterator();
+            while(q.hasNext())
+            {
+                Ice.ConnectionI connection = (Ice.ConnectionI)q.next();
+                if(connection.getAdapter() == adapter)
+                {
+                    try
+                    {
+                        connection.setAdapter(null);
+                    }
+                    catch(Ice.LocalException ex)
+                    {
+                        //
+                        // Ignore, the connection is being closed or closed.
+                        //
+                    }
+                }
+            }
+        }
     }
 
     public void
     flushBatchRequests()
     {
-	java.util.LinkedList c = new java.util.LinkedList();
+        java.util.LinkedList c = new java.util.LinkedList();
 
         synchronized(this)
-	{
-	    java.util.Iterator p = _connections.values().iterator();
-	    while(p.hasNext())
-	    {
-		java.util.LinkedList connectionList = (java.util.LinkedList)p.next();
-		java.util.Iterator q = connectionList.iterator();
-		while(q.hasNext())
-		{
-		    c.add(q.next());
-		}
-	    }
-	}
-
-	java.util.Iterator p = c.iterator();
-	while(p.hasNext())
-	{
-	    Ice.ConnectionI conn = (Ice.ConnectionI)p.next();
-	    try
-	    {
-		conn.flushBatchRequests();
-	    }
-	    catch(Ice.LocalException ex)
-	    {
-		// Ignore.
-	    }
-	}
+        {
+            java.util.Iterator p = _connections.values().iterator();
+            while(p.hasNext())
+            {
+                java.util.LinkedList connectionList = (java.util.LinkedList)p.next();
+                java.util.Iterator q = connectionList.iterator();
+                while(q.hasNext())
+                {
+                    c.add(q.next());
+                }
+            }
+        }
+
+        java.util.Iterator p = c.iterator();
+        while(p.hasNext())
+        {
+            Ice.ConnectionI conn = (Ice.ConnectionI)p.next();
+            try
+            {
+                conn.flushBatchRequests();
+            }
+            catch(Ice.LocalException ex)
+            {
+                // Ignore.
+            }
+        }
     }
 
     //
@@ -551,15 +551,15 @@ public final class OutgoingConnectionFactory
     OutgoingConnectionFactory(Instance instance)
     {
         _instance = instance;
-	_destroyed = false;
+        _destroyed = false;
     }
 
     protected synchronized void
     finalize()
         throws Throwable
     {
-	IceUtil.Assert.FinalizerAssert(_destroyed);
-	IceUtil.Assert.FinalizerAssert(_connections == null);
+        IceUtil.Assert.FinalizerAssert(_destroyed);
+        IceUtil.Assert.FinalizerAssert(_connections == null);
 
         super.finalize();
     }