1 files changed, 338 insertions, 0 deletions
diff --git a/gcc-4.4.3/libjava/classpath/gnu/CORBA/CDR/gnuRuntime.java b/gcc-4.4.3/libjava/classpath/gnu/CORBA/CDR/gnuRuntime.java
new file mode 100644
index 000000000..4af8c6851
--- /dev/null
+++ b/gcc-4.4.3/libjava/classpath/gnu/CORBA/CDR/gnuRuntime.java
@@ -0,0 +1,338 @@
+/* gnuRuntime.java --
+   Copyright (C) 2005 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.CORBA.CDR;
+
+import gnu.CORBA.Minor;
+
+import gnu.java.lang.CPStringBuilder;
+
+import org.omg.CORBA.LocalObject;
+import org.omg.CORBA.MARSHAL;
+
+import java.io.Serializable;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.IdentityHashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.TreeSet;
+
+/**
+ * Our implementation of the sending context runtime.
+ * 
+ * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org)
+ */
+public class gnuRuntime
+  extends LocalObject
+  implements org.omg.SendingContext.RunTime
+{
+  /**
+   * The data entry about the object that was written.
+   */
+  static class Entry
+  {
+    /**
+     * The stream position, where the object was written.
+     */
+    int at;
+
+    /**
+     * The object that was written.
+     */
+    Object object;
+
+    public String toString()
+    {
+      return object + "[" + at + "] "+object.getClass().getName();
+    }
+  }
+
+  /**
+   * The instruction that the actual object is stored at different location.
+   * Used when processing chunked data where positions shifts due removing the
+   * chunking tags.
+   */
+  static class Redirection
+    extends Entry
+  {
+    public String toString()
+    {
+      return "->" + at;
+    }
+  }
+
+  /**
+   * Use serialVersionUID for interoperability.
+   */
+  private static final long serialVersionUID = 1;
+
+  /**
+   * The history of the written objects, maps object to records. The different
+   * objects must be treated as different regardless that .equals returns.
+   */
+  private Map sh_objects = new IdentityHashMap();
+
+  /**
+   * The written repository Ids that can be shared.
+   */
+  private Map sh_ids = new TreeMap(new Comparator()
+  {
+    public int compare(Object a, Object b)
+    {
+      if (a instanceof String && b instanceof String)
+        // Comparing string with string.
+        return ((String) a).compareTo((String) b);
+      else if (a instanceof String[] && b instanceof String[])
+        {
+          // Comparing array with array.
+          String[] sa = (String[]) a;
+          String[] sb = (String[]) b;
+
+          if (sa.length != sb.length)
+            return sa.length - sb.length;
+          else
+            {
+              int c;
+              for (int i = 0; i < sa.length; i++)
+                {
+                  c = sa[i].compareTo(sb[i]);
+                  if (c != 0)
+                    return c;
+                }
+              return 0;
+            }
+        }
+      else
+        // Comparing string with array.
+        return a instanceof String ? 1 : -1;
+    }
+  });
+
+  /**
+   * The history of the written objects, maps positions to records. The
+   * different objects must be treated as different regardless that .equals
+   * returns.
+   */
+  private Map positions = new HashMap();
+
+  /**
+   * The Codebase.
+   */
+  private String codebase;
+
+  /**
+   * The pre-created instance of the object being written (avoid
+   * re-instantiation).
+   */
+  public Serializable target;
+
+  /**
+   * Create Runtime.
+   * 
+   * @param a_id a repository Id, if only one Id was specified in the stream.
+   * @param a_ids a repository Ids, if the multiple Ids were specified in te
+   * stream.
+   * @param a_codebase a codebase, if it was specified in the stream.
+   */
+  public gnuRuntime(String a_codebase, Object a_target)
+  {
+    if (a_target instanceof Serializable)
+      target = (Serializable) a_target;
+
+    codebase = a_codebase;
+  }
+
+  /**
+   * Mark the given object as written at the given position.
+   */
+  public void objectWritten(Object object, int at)
+  {
+    if (object == null || at < 0)
+      return; // No positional information provided.
+    if (sh_objects.containsKey(object))
+      throw new AssertionError("Repetetive writing of the same object "
+        + object + " at " + at + dump());
+
+    Entry e = new Entry();
+    e.at = at;
+    e.object = object;
+
+    sh_objects.put(object, e);
+    positions.put(new Integer(at), e);
+  }
+
+  /**
+   * Check if the object is already written.
+   * 
+   * @return the position, at that the object is allready written or -1 if it is
+   * not yet written.
+   */
+  public int isWrittenAt(Object x)
+  {
+    Entry e = (Entry) sh_objects.get(x);
+    return e == null ? -1 : e.at;
+  }
+
+  /**
+   * Set redirection, indicating that the object, searched at the p_searched
+   * position can be actually found at the p_present position.
+   */
+  public void redirect(int p_searched, int p_present)
+  {
+    Redirection redirection = new Redirection();
+    redirection.at = p_present;
+    positions.put(new Integer(p_searched), redirection);
+  }
+
+  /**
+   * Get the object, written at the given position. This returs both shared
+   * objects and repository Ids.
+   * 
+   * @return the position, at that the object is allready written.
+   * 
+   * @throws MARSHAL if there is no object written at that position.
+   */
+  public Object isObjectWrittenAt(int x, int offset)
+  {
+    Entry e = (Entry) positions.get(new Integer(x));
+    if (e instanceof Redirection)
+      return isObjectWrittenAt(e.at, offset);
+    else if (e != null)
+      return e.object;
+    else
+      {
+        MARSHAL m = new MARSHAL("No object was written at " + x + 
+          " (offset " + offset + ") r " + this + dump());
+        m.minor = Minor.Graph;
+        throw m;
+      }
+  }
+
+  /**
+   * Mark the given object as written at the given position.
+   */
+  public void singleIdWritten(String id, int at)
+  {
+    if (sh_ids.containsKey(id))
+      throw new InternalError("Repetetive writing of the same string " +
+        id + dump());
+
+    Entry e = new Entry();
+    e.at = at;
+    e.object = id;
+
+    sh_ids.put(id, e);
+    positions.put(new Integer(at), e);
+  }
+
+  /**
+   * Mark the given object as written at the given position.
+   */
+  public void multipleIdsWritten(String[] ids, int at)
+  {
+    if (sh_ids.containsKey(ids))
+      throw new InternalError("Repetetive writing of the same string " + 
+        ids + dump());
+
+    Entry e = new Entry();
+    e.at = at;
+    e.object = ids;
+
+    sh_ids.put(ids, e);
+    positions.put(new Integer(at), e);
+  }
+
+  /**
+   * Check if the object is already written.
+   * 
+   * @return the position, at that the object is allready written or -1 if it is
+   * not yet written.
+   */
+  public int idWrittenAt(Object x)
+  {
+    Entry e = (Entry) sh_ids.get(x);
+    return e == null ? -1 : e.at;
+  }
+
+  /**
+   * Get the codebase.
+   */
+  public String getCodeBase()
+  {
+    return codebase;
+  }
+
+  /**
+   * Set the codebase, preserving the old value if the passed parameter is null
+   * and forming the space delimited list if both new and old values are not
+   * null.
+   */
+  public void addCodeBase(String base)
+  {
+    if (base != null)
+      {
+        if (codebase == null)
+          codebase = base;
+        else
+          codebase = codebase + " " + base;
+      }
+  }
+
+  /**
+   * Dump all objects that are currently stored.
+   */
+  public String dump()
+  {
+    CPStringBuilder b = new CPStringBuilder(" Stream content: \n");
+
+    // Sort by position.
+    TreeSet t = new TreeSet(positions.keySet());
+    Iterator p = t.iterator();
+
+    while (p.hasNext())
+      {
+        Object k = p.next();
+        b.append("     " + k + ": " + ((Entry) positions.get(k)).toString()
+          + "\n");
+      }
+    return b.toString();
+  }
+
+}