8f523f3a10
* sources.am: Regenerated.
* Makefile.in: Likewise.
* scripts/makemake.tcl: Use glob -nocomplain.
From-SVN: r107049
1768 lines
45 KiB
Java
1768 lines
45 KiB
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" };
|
|
}
|
|
} |