porting against C++ tag icej_baseline_02012002

9 files changed, 412 insertions, 154 deletions

diff --git a/java/src/Ice/Object.java b/java/src/Ice/Object.java
index 34af1efcc57..d02442f8fd3 100644
--- a/java/src/Ice/Object.java
+++ b/java/src/Ice/Object.java
@@ -78,8 +78,69 @@ public class Object
         return IceInternal.DispatchStatus.DispatchOK;
     }
 
+    public String[]
+    ice_ids(Current current)
+    {
+        //
+        // Note in general this must be __ids, not __classIds since
+        // __classIds is only classes and not interfaces.
+        //
+        return __classIds;
+    }
+
+    public static IceInternal.DispatchStatus
+    ___ice_ids(Ice.Object __obj, IceInternal.Incoming __in, Current __current)
+    {
+        IceInternal.BasicStream __os = __in.os();
+        String[] __ret = __obj.ice_ids(__current);
+        __os.writeStringSeq(__ret);
+        return IceInternal.DispatchStatus.DispatchOK;
+    }
+
+    public String
+    ice_id(Current current)
+    {
+        return __classIds[0];
+    }
+
+    public static IceInternal.DispatchStatus
+    ___ice_id(Ice.Object __obj, IceInternal.Incoming __in, Current __current)
+    {
+        IceInternal.BasicStream __os = __in.os();
+        String __ret = __obj.ice_id(__current);
+        __os.writeString(__ret);
+        return IceInternal.DispatchStatus.DispatchOK;
+    }
+
+    public final String[]
+    ice_facets(Current current)
+    {
+        java.util.Set keySet = _activeFacetMap.keySet();
+        String[] v = new String[keySet.size()];
+        keySet.toArray(v);
+        return v;
+    }
+
+    public static IceInternal.DispatchStatus
+    ___ice_facets(Ice.Object __obj, IceInternal.Incoming __in, Current __current)
+    {
+        IceInternal.BasicStream __os = __in.os();
+        String[] __ret = __obj.ice_facets(__current);
+        __os.writeStringSeq(__ret);
+        return IceInternal.DispatchStatus.DispatchOK;
+    }
+
+    public static String
+    ice_staticId()
+    {
+        return __classIds[0];
+    }
+
     private static String[] __all =
     {
+        "ice_facets",
+        "ice_id",
+        "ice_ids",
         "ice_isA",
         "ice_ping"
     };
@@ -97,10 +158,22 @@ public class Object
         {
             case 0:
             {
-                return ___ice_isA(this, in, current);
+                return ___ice_facets(this, in, current);
             }
             case 1:
             {
+                return ___ice_id(this, in, current);
+            }
+            case 2:
+            {
+                return ___ice_ids(this, in, current);
+            }
+            case 3:
+            {
+                return ___ice_isA(this, in, current);
+            }
+            case 4:
+            {
                 return ___ice_ping(this, in, current);
             }
         }
@@ -137,17 +210,75 @@ public class Object
 
             _activeFacetMap.clear();
 
-            Ice.ObjectHolder h = new Ice.ObjectHolder();
             while (sz-- > 0)
             {
                 String key = __is.readString();
-                __is.readObject("", h);
-                _activeFacetMap.put(key, h.value);
+                Object value = __is.readObject("", null);
+                _activeFacetMap.put(key, value);
+            }
+        }
+    }
+
+    public void
+    __marshal(Ice.Stream __os)
+    {
+        synchronized(_activeFacetMapMutex)
+        {
+            final int sz = _activeFacetMap.size();
+
+            __os.startWriteDictionary("ice:facets", sz);
+            java.util.Set set = _activeFacetMap.keySet();
+            String[] keys = new String[sz];
+            set.toArray(keys);
+            for (int i = 0; i < sz; i++)
+            {
+                __os.startWriteDictionaryElement();
+                __os.writeString("key", keys[i]);
+                __os.writeObject("value", (Object)_activeFacetMap.get(keys[i]));
+                __os.endWriteDictionaryElement();
+            }
+            __os.endWriteDictionary();
+        }
+    }
+
+    public void
+    __unmarshal(Ice.Stream __is)
+    {
+        synchronized(_activeFacetMapMutex)
+        {
+            final String facetsName = "ice:facets";
+            final String keyName = "key";
+            final String valueName = "value";
+
+            int sz = __is.startReadDictionary(facetsName);
+
+            _activeFacetMap.clear();
+
+            while (sz-- > 0)
+            {
+                __is.startReadDictionaryElement();
+                String key = __is.readString(keyName);
+                Object value = __is.readObject(valueName, "", null);
+                _activeFacetMap.put(key, value);
+                __is.endReadDictionaryElement();
             }
+            __is.endReadDictionary();
         }
     }
 
     public final void
+    ice_marshal(String name, Ice.Stream stream)
+    {
+        stream.writeObject(name, this);
+    }
+
+    public static Object
+    ice_unmarshal(String name, Ice.Stream stream)
+    {
+        return stream.readObject(name, "", null);
+    }
+
+    public final void
     ice_addFacet(Object facet, String name)
     {
         synchronized(_activeFacetMapMutex)
diff --git a/java/src/Ice/ObjectPrx.java b/java/src/Ice/ObjectPrx.java
index 8de224cba90..6431ce2f7c4 100644
--- a/java/src/Ice/ObjectPrx.java
+++ b/java/src/Ice/ObjectPrx.java
@@ -12,49 +12,54 @@ package Ice;
 
 public interface ObjectPrx
 {
-    public int ice_hash();
+    int ice_hash();
 
-    public boolean ice_isA(String __id);
-    public boolean ice_isA(String __id, java.util.Map __context);
+    boolean ice_isA(String __id);
+    boolean ice_isA(String __id, java.util.Map __context);
 
-    public void ice_ping();
-    public void ice_ping(java.util.Map __context);
+    void ice_ping();
+    void ice_ping(java.util.Map __context);
 
-    //public String[] ice_ids();
-    //public String[] ice_ids(java.util.Map __context);
+    String[] ice_ids();
+    String[] ice_ids(java.util.Map __context);
 
-    public byte[] ice_invoke(String operation, boolean nonmutating,
-                             byte[] inParams);
-    public byte[] ice_invoke(String operation, boolean nonmutating,
-                             byte[] inParams, java.util.Map __context);
+    String ice_id();
+    String ice_id(java.util.Map __context);
 
-    public Identity ice_getIdentity();
+    String[] ice_facets();
+    String[] ice_facets(java.util.Map __context);
 
-    public ObjectPrx ice_newIdentity(Identity newIdentity);
+    byte[] ice_invoke(String operation, boolean nonmutating, byte[] inParams);
+    byte[] ice_invoke(String operation, boolean nonmutating, byte[] inParams,
+                      java.util.Map __context);
 
-    public String ice_getFacet();
+    Identity ice_getIdentity();
 
-    public ObjectPrx ice_newFacet(String newFacet);
+    ObjectPrx ice_newIdentity(Identity newIdentity);
 
-    public ObjectPrx ice_twoway();
+    String ice_getFacet();
 
-    public ObjectPrx ice_oneway();
+    ObjectPrx ice_newFacet(String newFacet);
 
-    public ObjectPrx ice_batchOneway();
+    ObjectPrx ice_twoway();
 
-    public ObjectPrx ice_datagram();
+    ObjectPrx ice_oneway();
 
-    public ObjectPrx ice_batchDatagram();
+    ObjectPrx ice_batchOneway();
 
-    public ObjectPrx ice_secure(boolean b);
+    ObjectPrx ice_datagram();
 
-    public ObjectPrx ice_timeout(int t);
+    ObjectPrx ice_batchDatagram();
 
-    public ObjectPrx ice_router(Ice.RouterPrx router);
+    ObjectPrx ice_secure(boolean b);
 
-    public ObjectPrx ice_default();
+    ObjectPrx ice_timeout(int t);
 
-    public void ice_flush();
+    ObjectPrx ice_router(Ice.RouterPrx router);
 
-    public boolean equals(java.lang.Object r);
+    ObjectPrx ice_default();
+
+    void ice_flush();
+
+    boolean equals(java.lang.Object r);
 }
diff --git a/java/src/Ice/ObjectPrxHelper.java b/java/src/Ice/ObjectPrxHelper.java
index 93aafe84e7e..6a3f34ca740 100644
--- a/java/src/Ice/ObjectPrxHelper.java
+++ b/java/src/Ice/ObjectPrxHelper.java
@@ -89,6 +89,102 @@ public class ObjectPrxHelper implements ObjectPrx
         }
     }
 
+    public String[]
+    ice_ids()
+    {
+        return ice_ids(null);
+    }
+
+    public String[]
+    ice_ids(java.util.Map __context)
+    {
+        int __cnt = 0;
+        while (true)
+        {
+            try
+            {
+                _ObjectDel __del = __getDelegate();
+                return __del.ice_ids(__context);
+            }
+            catch (LocationForward __ex)
+            {
+                __locationForward(__ex);
+            }
+            catch (IceInternal.NonRepeatable __ex)
+            {
+                __cnt = __handleException(__ex.get(), __cnt);
+            }
+            catch (LocalException __ex)
+            {
+                __cnt = __handleException(__ex, __cnt);
+            }
+        }
+    }
+
+    public String
+    ice_id()
+    {
+        return ice_id(null);
+    }
+
+    public String
+    ice_id(java.util.Map __context)
+    {
+        int __cnt = 0;
+        while (true)
+        {
+            try
+            {
+                _ObjectDel __del = __getDelegate();
+                return __del.ice_id(__context);
+            }
+            catch (LocationForward __ex)
+            {
+                __locationForward(__ex);
+            }
+            catch (IceInternal.NonRepeatable __ex)
+            {
+                __cnt = __handleException(__ex.get(), __cnt);
+            }
+            catch (LocalException __ex)
+            {
+                __cnt = __handleException(__ex, __cnt);
+            }
+        }
+    }
+
+    public String[]
+    ice_facets()
+    {
+        return ice_facets(null);
+    }
+
+    public String[]
+    ice_facets(java.util.Map __context)
+    {
+        int __cnt = 0;
+        while (true)
+        {
+            try
+            {
+                _ObjectDel __del = __getDelegate();
+                return __del.ice_facets(__context);
+            }
+            catch (LocationForward __ex)
+            {
+                __locationForward(__ex);
+            }
+            catch (IceInternal.NonRepeatable __ex)
+            {
+                __cnt = __handleException(__ex.get(), __cnt);
+            }
+            catch (LocalException __ex)
+            {
+                __cnt = __handleException(__ex, __cnt);
+            }
+        }
+    }
+
     public final byte[]
     ice_invoke(String operation, boolean nonmutating, byte[] inParams)
     {
diff --git a/java/src/Ice/PropertiesI.java b/java/src/Ice/PropertiesI.java
index a5b2bd719ac..dab3d730025 100644
--- a/java/src/Ice/PropertiesI.java
+++ b/java/src/Ice/PropertiesI.java
@@ -29,6 +29,21 @@ class PropertiesI implements Properties
         _properties.put(key, value);
     }
 
+    public String[]
+    getCommandLineOptions()
+    {
+        String[] result = new String[_properties.size()];
+        java.util.Iterator p = _properties.entrySet().iterator();
+        int i = 0;
+        while (p.hasNext())
+        {
+            java.util.Map.Entry entry = (java.util.Map.Entry)p.next();
+            result[i++] = "--" + entry.getKey() + "=" + entry.getValue();
+        }
+        assert(i == result.length);
+        return result;
+    }
+
     public Properties
     _clone()
     {
@@ -187,7 +202,7 @@ class PropertiesI implements Properties
         int end = -1;
         for (int i = 0; i < arr.length; i++)
         {
-            if (arr[i] == ' ' || arr[i] == '\t' || arr[i] == '=')
+            if (arr[i] == ' ' || arr[i] == '\t' || arr[i] == '\r' || arr[i] == '\n' || arr[i] == '=')
             {
                 end = i;
                 break;
@@ -199,11 +214,20 @@ class PropertiesI implements Properties
         }
 
         String key = s.substring(0, end);
+
+        end = s.indexOf('=', end);
+        if (end == -1)
+        {
+            return;
+        }
+        ++end;
+
         String value = "";
         if (end < s.length())
         {
-            value = s.substring(end + 1).trim();
+            value = s.substring(end).trim();
         }
+
         setProperty(key, value);
     }
 
diff --git a/java/src/Ice/UserException.java b/java/src/Ice/UserException.java
index d4ca48a8fc0..a394a8147d7 100644
--- a/java/src/Ice/UserException.java
+++ b/java/src/Ice/UserException.java
@@ -23,4 +23,18 @@ public abstract class UserException extends Exception
 
     public abstract void
     __read(IceInternal.BasicStream __is);
+
+    public abstract void
+    __marshal(Stream __os);
+
+    public abstract void
+    __unmarshal(Stream __is);
+
+    public final void
+    ice_marshal(String __name, Stream __os)
+    {
+        __os.startWriteException(__name);
+        __marshal(__os);
+        __os.endWriteException();
+    }
 }
diff --git a/java/src/Ice/_ObjectDel.java b/java/src/Ice/_ObjectDel.java
index ef909d061c0..cf767e3cd30 100644
--- a/java/src/Ice/_ObjectDel.java
+++ b/java/src/Ice/_ObjectDel.java
@@ -18,6 +18,15 @@ public interface _ObjectDel
     void ice_ping(java.util.Map __context)
         throws LocationForward, IceInternal.NonRepeatable;
 
+    String[] ice_ids(java.util.Map __context)
+        throws LocationForward, IceInternal.NonRepeatable;
+
+    String ice_id(java.util.Map __context)
+        throws LocationForward, IceInternal.NonRepeatable;
+
+    String[] ice_facets(java.util.Map __context)
+        throws LocationForward, IceInternal.NonRepeatable;
+
     byte[] ice_invoke(String operation, boolean nonmutating, byte[] inParams,
                       java.util.Map context)
         throws LocationForward, IceInternal.NonRepeatable;
diff --git a/java/src/Ice/_ObjectDelM.java b/java/src/Ice/_ObjectDelM.java
index d2c2eab18e8..61e3a77a488 100644
--- a/java/src/Ice/_ObjectDelM.java
+++ b/java/src/Ice/_ObjectDelM.java
@@ -42,6 +42,54 @@ public class _ObjectDelM implements _ObjectDel
         }
     }
 
+    public String[]
+    ice_ids(java.util.Map __context)
+        throws LocationForward, IceInternal.NonRepeatable
+    {
+        IceInternal.Outgoing __out =
+            new IceInternal.Outgoing(__connection, __reference, "ice_ids",
+                                     true, __context);
+        IceInternal.BasicStream __is = __out.is();
+        IceInternal.BasicStream __os = __out.os();
+        if (!__out.invoke())
+        {
+            throw new UnknownUserException();
+        }
+        return __is.readStringSeq();
+    }
+
+    public String
+    ice_id(java.util.Map __context)
+        throws LocationForward, IceInternal.NonRepeatable
+    {
+        IceInternal.Outgoing __out =
+            new IceInternal.Outgoing(__connection, __reference, "ice_id",
+                                     true, __context);
+        IceInternal.BasicStream __is = __out.is();
+        IceInternal.BasicStream __os = __out.os();
+        if (!__out.invoke())
+        {
+            throw new UnknownUserException();
+        }
+        return __is.readString();
+    }
+
+    public String[]
+    ice_facets(java.util.Map __context)
+        throws LocationForward, IceInternal.NonRepeatable
+    {
+        IceInternal.Outgoing __out =
+            new IceInternal.Outgoing(__connection, __reference, "ice_facets",
+                                     true, __context);
+        IceInternal.BasicStream __is = __out.is();
+        IceInternal.BasicStream __os = __out.os();
+        if (!__out.invoke())
+        {
+            throw new UnknownUserException();
+        }
+        return __is.readStringSeq();
+    }
+
     public byte[]
     ice_invoke(String operation, boolean nonmutating, byte[] inParams,
                java.util.Map __context)
diff --git a/java/src/IceInternal/BasicStream.java b/java/src/IceInternal/BasicStream.java
index 27a4903bce8..97e70ccb6e3 100644
--- a/java/src/IceInternal/BasicStream.java
+++ b/java/src/IceInternal/BasicStream.java
@@ -608,43 +608,15 @@ public class BasicStream
     public void
     writeString(String v)
     {
-        if (_currentWriteEncaps == null) // Lazy initialization
+        final int len = v.length();
+        writeInt(len);
+        if (len > 0)
         {
-            _currentWriteEncaps = new WriteEncaps();
-            _writeEncapsStack.add(_currentWriteEncaps);
-        }
-
-        Integer pos = null;
-        if (_currentWriteEncaps.stringsWritten != null) // Lazy creation
-        {
-            pos = (Integer)_currentWriteEncaps.stringsWritten.get(v);
-        }
-        if (pos != null)
-        {
-            writeInt(pos.intValue());
-        }
-        else
-        {
-            final int len = v.length();
-            writeInt(len);
-            if (len > 0)
+            final char[] arr = v.toCharArray();
+            expand(len);
+            for (int i = 0; i < len; i++)
             {
-                /*
-                if (_currentWriteEncaps.stringsWritten == null)
-                {
-                    _currentWriteEncaps.stringsWritten =
-                        new java.util.HashMap();
-                }
-                int num = _currentWriteEncaps.stringsWritten.size();
-                _currentWriteEncaps.stringsWritten.put(
-                    v, new Integer(-(num + 1)));
-                */
-                final char[] arr = v.toCharArray();
-                expand(len);
-                for (int i = 0; i < len; i++)
-                {
-                    _buf.put((byte)arr[i]);
-                }
+                _buf.put((byte)arr[i]);
             }
         }
     }
@@ -664,59 +636,35 @@ public class BasicStream
     {
         final int len = readInt();
 
-        if (_currentReadEncaps == null) // Lazy initialization
+        if (len == 0)
         {
-            _currentReadEncaps = new ReadEncaps();
-            _readEncapsStack.add(_currentReadEncaps);
+            return "";
         }
-
-        if (len < 0)
+        else
         {
-            if (_currentReadEncaps.stringsRead == null || // Lazy creation
-                -(len + 1) >= _currentReadEncaps.stringsRead.size())
+            try
             {
-                throw new Ice.IllegalIndirectionException();
+                /* TODO: Performance review
+                char[] arr = new char[len];
+                for (int i = 0; i < len; i++)
+                {
+                    arr[i] = (char)_buf.get();
+                }
+                String v = new String(arr);
+                */
+                byte[] arr = new byte[len];
+                _buf.get(arr);
+                String v = new String(arr, "ISO-8859-1");
+                return v;
             }
-            return (String)_currentReadEncaps.stringsRead.get(-(len + 1));
-        }
-        else
-        {
-            if (len == 0)
+            catch (java.io.UnsupportedEncodingException ex)
             {
+                assert(false);
                 return "";
             }
-            else
+            catch (java.nio.BufferUnderflowException ex)
             {
-                try
-                {
-                    /* TODO: Performance review
-                    char[] arr = new char[len];
-                    for (int i = 0; i < len; i++)
-                    {
-                        arr[i] = (char)_buf.get();
-                    }
-                    String v = new String(arr);
-                    */
-                    byte[] arr = new byte[len];
-                    _buf.get(arr);
-                    String v = new String(arr, "ISO-8859-1");
-                    if (_currentReadEncaps.stringsRead == null)
-                    {
-                        _currentReadEncaps.stringsRead =
-                            new java.util.ArrayList(10);
-                    }
-                    _currentReadEncaps.stringsRead.add(v);
-                    return v;
-                }
-                catch (java.io.UnsupportedEncodingException ex)
-                {
-                    assert(false);
-                    return "";
-                }
-                catch (java.nio.BufferUnderflowException ex)
-                {
-                    throw new Ice.UnmarshalOutOfBoundsException();
-                }
+                throw new Ice.UnmarshalOutOfBoundsException();
             }
         }
     }
@@ -788,12 +736,11 @@ public class BasicStream
         }
     }
 
-    //
-    // TODO: Can we eliminate the need for a Holder?
-    //
-    public boolean
-    readObject(String signatureType, Ice.ObjectHolder v)
+    public Ice.Object
+    readObject(String signatureType, Ice.ObjectFactory factory)
     {
+        Ice.Object v = null;
+
         if (_currentReadEncaps == null) // Lazy initialization
         {
             _currentReadEncaps = new ReadEncaps();
@@ -809,8 +756,7 @@ public class BasicStream
             {
                 throw new Ice.IllegalIndirectionException();
             }
-            v.value = (Ice.Object)_currentReadEncaps.objectsRead.get(pos);
-            return true;
+            v = (Ice.Object)_currentReadEncaps.objectsRead.get(pos);
         }
         else
         {
@@ -818,54 +764,41 @@ public class BasicStream
 
             if (id.length() == 0)
             {
-                v.value = null;
-                return true;
+                return null;
             }
             else if (id.equals("::Ice::Object"))
             {
-                v.value = new Ice.Object();
-                readObject(v.value);
-                return true;
+                v = new Ice.Object();
             }
             else
             {
-                Ice.ObjectFactory factory =
-                    _instance.servantFactoryManager().find(id);
-                if (factory != null)
+                Ice.ObjectFactory userFactory = _instance.servantFactoryManager().find(id);
+                if (userFactory != null)
                 {
-                    v.value = factory.create(id);
-                    if (v.value != null)
-                    {
-                        readObject(v.value);
-                        return true;
-                    }
+                    v = userFactory.create(id);
                 }
 
-                if (id.equals(signatureType))
+                if (v == null && id.equals(signatureType))
                 {
-                    return false;
+                    assert(factory != null);
+                    v = factory.create(id);
+                    assert(v != null);
                 }
 
-                throw new Ice.NoObjectFactoryException();
+                if (v == null)
+                {
+                    throw new Ice.NoObjectFactoryException();
+                }
+            }
+            if (_currentReadEncaps.objectsRead == null) // Lazy creation
+            {
+                _currentReadEncaps.objectsRead = new java.util.ArrayList(10);
             }
+            _currentReadEncaps.objectsRead.add(v);
+            v.__read(this);
         }
-    }
 
-    public void
-    readObject(Ice.Object v)
-    {
-        assert(v != null);
-        if (_currentReadEncaps == null) // Lazy initialization
-        {
-            _currentReadEncaps = new ReadEncaps();
-            _readEncapsStack.add(_currentReadEncaps);
-        }
-        if (_currentReadEncaps.objectsRead == null) // Lazy creation
-        {
-            _currentReadEncaps.objectsRead = new java.util.ArrayList(10);
-        }
-        _currentReadEncaps.objectsRead.add(v);
-        v.__read(this);
+        return v;
     }
 
     public void
@@ -958,7 +891,6 @@ public class BasicStream
     {
         int start;
         byte encoding;
-        java.util.ArrayList stringsRead;
         java.util.ArrayList objectsRead;
     }
 
@@ -966,7 +898,6 @@ public class BasicStream
     {
         int start;
         byte encoding;
-        java.util.HashMap stringsWritten;
         java.util.IdentityHashMap objectsWritten;
     }
 
diff --git a/java/src/IceInternal/UdpTransceiver.java b/java/src/IceInternal/UdpTransceiver.java
index bc84d35fd39..7956b7eae1a 100644
--- a/java/src/IceInternal/UdpTransceiver.java
+++ b/java/src/IceInternal/UdpTransceiver.java
@@ -23,7 +23,7 @@ final class UdpTransceiver implements Transceiver
     {
         if (_traceLevels.network >= 1)
         {
-            String s = "closing udp connection\n" + toString();
+            String s = "closing " + _protocolName + " connection\n" + toString();
             _logger.trace(_traceLevels.networkCat, s);
         }