CORBA/CDR/gnuRuntime.java

/* 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 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_codabase 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()
  {
    StringBuffer b = new StringBuffer(" 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();
  }

}