| /* 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; | |
| } | |
| } |