CORBA/CDR/AbstractCdrInput.java

/* AbstractCdrInput.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.BigDecimalHelper;
import gnu.CORBA.OrbFunctional;
import gnu.CORBA.GIOP.CharSets_OSF;
import gnu.CORBA.GIOP.CodeSetServiceContext;
import gnu.CORBA.IOR;
import gnu.CORBA.IorDelegate;
import gnu.CORBA.Minor;
import gnu.CORBA.TypeCodeHelper;
import gnu.CORBA.Unexpected;
import gnu.CORBA.Version;
import gnu.CORBA.gnuAny;
import gnu.CORBA.StubLocator;

import org.omg.CORBA.Any;
import org.omg.CORBA.AnySeqHolder;
import org.omg.CORBA.BAD_OPERATION;
import org.omg.CORBA.BooleanSeqHolder;
import org.omg.CORBA.CharSeqHolder;
import org.omg.CORBA.DoubleSeqHolder;
import org.omg.CORBA.FloatSeqHolder;
import org.omg.CORBA.LongLongSeqHolder;
import org.omg.CORBA.LongSeqHolder;
import org.omg.CORBA.MARSHAL;
import org.omg.CORBA.ORB;
import org.omg.CORBA.OctetSeqHolder;
import org.omg.CORBA.ShortSeqHolder;
import org.omg.CORBA.TypeCode;
import org.omg.CORBA.TypeCodePackage.BadKind;
import org.omg.CORBA.TypeCodePackage.Bounds;
import org.omg.CORBA.ULongLongSeqHolder;
import org.omg.CORBA.ULongSeqHolder;
import org.omg.CORBA.UShortSeqHolder;
import org.omg.CORBA.WCharSeqHolder;
import org.omg.CORBA.portable.InputStream;
import org.omg.CORBA.portable.ObjectImpl;

import java.io.EOFException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Serializable;

import java.math.BigDecimal;

/**
 * A simple CORBA CDR (common data representation) input stream, reading data
 * from the given {@link java.io.InputStream}. The primitive types are aligned
 * on they natural boundaries by implementing the abstract method
 * {@link #align(int boundary)}.
 *
 * The same class also implements {@link org.omg.CORBA.DataInputStream} to read
 * the object content in a user defined way.
 *
 * TODO This class uses 16 bits per Unicode character only, as it was until jdk
 * 1.4 inclusive.
 *
 * @author Audrius Meskauskas (AudriusA@Bioinformatics.org)
 */
public abstract class AbstractCdrInput
  extends org.omg.CORBA_2_3.portable.InputStream
  implements org.omg.CORBA.DataInputStream
{
  /**
   * The runtime, associated with this stream. This field is only used when
   * reading and writing value types and filled-in in gnu.CORBA.CDR.Vio.
   */
  public transient gnuRuntime runtime;

  /**
   * The message, explaining that the exception has been thrown due unexpected
   * end of the input stream. This usually happens the server and client
   * disagree on communication or data representation rules.
   */
  protected static final String UNEXP_EOF = "Unexpected end of stream";

  /**
   * This instance is used to convert primitive data types into the byte
   * sequences.
   */
  protected AbstractDataInput b;

  /**
   * The input stream, from where the data are actually being read.
   */
  protected java.io.InputStream actual_stream;

  /**
   * The associated orb, if any.
   */
  protected ORB orb;

  /**
   * The GIOP version.
   */
  protected Version giop = new Version(1, 2);

  /**
   * The code set information.
   */
  protected CodeSetServiceContext codeset = CodeSetServiceContext.STANDARD;

  /**
   * The name of the currently used narrow charset, null if the native narrow
   * charset is used.
   */
  private String narrow_charset = null;

  /**
   * The name of the currently used wide charset, null if the native wide
   * charset is used.
   */
  private String wide_charset = null;

  /**
   * True if the native code set is used for narrow characters. If the set is
   * native, no the intermediate Reader object is instantiated when writing
   * characters.
   */
  private boolean narrow_native;

  /**
   * True if the native code set is used for wide characters. If the set is
   * native, no the intermediate Reader object is instantiated when writing
   * characters.
   */
  private boolean wide_native;

  /**
   * If true, the stream expect the multi-byte data in the form "less
   * significant byte first" (Little Endian). This is the opposite to the java
   * standard (Big Endian).
   */
  private boolean little_endian;

  /**
   * Creates the stream. The stream reads Big Endian by default.
   *
   * @param readFrom a stream to read CORBA input from.
   */
  public AbstractCdrInput(java.io.InputStream readFrom)
  {
    setInputStream(readFrom);
    setCodeSet(CodeSetServiceContext.STANDARD);
  }

  /**
   * Creates the stream, requiring the subsequent call of
   * {@link #setInputStream(java.io.InputStream)}.
   */
  public AbstractCdrInput()
  {
    setCodeSet(CodeSetServiceContext.STANDARD);
  }

  /**
   * Set the Big Endian or Little Endian encoding. The stream reads Big Endian
   * by default.
   *
   * @param use_little_endian if true, the stream expect the multi-byte data in
   * the form "less significant byte first" (Little Endian). This is the
   * opposite to the java standard (Big Endian).
   */
  public void setBigEndian(boolean use_big_endian)
  {
    little_endian = !use_big_endian;
    setInputStream(actual_stream);
  }

  /**
   * Get the used encoding.
   *
   * @param true for Big Endian, false for Little Endian.
   */
  public boolean isBigEndian()
  {
    return !little_endian;
  }

  /**
   * Clone all important settings to another stream.
   */
  public void cloneSettings(AbstractCdrInput stream)
  {
    stream.setBigEndian(isBigEndian());
    stream.setCodeSet(getCodeSet());
    stream.setVersion(giop);
    stream.setOrb(orb);
  }

  /**
   * Set the input stream that receives the CORBA input.
   *
   * @param readFrom the stream.
   */
  public void setInputStream(java.io.InputStream readFrom)
  {
    if (little_endian)
      b = new LittleEndianInputStream(readFrom);
    else
      b = new BigEndianInputStream(readFrom);

    actual_stream = readFrom;
  }

  /**
   * Set the alignment offset, if the index of the first byte in the stream is
   * different from 0.
   */
  public abstract void setOffset(int offset);

  /**
   * Set the orb, associated with this stream.
   *
   * @param an_orb
   */
  public void setOrb(ORB an_orb)
  {
    orb = an_orb;
  }

  /**
   * Set the GIOP version. Some data types are written differently for the
   * different versions. The default version is 1.0 .
   */
  public void setVersion(Version giop_version)
  {
    giop = giop_version;
  }

  /**
   * Align the curretn position at the given natural boundary.
   */
  public abstract void align(int boundary);

  /**
   * Reads the CORBA unsigned long (java int), returning the value in the
   * sufficiently large java long.
   */
  public long gnu_read_ulong()
  {
    try
      {
        long l = b.readInt();
        l &= 0xFFFFFFF;
        return l;
      }
    catch (EOFException ex)
      {
        MARSHAL t = new MARSHAL(UNEXP_EOF);
        t.minor = Minor.EOF;
        t.initCause(ex);
        throw t;
      }
    catch (IOException ex)
      {
        throw new Unexpected(ex);
      }
  }

  /**
   * Read the unsigned short integer value and return it as java int,
   * sufficiently large to hold all values.
   */
  public int gnu_read_ushort()
  {
    try
      {
        align(2);
        return b.readUnsignedShort();
      }
    catch (EOFException ex)
      {
        MARSHAL t = new MARSHAL(UNEXP_EOF);
        t.minor = Minor.EOF;
        t.initCause(ex);
        throw t;
      }

    catch (IOException ex)
      {
        throw new Unexpected(ex);
      }
  }

  /**
   * Return the associated {@link ORB}.
   *
   * @return the associated {@link ORB} or null is no such is set.
   */
  public ORB orb()
  {
    return orb;
  }

  /**
   * Read a single byte directly from the buffer.
   */
  public int read()
    throws java.io.IOException
  {
    try
      {
        return b.read();
      }
    catch (EOFException ex)
      {
        MARSHAL t = new MARSHAL(UNEXP_EOF);
        t.minor = Minor.EOF;
        t.initCause(ex);
        throw t;
      }
  }

  /**
   * Read bytes directly from the buffer.
   */
  public int read(byte[] x, int ofs, int len)
    throws java.io.IOException
  {
    try
      {
        return b.read(x, ofs, len);
      }
    catch (EOFException ex)
      {
        MARSHAL t = new MARSHAL(UNEXP_EOF);
        t.minor = Minor.EOF;
        t.initCause(ex);
        throw t;
      }
  }

  /**
   * Read bytes directly from the buffer.
   */
  public int read(byte[] x)
    throws java.io.IOException
  {
    try
      {
        return b.read(x);
      }
    catch (EOFException ex)
      {
        MARSHAL t = new MARSHAL(UNEXP_EOF);
        t.minor = Minor.EOF;
        t.initCause(ex);
        throw t;
      }
  }

  /**
   * Read the CORBA object. The object to read is represented in the form of the
   * plain (not a string-encoded) IOR profile without the heading endian
   * indicator. The responsible method for reading such data is
   * {@link IOR.read_no_endian}.
   *
   * The returned object is usually casted into the given type using the .narrow
   * method of its helper, despite in some cases the direct cast would also
   * work.
   *
   * The null objects are recognised from the empty profile set. For such
   * objects, null is returned.
   *
   * @return the loaded and constructed object.
   */
  public org.omg.CORBA.Object read_Object()
  {
    try
      {
        IOR ior = new IOR();
        ior._read_no_endian(this);

        if (ior.Id == null)
          return null;

        // Check maybe this is a remote reference to the local object.
        // This is only possible if we access the repository of the
        // connected object.
        if (orb instanceof OrbFunctional)
          {
            OrbFunctional forb = (OrbFunctional) orb;
            org.omg.CORBA.Object local = forb.find_local_object(ior);
            if (local != null)
              return local;
          }

        // Search for the available stubs.
        ObjectImpl impl = StubLocator.search(orb, ior);
        try
          {
            if (impl._get_delegate() == null)
              impl._set_delegate(new IorDelegate(orb, ior));
          }
        catch (BAD_OPERATION ex)
          {
            // Some colaborants may throw this exception
            // in response to the attempt to get the unset delegate.
            impl._set_delegate(new IorDelegate(orb, ior));
          }

        return impl;
      }
    catch (IOException ex)
      {
        MARSHAL bad = new MARSHAL();
        bad.minor = Minor.IOR;
        bad.initCause(ex);
        throw bad;
      }
  }

  /**
   * Read the type code. The type code format is defined in the CORBA
   * documenation.
   */
  public TypeCode read_TypeCode()
  {
    try
      {
        return TypeCodeHelper.read(this);
      }

    catch (Bounds ex)
      {
        throw new Unexpected();
      }
    catch (BadKind ex)
      {
        throw new Unexpected();
      }
  }

  /**
   * Read the CORBA {@link Any}. This method first reads the type code, then
   * delegates the functionality to {@link Any#read_value}.
   */
  public Any read_any()
  {
    TypeCode ty = read_TypeCode();
    gnuAny any = new gnuAny();
    any.read_value(this, ty);
    return any;
  }

  /**
   * Read the boolean, treating any non zero byte as true, zero byte as false.
   */
  public boolean read_boolean()
  {
    try
      {
        return b.read() == 0 ? false : true;
      }
    catch (EOFException ex)
      {
        MARSHAL t = new MARSHAL(UNEXP_EOF);
        t.minor = Minor.EOF;
        t.initCause(ex);
        throw t;
      }
    catch (IOException ex)
      {
        throw new Unexpected(ex);
      }
  }

  /**
   * Read the array of boolean.
   */
  public void read_boolean_array(boolean[] x, int offs, int len)
  {
    try
      {
        for (int i = offs; i < offs + len; i++)
          {
            x[i] = b.read() == 0 ? false : true;
          }
      }
    catch (EOFException ex)
      {
        MARSHAL t = new MARSHAL(UNEXP_EOF);
        t.minor = Minor.EOF;
        t.initCause(ex);
        throw t;
      }

    catch (IOException ex)
      {
        throw new Unexpected(ex);
      }
  }

  /**
   * Read a character using narrow charset encoding. Depending form which
   * encoding is set, this still can be Unicode or ever wider.
   */
  public char read_char()
  {
    try
      {
        if (narrow_native)
          return (char) b.read();
        else
          return (char) new InputStreamReader((InputStream) b, narrow_charset).read();
      }
    catch (EOFException ex)
      {
        MARSHAL t = new MARSHAL(UNEXP_EOF);
        t.minor = Minor.EOF;
        t.initCause(ex);
        throw t;
      }

    catch (IOException ex)
      {
        throw new Unexpected(ex);
      }
  }

  /**
   * Read a character array, using narrow charset encoding.
   */
  public void read_char_array(char[] x, int offset, int length)
  {
    try
      {
        if (narrow_native)
          {
            for (int i = offset; i < offset + length; i++)
              x[i] = (char) b.read();
          }
        else
          {
            InputStreamReader reader = new InputStreamReader((InputStream) b,
              narrow_charset);
            reader.read(x, offset, length);
          }
      }
    catch (EOFException ex)
      {
        MARSHAL t = new MARSHAL(UNEXP_EOF);
        t.minor = Minor.EOF;
        t.initCause(ex);
        throw t;
      }

    catch (IOException ex)
      {
        throw new Unexpected(ex);
      }
  }

  /**
   * Read the double value, IEEE 754 format.
   */
  public double read_double()
  {
    try
      {
        align(8);
        return b.readDouble();
      }
    catch (EOFException ex)
      {
        MARSHAL t = new MARSHAL(UNEXP_EOF);
        t.minor = Minor.EOF;
        t.initCause(ex);
        throw t;
      }

    catch (IOException ex)
      {
        throw new Unexpected();
      }
  }

  /**
   * Read the array of double values, IEEE 754 format.
   */
  public void read_double_array(double[] x, int offs, int len)
  {
    try
      {
        align(8);
        for (int i = offs; i < offs + len; i++)
          {
            x[i] = b.readDouble();
          }
      }
    catch (EOFException ex)
      {
        MARSHAL t = new MARSHAL(UNEXP_EOF);
        t.minor = Minor.EOF;
        t.initCause(ex);
        throw t;
      }

    catch (IOException ex)
      {
        throw new Unexpected(ex);
      }
  }

  /**
   * Read the encapsulated stream. If the encapsulated sequence appears to be in
   * the Little endian format, the flag of the returned stream is set to read
   * Little endian.
   */
  public BufferredCdrInput read_encapsulation()
  {
    try
      {
        int l = read_long();

        byte[] r = new byte[l];
        int n = 0;
        reading: while (n < r.length)
          {
            n += read(r, n, r.length - n);
          }

        BufferredCdrInput capsule = new BufferredCdrInput(r);
        capsule.setOrb(orb);

        int endian = capsule.read_octet();

        if (endian != 0)
          {
            capsule.setBigEndian(false);
          }

        return capsule;
      }
    catch (EOFException ex)
      {
        MARSHAL t = new MARSHAL(UNEXP_EOF);
        t.minor = Minor.EOF;
        t.initCause(ex);
        throw t;
      }

    catch (IOException ex)
      {
        throw new Unexpected(ex);
      }
  }

  /**
   * Read the CORBA fixed (the end of the <code>fixed</code> can be determined
   * by its last byte). The scale is always assumed to be zero.
   */
  public BigDecimal read_fixed()
  {
    try
      {
        return BigDecimalHelper.read(this, 0);
      }
    catch (EOFException ex)
      {
        MARSHAL t = new MARSHAL(UNEXP_EOF);
        t.minor = Minor.EOF;
        t.initCause(ex);
        throw t;
      }

    catch (IOException ex)
      {
        throw new Unexpected(ex);
      }
  }

  /**
   * Read the float value, IEEE 754 format.
   */
  public float read_float()
  {
    try
      {
        align(4);
        return b.readFloat();
      }
    catch (EOFException ex)
      {
        MARSHAL t = new MARSHAL(UNEXP_EOF);
        t.minor = Minor.EOF;
        t.initCause(ex);
        throw t;
      }

    catch (IOException ex)
      {
        throw new Unexpected(ex);
      }
  }

  /**
   * Read an array of float values, IEEE 754 format.
   */
  public void read_float_array(float[] x, int offs, int len)
  {
    try
      {
        align(4);
        for (int i = offs; i < offs + len; i++)
          {
            x[i] = b.readFloat();
          }
      }
    catch (EOFException ex)
      {
        MARSHAL t = new MARSHAL(UNEXP_EOF);
        t.minor = Minor.EOF;
        t.initCause(ex);
        throw t;
      }

    catch (IOException ex)
      {
        throw new Unexpected(ex);
      }
  }

  /**
   * Read the CORBA long (java int), high byte first.
   */
  public int read_long()
  {
    try
      {
        align(4);
        return b.readInt();
      }
    catch (EOFException ex)
      {
        MARSHAL t = new MARSHAL(UNEXP_EOF);
        t.minor = Minor.EOF;
        t.initCause(ex);
        throw t;
      }

    catch (IOException ex)
      {
        throw new Unexpected(ex);
      }
  }

  /**
   * Read an array of CORBA longs (java ints).
   */
  public void read_long_array(int[] x, int offs, int len)
  {
    try
      {
        align(4);
        for (int i = offs; i < offs + len; i++)
          {
            x[i] = b.readInt();
          }
      }
    catch (EOFException ex)
      {
        MARSHAL t = new MARSHAL(UNEXP_EOF);
        t.minor = Minor.EOF;
        t.initCause(ex);
        throw t;
      }

    catch (IOException ex)
      {
        throw new Unexpected(ex);
      }
  }

  /**
   * Read the CORBA long long (java long).
   */
  public long read_longlong()
  {
    try
      {
        align(8);
        return b.readLong();
      }
    catch (EOFException ex)
      {
        MARSHAL t = new MARSHAL(UNEXP_EOF);
        t.minor = Minor.EOF;
        throw t;
      }

    catch (IOException ex)
      {
        throw new Unexpected(ex);
      }
  }

  /**
   * Read an array of CORBA long longs (java longs).
   */
  public void read_longlong_array(long[] x, int offs, int len)
  {
    try
      {
        align(8);
        for (int i = offs; i < offs + len; i++)
          {
            x[i] = b.readLong();
          }
      }
    catch (EOFException ex)
      {
        MARSHAL t = new MARSHAL(UNEXP_EOF);
        t.minor = Minor.EOF;
        t.initCause(ex);
        throw t;
      }

    catch (IOException ex)
      {
        throw new Unexpected(ex);
      }
  }

  /**
   * Read a single byte.
   */
  public byte read_octet()
  {
    try
      {
        return b.readByte();
      }
    catch (EOFException ex)
      {
        MARSHAL t = new MARSHAL(UNEXP_EOF);
        t.minor = Minor.EOF;
        t.initCause(ex);
        throw t;
      }

    catch (IOException ex)
      {
        throw new Unexpected(ex);
      }
  }

  /**
   * Read the byte array.
   */
  public void read_octet_array(byte[] x, int offs, int len)
  {
    try
      {
        b.read(x, offs, len);
      }
    catch (EOFException ex)
      {
        MARSHAL t = new MARSHAL(UNEXP_EOF);
        t.minor = Minor.EOF;
        t.initCause(ex);
        throw t;
      }

    catch (IOException ex)
      {
        throw new Unexpected(ex);
      }
  }

  /**
   * Read the length of the byte array as CORBA long and then the array itseld.
   */
  public byte[] read_sequence()
  {
    try
      {
        int l = read_long();
        byte[] buf = new byte[l];
        if (l > 0)
          {
            b.readFully(buf);
          }
        return buf;
      }
    catch (EOFException ex)
      {
        MARSHAL t = new MARSHAL(UNEXP_EOF);
        t.minor = Minor.EOF;
        t.initCause(ex);
        throw t;
      }

    catch (IOException ex)
      {
        throw new Unexpected(ex);
      }
  }

  /**
   * Read the CORBA short integer.
   */
  public short read_short()
  {
    try
      {
        align(2);
        return b.readShort();
      }
    catch (EOFException ex)
      {
        MARSHAL t = new MARSHAL(UNEXP_EOF);
        t.minor = Minor.EOF;
        t.initCause(ex);
        throw t;
      }

    catch (IOException ex)
      {
        throw new Unexpected(ex);
      }
  }

  /**
   * Read the array of CORBA short integer values.
   */
  public void read_short_array(short[] x, int offs, int len)
  {
    try
      {
        align(2);
        for (int i = offs; i < offs + len; i++)
          {
            x[i] = b.readShort();
          }
      }
    catch (EOFException ex)
      {
        MARSHAL t = new MARSHAL(UNEXP_EOF);
        t.minor = Minor.EOF;
        t.initCause(ex);
        throw t;
      }

    catch (IOException ex)
      {
        throw new Unexpected(ex);
      }
  }

  /**
   * Read a singe byte string. The method firs reads the byte array and then
   * calls a constructor to create a string from this array. The character
   * encoding, if previously set, is taken into consideration.
   *
   * @return a loaded string.
   */
  public String read_string()
  {
    int n = 0;
    try
      {
        align(4);

        n = b.readInt();
        byte[] s = new byte[n];
        b.read(s);

        // Discard the null terminator.
        if (narrow_charset == null)
          return new String(s, 0, n - 1);
        else
          return new String(s, 0, n - 1, narrow_charset);
      }
    catch (EOFException ex)
      {
        MARSHAL t = new MARSHAL(UNEXP_EOF);
        t.minor = Minor.EOF;
        t.initCause(ex);
        throw t;
      }
    catch (IOException ex)
      {
        throw new Unexpected();
      }
    catch (NegativeArraySizeException nex)
      {
        MARSHAL m = new MARSHAL("Input stream broken, got " + n + "(0x"
          + Integer.toHexString(n) + ") as a string size");
        m.minor = Minor.Negative;
        throw m;
      }
  }

  /**
   * Reads the CORBA unsigned long (java int), delegating functionality to
   * {@link #read_long}.
   */
  public int read_ulong()
  {
    return read_long();
  }

  /**
   * Reads the array of CORBA unsigned long (java integer) values, delegating
   * functionality to {@link #real_long_array}.
   */
  public void read_ulong_array(int[] x, int offs, int len)
  {
    read_long_array(x, offs, len);
  }

  /**
   * Read the CORBA unsigned long long value, delegating functionality to
   * {@link #read_longlong}. There is no way to return values over the limit of
   * the java signed long in other way than returning the negative value.
   */
  public long read_ulonglong()
  {
    return read_longlong();
  }

  /**
   * Reads the array of CORBA long long (java long) values, delegating
   * functionality to {@link #real_longlong_array}.
   */
  public void read_ulonglong_array(long[] x, int offs, int len)
  {
    read_longlong_array(x, offs, len);
  }

  /**
   * Read the unsigned short integer value. Due strange specification, the
   * returned value must be the short type as well, so the the best solution
   * seems just to delegete functionality to read_short.
   */
  public short read_ushort()
  {
    return read_short();
  }

  /**
   * Read an array of unsigned short values, delegating the functionality to
   * {@link read_short_array}.
   */
  public void read_ushort_array(short[] x, int offs, int len)
  {
    read_short_array(x, offs, len);
  }

  /**
   * Reads the wide character using the encoding, specified in the wide_charset.
   */
  public char read_wchar()
  {
    try
      {
        if (giop.until_inclusive(1, 1))
          {
            align(2);

            if (wide_native)
              return (char) b.readShort();
            else
              return (char) new InputStreamReader((InputStream) b, wide_charset).read();
          }
        else
          {
            int l = b.read();
            if (l == 2 && wide_native)
              return b.readChar();
            else if (l <= 0)
              {
                 MARSHAL m = new MARSHAL("wchar size " + l);
                 m.minor = Minor.Negative;
                 throw m;
              }
            else
              {
                byte[] bytes = new byte[l];
                b.readFully(bytes);
                String cs;

                if (bytes.length > 2 && bytes[0] == 0xFE && bytes[1] == 0xFF)
                  cs = new String(bytes, 2, bytes.length - 2, wide_charset);
                else if (bytes.length > 2 && bytes[0] == 0xFF
                  && bytes[1] == 0xFE)
                  {
                    // Litle endian detected - swap bytes.
                    byte t;
                    for (int i = 3; i < bytes.length; i = i + 2)
                      {
                        t = bytes[i];
                        bytes[i - 1] = bytes[i];
                        bytes[i] = t;
                      }
                    cs = new String(bytes, 2, bytes.length - 2, wide_charset);
                  }
                else
                  cs = new String(bytes, wide_charset);

                return cs.charAt(0);
              }
          }
      }
    catch (EOFException ex)
      {
        MARSHAL t = new MARSHAL(UNEXP_EOF);
        t.minor = Minor.EOF;
        t.initCause(ex);
        throw t;
      }
    catch (IOException ex)
      {
        throw new Unexpected();
      }
  }

  /**
   * Read an array of "wide chars", each representing a two byte Unicode
   * character, high byte first.
   */
  public void read_wchar_array(char[] x, int offset, int length)
  {
    try
      {
        if (giop.until_inclusive(1, 1))
          align(2);

        if (wide_native)
          {
            for (int i = offset; i < offset + length; i++)
              x[i] = (char) b.readShort();
          }
        else
          {
            InputStreamReader reader = new InputStreamReader((InputStream) b,
              wide_charset);
            reader.read(x, offset, length);
          }
      }
    catch (EOFException ex)
      {
        MARSHAL t = new MARSHAL(UNEXP_EOF);
        t.minor = Minor.EOF;
        t.initCause(ex);
        throw t;
      }

    catch (IOException ex)
      {
        throw new Unexpected(ex);
      }
  }

  /**
   * Reads the string in wide character format (ussually UTF-16, Unicode). Takes
   * the currently set charset into consideration.
   *
   * If the native (UTF-16) encoding is used of the GIOP protocol is before 1.2,
   * delegates functionality to "plain" {@link #read_wstring_UTF_16}.
   */
  public String read_wstring()
  {
    // Native encoding or word oriented data.
    if (wide_native || giop.until_inclusive(1, 1))
      return read_wstring_UTF_16();
    try
      {
        align(4);

        int n = b.readInt();
        byte[] s = new byte[n];
        b.read(s);

        return new String(s, 0, n, wide_charset);
      }
    catch (EOFException ex)
      {
        MARSHAL t = new MARSHAL(UNEXP_EOF);
        t.minor = Minor.EOF;
        t.initCause(ex);
        throw t;
      }

    catch (IOException ex)
      {
        throw new Unexpected(ex);
      }
  }

  /**
   * Reads first length of the string and the all characters as an Unicode
   * (UTF-16) characters. Mind that GIOP 1.1 has the extra null character at the
   * end that must be discarded.
   */
  public String read_wstring_UTF_16()
  {
    try
      {
        int p = 0;
        int n = read_long();

        if (n<0)
          {
            MARSHAL m = new MARSHAL("Negative string size");
            m.minor = Minor.Negative;
            throw m;
          }

        // The null terminator that is no longer present since 1.2 .
        int nt = giop.since_inclusive(1, 2) ? 0 : 1;

        // Convert bytes to shorts.
        n = n / 2;

        // Empty string.
        if (n == 0)
          return "";

        char[] s = new char[n];

        for (int i = 0; i < s.length; i++)
          s[i] = (char) b.readShort();

        // Check for the byte order marker here.
        if (s[0] == 0xFEFF)
          {
            // Big endian encoding - do nothing, but move the pointer
            // one position forward.
            p = 1;
          }
        else if (s[0] == 0xFFFE)
          {
            // Little endian encoding, swap the bytes and move one
            // position forward.
            p = 1;

            for (int i = p; i < s.length; i++)
              s[i] = swap(s[i]);
          }

        // Discard the null terminator and, if needed, the endian marker.
        String r = new String(s, p, n - nt - p);
        return r;
      }
    catch (EOFException ex)
      {
        MARSHAL t = new MARSHAL(UNEXP_EOF);
        t.minor = Minor.EOF;
        t.initCause(ex);
        throw t;
      }

    catch (IOException ex)
      {
        throw new Unexpected(ex);
      }
  }

  /**
   * Swap bytes in the character.
   */
  public static char swap(char x)
  {
    int hi;
    int lo;

    lo = x & 0xFF;
    hi = (x >> 8) & 0xFF;

    return (char) ((lo << 8) | hi);
  }

  /**
   * Set the current code set context.
   */
  public void setCodeSet(CodeSetServiceContext a_codeset)
  {
    this.codeset = a_codeset;
    narrow_charset = CharSets_OSF.getName(codeset.char_data);
    wide_charset = CharSets_OSF.getName(codeset.wide_char_data);

    narrow_native = CharSets_OSF.NATIVE_CHARACTER == codeset.char_data;
    wide_native = CharSets_OSF.NATIVE_WIDE_CHARACTER == codeset.wide_char_data;
  }

  /**
   * Get the current code set context.
   */
  public CodeSetServiceContext getCodeSet()
  {
    return codeset;
  }

  /**
   * Read the object that is an instance of the given class. The current
   * implementation delegates functionality to the parameterless
   * {@link readObject()}.
   *
   * @param klass a class of that this object the instance is.
   *
   * @return the returned object.
   */
  public org.omg.CORBA.Object read_Object(Class klass)
  {
    return read_Object();
  }

  /**
   * Read a value type structure from the stream.
   *
   * OMG specification states the writing format is outside the scope of GIOP
   * definition. This implementation uses java serialization mechanism, calling
   * {@link ObjectInputStream#readObject}
   *
   * @return an value type structure, unmarshaled from the stream
   */
  public Serializable read_Value()
  {
    return read_value();
  }

  /**
   * Read the abstract interface. An abstract interface can be either CORBA
   * value type or CORBA object and is returned as an abstract java.lang.Object.
   *
   * As specified in OMG specification, this reads a single boolean and then
   * delegates either to {@link #read_Object()} (for false) or to
   * {@link #read_Value()} (for true).
   *
   * @return an abstract interface, unmarshaled from the stream
   */
  public java.lang.Object read_Abstract()
  {
    return read_abstract_interface();
  }

  /**
   * Read an array. In OMG specification is written that if the data does not
   * fit into the holder value field, that array must be resized. The
   * implementation follows this rule. If the holder value field contains null,
   * it is newly instantiated.
   */
  public void read_char_array(CharSeqHolder holder, int offset, int length)
  {
    holder.value = ensureArray(holder.value, offset, length);
    read_char_array(holder.value, offset, length);
  }

  /**
   * Read an array. In OMG specification is written that if the data does not
   * fit into the holder value field, that array must be resized. The
   * implementation follows this rule. If the holder value field contains null,
   * it is newly instantiated.
   */
  public void read_wchar_array(WCharSeqHolder holder, int offset, int length)
  {
    holder.value = ensureArray(holder.value, offset, length);
    read_wchar_array(holder.value, offset, length);
  }

  /**
   * If required, allocate or resize the char array to fit the newly read
   * values.
   *
   * @param holder_value the existing char array, may be null.
   * @param offset the required offset to read.
   * @param length the length of the new sequence.
   *
   * @return the allocated or resized array, same array if no such operations
   * are required.
   */
  private char[] ensureArray(char[] holder_value, int offset, int length)
  {
    if (holder_value == null)
      return new char[offset + length];
    else if (holder_value.length < offset + length)
      {
        char[] value = new char[offset + length];
        System.arraycopy(holder_value, 0, value, 0, holder_value.length);
        return value;
      }
    else
      return holder_value;
  }

  /**
   * Read an array. In OMG specification is written that if the data does not
   * fit into the holder value field, that array must be resized. The
   * implementation follows this rule. If the holder value field contains null,
   * it is newly instantiated.
   */
  public void read_ulong_array(ULongSeqHolder holder, int offset, int length)
  {
    holder.value = ensureArray(holder.value, offset, length);
    read_ulong_array(holder.value, offset, length);
  }

  /**
   * Read an array. In OMG specification is written that if the data does not
   * fit into the holder value field, that array must be resized. The
   * implementation follows this rule. If the holder value field contains null,
   * it is newly instantiated.
   */
  public void read_long_array(LongSeqHolder holder, int offset, int length)
  {
    holder.value = ensureArray(holder.value, offset, length);
    read_ulong_array(holder.value, offset, length);
  }

  /**
   * If required, allocate or resize the int array to fit the newly read values.
   *
   * @param holder_value the existing int array, may be null.
   * @param offset the required offset to read.
   * @param length the length of the new sequence.
   *
   * @return the allocated or resized array, same array if no such operations
   * are required.
   */
  private int[] ensureArray(int[] holder_value, int offset, int length)
  {
    if (holder_value == null)
      return new int[offset + length];
    else if (holder_value.length < offset + length)
      {
        int[] value = new int[offset + length];
        System.arraycopy(holder_value, 0, value, 0, holder_value.length);
        return value;
      }
    else
      return holder_value;
  }

  /**
   * Read an array. In OMG specification is written that if the data does not
   * fit into the holder value field, that array must be resized. The
   * implementation follows this rule. If the holder value field contains null,
   * it is newly instantiated.
   */
  public void read_float_array(FloatSeqHolder holder, int offset, int length)
  {
    holder.value = ensureArray(holder.value, offset, length);
    read_float_array(holder.value, offset, length);
  }

  /**
   * If required, allocate or resize the float array to fit the newly read
   * values.
   *
   * @param holder_value the existing float array, may be null.
   * @param offset the required offset to read.
   * @param length the length of the new sequence.
   *
   * @return the allocated or resized array, same array if no such operations
   * are required.
   */
  private float[] ensureArray(float[] holder_value, int offset, int length)
  {
    if (holder_value == null)
      return new float[offset + length];
    else if (holder_value.length < offset + length)
      {
        float[] value = new float[offset + length];
        System.arraycopy(holder_value, 0, value, 0, holder_value.length);
        return value;
      }
    else
      return holder_value;
  }

  /**
   * Read an array. In OMG specification is written that if the data does not
   * fit into the holder value field, that array must be resized. The
   * implementation follows this rule. If the holder value field contains null,
   * it is newly instantiated.
   */
  public void read_double_array(DoubleSeqHolder holder, int offset, int length)
  {
    holder.value = ensureArray(holder.value, offset, length);
    read_double_array(holder.value, offset, length);
  }

  /**
   * If required, allocate or resize the double array to fit the newly read
   * values.
   *
   * @param holder_value the existing double array, may be null.
   * @param offset the required offset to read.
   * @param length the length of the new sequence.
   *
   * @return the allocated or resized array, same array if no such operations
   * are required.
   */
  private double[] ensureArray(double[] holder_value, int offset, int length)
  {
    if (holder_value == null)
      return new double[offset + length];
    else if (holder_value.length < offset + length)
      {
        double[] value = new double[offset + length];
        System.arraycopy(holder_value, 0, value, 0, holder_value.length);
        return value;
      }
    else
      return holder_value;
  }

  /**
   * Read an array. In OMG specification is written that if the data does not
   * fit into the holder value field, that array must be resized. The
   * implementation follows this rule. If the holder value field contains null,
   * it is newly instantiated.
   */
  public void read_short_array(ShortSeqHolder holder, int offset, int length)
  {
    holder.value = ensureArray(holder.value, offset, length);
    read_short_array(holder.value, offset, length);
  }

  /** {@inheritDoc} */
  public void read_ushort_array(UShortSeqHolder holder, int offset, int length)
  {
    holder.value = ensureArray(holder.value, offset, length);
    read_ushort_array(holder.value, offset, length);
  }

  /**
   * If required, allocate or resize the short array to fit the newly read
   * values.
   *
   * @param holder_value the existing short array, may be null.
   * @param offset the required offset to read.
   * @param length the length of the new sequence.
   *
   * @return the allocated or resized array, same array if no such operations
   * are required.
   */
  private short[] ensureArray(short[] holder_value, int offset, int length)
  {
    if (holder_value == null)
      return new short[offset + length];
    else if (holder_value.length < offset + length)
      {
        short[] value = new short[offset + length];
        System.arraycopy(holder_value, 0, value, 0, holder_value.length);
        return value;
      }
    else
      return holder_value;
  }

  /**
   * Read an array. In OMG specification is written that if the data does not
   * fit into the holder value field, that array must be resized. The
   * implementation follows this rule. If the holder value field contains null,
   * it is newly instantiated.
   */
  public void read_octet_array(OctetSeqHolder holder, int offset, int length)
  {
    holder.value = ensureArray(holder.value, offset, length);
    read_octet_array(holder.value, offset, length);
  }

  /**
   * If required, allocate or resize the byte array to fit the newly read
   * values.
   *
   * @param holder_value the existing byte array, may be null.
   * @param offset the required offset to read.
   * @param length the length of the new sequence.
   *
   * @return the allocated or resized array, same array if no such operations
   * are required.
   */
  private byte[] ensureArray(byte[] holder_value, int offset, int length)
  {
    if (holder_value == null)
      return new byte[offset + length];
    else if (holder_value.length < offset + length)
      {
        byte[] value = new byte[offset + length];
        System.arraycopy(holder_value, 0, value, 0, holder_value.length);
        return value;
      }
    else
      return holder_value;
  }

  /**
   * Read an array. In OMG specification is written that if the data does not
   * fit into the holder value field, that array must be resized. The
   * implementation follows this rule. If the holder value field contains null,
   * it is newly instantiated.
   */
  public void read_longlong_array(LongLongSeqHolder holder, int offset,
    int length)
  {
    holder.value = ensureArray(holder.value, offset, length);
    read_longlong_array(holder.value, offset, length);
  }

  /**
   * Read an array. In OMG specification is written that if the data does not
   * fit into the holder value field, that array must be resized. The
   * implementation follows this rule. If the holder value field contains null,
   * it is newly instantiated.
   */
  public void read_ulonglong_array(ULongLongSeqHolder holder, int offset,
    int length)
  {
    holder.value = ensureArray(holder.value, offset, length);
    read_ulonglong_array(holder.value, offset, length);
  }

  /**
   * If required, allocate or resize the array of longs to fit the newly read
   * values.
   *
   * @param holder_value the existing array, may be null.
   * @param offset the required offset to read.
   * @param length the length of the new sequence.
   *
   * @return the allocated or resized array, same array if no such operations
   * are required.
   */
  private long[] ensureArray(long[] holder_value, int offset, int length)
  {
    if (holder_value == null)
      return new long[offset + length];
    else if (holder_value.length < offset + length)
      {
        long[] value = new long[offset + length];
        System.arraycopy(holder_value, 0, value, 0, holder_value.length);
        return value;
      }
    else
      return holder_value;
  }

  /**
   * Read an array. In OMG specification is written that if the data does not
   * fit into the holder value field, that array must be resized. The
   * implementation follows this rule. If the holder value field contains null,
   * it is newly instantiated.
   */
  public void read_boolean_array(BooleanSeqHolder holder, int offset, int length)
  {
    holder.value = ensureArray(holder.value, offset, length);
    read_boolean_array(holder.value, offset, length);
  }

  /**
   * If required, allocate or resize the array of booleans to fit the newly read
   * values.
   *
   * @param holder_value the existing array of booleans, may be null.
   * @param offset the required offset to read.
   * @param length the length of the new sequence.
   *
   * @return the allocated or resized array, same array if no such operations
   * are required.
   */
  private boolean[] ensureArray(boolean[] holder_value, int offset, int length)
  {
    if (holder_value == null)
      return new boolean[offset + length];
    else if (holder_value.length < offset + length)
      {
        boolean[] value = new boolean[offset + length];
        System.arraycopy(holder_value, 0, value, 0, holder_value.length);
        return value;
      }
    else
      return holder_value;
  }

  /**
   * Read an array. In OMG specification is written that if the data does not
   * fit into the holder value field, that array must be resized. The
   * implementation follows this rule. If the holder value field contains null,
   * it is newly instantiated.
   */
  public void read_any_array(AnySeqHolder holder, int offset, int length)
  {
    holder.value = ensureArray(holder.value, offset, length);
    for (int i = offset; i < offset + length; i++)
      {
        holder.value[i] = read_any();
      }
  }

  /**
   * If required, allocate or resize the array of Anys to fit the newly read
   * values.
   *
   * @param holder_value the existing array of Anys, may be null.
   * @param offset the required offset to read.
   * @param length the length of the new sequence.
   *
   * @return the allocated or resized array, same array if no such operations
   * are required.
   */
  private Any[] ensureArray(Any[] holder_value, int offset, int length)
  {
    if (holder_value == null)
      return new Any[offset + length];
    else if (holder_value.length < offset + length)
      {
        Any[] value = new Any[offset + length];
        System.arraycopy(holder_value, 0, value, 0, holder_value.length);
        return value;
      }
    else
      return holder_value;
  }

  /**
   * This method is required to represent the DataInputStream as a value type
   * object.
   *
   * @return a single entity "IDL:omg.org/CORBA/DataInputStream:1.0", always.
   */
  public String[] _truncatable_ids()
  {
    return new String[] { "IDL:omg.org/CORBA/DataInputStream:1.0" };
  }
}