corba/src/java.corba/share/classes/org/omg/CORBA/DynAny.java
changeset 32688 936c391804a5
parent 31188 123a0b07b632
equal deleted inserted replaced
32550:6521875cb63e 32688:936c391804a5
    25 
    25 
    26 
    26 
    27 package org.omg.CORBA;
    27 package org.omg.CORBA;
    28 
    28 
    29 
    29 
    30 /** Enables <tt>org.omg.CORBA.Any</tt> values to be dynamically
    30 /**
       
    31  * Enables {@code org.omg.CORBA.Any} values to be dynamically
    31  * interpreted (traversed) and
    32  * interpreted (traversed) and
    32  *  constructed. A <tt>DynAny</tt> object is associated with a data value
    33  * constructed. A {@code DynAny} object is associated with a data value
    33  *  which may correspond to a copy of the value inserted into an <tt>Any</tt>.
    34  * which may correspond to a copy of the value inserted into an {@code Any}.
    34  *  The <tt>DynAny</tt> APIs enable traversal of the data value associated with an
    35  * The {@code DynAny} APIs enable traversal of the data value associated with an
    35  *  Any at runtime and extraction of the primitive constituents of the
    36  * Any at runtime and extraction of the primitive constituents of the
    36  *  data value.
    37  * data value.
    37  * @deprecated Use the new <a href="../DynamicAny/DynAny.html">DynAny</a> instead
    38  * @deprecated Use the new <a href="../DynamicAny/DynAny.html">DynAny</a> instead
    38  */
    39  */
    39 @Deprecated
    40 @Deprecated
    40 public interface DynAny extends org.omg.CORBA.Object
    41 public interface DynAny extends org.omg.CORBA.Object
    41 {
    42 {
    42     /**
    43     /**
    43      * Returns the <code>TypeCode</code> of the object inserted into
    44      * Returns the {@code TypeCode} of the object inserted into
    44      * this <code>DynAny</code>.
    45      * this {@code DynAny}.
    45      *
    46      *
    46      * @return the <code>TypeCode</code> object.
    47      * @return the {@code TypeCode} object.
    47      */
    48      */
    48     public org.omg.CORBA.TypeCode type() ;
    49     public org.omg.CORBA.TypeCode type() ;
    49 
    50 
    50     /**
    51     /**
    51      * Copy the contents from one Dynamic Any into another.
    52      * Copy the contents from one Dynamic Any into another.
    52      *
    53      *
    53      * @param dyn_any the <code>DynAny</code> object whose contents
    54      * @param dyn_any the {@code DynAny} object whose contents
    54      *                are assigned to this <code>DynAny</code>.
    55      *                are assigned to this {@code DynAny}.
    55      * @throws org.omg.CORBA.DynAnyPackage.Invalid if the source
    56      * @throws org.omg.CORBA.DynAnyPackage.Invalid if the source
    56      * <code>DynAny</code> is invalid
    57      * {@code DynAny} is invalid
    57      */
    58      */
    58     public void assign(org.omg.CORBA.DynAny dyn_any)
    59     public void assign(org.omg.CORBA.DynAny dyn_any)
    59         throws org.omg.CORBA.DynAnyPackage.Invalid;
    60         throws org.omg.CORBA.DynAnyPackage.Invalid;
    60 
    61 
    61     /**
    62     /**
    62      * Make a <code>DynAny</code> object from an <code>Any</code>
    63      * Make a {@code DynAny} object from an {@code Any}
    63      * object.
    64      * object.
    64      *
    65      *
    65      * @param value the <code>Any</code> object.
    66      * @param value the {@code Any} object.
    66      * @throws org.omg.CORBA.DynAnyPackage.Invalid if the source
    67      * @throws org.omg.CORBA.DynAnyPackage.Invalid if the source
    67      * <code>Any</code> object is empty or bad
    68      * {@code Any} object is empty or bad
    68      */
    69      */
    69     public void from_any(org.omg.CORBA.Any value)
    70     public void from_any(org.omg.CORBA.Any value)
    70         throws org.omg.CORBA.DynAnyPackage.Invalid;
    71         throws org.omg.CORBA.DynAnyPackage.Invalid;
    71 
    72 
    72     /**
    73     /**
    73      * Convert a <code>DynAny</code> object to an <code>Any</code>
    74      * Convert a {@code DynAny} object to an {@code Any}
    74      * object.
    75      * object.
    75      *
    76      *
    76      * @return the <code>Any</code> object.
    77      * @return the {@code Any} object.
    77      * @throws org.omg.CORBA.DynAnyPackage.Invalid if this
    78      * @throws org.omg.CORBA.DynAnyPackage.Invalid if this
    78      * <code>DynAny</code> is empty or bad.
    79      * {@code DynAny} is empty or bad.
    79      *            created or does not contain a meaningful value
    80      *            created or does not contain a meaningful value
    80      */
    81      */
    81     public org.omg.CORBA.Any to_any()
    82     public org.omg.CORBA.Any to_any()
    82         throws org.omg.CORBA.DynAnyPackage.Invalid;
    83         throws org.omg.CORBA.DynAnyPackage.Invalid;
    83 
    84 
    84     /**
    85     /**
    85      * Destroys this <code>DynAny</code> object and frees any resources
    86      * Destroys this {@code DynAny} object and frees any resources
    86      * used to represent the data value associated with it. This method
    87      * used to represent the data value associated with it. This method
    87      * also destroys all <code>DynAny</code> objects obtained from it.
    88      * also destroys all {@code DynAny} objects obtained from it.
    88      * <p>
    89      * <p>
    89      * Destruction of <code>DynAny</code> objects should be handled with
    90      * Destruction of {@code DynAny} objects should be handled with
    90      * care, taking into account issues dealing with the representation of
    91      * care, taking into account issues dealing with the representation of
    91      * data values associated with <code>DynAny</code> objects.  A programmer
    92      * data values associated with {@code DynAny} objects.  A programmer
    92      * who wants to destroy a <code>DynAny</code> object but still be able
    93      * who wants to destroy a {@code DynAny} object but still be able
    93      * to manipulate some component of the data value associated with it,
    94      * to manipulate some component of the data value associated with it,
    94      * should first create a <code>DynAny</code> object for the component
    95      * should first create a {@code DynAny} object for the component
    95      * and then make a copy of the created <code>DynAny</code> object.
    96      * and then make a copy of the created {@code DynAny} object.
    96      */
    97      */
    97     public void destroy() ;
    98     public void destroy() ;
    98 
    99 
    99     /**
   100     /**
   100      * Clones this <code>DynAny</code> object.
   101      * Clones this {@code DynAny} object.
   101      *
   102      *
   102      * @return a copy of this <code>DynAny</code> object
   103      * @return a copy of this {@code DynAny} object
   103      */
   104      */
   104     public org.omg.CORBA.DynAny copy() ;
   105     public org.omg.CORBA.DynAny copy() ;
   105 
   106 
   106     /**
   107     /**
   107      * Inserts the given <code>boolean</code> as the value for this
   108      * Inserts the given {@code boolean} as the value for this
   108      * <code>DynAny</code> object.
   109      * {@code DynAny} object.
   109      *
   110      *
   110      * <p> If this method is called on a constructed <code>DynAny</code>
   111      * <p> If this method is called on a constructed {@code DynAny}
   111      * object, it initializes the next component of the constructed data
   112      * object, it initializes the next component of the constructed data
   112      * value associated with this <code>DynAny</code> object.
   113      * value associated with this {@code DynAny} object.
   113      *
   114      *
   114      * @param value the <code>boolean</code> to insert into this
   115      * @param value the {@code boolean} to insert into this
   115      *              <code>DynAny</code> object
   116      *              {@code DynAny} object
   116      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   117      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   117      *            if the value inserted is not consistent with the type
   118      *            if the value inserted is not consistent with the type
   118      *            of the accessed component in this <code>DynAny</code> object
   119      *            of the accessed component in this {@code DynAny} object
   119      */
   120      */
   120     public void insert_boolean(boolean value)
   121     public void insert_boolean(boolean value)
   121         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   122         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   122 
   123 
   123     /**
   124     /**
   124      * Inserts the given <code>byte</code> as the value for this
   125      * Inserts the given {@code byte} as the value for this
   125      * <code>DynAny</code> object.
   126      * {@code DynAny} object.
   126      *
   127      *
   127      * <p> If this method is called on a constructed <code>DynAny</code>
   128      * <p> If this method is called on a constructed {@code DynAny}
   128      * object, it initializes the next component of the constructed data
   129      * object, it initializes the next component of the constructed data
   129      * value associated with this <code>DynAny</code> object.
   130      * value associated with this {@code DynAny} object.
   130      *
   131      *
   131      * @param value the <code>byte</code> to insert into this
   132      * @param value the {@code byte} to insert into this
   132      *              <code>DynAny</code> object
   133      *              {@code DynAny} object
   133      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   134      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   134      *            if the value inserted is not consistent with the type
   135      *            if the value inserted is not consistent with the type
   135      *            of the accessed component in this <code>DynAny</code> object
   136      *            of the accessed component in this {@code DynAny} object
   136      */
   137      */
   137     public void insert_octet(byte value)
   138     public void insert_octet(byte value)
   138         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   139         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   139 
   140 
   140     /**
   141     /**
   141      * Inserts the given <code>char</code> as the value for this
   142      * Inserts the given {@code char} as the value for this
   142      * <code>DynAny</code> object.
   143      * {@code DynAny} object.
   143      *
   144      *
   144      * <p> If this method is called on a constructed <code>DynAny</code>
   145      * <p> If this method is called on a constructed {@code DynAny}
   145      * object, it initializes the next component of the constructed data
   146      * object, it initializes the next component of the constructed data
   146      * value associated with this <code>DynAny</code> object.
   147      * value associated with this {@code DynAny} object.
   147      *
   148      *
   148      * @param value the <code>char</code> to insert into this
   149      * @param value the {@code char} to insert into this
   149      *              <code>DynAny</code> object
   150      *              {@code DynAny} object
   150      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   151      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   151      *            if the value inserted is not consistent with the type
   152      *            if the value inserted is not consistent with the type
   152      *            of the accessed component in this <code>DynAny</code> object
   153      *            of the accessed component in this {@code DynAny} object
   153      */
   154      */
   154     public void insert_char(char value)
   155     public void insert_char(char value)
   155         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   156         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   156 
   157 
   157     /**
   158     /**
   158      * Inserts the given <code>short</code> as the value for this
   159      * Inserts the given {@code short} as the value for this
   159      * <code>DynAny</code> object.
   160      * {@code DynAny} object.
   160      *
   161      *
   161      * <p> If this method is called on a constructed <code>DynAny</code>
   162      * <p> If this method is called on a constructed {@code DynAny}
   162      * object, it initializes the next component of the constructed data
   163      * object, it initializes the next component of the constructed data
   163      * value associated with this <code>DynAny</code> object.
   164      * value associated with this {@code DynAny} object.
   164      *
   165      *
   165      * @param value the <code>short</code> to insert into this
   166      * @param value the {@code short} to insert into this
   166      *              <code>DynAny</code> object
   167      *              {@code DynAny} object
   167      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   168      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   168      *            if the value inserted is not consistent with the type
   169      *            if the value inserted is not consistent with the type
   169      *            of the accessed component in this <code>DynAny</code> object
   170      *            of the accessed component in this {@code DynAny} object
   170      */
   171      */
   171     public void insert_short(short value)
   172     public void insert_short(short value)
   172         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   173         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   173 
   174 
   174     /**
   175     /**
   175      * Inserts the given <code>short</code> as the value for this
   176      * Inserts the given {@code short} as the value for this
   176      * <code>DynAny</code> object.
   177      * {@code DynAny} object.
   177      *
   178      *
   178      * <p> If this method is called on a constructed <code>DynAny</code>
   179      * <p> If this method is called on a constructed {@code DynAny}
   179      * object, it initializes the next component of the constructed data
   180      * object, it initializes the next component of the constructed data
   180      * value associated with this <code>DynAny</code> object.
   181      * value associated with this {@code DynAny} object.
   181      *
   182      *
   182      * @param value the <code>short</code> to insert into this
   183      * @param value the {@code short} to insert into this
   183      *              <code>DynAny</code> object
   184      *              {@code DynAny} object
   184      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   185      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   185      *            if the value inserted is not consistent with the type
   186      *            if the value inserted is not consistent with the type
   186      *            of the accessed component in this <code>DynAny</code> object
   187      *            of the accessed component in this {@code DynAny} object
   187      */
   188      */
   188     public void insert_ushort(short value)
   189     public void insert_ushort(short value)
   189         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   190         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   190 
   191 
   191     /**
   192     /**
   192      * Inserts the given <code>int</code> as the value for this
   193      * Inserts the given {@code int} as the value for this
   193      * <code>DynAny</code> object.
   194      * {@code DynAny} object.
   194      *
   195      *
   195      * <p> If this method is called on a constructed <code>DynAny</code>
   196      * <p> If this method is called on a constructed {@code DynAny}
   196      * object, it initializes the next component of the constructed data
   197      * object, it initializes the next component of the constructed data
   197      * value associated with this <code>DynAny</code> object.
   198      * value associated with this {@code DynAny} object.
   198      *
   199      *
   199      * @param value the <code>int</code> to insert into this
   200      * @param value the {@code int} to insert into this
   200      *              <code>DynAny</code> object
   201      *              {@code DynAny} object
   201      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   202      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   202      *            if the value inserted is not consistent with the type
   203      *            if the value inserted is not consistent with the type
   203      *            of the accessed component in this <code>DynAny</code> object
   204      *            of the accessed component in this {@code DynAny} object
   204      */
   205      */
   205     public void insert_long(int value)
   206     public void insert_long(int value)
   206         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   207         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   207 
   208 
   208     /**
   209     /**
   209      * Inserts the given <code>int</code> as the value for this
   210      * Inserts the given {@code int} as the value for this
   210      * <code>DynAny</code> object.
   211      * {@code DynAny} object.
   211      *
   212      *
   212      * <p> If this method is called on a constructed <code>DynAny</code>
   213      * <p> If this method is called on a constructed {@code DynAny}
   213      * object, it initializes the next component of the constructed data
   214      * object, it initializes the next component of the constructed data
   214      * value associated with this <code>DynAny</code> object.
   215      * value associated with this {@code DynAny} object.
   215      *
   216      *
   216      * @param value the <code>int</code> to insert into this
   217      * @param value the {@code int} to insert into this
   217      *              <code>DynAny</code> object
   218      *              {@code DynAny} object
   218      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   219      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   219      *            if the value inserted is not consistent with the type
   220      *            if the value inserted is not consistent with the type
   220      *            of the accessed component in this <code>DynAny</code> object
   221      *            of the accessed component in this {@code DynAny} object
   221      */
   222      */
   222     public void insert_ulong(int value)
   223     public void insert_ulong(int value)
   223         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   224         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   224 
   225 
   225     /**
   226     /**
   226      * Inserts the given <code>float</code> as the value for this
   227      * Inserts the given {@code float} as the value for this
   227      * <code>DynAny</code> object.
   228      * {@code DynAny} object.
   228      *
   229      *
   229      * <p> If this method is called on a constructed <code>DynAny</code>
   230      * <p> If this method is called on a constructed {@code DynAny}
   230      * object, it initializes the next component of the constructed data
   231      * object, it initializes the next component of the constructed data
   231      * value associated with this <code>DynAny</code> object.
   232      * value associated with this {@code DynAny} object.
   232      *
   233      *
   233      * @param value the <code>float</code> to insert into this
   234      * @param value the {@code float} to insert into this
   234      *              <code>DynAny</code> object
   235      *              {@code DynAny} object
   235      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   236      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   236      *            if the value inserted is not consistent with the type
   237      *            if the value inserted is not consistent with the type
   237      *            of the accessed component in this <code>DynAny</code> object
   238      *            of the accessed component in this {@code DynAny} object
   238      */
   239      */
   239     public void insert_float(float value)
   240     public void insert_float(float value)
   240         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   241         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   241 
   242 
   242     /**
   243     /**
   243      * Inserts the given <code>double</code> as the value for this
   244      * Inserts the given {@code double} as the value for this
   244      * <code>DynAny</code> object.
   245      * {@code DynAny} object.
   245      *
   246      *
   246      * <p> If this method is called on a constructed <code>DynAny</code>
   247      * <p> If this method is called on a constructed {@code DynAny}
   247      * object, it initializes the next component of the constructed data
   248      * object, it initializes the next component of the constructed data
   248      * value associated with this <code>DynAny</code> object.
   249      * value associated with this {@code DynAny} object.
   249      *
   250      *
   250      * @param value the <code>double</code> to insert into this
   251      * @param value the {@code double} to insert into this
   251      *              <code>DynAny</code> object
   252      *              {@code DynAny} object
   252      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   253      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   253      *            if the value inserted is not consistent with the type
   254      *            if the value inserted is not consistent with the type
   254      *            of the accessed component in this <code>DynAny</code> object
   255      *            of the accessed component in this {@code DynAny} object
   255      */
   256      */
   256     public void insert_double(double value)
   257     public void insert_double(double value)
   257         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   258         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   258 
   259 
   259     /**
   260     /**
   260      * Inserts the given <code>String</code> object as the value for this
   261      * Inserts the given {@code String} object as the value for this
   261      * <code>DynAny</code> object.
   262      * {@code DynAny} object.
   262      *
   263      *
   263      * <p> If this method is called on a constructed <code>DynAny</code>
   264      * <p> If this method is called on a constructed {@code DynAny}
   264      * object, it initializes the next component of the constructed data
   265      * object, it initializes the next component of the constructed data
   265      * value associated with this <code>DynAny</code> object.
   266      * value associated with this {@code DynAny} object.
   266      *
   267      *
   267      * @param value the <code>String</code> to insert into this
   268      * @param value the {@code String} to insert into this
   268      *              <code>DynAny</code> object
   269      *              {@code DynAny} object
   269      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   270      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   270      *            if the value inserted is not consistent with the type
   271      *            if the value inserted is not consistent with the type
   271      *            of the accessed component in this <code>DynAny</code> object
   272      *            of the accessed component in this {@code DynAny} object
   272      */
   273      */
   273     public void insert_string(String value)
   274     public void insert_string(String value)
   274         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   275         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   275 
   276 
   276     /**
   277     /**
   277      * Inserts the given <code>org.omg.CORBA.Object</code> as the value for this
   278      * Inserts the given {@code org.omg.CORBA.Object} as the value for this
   278      * <code>DynAny</code> object.
   279      * {@code DynAny} object.
   279      *
   280      *
   280      * <p> If this method is called on a constructed <code>DynAny</code>
   281      * <p> If this method is called on a constructed {@code DynAny}
   281      * object, it initializes the next component of the constructed data
   282      * object, it initializes the next component of the constructed data
   282      * value associated with this <code>DynAny</code> object.
   283      * value associated with this {@code DynAny} object.
   283      *
   284      *
   284      * @param value the <code>org.omg.CORBA.Object</code> to insert into this
   285      * @param value the {@code org.omg.CORBA.Object} to insert into this
   285      *              <code>DynAny</code> object
   286      *              {@code DynAny} object
   286      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   287      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   287      *            if the value inserted is not consistent with the type
   288      *            if the value inserted is not consistent with the type
   288      *            of the accessed component in this <code>DynAny</code> object
   289      *            of the accessed component in this {@code DynAny} object
   289      */
   290      */
   290     public void insert_reference(org.omg.CORBA.Object value)
   291     public void insert_reference(org.omg.CORBA.Object value)
   291         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   292         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   292 
   293 
   293     /**
   294     /**
   294      * Inserts the given <code>org.omg.CORBA.TypeCode</code> as the value for this
   295      * Inserts the given {@code org.omg.CORBA.TypeCode} as the value for this
   295      * <code>DynAny</code> object.
   296      * {@code DynAny} object.
   296      *
   297      *
   297      * <p> If this method is called on a constructed <code>DynAny</code>
   298      * <p> If this method is called on a constructed {@code DynAny}
   298      * object, it initializes the next component of the constructed data
   299      * object, it initializes the next component of the constructed data
   299      * value associated with this <code>DynAny</code> object.
   300      * value associated with this {@code DynAny} object.
   300      *
   301      *
   301      * @param value the <code>org.omg.CORBA.TypeCode</code> to insert into this
   302      * @param value the {@code org.omg.CORBA.TypeCode} to insert into this
   302      *              <code>DynAny</code> object
   303      *              {@code DynAny} object
   303      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   304      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   304      *            if the value inserted is not consistent with the type
   305      *            if the value inserted is not consistent with the type
   305      *            of the accessed component in this <code>DynAny</code> object
   306      *            of the accessed component in this {@code DynAny} object
   306      */
   307      */
   307     public void insert_typecode(org.omg.CORBA.TypeCode value)
   308     public void insert_typecode(org.omg.CORBA.TypeCode value)
   308         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   309         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   309 
   310 
   310     /**
   311     /**
   311      * Inserts the given <code>long</code> as the value for this
   312      * Inserts the given {@code long} as the value for this
   312      * <code>DynAny</code> object.
   313      * {@code DynAny} object.
   313      *
   314      *
   314      * <p> If this method is called on a constructed <code>DynAny</code>
   315      * <p> If this method is called on a constructed {@code DynAny}
   315      * object, it initializes the next component of the constructed data
   316      * object, it initializes the next component of the constructed data
   316      * value associated with this <code>DynAny</code> object.
   317      * value associated with this {@code DynAny} object.
   317      *
   318      *
   318      * @param value the <code>long</code> to insert into this
   319      * @param value the {@code long} to insert into this
   319      *              <code>DynAny</code> object
   320      *              {@code DynAny} object
   320      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   321      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   321      *            if the value inserted is not consistent with the type
   322      *            if the value inserted is not consistent with the type
   322      *            of the accessed component in this <code>DynAny</code> object
   323      *            of the accessed component in this {@code DynAny} object
   323      */
   324      */
   324     public void insert_longlong(long value)
   325     public void insert_longlong(long value)
   325         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   326         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   326 
   327 
   327     /**
   328     /**
   328      * Inserts the given <code>long</code> as the value for this
   329      * Inserts the given {@code long} as the value for this
   329      * <code>DynAny</code> object.
   330      * {@code DynAny} object.
   330      *
   331      *
   331      * <p> If this method is called on a constructed <code>DynAny</code>
   332      * <p> If this method is called on a constructed {@code DynAny}
   332      * object, it initializes the next component of the constructed data
   333      * object, it initializes the next component of the constructed data
   333      * value associated with this <code>DynAny</code> object.
   334      * value associated with this {@code DynAny} object.
   334      *
   335      *
   335      * @param value the <code>long</code> to insert into this
   336      * @param value the {@code long} to insert into this
   336      *              <code>DynAny</code> object
   337      *              {@code DynAny} object
   337      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   338      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   338      *            if the value inserted is not consistent with the type
   339      *            if the value inserted is not consistent with the type
   339      *            of the accessed component in this <code>DynAny</code> object
   340      *            of the accessed component in this {@code DynAny} object
   340      */
   341      */
   341     public void insert_ulonglong(long value)
   342     public void insert_ulonglong(long value)
   342         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   343         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   343 
   344 
   344     /**
   345     /**
   345      * Inserts the given <code>char</code> as the value for this
   346      * Inserts the given {@code char} as the value for this
   346      * <code>DynAny</code> object.
   347      * {@code DynAny} object.
   347      *
   348      *
   348      * <p> If this method is called on a constructed <code>DynAny</code>
   349      * <p> If this method is called on a constructed {@code DynAny}
   349      * object, it initializes the next component of the constructed data
   350      * object, it initializes the next component of the constructed data
   350      * value associated with this <code>DynAny</code> object.
   351      * value associated with this {@code DynAny} object.
   351      *
   352      *
   352      * @param value the <code>char</code> to insert into this
   353      * @param value the {@code char} to insert into this
   353      *              <code>DynAny</code> object
   354      *              {@code DynAny} object
   354      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   355      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   355      *            if the value inserted is not consistent with the type
   356      *            if the value inserted is not consistent with the type
   356      *            of the accessed component in this <code>DynAny</code> object
   357      *            of the accessed component in this {@code DynAny} object
   357      */
   358      */
   358     public void insert_wchar(char value)
   359     public void insert_wchar(char value)
   359         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   360         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   360 
   361 
   361     /**
   362     /**
   362      * Inserts the given <code>String</code> as the value for this
   363      * Inserts the given {@code String} as the value for this
   363      * <code>DynAny</code> object.
   364      * {@code DynAny} object.
   364      *
   365      *
   365      * <p> If this method is called on a constructed <code>DynAny</code>
   366      * <p> If this method is called on a constructed {@code DynAny}
   366      * object, it initializes the next component of the constructed data
   367      * object, it initializes the next component of the constructed data
   367      * value associated with this <code>DynAny</code> object.
   368      * value associated with this {@code DynAny} object.
   368      *
   369      *
   369      * @param value the <code>String</code> to insert into this
   370      * @param value the {@code String} to insert into this
   370      *              <code>DynAny</code> object
   371      *              {@code DynAny} object
   371      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   372      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   372      *            if the value inserted is not consistent with the type
   373      *            if the value inserted is not consistent with the type
   373      *            of the accessed component in this <code>DynAny</code> object
   374      *            of the accessed component in this {@code DynAny} object
   374      */
   375      */
   375     public void insert_wstring(String value)
   376     public void insert_wstring(String value)
   376         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   377         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   377 
   378 
   378     /**
   379     /**
   379      * Inserts the given <code>org.omg.CORBA.Any</code> object as the value for this
   380      * Inserts the given {@code org.omg.CORBA.Any} object as the value for this
   380      * <code>DynAny</code> object.
   381      * {@code DynAny} object.
   381      *
   382      *
   382      * <p> If this method is called on a constructed <code>DynAny</code>
   383      * <p> If this method is called on a constructed {@code DynAny}
   383      * object, it initializes the next component of the constructed data
   384      * object, it initializes the next component of the constructed data
   384      * value associated with this <code>DynAny</code> object.
   385      * value associated with this {@code DynAny} object.
   385      *
   386      *
   386      * @param value the <code>org.omg.CORBA.Any</code> object to insert into this
   387      * @param value the {@code org.omg.CORBA.Any} object to insert into this
   387      *              <code>DynAny</code> object
   388      *              {@code DynAny} object
   388      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   389      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   389      *            if the value inserted is not consistent with the type
   390      *            if the value inserted is not consistent with the type
   390      *            of the accessed component in this <code>DynAny</code> object
   391      *            of the accessed component in this {@code DynAny} object
   391      */
   392      */
   392     public void insert_any(org.omg.CORBA.Any value)
   393     public void insert_any(org.omg.CORBA.Any value)
   393         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   394         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   394 
   395 
   395     // orbos 98-01-18: Objects By Value -- begin
   396     // orbos 98-01-18: Objects By Value -- begin
   396 
   397 
   397     /**
   398     /**
   398      * Inserts the given <code>java.io.Serializable</code> object as the value for this
   399      * Inserts the given {@code java.io.Serializable} object as the value for this
   399      * <code>DynAny</code> object.
   400      * {@code DynAny} object.
   400      *
   401      *
   401      * <p> If this method is called on a constructed <code>DynAny</code>
   402      * <p> If this method is called on a constructed {@code DynAny}
   402      * object, it initializes the next component of the constructed data
   403      * object, it initializes the next component of the constructed data
   403      * value associated with this <code>DynAny</code> object.
   404      * value associated with this {@code DynAny} object.
   404      *
   405      *
   405      * @param value the <code>java.io.Serializable</code> object to insert into this
   406      * @param value the {@code java.io.Serializable} object to insert into this
   406      *              <code>DynAny</code> object
   407      *              {@code DynAny} object
   407      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   408      * @throws org.omg.CORBA.DynAnyPackage.InvalidValue
   408      *            if the value inserted is not consistent with the type
   409      *            if the value inserted is not consistent with the type
   409      *            of the accessed component in this <code>DynAny</code> object
   410      *            of the accessed component in this {@code DynAny} object
   410      */
   411      */
   411     public void insert_val(java.io.Serializable value)
   412     public void insert_val(java.io.Serializable value)
   412         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   413         throws org.omg.CORBA.DynAnyPackage.InvalidValue;
   413 
   414 
   414     /**
   415     /**
   415      * Retrieves the <code>java.io.Serializable</code> object contained
   416      * Retrieves the {@code java.io.Serializable} object contained
   416      * in this <code>DynAny</code> object.
   417      * in this {@code DynAny} object.
   417      *
   418      *
   418      * @return the <code>java.io.Serializable</code> object that is the
   419      * @return the {@code java.io.Serializable} object that is the
   419      *         value for this <code>DynAny</code> object
   420      *         value for this {@code DynAny} object
   420      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   421      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   421      *               if the type code of the accessed component in this
   422      *               if the type code of the accessed component in this
   422      *               <code>DynAny</code> object is not equivalent to
   423      *               {@code DynAny} object is not equivalent to
   423      *               the type code for a <code>java.io.Serializable</code> object
   424      *               the type code for a {@code java.io.Serializable} object
   424      */
   425      */
   425     public java.io.Serializable get_val()
   426     public java.io.Serializable get_val()
   426         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   427         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   427 
   428 
   428     // orbos 98-01-18: Objects By Value -- end
   429     // orbos 98-01-18: Objects By Value -- end
   429 
   430 
   430     /**
   431     /**
   431      * Retrieves the <code>boolean</code> contained
   432      * Retrieves the {@code boolean} contained
   432      * in this <code>DynAny</code> object.
   433      * in this {@code DynAny} object.
   433      *
   434      *
   434      * @return the <code>boolean</code> that is the
   435      * @return the {@code boolean} that is the
   435      *         value for this <code>DynAny</code> object
   436      *         value for this {@code DynAny} object
   436      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   437      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   437      *               if the type code of the accessed component in this
   438      *               if the type code of the accessed component in this
   438      *               <code>DynAny</code> object is not equivalent to
   439      *               {@code DynAny} object is not equivalent to
   439      *               the type code for a <code>boolean</code>
   440      *               the type code for a {@code boolean}
   440      */
   441      */
   441     public boolean get_boolean()
   442     public boolean get_boolean()
   442         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   443         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   443 
   444 
   444 
   445 
   445     /**
   446     /**
   446      * Retrieves the <code>byte</code> contained
   447      * Retrieves the {@code byte} contained
   447      * in this <code>DynAny</code> object.
   448      * in this {@code DynAny} object.
   448      *
   449      *
   449      * @return the <code>byte</code> that is the
   450      * @return the {@code byte} that is the
   450      *         value for this <code>DynAny</code> object
   451      *         value for this {@code DynAny} object
   451      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   452      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   452      *               if the type code of the accessed component in this
   453      *               if the type code of the accessed component in this
   453      *               <code>DynAny</code> object is not equivalent to
   454      *               {@code DynAny} object is not equivalent to
   454      *               the type code for a <code>byte</code>
   455      *               the type code for a {@code byte}
   455      */
   456      */
   456     public byte get_octet()
   457     public byte get_octet()
   457         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   458         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   458 
   459 
   459     /**
   460     /**
   460      * Retrieves the <code>char</code> contained
   461      * Retrieves the {@code char} contained
   461      * in this <code>DynAny</code> object.
   462      * in this {@code DynAny} object.
   462      *
   463      *
   463      * @return the <code>char</code> that is the
   464      * @return the {@code char} that is the
   464      *         value for this <code>DynAny</code> object
   465      *         value for this {@code DynAny} object
   465      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   466      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   466      *               if the type code of the accessed component in this
   467      *               if the type code of the accessed component in this
   467      *               <code>DynAny</code> object is not equivalent to
   468      *               {@code DynAny} object is not equivalent to
   468      *               the type code for a <code>char</code>
   469      *               the type code for a {@code char}
   469      */
   470      */
   470     public char get_char()
   471     public char get_char()
   471         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   472         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   472 
   473 
   473 
   474 
   474     /**
   475     /**
   475      * Retrieves the <code>short</code> contained
   476      * Retrieves the {@code short} contained
   476      * in this <code>DynAny</code> object.
   477      * in this {@code DynAny} object.
   477      *
   478      *
   478      * @return the <code>short</code> that is the
   479      * @return the {@code short} that is the
   479      *         value for this <code>DynAny</code> object
   480      *         value for this {@code DynAny} object
   480      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   481      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   481      *               if the type code of the accessed component in this
   482      *               if the type code of the accessed component in this
   482      *               <code>DynAny</code> object is not equivalent to
   483      *               {@code DynAny} object is not equivalent to
   483      *               the type code for a <code>short</code>
   484      *               the type code for a {@code short}
   484      */
   485      */
   485     public short get_short()
   486     public short get_short()
   486         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   487         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   487 
   488 
   488 
   489 
   489     /**
   490     /**
   490      * Retrieves the <code>short</code> contained
   491      * Retrieves the {@code short} contained
   491      * in this <code>DynAny</code> object.
   492      * in this {@code DynAny} object.
   492      *
   493      *
   493      * @return the <code>short</code> that is the
   494      * @return the {@code short} that is the
   494      *         value for this <code>DynAny</code> object
   495      *         value for this {@code DynAny} object
   495      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   496      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   496      *               if the type code of the accessed component in this
   497      *               if the type code of the accessed component in this
   497      *               <code>DynAny</code> object is not equivalent to
   498      *               {@code DynAny} object is not equivalent to
   498      *               the type code for a <code>short</code>
   499      *               the type code for a {@code short}
   499      */
   500      */
   500     public short get_ushort()
   501     public short get_ushort()
   501         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   502         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   502 
   503 
   503 
   504 
   504     /**
   505     /**
   505      * Retrieves the <code>int</code> contained
   506      * Retrieves the {@code int} contained
   506      * in this <code>DynAny</code> object.
   507      * in this {@code DynAny} object.
   507      *
   508      *
   508      * @return the <code>int</code> that is the
   509      * @return the {@code int} that is the
   509      *         value for this <code>DynAny</code> object
   510      *         value for this {@code DynAny} object
   510      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   511      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   511      *               if the type code of the accessed component in this
   512      *               if the type code of the accessed component in this
   512      *               <code>DynAny</code> object is not equivalent to
   513      *               {@code DynAny} object is not equivalent to
   513      *               the type code for a <code>int</code>
   514      *               the type code for a {@code int}
   514      */
   515      */
   515     public int get_long()
   516     public int get_long()
   516         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   517         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   517 
   518 
   518 
   519 
   519     /**
   520     /**
   520      * Retrieves the <code>int</code> contained
   521      * Retrieves the {@code int} contained
   521      * in this <code>DynAny</code> object.
   522      * in this {@code DynAny} object.
   522      *
   523      *
   523      * @return the <code>int</code> that is the
   524      * @return the {@code int} that is the
   524      *         value for this <code>DynAny</code> object
   525      *         value for this {@code DynAny} object
   525      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   526      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   526      *               if the type code of the accessed component in this
   527      *               if the type code of the accessed component in this
   527      *               <code>DynAny</code> object is not equivalent to
   528      *               {@code DynAny} object is not equivalent to
   528      *               the type code for a <code>int</code>
   529      *               the type code for a {@code int}
   529      */
   530      */
   530     public int get_ulong()
   531     public int get_ulong()
   531         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   532         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   532 
   533 
   533 
   534 
   534     /**
   535     /**
   535      * Retrieves the <code>float</code> contained
   536      * Retrieves the {@code float} contained
   536      * in this <code>DynAny</code> object.
   537      * in this {@code DynAny} object.
   537      *
   538      *
   538      * @return the <code>float</code> that is the
   539      * @return the {@code float} that is the
   539      *         value for this <code>DynAny</code> object
   540      *         value for this {@code DynAny} object
   540      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   541      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   541      *               if the type code of the accessed component in this
   542      *               if the type code of the accessed component in this
   542      *               <code>DynAny</code> object is not equivalent to
   543      *               {@code DynAny} object is not equivalent to
   543      *               the type code for a <code>float</code>
   544      *               the type code for a {@code float}
   544      */
   545      */
   545     public float get_float()
   546     public float get_float()
   546         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   547         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   547 
   548 
   548 
   549 
   549     /**
   550     /**
   550      * Retrieves the <code>double</code> contained
   551      * Retrieves the {@code double} contained
   551      * in this <code>DynAny</code> object.
   552      * in this {@code DynAny} object.
   552      *
   553      *
   553      * @return the <code>double</code> that is the
   554      * @return the {@code double} that is the
   554      *         value for this <code>DynAny</code> object
   555      *         value for this {@code DynAny} object
   555      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   556      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   556      *               if the type code of the accessed component in this
   557      *               if the type code of the accessed component in this
   557      *               <code>DynAny</code> object is not equivalent to
   558      *               {@code DynAny} object is not equivalent to
   558      *               the type code for a <code>double</code>
   559      *               the type code for a {@code double}
   559      */
   560      */
   560     public double get_double()
   561     public double get_double()
   561         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   562         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   562 
   563 
   563 
   564 
   564     /**
   565     /**
   565      * Retrieves the <code>String</code> contained
   566      * Retrieves the {@code String} contained
   566      * in this <code>DynAny</code> object.
   567      * in this {@code DynAny} object.
   567      *
   568      *
   568      * @return the <code>String</code> that is the
   569      * @return the {@code String} that is the
   569      *         value for this <code>DynAny</code> object
   570      *         value for this {@code DynAny} object
   570      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   571      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   571      *               if the type code of the accessed component in this
   572      *               if the type code of the accessed component in this
   572      *               <code>DynAny</code> object is not equivalent to
   573      *               {@code DynAny} object is not equivalent to
   573      *               the type code for a <code>String</code>
   574      *               the type code for a {@code String}
   574      */
   575      */
   575     public String get_string()
   576     public String get_string()
   576         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   577         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   577 
   578 
   578 
   579 
   579     /**
   580     /**
   580      * Retrieves the <code>org.omg.CORBA.Other</code> contained
   581      * Retrieves the {@code org.omg.CORBA.Other} contained
   581      * in this <code>DynAny</code> object.
   582      * in this {@code DynAny} object.
   582      *
   583      *
   583      * @return the <code>org.omg.CORBA.Other</code> that is the
   584      * @return the {@code org.omg.CORBA.Other} that is the
   584      *         value for this <code>DynAny</code> object
   585      *         value for this {@code DynAny} object
   585      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   586      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   586      *               if the type code of the accessed component in this
   587      *               if the type code of the accessed component in this
   587      *               <code>DynAny</code> object is not equivalent to
   588      *               {@code DynAny} object is not equivalent to
   588      *               the type code for an <code>org.omg.CORBA.Other</code>
   589      *               the type code for an {@code org.omg.CORBA.Other}
   589      */
   590      */
   590     public org.omg.CORBA.Object get_reference()
   591     public org.omg.CORBA.Object get_reference()
   591         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   592         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   592 
   593 
   593 
   594 
   594     /**
   595     /**
   595      * Retrieves the <code>org.omg.CORBA.TypeCode</code> contained
   596      * Retrieves the {@code org.omg.CORBA.TypeCode} contained
   596      * in this <code>DynAny</code> object.
   597      * in this {@code DynAny} object.
   597      *
   598      *
   598      * @return the <code>org.omg.CORBA.TypeCode</code> that is the
   599      * @return the {@code org.omg.CORBA.TypeCode} that is the
   599      *         value for this <code>DynAny</code> object
   600      *         value for this {@code DynAny} object
   600      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   601      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   601      *               if the type code of the accessed component in this
   602      *               if the type code of the accessed component in this
   602      *               <code>DynAny</code> object is not equivalent to
   603      *               {@code DynAny} object is not equivalent to
   603      *               the type code for a <code>org.omg.CORBA.TypeCode</code>
   604      *               the type code for a {@code org.omg.CORBA.TypeCode}
   604      */
   605      */
   605     public org.omg.CORBA.TypeCode get_typecode()
   606     public org.omg.CORBA.TypeCode get_typecode()
   606         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   607         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   607 
   608 
   608 
   609 
   609     /**
   610     /**
   610      * Retrieves the <code>long</code> contained
   611      * Retrieves the {@code long} contained
   611      * in this <code>DynAny</code> object.
   612      * in this {@code DynAny} object.
   612      *
   613      *
   613      * @return the <code>long</code> that is the
   614      * @return the {@code long} that is the
   614      *         value for this <code>DynAny</code> object
   615      *         value for this {@code DynAny} object
   615      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   616      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   616      *               if the type code of the accessed component in this
   617      *               if the type code of the accessed component in this
   617      *               <code>DynAny</code> object is not equivalent to
   618      *               {@code DynAny} object is not equivalent to
   618      *               the type code for a <code>long</code>
   619      *               the type code for a {@code long}
   619      */
   620      */
   620     public long get_longlong()
   621     public long get_longlong()
   621         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   622         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   622 
   623 
   623 
   624 
   624     /**
   625     /**
   625      * Retrieves the <code>long</code> contained
   626      * Retrieves the {@code long} contained
   626      * in this <code>DynAny</code> object.
   627      * in this {@code DynAny} object.
   627      *
   628      *
   628      * @return the <code>long</code> that is the
   629      * @return the {@code long} that is the
   629      *         value for this <code>DynAny</code> object
   630      *         value for this {@code DynAny} object
   630      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   631      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   631      *               if the type code of the accessed component in this
   632      *               if the type code of the accessed component in this
   632      *               <code>DynAny</code> object is not equivalent to
   633      *               {@code DynAny} object is not equivalent to
   633      *               the type code for a <code>long</code>
   634      *               the type code for a {@code long}
   634      */
   635      */
   635     public long get_ulonglong()
   636     public long get_ulonglong()
   636         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   637         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   637 
   638 
   638 
   639 
   639     /**
   640     /**
   640      * Retrieves the <code>char</code> contained
   641      * Retrieves the {@code char} contained
   641      * in this <code>DynAny</code> object.
   642      * in this {@code DynAny} object.
   642      *
   643      *
   643      * @return the <code>char</code> that is the
   644      * @return the {@code char} that is the
   644      *         value for this <code>DynAny</code> object
   645      *         value for this {@code DynAny} object
   645      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   646      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   646      *               if the type code of the accessed component in this
   647      *               if the type code of the accessed component in this
   647      *               <code>DynAny</code> object is not equivalent to
   648      *               {@code DynAny} object is not equivalent to
   648      *               the type code for a <code>char</code>
   649      *               the type code for a {@code char}
   649      */
   650      */
   650     public char get_wchar()
   651     public char get_wchar()
   651         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   652         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   652 
   653 
   653 
   654 
   654     /**
   655     /**
   655      * Retrieves the <code>String</code> contained
   656      * Retrieves the {@code String} contained
   656      * in this <code>DynAny</code> object.
   657      * in this {@code DynAny} object.
   657      *
   658      *
   658      * @return the <code>String</code> that is the
   659      * @return the {@code String} that is the
   659      *         value for this <code>DynAny</code> object
   660      *         value for this {@code DynAny} object
   660      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   661      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   661      *               if the type code of the accessed component in this
   662      *               if the type code of the accessed component in this
   662      *               <code>DynAny</code> object is not equivalent to
   663      *               {@code DynAny} object is not equivalent to
   663      *               the type code for a <code>String</code>
   664      *               the type code for a {@code String}
   664      */
   665      */
   665     public String get_wstring()
   666     public String get_wstring()
   666         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   667         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   667 
   668 
   668 
   669 
   669     /**
   670     /**
   670      * Retrieves the <code>org.omg.CORBA.Any</code> contained
   671      * Retrieves the {@code org.omg.CORBA.Any} contained
   671      * in this <code>DynAny</code> object.
   672      * in this {@code DynAny} object.
   672      *
   673      *
   673      * @return the <code>org.omg.CORBA.Any</code> that is the
   674      * @return the {@code org.omg.CORBA.Any} that is the
   674      *         value for this <code>DynAny</code> object
   675      *         value for this {@code DynAny} object
   675      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   676      * @throws org.omg.CORBA.DynAnyPackage.TypeMismatch
   676      *               if the type code of the accessed component in this
   677      *               if the type code of the accessed component in this
   677      *               <code>DynAny</code> object is not equivalent to
   678      *               {@code DynAny} object is not equivalent to
   678      *               the type code for an <code>org.omg.CORBA.Any</code>
   679      *               the type code for an {@code org.omg.CORBA.Any}
   679      */
   680      */
   680     public org.omg.CORBA.Any get_any()
   681     public org.omg.CORBA.Any get_any()
   681         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   682         throws org.omg.CORBA.DynAnyPackage.TypeMismatch;
   682 
   683 
   683     /**
   684     /**
   684      * Returns a <code>DynAny</code> object reference that can
   685      * Returns a {@code DynAny} object reference that can
   685      * be used to get/set the value of the component currently accessed.
   686      * be used to get/set the value of the component currently accessed.
   686      * The appropriate <code>insert</code> method
   687      * The appropriate {@code insert} method
   687      * can be called on the resulting <code>DynAny</code> object
   688      * can be called on the resulting {@code DynAny} object
   688      * to initialize the component.
   689      * to initialize the component.
   689      * The appropriate <code>get</code> method
   690      * The appropriate {@code get} method
   690      * can be called on the resulting <code>DynAny</code> object
   691      * can be called on the resulting {@code DynAny} object
   691      * to extract the value of the component.
   692      * to extract the value of the component.
   692          *
   693          *
   693          * @return a <code>DynAny</code> object reference that can be
   694          * @return a {@code DynAny} object reference that can be
   694          *         used to retrieve or set the value of the component currently
   695          *         used to retrieve or set the value of the component currently
   695          *         accessed
   696          *         accessed
   696      */
   697      */
   697     public org.omg.CORBA.DynAny current_component() ;
   698     public org.omg.CORBA.DynAny current_component() ;
   698 
   699 
   699     /**
   700     /**
   700      * Moves to the next component of this <code>DynAny</code> object.
   701      * Moves to the next component of this {@code DynAny} object.
   701      * This method is used for iterating through the components of
   702      * This method is used for iterating through the components of
   702      * a constructed type, effectively moving a pointer from one
   703      * a constructed type, effectively moving a pointer from one
   703      * component to the next.  The pointer starts out on the first
   704      * component to the next.  The pointer starts out on the first
   704      * component when a <code>DynAny</code> object is created.
   705      * component when a {@code DynAny} object is created.
   705      *
   706      *
   706      * @return <code>true</code> if the pointer points to a component;
   707      * @return {@code true} if the pointer points to a component;
   707      * <code>false</code> if there are no more components or this
   708      * {@code false} if there are no more components or this
   708      * <code>DynAny</code> is associated with a basic type rather than
   709      * {@code DynAny} is associated with a basic type rather than
   709      * a constructed type
   710      * a constructed type
   710      */
   711      */
   711     public boolean next() ;
   712     public boolean next() ;
   712 
   713 
   713     /**
   714     /**
   714      * Moves the internal pointer to the given index. Logically, this method
   715      * Moves the internal pointer to the given index. Logically, this method
   715      * sets a new offset for this pointer.
   716      * sets a new offset for this pointer.
   716      *
   717      *
   717      * @param index an <code>int</code> indicating the position to which
   718      * @param index an {@code int} indicating the position to which
   718      *              the pointer should move.  The first position is 0.
   719      *              the pointer should move.  The first position is 0.
   719      * @return <code>true</code> if the pointer points to a component;
   720      * @return {@code true} if the pointer points to a component;
   720      * <code>false</code> if there is no component at the designated
   721      * {@code false} if there is no component at the designated
   721      * index.  If this <code>DynAny</code> object is associated with a
   722      * index.  If this {@code DynAny} object is associated with a
   722      * basic type, this method returns <code>false</code> for any index
   723      * basic type, this method returns {@code false} for any index
   723      * other than 0.
   724      * other than 0.
   724      */
   725      */
   725     public boolean seek(int index) ;
   726     public boolean seek(int index) ;
   726 
   727 
   727     /**
   728     /**