/**
   * Sets the current position to index. The current position is indexed 0 to n-1, that is, index
   * zero corresponds to the first component. The operation returns true if the resulting current
   * position indicates a component of the DynAny and false if index indicates a position that does
   * not correspond to a component. Calling seek with a negative index is legal. It sets the current
   * position to -1 to indicate no component and returns false. Passing a non-negative index value
   * for a DynAny that does not have a component at the corresponding position sets the current
   * position to -1 and returns false.
   */
  public boolean seek(int index) {
    org.omg.CORBA.portable.ServantObject $so = _servant_preinvoke("seek", _opsClass);
    DynFixedOperations $self = (DynFixedOperations) $so.servant;

    try {
      return $self.seek(index);
    } finally {
      _servant_postinvoke($so);
    }
  } // seek
  /** Is equivalent to seek(0). */
  public void rewind() {
    org.omg.CORBA.portable.ServantObject $so = _servant_preinvoke("rewind", _opsClass);
    DynFixedOperations $self = (DynFixedOperations) $so.servant;

    try {
      $self.rewind();
    } finally {
      _servant_postinvoke($so);
    }
  } // rewind
  /**
   * Creates a new DynAny object whose value is a deep copy of the DynAny on which it is invoked.
   * The operation is polymorphic, that is, invoking it on one of the types derived from DynAny,
   * such as DynStruct, creates the derived type but returns its reference as the DynAny base type.
   *
   * @return a deep copy of the DynAny object
   */
  public org.omg.DynamicAny.DynAny copy() {
    org.omg.CORBA.portable.ServantObject $so = _servant_preinvoke("copy", _opsClass);
    DynFixedOperations $self = (DynFixedOperations) $so.servant;

    try {
      return $self.copy();
    } finally {
      _servant_postinvoke($so);
    }
  } // copy
  /**
   * Returns the TypeCode associated with this DynAny object. A DynAny object is created with a
   * TypeCode value assigned to it. This TypeCode value determines the type of the value handled
   * through the DynAny object. Note that the TypeCode associated with a DynAny object is
   * initialized at the time the DynAny is created and cannot be changed during lifetime of the
   * DynAny object.
   *
   * @return The TypeCode associated with this DynAny object
   */
  public org.omg.CORBA.TypeCode type() {
    org.omg.CORBA.portable.ServantObject $so = _servant_preinvoke("type", _opsClass);
    DynFixedOperations $self = (DynFixedOperations) $so.servant;

    try {
      return $self.type();
    } finally {
      _servant_postinvoke($so);
    }
  } // type
  /** Returns the value of a DynFixed. */
  public String get_value() {
    org.omg.CORBA.portable.ServantObject $so = _servant_preinvoke("get_value", _opsClass);
    DynFixedOperations $self = (DynFixedOperations) $so.servant;

    try {
      return $self.get_value();
    } finally {
      _servant_postinvoke($so);
    }
  } // get_value
  /**
   * Compares two DynAny values for equality. Two DynAny values are equal if their TypeCodes are
   * equivalent and, recursively, all component DynAnys have equal values. The current position of
   * the two DynAnys being compared has no effect on the result of equal.
   *
   * @return true of the DynAnys are equal, false otherwise
   */
  public boolean equal(org.omg.DynamicAny.DynAny dyn_any) {
    org.omg.CORBA.portable.ServantObject $so = _servant_preinvoke("equal", _opsClass);
    DynFixedOperations $self = (DynFixedOperations) $so.servant;

    try {
      return $self.equal(dyn_any);
    } finally {
      _servant_postinvoke($so);
    }
  } // equal
  /**
   * Returns the number of components of a DynAny. For a DynAny without components, it returns zero.
   * The operation only counts the components at the top level. For example, if component_count is
   * invoked on a DynStruct with a single member, the return value is 1, irrespective of the type of
   * the member.
   *
   * <UL>
   *   <LI>For sequences, the operation returns the current number of elements.
   *   <LI>For structures, exceptions, and value types, the operation returns the number of members.
   *   <LI>For arrays, the operation returns the number of elements.
   *   <LI>For unions, the operation returns 2 if the discriminator indicates that a named member is
   *       active, otherwise, it returns 1.
   *   <LI>For DynFixed and DynEnum, the operation returns zero.
   * </UL>
   */
  public int component_count() {
    org.omg.CORBA.portable.ServantObject $so = _servant_preinvoke("component_count", _opsClass);
    DynFixedOperations $self = (DynFixedOperations) $so.servant;

    try {
      return $self.component_count();
    } finally {
      _servant_postinvoke($so);
    }
  } // component_count
  /**
   * Advances the current position to the next component. The operation returns true while the
   * resulting current position indicates a component, false otherwise. A false return value leaves
   * the current position at -1. Invoking next on a DynAny without components leaves the current
   * position at -1 and returns false.
   */
  public boolean next() {
    org.omg.CORBA.portable.ServantObject $so = _servant_preinvoke("next", _opsClass);
    DynFixedOperations $self = (DynFixedOperations) $so.servant;

    try {
      return $self.next();
    } finally {
      _servant_postinvoke($so);
    }
  } // next
  /**
   * Initializes the value associated with a DynAny object with the value associated with another
   * DynAny object. The current position of the target DynAny is set to zero for values that have
   * components and to -1 for values that do not have components.
   *
   * @param dyn_any
   * @exception TypeMismatch if the type of the passed DynAny is not equivalent to the type of
   *     target DynAny
   */
  public void assign(org.omg.DynamicAny.DynAny dyn_any)
      throws org.omg.DynamicAny.DynAnyPackage.TypeMismatch {
    org.omg.CORBA.portable.ServantObject $so = _servant_preinvoke("assign", _opsClass);
    DynFixedOperations $self = (DynFixedOperations) $so.servant;

    try {
      $self.assign(dyn_any);
    } finally {
      _servant_postinvoke($so);
    }
  } // assign
  /**
   * Returns the DynAny for the component at the current position. It does not advance the current
   * position, so repeated calls to current_component without an intervening call to rewind, next,
   * or seek return the same component. The returned DynAny object reference can be used to get/set
   * the value of the current component. If the current component represents a complex type, the
   * returned reference can be narrowed based on the TypeCode to get the interface corresponding to
   * the to the complex type. Calling current_component on a DynAny that cannot have components,
   * such as a DynEnum or an empty exception, raises TypeMismatch. Calling current_component on a
   * DynAny whose current position is -1 returns a nil reference. The iteration operations, together
   * with current_component, can be used to dynamically compose an any value. After creating a
   * dynamic any, such as a DynStruct, current_component and next can be used to initialize all the
   * components of the value. Once the dynamic value is completely initialized, to_any creates the
   * corresponding any value.
   *
   * @exception TypeMismatch If called on a DynAny that cannot have components, such as a DynEnum or
   *     an empty exception
   */
  public org.omg.DynamicAny.DynAny current_component()
      throws org.omg.DynamicAny.DynAnyPackage.TypeMismatch {
    org.omg.CORBA.portable.ServantObject $so = _servant_preinvoke("current_component", _opsClass);
    DynFixedOperations $self = (DynFixedOperations) $so.servant;

    try {
      return $self.current_component();
    } finally {
      _servant_postinvoke($so);
    }
  } // current_component
  /**
   * Extracts a Serializable object from this DynAny. The IDL ValueBase type is mapped to the Java
   * Serializable type.
   *
   * @exception TypeMismatch if the accessed component in the DynAny is of a type that is not
   *     equivalent to the requested type.
   * @exception TypeMismatch if called on a DynAny whose current component itself has components
   * @exception InvalidValue if this DynAny has components but has a current position of -1
   */
  public java.io.Serializable get_val()
      throws org.omg.DynamicAny.DynAnyPackage.TypeMismatch,
          org.omg.DynamicAny.DynAnyPackage.InvalidValue {
    org.omg.CORBA.portable.ServantObject $so = _servant_preinvoke("get_val", _opsClass);
    DynFixedOperations $self = (DynFixedOperations) $so.servant;

    try {
      return $self.get_val();
    } finally {
      _servant_postinvoke($so);
    }
  } // get_val
  /**
   * Inserts the Any value contained in the parameter DynAny into the Any represented by this
   * DynAny.
   *
   * @exception InvalidValue if this DynAny has components but has a current position of -1
   * @exception TypeMismatch if called on a DynAny whose current component itself has components
   */
  public void insert_dyn_any(org.omg.DynamicAny.DynAny value)
      throws org.omg.DynamicAny.DynAnyPackage.TypeMismatch,
          org.omg.DynamicAny.DynAnyPackage.InvalidValue {
    org.omg.CORBA.portable.ServantObject $so = _servant_preinvoke("insert_dyn_any", _opsClass);
    DynFixedOperations $self = (DynFixedOperations) $so.servant;

    try {
      $self.insert_dyn_any(value);
    } finally {
      _servant_postinvoke($so);
    }
  } // insert_dyn_any
  /**
   * Sets the value of the DynFixed. The val string must contain a fixed string constant in the same
   * format as used for IDL fixed-point literals. However, the trailing d or D is optional. The
   * return value is true if val can be represented as the DynFixed without loss of precision. If
   * val has more fractional digits than can be represented in the DynFixed, fractional digits are
   * truncated and the return value is false.
   *
   * @exception TypeMismatch If val does not contain a valid fixed-point literal or contains
   *     extraneous characters other than leading or trailing white space
   * @exception InvalidValue If val contains a value whose scale exceeds that of the DynFixed or is
   *     not initialized
   */
  public boolean set_value(String val)
      throws org.omg.DynamicAny.DynAnyPackage.TypeMismatch,
          org.omg.DynamicAny.DynAnyPackage.InvalidValue {
    org.omg.CORBA.portable.ServantObject $so = _servant_preinvoke("set_value", _opsClass);
    DynFixedOperations $self = (DynFixedOperations) $so.servant;

    try {
      return $self.set_value(val);
    } finally {
      _servant_postinvoke($so);
    }
  } // set_value