/** * Returns a sequence of NameValuePairs describing the name and the value of each member in the * struct associated with a DynStruct object. The sequence contains members in the same order as * the declaration order of members as indicated by the DynStruct's TypeCode. The current position * is not affected. The member names in the returned sequence will be empty strings if the * DynStruct's TypeCode does not contain member names. */ public org.omg.DynamicAny.NameValuePair[] get_members() { org.omg.CORBA.portable.ServantObject $so = _servant_preinvoke("get_members", _opsClass); DynStructOperations $self = (DynStructOperations) $so.servant; try { return $self.get_members(); } finally { _servant_postinvoke($so); } } // get_members
/** * 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); DynStructOperations $self = (DynStructOperations) $so.servant; try { return $self.copy(); } finally { _servant_postinvoke($so); } } // copy
/** * 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); DynStructOperations $self = (DynStructOperations) $so.servant; try { return $self.equal(dyn_any); } finally { _servant_postinvoke($so); } } // equal
/** * Destroys a DynAny object. This operation frees any resources used to represent the data value * associated with a DynAny object. It must be invoked on references obtained from one of the * creation operations on the ORB interface or on a reference returned by DynAny.copy() to avoid * resource leaks. Invoking destroy on component DynAny objects (for example, on objects returned * by the current_component operation) does nothing. Destruction of a DynAny object implies * destruction of all DynAny objects obtained from it. That is, references to components of a * destroyed DynAny become invalid. Invocations on such references raise OBJECT_NOT_EXIST. It is * possible to manipulate a component of a DynAny beyond the life time of the DynAny from which * the component was obtained by making a copy of the component with the copy operation before * destroying the DynAny from which the component was obtained. */ public void destroy() { org.omg.CORBA.portable.ServantObject $so = _servant_preinvoke("destroy", _opsClass); DynStructOperations $self = (DynStructOperations) $so.servant; try { $self.destroy(); } finally { _servant_postinvoke($so); } } // destroy
/** * 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); DynStructOperations $self = (DynStructOperations) $so.servant; try { return $self.component_count(); } finally { _servant_postinvoke($so); } } // component_count
/** * Creates an any value from a DynAny object. A copy of the TypeCode associated with the DynAny * object is assigned to the resulting any. The value associated with the DynAny object is copied * into the any. * * @return a new Any object with the same value and TypeCode */ public org.omg.CORBA.Any to_any() { org.omg.CORBA.portable.ServantObject $so = _servant_preinvoke("to_any", _opsClass); DynStructOperations $self = (DynStructOperations) $so.servant; try { return $self.to_any(); } finally { _servant_postinvoke($so); } } // to_any
/** * 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); DynStructOperations $self = (DynStructOperations) $so.servant; try { return $self.next(); } finally { _servant_postinvoke($so); } } // next
/** * 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); DynStructOperations $self = (DynStructOperations) $so.servant; try { return $self.seek(index); } finally { _servant_postinvoke($so); } } // seek
/** * 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); DynStructOperations $self = (DynStructOperations) $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); DynStructOperations $self = (DynStructOperations) $so.servant; try { return $self.current_component(); } finally { _servant_postinvoke($so); } } // current_component
/** * Extracts the string value from this DynAny. Both bounded and unbounded strings are extracted * using this method. * * @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 */ public String get_wstring() throws org.omg.DynamicAny.DynAnyPackage.TypeMismatch, org.omg.DynamicAny.DynAnyPackage.InvalidValue { org.omg.CORBA.portable.ServantObject $so = _servant_preinvoke("get_wstring", _opsClass); DynStructOperations $self = (DynStructOperations) $so.servant; try { return $self.get_wstring(); } finally { _servant_postinvoke($so); } } // get_wstring
/** * Initializes the struct data value associated with a DynStruct object from a sequence of * NameValuePairs. The operation sets the current position to zero if the passed sequences has * non-zero length. Otherwise, if an empty sequence is passed, the current position is set to -1. * * <p>Members must appear in the NameValuePairs in the order in which they appear in the IDL * specification of the struct as indicated by the DynStruct's TypeCode or they must be empty * strings. The operation makes no attempt to assign member values based on member names. * * @exception TypeMismatch if the member names supplied in the passed sequence do not match the * corresponding member name in the DynStruct's TypeCode and they are not empty strings * @exception InvalidValue if the passed sequence has a number of elements that disagrees with the * number of members as indicated by the DynStruct's TypeCode */ public void set_members(org.omg.DynamicAny.NameValuePair[] value) throws org.omg.DynamicAny.DynAnyPackage.TypeMismatch, org.omg.DynamicAny.DynAnyPackage.InvalidValue { org.omg.CORBA.portable.ServantObject $so = _servant_preinvoke("set_members", _opsClass); DynStructOperations $self = (DynStructOperations) $so.servant; try { $self.set_members(value); } finally { _servant_postinvoke($so); } } // set_members
/** * Inserts a reference to a Serializable object into this DynAny. The IDL ValueBase type is mapped * to the Java Serializable type. * * @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_val(java.io.Serializable value) throws org.omg.DynamicAny.DynAnyPackage.TypeMismatch, org.omg.DynamicAny.DynAnyPackage.InvalidValue { org.omg.CORBA.portable.ServantObject $so = _servant_preinvoke("insert_val", _opsClass); DynStructOperations $self = (DynStructOperations) $so.servant; try { $self.insert_val(value); } finally { _servant_postinvoke($so); } } // insert_val
/** * Returns the TCKind associated with the member at the current position. * * @exception TypeMismatch if the DynStruct represents an empty exception. * @exception InvalidValue if the current position does not indicate a member */ public org.omg.CORBA.TCKind current_member_kind() throws org.omg.DynamicAny.DynAnyPackage.TypeMismatch, org.omg.DynamicAny.DynAnyPackage.InvalidValue { org.omg.CORBA.portable.ServantObject $so = _servant_preinvoke("current_member_kind", _opsClass); DynStructOperations $self = (DynStructOperations) $so.servant; try { return $self.current_member_kind(); } finally { _servant_postinvoke($so); } } // current_member_kind
/** * Initializes the value associated with a DynAny object with the value contained in an any. 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. * * @exception TypeMismatch if the type of the passed Any is not equivalent to the type of target * DynAny * @exception InvalidValue if the passed Any does not contain a legal value (such as a null * string) */ public void from_any(org.omg.CORBA.Any value) throws org.omg.DynamicAny.DynAnyPackage.TypeMismatch, org.omg.DynamicAny.DynAnyPackage.InvalidValue { org.omg.CORBA.portable.ServantObject $so = _servant_preinvoke("from_any", _opsClass); DynStructOperations $self = (DynStructOperations) $so.servant; try { $self.from_any(value); } finally { _servant_postinvoke($so); } } // from_any