dynanyoperations.java

gcc的组建

           throws TypeMismatch, InvalidValue;

  /**
   * Insert the boolean value into the enclosed {@link Any} inside this DynAny
   *
   * @param a_x the value being inserted.
   * @throws InvalidValue if the value type does not match the typecode of the
   * enclosed {@link Any}.
   */
  void insert_boolean(boolean a_x)
               throws InvalidValue, TypeMismatch;

  /**
   * Insert the char value into the enclosed {@link Any} inside this DynAny
   *
   * @param a_x the value being inserted.
   * @throws InvalidValue if the value type does not match the typecode of the
   * enclosed {@link Any}.
   */
  void insert_char(char a_x)
            throws InvalidValue, TypeMismatch;

  /**
   * Insert the double value into the enclosed {@link Any} inside this DynAny
   *
   * @param a_x the value being inserted.
   * @throws InvalidValue if the value type does not match the typecode of the
   * enclosed {@link Any}.
   */
  void insert_double(double a_x)
              throws InvalidValue, TypeMismatch;

  /**
   * Insert the float value into the enclosed {@link Any} inside this DynAny
   *
   * @param a_x the value being inserted.
   * @throws InvalidValue if the value type does not match the typecode of the
   * enclosed {@link Any}.
   */
  void insert_float(float a_x)
             throws InvalidValue, TypeMismatch;

  /**
   * Insert the int (CORBA long) value into the enclosed {@link Any} inside this
   * DynAny
   *
   * @param a_x the value being inserted.
   * @throws InvalidValue if the value type does not match the typecode of the
   * enclosed {@link Any}.
   */
  void insert_long(int a_x)
            throws InvalidValue, TypeMismatch;

  /**
   * Insert the long (CORBA long long) value into the enclosed {@link Any}
   * inside this DynAny
   *
   * @param a_x the value being inserted.
   * @throws InvalidValue if the value type does not match the typecode of the
   * enclosed {@link Any}.
   */
  void insert_longlong(long a_x)
                throws InvalidValue, TypeMismatch;

  /**
   * Insert the byte (CORBA octet) value into the enclosed {@link Any} inside
   * this DynAny
   *
   * @param a_x the value being inserted.
   * @throws InvalidValue if the value type does not match the typecode of the
   * enclosed {@link Any}.
   */
  void insert_octet(byte a_x)
             throws InvalidValue, TypeMismatch;

  /**
   * Insert the object reference into the enclosed {@link Any} inside this
   * DynAny
   *
   * @param a_x the value being inserted.
   * @throws InvalidValue if the value type does not match the typecode of the
   * enclosed {@link Any}.
   */
  void insert_reference(org.omg.CORBA.Object a_x)
                 throws InvalidValue, TypeMismatch;

  /**
   * Insert the <code>short</code> value into the enclosed {@link Any} inside
   * this DynAny
   *
   * @param a_x the value being inserted.
   * @throws InvalidValue if the value type does not match the typecode of the
   * enclosed {@link Any}.
   */
  void insert_short(short a_x)
             throws InvalidValue, TypeMismatch;

  /**
   * Insert the string value into the enclosed {@link Any} inside this DynAny
   *
   * @param a_x the value being inserted.
   * @throws InvalidValue if the value type does not match the typecode of the
   * enclosed {@link Any}.
   */
  void insert_string(String a_x)
              throws InvalidValue, TypeMismatch;

  /**
   * Insert the {@link TypeCode} value into the enclosed {@link Any} inside this
   * DynAny
   *
   * @param a_x the value being inserted.
   * @throws InvalidValue if the value type does not match the typecode of the
   * enclosed {@link Any}.
   */
  void insert_typecode(TypeCode a_x)
                throws InvalidValue, TypeMismatch;

  /**
   * Insert the int (CORBA unsinged long) value into the enclosed {@link Any}
   * inside this DynAny
   *
   * @param a_x the value being inserted.
   * @throws InvalidValue if the value type does not match the typecode of the
   * enclosed {@link Any}.
   */
  void insert_ulong(int a_x)
             throws InvalidValue, TypeMismatch;

  /**
   * Insert the long (CORBA unsigned long long) value into the enclosed
   * {@link Any} inside this DynAny
   *
   * @param a_x the value being inserted.
   * @throws InvalidValue if the value type does not match the typecode of the
   * enclosed {@link Any}.
   */
  void insert_ulonglong(long a_x)
                 throws InvalidValue, TypeMismatch;

  /**
   * Insert the short (CORBA unsigned short) value into the enclosed {@link Any}
   * inside this DynAny
   *
   * @param a_x the value being inserted.
   * @throws InvalidValue if the value type does not match the typecode of the
   * enclosed {@link Any}.
   */
  void insert_ushort(short a_x)
              throws InvalidValue, TypeMismatch;

  /**
   * Insert the value into the enclosed {@link Any} inside this DynAny
   *
   * @param a_x the value being inserted.
   * @throws InvalidValue if the value type does not match the typecode of the
   * enclosed {@link Any}.
   */
  void insert_val(Serializable a_x)
           throws InvalidValue, TypeMismatch;

  /**
   * Insert the wide char (usually UTF-16) value into the enclosed {@link Any}
   * inside this DynAny
   *
   * @param a_x the value being inserted.
   * @throws InvalidValue if the value type does not match the typecode of the
   * enclosed {@link Any}.
   */
  void insert_wchar(char a_x)
             throws InvalidValue, TypeMismatch;

  /**
   * Insert the wide string (usually UTF-16) into the enclosed {@link Any}
   * inside this DynAny
   *
   * @param a_x the value being inserted.
   * @throws InvalidValue if the value type does not match the typecode of the
   * enclosed {@link Any}.
   */
  void insert_wstring(String a_x)
               throws InvalidValue, TypeMismatch;

  /**
   * Advances the internal pointer, described in the {@link current_component},
   * one position forward.
   *
   * @return true if the pointer now points to the new component, false if there
   * are no more components of this DynAny holds a basic type that is not
   * divided into components.
   */
  boolean next();

  /**
   * Moves the internal pointer, described in the {@link current_component}, to
   * the first component.
   */
  void rewind();

  /**
   * Moves the internal pointer, described in the {@link current_component}, to
   * the given position.
   *
   * @param p the number of the internal component on that the internal pointer
   * must be focused.
   * @return true on success or false if there is no component with the given
   * number. If the DynAny holds the basic type, this method returs false p
   * values other than 0.
   */
  boolean seek(int p);

  /**
   * Returns a shallow copy of the enclosed {@link Any},
   *
   * @return shallow copy of the enclosed {@link Any}.
   */
  Any to_any();

  /**
   * Returns the typecode of the object, inserted into this DynAny.
   *
   * @return the typecode of the inserted {@link Any} or null typecode if no
   * {@link Any has been yet inserted}.
   */
  TypeCode type();

  /**
   * Insert a value at the current position.
   *
   * @param insert_it a value to insert.
   * @throws TypeMismatch if the component at the current position has a
   * different type.
   * @throws InvalidValue if the current position points nowhere.
   */
  void insert_dyn_any(DynAny insert_it)
               throws TypeMismatch, InvalidValue;

  /**
   * Checks for equality with another Dynamic Any.
   *
   *
   * @specnote This method is currently only implemented only for case when
   * another DynAny was created by the factory of this implementation and is not
   * an independent class, just implementing interface. Otherwise, a
   * NO_IMPLEMENT minor 8148 will be thrown. General implementation is highly
   * ineffective, but we will do if somebody would ever need it.
   */
  boolean equal(DynAny other);

  /**
   * Get the number number of fields in the enclosed structure or number of
   * memebers in the enclosed array, sequence, enumeration, etc. This method
   * only counts elements at the top level. For instance, if invoked on a
   * DynStruct with a single member, it returns 1, irrespective of the type of
   * the member.
   *
   * @return number of components or 0 if the enclosed Any is not divideable.
   */
  int component_count();

  /**
   * Return DynAny, wrapping the second (enclosed any) that is stored in the
   * wrapped Any.
   *
   * @throws TypeMismatch if the wrapped Any does not store another Any.
   * @throws InvalidValue if the current position points nowhere.
   */
  DynAny get_dyn_any()
              throws TypeMismatch, InvalidValue;
}