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