< prev index next >

src/java.corba/share/classes/org/omg/CORBA/DynAny.java

Print this page




  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 
  27 package org.omg.CORBA;
  28 
  29 
  30 /** Enables <tt>org.omg.CORBA.Any</tt> values to be dynamically

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


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