8f523f3a10
* sources.am: Regenerated.
* Makefile.in: Likewise.
* scripts/makemake.tcl: Use glob -nocomplain.
From-SVN: r107049
907 lines
22 KiB
Java
907 lines
22 KiB
Java
/* gnuAny.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;
|
|
|
|
import gnu.CORBA.CDR.Vio;
|
|
import gnu.CORBA.CDR.BufferredCdrInput;
|
|
import gnu.CORBA.CDR.BufferedCdrOutput;
|
|
import gnu.CORBA.typecodes.PrimitiveTypeCode;
|
|
import gnu.CORBA.typecodes.StringTypeCode;
|
|
|
|
import org.omg.CORBA.Any;
|
|
import org.omg.CORBA.AnyHolder;
|
|
import org.omg.CORBA.BAD_OPERATION;
|
|
import org.omg.CORBA.BooleanHolder;
|
|
import org.omg.CORBA.CharHolder;
|
|
import org.omg.CORBA.DoubleHolder;
|
|
import org.omg.CORBA.FixedHolder;
|
|
import org.omg.CORBA.FloatHolder;
|
|
import org.omg.CORBA.IntHolder;
|
|
import org.omg.CORBA.LongHolder;
|
|
import org.omg.CORBA.MARSHAL;
|
|
import org.omg.CORBA.ORB;
|
|
import org.omg.CORBA.ObjectHolder;
|
|
import org.omg.CORBA.Principal;
|
|
import org.omg.CORBA.PrincipalHolder;
|
|
import org.omg.CORBA.ShortHolder;
|
|
import org.omg.CORBA.StringHolder;
|
|
import org.omg.CORBA.TCKind;
|
|
import org.omg.CORBA.TypeCode;
|
|
import org.omg.CORBA.TypeCodeHolder;
|
|
import org.omg.CORBA.ValueBaseHolder;
|
|
import org.omg.CORBA.portable.Streamable;
|
|
|
|
import java.io.Serializable;
|
|
import java.lang.reflect.Field;
|
|
import java.math.BigDecimal;
|
|
import java.util.Arrays;
|
|
import java.util.zip.Adler32;
|
|
|
|
/**
|
|
* The implementation of {@link Any}.
|
|
*
|
|
* For performance reasonse, the inserted values are not cloned.
|
|
* If the value object allows modifications (like {@link Streamable}),
|
|
* these subsequent alterations are reflected by the instance of
|
|
* this gnuAny, and the gnuAny alterations are reflected by the
|
|
* returned value. If it is required to have the uncoupled value,
|
|
* it must be requested from the copy of the current instance.
|
|
* The {@link gnuAny} can be simply cloned by the provided
|
|
* {@link Clone()} method.
|
|
*
|
|
* @author Audrius Meskauskas (AudriusA@Bioinformatics.org)
|
|
*/
|
|
public class gnuAny
|
|
extends Any
|
|
{
|
|
/**
|
|
* Use serialVersionUID for interoperability.
|
|
*/
|
|
private static final long serialVersionUID = 1;
|
|
|
|
/**
|
|
* The value, returned by {@link #type()} if the value has been
|
|
* not intialized.
|
|
*/
|
|
protected static final TypeCode nullType =
|
|
new PrimitiveTypeCode(TCKind.tk_null);
|
|
|
|
/**
|
|
* The Streamable, representing the value, held by this gnuAny.
|
|
*/
|
|
protected Streamable has;
|
|
|
|
/**
|
|
* The complete typecode of the Streamable, if explicitly set.
|
|
*/
|
|
protected TypeCode typecode;
|
|
|
|
/**
|
|
* The typecode kind of the Streamable, if explicitly set.
|
|
*/
|
|
protected int xKind = -1;
|
|
|
|
/**
|
|
* The associated ORB.
|
|
*/
|
|
private ORB orb;
|
|
|
|
/**
|
|
* Set the associated orb.
|
|
*/
|
|
public void setOrb(ORB an_orb)
|
|
{
|
|
orb = an_orb;
|
|
}
|
|
|
|
/**
|
|
* Creates a deep copy of this gnuAny, writing to and subsequently
|
|
* reading from from the byte buffer.
|
|
*
|
|
* @return the uncoupled gnuAny with all fields set to identical
|
|
* values.
|
|
*/
|
|
public gnuAny Clone()
|
|
{
|
|
BufferedCdrOutput out = new BufferedCdrOutput();
|
|
out.setOrb(orb);
|
|
out.write_any(this);
|
|
|
|
BufferredCdrInput in = new BufferredCdrInput(out.buffer.toByteArray());
|
|
in.setOrb(orb);
|
|
return (gnuAny) in.read_any();
|
|
}
|
|
|
|
/**
|
|
* Create the buffered CDR input stream, containing the
|
|
* value, stored inside of this {@link Any}.
|
|
*/
|
|
public org.omg.CORBA.portable.InputStream create_input_stream()
|
|
{
|
|
if (has instanceof GeneralHolder)
|
|
{
|
|
GeneralHolder u = (GeneralHolder) has;
|
|
return u.getInputStream();
|
|
}
|
|
else
|
|
{
|
|
BufferedCdrOutput out = new BufferedCdrOutput();
|
|
out.setOrb(orb);
|
|
write_value(out);
|
|
|
|
BufferredCdrInput in = new BufferredCdrInput(out.buffer.toByteArray());
|
|
in.setOrb(orb);
|
|
return in;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create the buffered CDR output stream (empty).
|
|
*/
|
|
public org.omg.CORBA.portable.OutputStream create_output_stream()
|
|
{
|
|
BufferedCdrOutput stream = new BufferedCdrOutput();
|
|
stream.setOrb(orb);
|
|
return stream;
|
|
}
|
|
|
|
/**
|
|
* Compare two Any's for equality.
|
|
* @param other the other Any to compare.
|
|
*/
|
|
public boolean equal(Any other)
|
|
{
|
|
if (other == this)
|
|
return true;
|
|
if (type().kind() != other.type().kind())
|
|
return false;
|
|
|
|
if (has != null && other instanceof gnuAny)
|
|
if (has.equals(((gnuAny) other).has))
|
|
return true;
|
|
|
|
BufferedCdrOutput a = new BufferedCdrOutput();
|
|
a.setOrb(orb);
|
|
write_value(a);
|
|
|
|
BufferedCdrOutput b = new BufferedCdrOutput();
|
|
b.setOrb(orb);
|
|
other.write_value(b);
|
|
|
|
byte[] ba = a.buffer.toByteArray();
|
|
byte[] bb = b.buffer.toByteArray();
|
|
|
|
return Arrays.equals(ba, bb);
|
|
}
|
|
|
|
/**
|
|
* Get the content - dependent hashcode.
|
|
*/
|
|
public int hashCode()
|
|
{
|
|
if (has == null)
|
|
return type().kind().value();
|
|
else
|
|
{
|
|
Adler32 adler = new Adler32();
|
|
|
|
BufferedCdrOutput a = new BufferedCdrOutput();
|
|
a.setOrb(orb);
|
|
write_value(a);
|
|
|
|
adler.update(a.buffer.toByteArray());
|
|
adler.update(type().kind().value());
|
|
|
|
return (int) adler.getValue() & Integer.MAX_VALUE;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Delegates functionality to {@link #equal(Any)}.
|
|
*/
|
|
public boolean equals(java.lang.Object other)
|
|
{
|
|
if (other == this)
|
|
return true;
|
|
if (!(other instanceof Any))
|
|
return false;
|
|
|
|
return equal((Any) other);
|
|
}
|
|
|
|
/**
|
|
* Extract the previously stored object.
|
|
*/
|
|
public org.omg.CORBA.Object extract_Object()
|
|
{
|
|
try
|
|
{
|
|
return ((ObjectHolder) has).value;
|
|
}
|
|
catch (ClassCastException ex)
|
|
{
|
|
BAD_OPERATION bad = new BAD_OPERATION();
|
|
bad.initCause(ex);
|
|
bad.minor = Minor.Any;
|
|
throw bad;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Extract the previously inserted CORBA <code>Principal</code>/
|
|
* @return the previously inserted value.
|
|
*
|
|
* @throws org.omg.CORBA.BAD_OPERATION if the holder contains something
|
|
* else than Principal.
|
|
*
|
|
* @deprecated by CORBA 2.2.
|
|
*/
|
|
public Principal extract_Principal()
|
|
{
|
|
check(TCKind._tk_Principal);
|
|
return ((PrincipalHolder) has).value;
|
|
}
|
|
|
|
/**
|
|
* Return the value, encapsulated in a suitable holder.
|
|
* This implementation returns the direct reference,
|
|
* so the alterations on the returned streamable are
|
|
* directly reflected to the content of this {@link Any}.
|
|
*/
|
|
public Streamable extract_Streamable()
|
|
{
|
|
return has;
|
|
}
|
|
|
|
public TypeCode extract_TypeCode()
|
|
throws BAD_OPERATION
|
|
{
|
|
check(TCKind._tk_TypeCode);
|
|
return ((TypeCodeHolder) has).value;
|
|
}
|
|
|
|
/**
|
|
* Extract the stored value type.
|
|
*
|
|
* @return the previously stored value type.
|
|
*
|
|
* @throws BAD_OPERATION if the Any contains something different.
|
|
*
|
|
* @see org.omg.CORBA.portable.ValueBase
|
|
*/
|
|
public Serializable extract_Value()
|
|
throws BAD_OPERATION
|
|
{
|
|
try
|
|
{
|
|
if (has instanceof ValueBaseHolder)
|
|
return ((ValueBaseHolder) has).value;
|
|
else
|
|
{
|
|
// Normally, ValueBase holder must be an instance of the
|
|
// ValueBaseHolder. However some IDL compilers probably
|
|
// have a bug, do not deriving this way. The the only
|
|
// way to access the wrapped value is via reflection.
|
|
Field f = has.getClass().getField("value");
|
|
return (Serializable) f.get(has);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
BAD_OPERATION bad = new BAD_OPERATION("Value type expected");
|
|
bad.minor = Minor.Any;
|
|
bad.initCause(ex);
|
|
throw bad;
|
|
}
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public Any extract_any()
|
|
throws BAD_OPERATION
|
|
{
|
|
check(TCKind._tk_any);
|
|
return ((AnyHolder) has).value;
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public boolean extract_boolean()
|
|
throws BAD_OPERATION
|
|
{
|
|
check(TCKind._tk_boolean);
|
|
return ((BooleanHolder) has).value;
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public char extract_char()
|
|
throws BAD_OPERATION
|
|
{
|
|
check(TCKind._tk_char);
|
|
return ((CharHolder) has).value;
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public double extract_double()
|
|
throws BAD_OPERATION
|
|
{
|
|
check(TCKind._tk_double);
|
|
return ((DoubleHolder) has).value;
|
|
}
|
|
|
|
/**
|
|
* Extract the previously inserted CORBA <code>fixed</code>/
|
|
* @return the previously inserted value.
|
|
*
|
|
* @throws org.omg.CORBA.BAD_OPERATION if the holder contains something
|
|
* else than BigDecimal.
|
|
*/
|
|
public BigDecimal extract_fixed()
|
|
throws org.omg.CORBA.BAD_OPERATION
|
|
{
|
|
check(TCKind._tk_fixed);
|
|
return ((FixedHolder) has).value;
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public float extract_float()
|
|
throws BAD_OPERATION
|
|
{
|
|
check(TCKind._tk_float);
|
|
return ((FloatHolder) has).value;
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public int extract_long()
|
|
throws BAD_OPERATION
|
|
{
|
|
// CORBA long = java int.
|
|
check(TCKind._tk_long);
|
|
return ((IntHolder) has).value;
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public long extract_longlong()
|
|
throws BAD_OPERATION
|
|
{
|
|
check(TCKind._tk_longlong);
|
|
return ((LongHolder) has).value;
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public byte extract_octet()
|
|
throws BAD_OPERATION
|
|
{
|
|
// ShortHolder holds also octets.
|
|
check(TCKind._tk_octet);
|
|
return (byte) ((OctetHolder) has).value;
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public short extract_short()
|
|
throws BAD_OPERATION
|
|
{
|
|
check(TCKind._tk_short);
|
|
return ((ShortHolder) has).value;
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public String extract_string()
|
|
throws BAD_OPERATION
|
|
{
|
|
check(TCKind._tk_string);
|
|
return ((StringHolder) has).value;
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public int extract_ulong()
|
|
throws BAD_OPERATION
|
|
{
|
|
// IntHolder also holds ulongs.
|
|
check(TCKind._tk_ulong);
|
|
return ((IntHolder) has).value;
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public long extract_ulonglong()
|
|
throws BAD_OPERATION
|
|
{
|
|
// LongHolder also holds ulonglong
|
|
check(TCKind._tk_ulonglong);
|
|
return ((LongHolder) has).value;
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public short extract_ushort()
|
|
throws BAD_OPERATION
|
|
{
|
|
// ShortHolder also holds ushorts.
|
|
check(TCKind._tk_ushort);
|
|
return ((ShortHolder) has).value;
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public char extract_wchar()
|
|
throws BAD_OPERATION
|
|
{
|
|
check(TCKind._tk_wchar);
|
|
return ((WCharHolder) has).value;
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public String extract_wstring()
|
|
throws BAD_OPERATION
|
|
{
|
|
// StringHolder also holds wstrings.
|
|
check(TCKind._tk_wstring);
|
|
return ((WStringHolder) has).value;
|
|
}
|
|
|
|
/**
|
|
* Inserts the CORBA object and sets the typecode to the given type.
|
|
*/
|
|
public void insert_Object(org.omg.CORBA.Object x, TypeCode typecode)
|
|
{
|
|
has = new ObjectHolder(x);
|
|
type(typecode);
|
|
}
|
|
|
|
/**
|
|
* Inserts the CORBA object.
|
|
*/
|
|
public void insert_Object(org.omg.CORBA.Object x)
|
|
{
|
|
has = new ObjectHolder(x);
|
|
}
|
|
|
|
/**
|
|
* Insert the CORBA Principal.
|
|
* This implementation uses direct assignment, so the later
|
|
* alterations of that BigDecimal are reflected on the
|
|
* content of this {@link Any}.
|
|
*
|
|
* @deprecated by CORBA 2.2.
|
|
*/
|
|
public void insert_Principal(Principal x)
|
|
{
|
|
resetTypes();
|
|
if (has instanceof PrincipalHolder)
|
|
((PrincipalHolder) has).value = x;
|
|
else
|
|
has = new PrincipalHolder(x);
|
|
}
|
|
|
|
/**
|
|
* Sets the value to the value, encapsulated in this holder.
|
|
* This implementation uses direct assignment, so the later
|
|
* alterations of that streamable are reflected on the
|
|
* content of this {@link Any}.
|
|
*/
|
|
public void insert_Streamable(Streamable x)
|
|
{
|
|
resetTypes();
|
|
has = x;
|
|
}
|
|
|
|
/**
|
|
* Insert the typecode into this Any
|
|
* @param typecode the typecode to insert.
|
|
*/
|
|
public void insert_TypeCode(TypeCode typecode)
|
|
{
|
|
resetTypes();
|
|
if (has instanceof TypeCodeHolder)
|
|
((TypeCodeHolder) has).value = typecode;
|
|
else
|
|
has = new TypeCodeHolder(typecode);
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public void insert_Value(Serializable x, TypeCode c_typecode)
|
|
{
|
|
if (typecode != null && typecode.kind() == TCKind.tk_value_box)
|
|
{
|
|
has = new gnuValueHolder(x, typecode);
|
|
}
|
|
else
|
|
{
|
|
type(typecode);
|
|
insert_Value(x);
|
|
}
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public void insert_Value(Serializable x)
|
|
{
|
|
if (typecode != null && typecode.kind() == TCKind.tk_value_box)
|
|
{
|
|
has = new gnuValueHolder(x, typecode);
|
|
}
|
|
else
|
|
{
|
|
if (has instanceof ValueBaseHolder)
|
|
((ValueBaseHolder) has).value = x;
|
|
else
|
|
has = new ValueBaseHolder(x);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Insert another {@link Any} into this {@link Any}.
|
|
* This implementation uses direct assignment, so the later
|
|
* alterations of that {@link Any} are reflected on the
|
|
* content of this {@link Any}.
|
|
*/
|
|
public void insert_any(Any an_any)
|
|
{
|
|
resetTypes();
|
|
if (has instanceof AnyHolder)
|
|
((AnyHolder) has).value = an_any;
|
|
else
|
|
has = new AnyHolder(an_any);
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public void insert_boolean(boolean x)
|
|
{
|
|
resetTypes();
|
|
if (has instanceof BooleanHolder)
|
|
((BooleanHolder) has).value = x;
|
|
else
|
|
has = new BooleanHolder(x);
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public void insert_char(char x)
|
|
{
|
|
resetTypes();
|
|
if (has instanceof CharHolder)
|
|
((CharHolder) has).value = x;
|
|
else
|
|
has = new CharHolder(x);
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public void insert_double(double x)
|
|
{
|
|
resetTypes();
|
|
if (has instanceof DoubleHolder)
|
|
((DoubleHolder) has).value = x;
|
|
else
|
|
has = new DoubleHolder(x);
|
|
}
|
|
|
|
/**
|
|
* Inserts the CORBA <code>fixed</code>, setting the typecode
|
|
* explicitly.
|
|
* This implementation uses direct assignment, so the later
|
|
* alterations of that BigDecimal are reflected on the
|
|
* content of this {@link Any}.
|
|
*/
|
|
public void insert_fixed(BigDecimal x, TypeCode x_typecode)
|
|
{
|
|
resetTypes();
|
|
insert_fixed(x);
|
|
typecode = x_typecode;
|
|
}
|
|
|
|
/**
|
|
* Inserts the CORBA <code>fixed</code>, setting the typecode
|
|
* by example of the currently passed value.
|
|
* This implementation uses direct assignment, so the later
|
|
* alterations of that BigDecimal are reflected on the
|
|
* content of this {@link Any}, including the typecode.
|
|
*/
|
|
public void insert_fixed(BigDecimal x)
|
|
{
|
|
resetTypes();
|
|
if (has instanceof FixedHolder)
|
|
((FixedHolder) has).value = x;
|
|
else
|
|
has = new FixedHolder(x);
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public void insert_float(float x)
|
|
{
|
|
resetTypes();
|
|
if (has instanceof FloatHolder)
|
|
((FloatHolder) has).value = x;
|
|
else
|
|
has = new FloatHolder(x);
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public void insert_long(int x)
|
|
{
|
|
resetTypes();
|
|
if (has instanceof IntHolder)
|
|
((IntHolder) has).value = x;
|
|
else
|
|
has = new IntHolder(x);
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public void insert_longlong(long x)
|
|
{
|
|
resetTypes();
|
|
if (has instanceof LongHolder)
|
|
((LongHolder) has).value = x;
|
|
else
|
|
has = new LongHolder(x);
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public void insert_octet(byte x)
|
|
{
|
|
resetTypes();
|
|
if (has instanceof OctetHolder)
|
|
((OctetHolder) has).value = x;
|
|
else
|
|
has = new OctetHolder(x);
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public void insert_short(short x)
|
|
{
|
|
resetTypes();
|
|
if (has instanceof ShortHolder)
|
|
((ShortHolder) has).value = x;
|
|
else
|
|
has = new ShortHolder(x);
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public void insert_string(String x)
|
|
{
|
|
resetTypes();
|
|
if (has instanceof StringHolder)
|
|
((StringHolder) has).value = x;
|
|
else
|
|
has = new StringHolder(x);
|
|
|
|
typecode = new StringTypeCode(TCKind.tk_string);
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public void insert_ulong(int x)
|
|
{
|
|
resetTypes();
|
|
if (has instanceof IntHolder)
|
|
((IntHolder) has).value = x;
|
|
else
|
|
has = new IntHolder(x);
|
|
xKind = TCKind._tk_ulong;
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public void insert_ulonglong(long x)
|
|
{
|
|
resetTypes();
|
|
if (has instanceof LongHolder)
|
|
((LongHolder) has).value = x;
|
|
else
|
|
has = new LongHolder(x);
|
|
xKind = TCKind._tk_ulonglong;
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public void insert_ushort(short x)
|
|
{
|
|
resetTypes();
|
|
if (has instanceof ShortHolder)
|
|
((ShortHolder) has).value = x;
|
|
else
|
|
has = new ShortHolder(x);
|
|
xKind = TCKind._tk_ushort;
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public void insert_wchar(char x)
|
|
{
|
|
resetTypes();
|
|
if (has instanceof WCharHolder)
|
|
((WCharHolder) has).value = x;
|
|
else
|
|
has = new WCharHolder(x);
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public void insert_wstring(String x)
|
|
{
|
|
resetTypes();
|
|
if (has instanceof WStringHolder)
|
|
((WStringHolder) has).value = x;
|
|
else
|
|
has = new WStringHolder(x);
|
|
}
|
|
|
|
/**
|
|
* Return the associated orb.
|
|
*/
|
|
public ORB orb()
|
|
{
|
|
return orb;
|
|
}
|
|
|
|
/**
|
|
* Read the value of the given type from the given stream.
|
|
*
|
|
* @param input a stream to read from.
|
|
* @param a_type a typecode of the value to read.
|
|
*/
|
|
public void read_value(org.omg.CORBA.portable.InputStream input,
|
|
TypeCode a_type
|
|
)
|
|
throws MARSHAL
|
|
{
|
|
try
|
|
{
|
|
int kind = a_type.kind().value();
|
|
|
|
// Fixed needs special handling.
|
|
if (kind == TCKind._tk_fixed)
|
|
{
|
|
BigDecimal dec = BigDecimalHelper.read(input, a_type.fixed_scale());
|
|
has = new FixedHolder(dec);
|
|
}
|
|
else
|
|
{
|
|
has = HolderLocator.createHolder(a_type);
|
|
if (has == null)
|
|
{
|
|
// Use the Universal Holder that reads till the end of stream.
|
|
// This works with the extract/insert pair of the typical
|
|
// Helper.
|
|
BufferedCdrOutput buffer = new BufferedCdrOutput();
|
|
buffer.setOrb(orb);
|
|
has = new GeneralHolder(buffer);
|
|
}
|
|
}
|
|
type(a_type);
|
|
|
|
if (!(has instanceof GeneralHolder) &&
|
|
(kind == TCKind._tk_value_box))
|
|
{
|
|
// The streamable only contains operations for
|
|
// reading the value, not the value header.
|
|
Field vField = has.getClass().getField("value");
|
|
|
|
Object content = Vio.read(input, a_type.id());
|
|
vField.set(has, content);
|
|
}
|
|
else
|
|
has._read(input);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MARSHAL m = new MARSHAL();
|
|
m.minor = Minor.Any;
|
|
m.initCause(ex);
|
|
throw m;
|
|
}
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public TypeCode type()
|
|
{
|
|
if (typecode != null)
|
|
return typecode;
|
|
else if (xKind >= 0)
|
|
{
|
|
typecode = new PrimitiveTypeCode(TCKind.from_int(xKind));
|
|
return typecode;
|
|
}
|
|
else
|
|
return has != null ? has._type() : nullType;
|
|
}
|
|
|
|
/**
|
|
* Explicitly set the typecode of the value to the given type.
|
|
*
|
|
* @param valueTypeCode the typecode of the value.
|
|
*/
|
|
public void type(TypeCode valueTypeCode)
|
|
{
|
|
xKind = valueTypeCode.kind().value();
|
|
typecode = valueTypeCode;
|
|
}
|
|
|
|
/** {@inheritDoc} */
|
|
public void write_value(org.omg.CORBA.portable.OutputStream output)
|
|
{
|
|
if (has != null)
|
|
has._write(output);
|
|
else
|
|
// These kinds support null.
|
|
if (xKind == TCKind._tk_null || xKind == TCKind._tk_objref ||
|
|
xKind == TCKind._tk_value || xKind == TCKind._tk_value_box
|
|
)
|
|
output.write_long(0);
|
|
}
|
|
|
|
/**
|
|
* Check if the current value if the value of the given kind.
|
|
*
|
|
* @param kind a kind to check.
|
|
* @throws BAD_OPERATION if the value is not set of is different kind.
|
|
*/
|
|
protected void check(int kind)
|
|
throws BAD_OPERATION
|
|
{
|
|
if (has == null)
|
|
{
|
|
BAD_OPERATION bad = new BAD_OPERATION("value not set");
|
|
bad.minor = Minor.Any;
|
|
throw bad;
|
|
}
|
|
|
|
if (xKind >= 0)
|
|
{
|
|
if (xKind != kind)
|
|
if (!(xKind == TCKind._tk_alias && has._type().kind().value() == kind))
|
|
{
|
|
BAD_OPERATION bad = new BAD_OPERATION("Extracting "
|
|
+ TypeKindNamer.nameIt(kind) + " when stored "
|
|
+ TypeKindNamer.nameIt(xKind));
|
|
bad.minor = Minor.Any;
|
|
throw bad;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (type().kind().value() != kind)
|
|
if (!(type().kind().value() == TCKind._tk_alias && has._type().kind().value() == kind))
|
|
{
|
|
BAD_OPERATION bad = new BAD_OPERATION("Extracting "
|
|
+ TypeKindNamer.nameIt(kind) + " stored "
|
|
+ TypeKindNamer.nameIt(type()));
|
|
bad.minor = Minor.Any;
|
|
throw bad;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Clear the additional type information before reusing this instance.
|
|
*/
|
|
private final void resetTypes()
|
|
{
|
|
typecode = null;
|
|
xKind = -1;
|
|
}
|
|
} |