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