1. /*

  2.  * @(#)DataOutputStream.java	1.12 03/12/19

  3.  *

  4.  * Copyright 2004 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. 

  8. package org.omg.CORBA;

  9. 

  10. /** Defines the methods used to write primitive data types to output streams

  11. * for marshalling custom value types.  This interface is used by user

  12. * written custom marshalling code for custom value types.

  13. * @see org.omg.CORBA.DataInputStream

  14. * @see org.omg.CORBA.CustomMarshal

  15. * @version 1.12 12/19/03

  16. */

  17. public interface DataOutputStream extends org.omg.CORBA.portable.ValueBase

  18. {

  19.     /** 

  20.     * Writes the Any value to the output stream.

  21.     * @param value The value to be written.

  22.     */

  23.     void write_any (org.omg.CORBA.Any value);

  24. 

  25.     /** 

  26.     * Writes the boolean value to the output stream.

  27.     * @param value The value to be written.

  28.     */

  29.     void write_boolean (boolean value);

  30. 

  31.     /** 

  32.     * Writes the IDL character value to the output stream.

  33.     * @param value The value to be written.

  34.     */

  35.     void write_char (char value);

  36. 

  37.     /** 

  38.     * Writes the IDL wide character value to the output stream.

  39.     * @param value The value to be written.

  40.     */

  41.     void write_wchar (char value);

  42. 

  43.     /** 

  44.     * Writes the IDL octet value (represented as a Java byte) to the output stream.

  45.     * @param value The value to be written.

  46.     */

  47.     void write_octet (byte value);

  48. 

  49.     /** 

  50.     * Writes the IDL short value to the output stream.

  51.     * @param value The value to be written.

  52.     */

  53.     void write_short (short value);

  54. 

  55.     /** 

  56.     * Writes the IDL unsigned short value (represented as a Java short 

  57.     * value) to the output stream.

  58.     * @param value The value to be written.

  59.     */

  60.     void write_ushort (short value);

  61. 

  62.     /** 

  63.     * Writes the IDL long value (represented as a Java int) to the output stream.

  64.     * @param value The value to be written.

  65.     */

  66.     void write_long (int value);

  67. 

  68.     /** 

  69.     * Writes the IDL unsigned long value (represented as a Java int) to the output stream.

  70.     * @param value The value to be written.

  71.     */

  72.     void write_ulong (int value);

  73. 

  74.     /** 

  75.     * Writes the IDL long long value (represented as a Java long) to the output stream.

  76.     * @param value The value to be written.

  77.     */

  78.     void write_longlong (long value);

  79. 

  80.     /** 

  81.     * Writes the IDL unsigned long long value (represented as a Java long)

  82.     * to the output stream.

  83.     * @param value The value to be written.

  84.     */

  85.     void write_ulonglong (long value);

  86. 

  87.     /** 

  88.     * Writes the IDL float value to the output stream.

  89.     * @param value The value to be written.

  90.     */

  91.     void write_float (float value);

  92. 

  93.     /** 

  94.     * Writes the IDL double value to the output stream.

  95.     * @param value The value to be written.

  96.     */

  97.     void write_double (double value);

  98. 

  99.     // write_longdouble not supported by IDL/Java mapping

  100. 

  101.     /** 

  102.     * Writes the IDL string value to the output stream.

  103.     * @param value The value to be written.

  104.     */

  105.     void write_string (String value);

  106. 

  107.     /** 

  108.     * Writes the IDL wide string value (represented as a Java String) to the output stream.

  109.     * @param value The value to be written.

  110.     */

  111.     void write_wstring (String value);

  112. 

  113.     /** 

  114.     * Writes the IDL CORBA::Object value to the output stream.

  115.     * @param value The value to be written.

  116.     */

  117.     void write_Object (org.omg.CORBA.Object value);

  118. 

  119.     /** 

  120.     * Writes the IDL Abstract interface type to the output stream.

  121.     * @param value The value to be written.

  122.     */

  123.     void write_Abstract (java.lang.Object value);

  124. 

  125.     /** 

  126.     * Writes the IDL value type value to the output stream.

  127.     * @param value The value to be written.

  128.     */

  129.     void write_Value (java.io.Serializable value);

  130. 

  131.     /** 

  132.     * Writes the typecode to the output stream.

  133.     * @param value The value to be written.

  134.     */

  135.     void write_TypeCode (org.omg.CORBA.TypeCode value);

  136.     

  137.     /** 

  138.     * Writes the array of IDL Anys from offset for length elements to the

  139.     * output stream.  

  140.     * @param seq The array to be written.

  141.     * @param offset The index into seq of the first element to write to the

  142.     * output stream.

  143.     * @param length The number of elements to write to the output stream.

  144.     */

  145.     void write_any_array (org.omg.CORBA.Any[] seq, int offset, int length);

  146. 

  147.     /** 

  148.     * Writes the array of IDL booleans from offset for length elements to the

  149.     * output stream.  

  150.     * @param seq The array to be written.

  151.     * @param offset The index into seq of the first element to write to the

  152.     * output stream.

  153.     * @param length The number of elements to write to the output stream.

  154.     */

  155.     void write_boolean_array (boolean[] seq, int offset, int length);

  156. 

  157.     /** 

  158.     * Writes the array of IDL characters from offset for length elements to the

  159.     * output stream.  

  160.     * @param seq The array to be written.

  161.     * @param offset The index into seq of the first element to write to the

  162.     * output stream.

  163.     * @param length The number of elements to write to the output stream.

  164.     */

  165.     void write_char_array (char[] seq, int offset, int length);

  166. 

  167.     /** 

  168.     * Writes the array of IDL wide characters from offset for length elements to the

  169.     * output stream.  

  170.     * @param seq The array to be written.

  171.     * @param offset The index into seq of the first element to write to the

  172.     * output stream.

  173.     * @param length The number of elements to write to the output stream.

  174.     */

  175.     void write_wchar_array (char[] seq, int offset, int length);

  176. 

  177.     /** 

  178.     * Writes the array of IDL octets from offset for length elements to the

  179.     * output stream.  

  180.     * @param seq The array to be written.

  181.     * @param offset The index into seq of the first element to write to the

  182.     * output stream.

  183.     * @param length The number of elements to write to the output stream.

  184.     */

  185.     void write_octet_array (byte[] seq, int offset, int length);

  186. 

  187.     /** 

  188.     * Writes the array of IDL shorts from offset for length elements to the

  189.     * output stream.  

  190.     * @param seq The array to be written.

  191.     * @param offset The index into seq of the first element to write to the

  192.     * output stream.

  193.     * @param length The number of elements to write to the output stream.

  194.     */

  195.     void write_short_array (short[] seq, int offset, int length);

  196. 

  197.     /** 

  198.     * Writes the array of IDL unsigned shorts (represented as Java shorts)

  199.     * from offset for length elements to the output stream.  

  200.     * @param seq The array to be written.

  201.     * @param offset The index into seq of the first element to write to the

  202.     * output stream.

  203.     * @param length The number of elements to write to the output stream.

  204.     */

  205.     void write_ushort_array (short[] seq, int offset, int length);

  206. 

  207.     /** 

  208.     * Writes the array of IDL longs from offset for length elements to the

  209.     * output stream.  

  210.     * @param seq The array to be written.

  211.     * @param offset The index into seq of the first element to write to the

  212.     * output stream.

  213.     * @param length The number of elements to write to the output stream.

  214.     */

  215.     void write_long_array (int[] seq, int offset, int length);

  216. 

  217.     /** 

  218.     * Writes the array of IDL unsigned longs (represented as Java ints) 

  219.     * from offset for length elements to the output stream.  

  220.     * @param seq The array to be written.

  221.     * @param offset The index into seq of the first element to write to the

  222.     * output stream.

  223.     * @param length The number of elements to write to the output stream.

  224.     */

  225.     void write_ulong_array (int[] seq, int offset, int length);

  226. 

  227.     /** 

  228.     * Writes the array of IDL unsigned long longs (represented as Java longs)

  229.     * from offset for length elements to the output stream.  

  230.     * @param seq The array to be written.

  231.     * @param offset The index into seq of the first element to write to the

  232.     * output stream.

  233.     * @param length The number of elements to write to the output stream.

  234.     */

  235.     void write_ulonglong_array (long[] seq, int offset, int length);

  236. 

  237.     /** 

  238.     * Writes the array of IDL long longs from offset for length elements to the

  239.     * output stream.  

  240.     * @param seq The array to be written.

  241.     * @param offset The index into seq of the first element to write to the

  242.     * output stream.

  243.     * @param length The number of elements to write to the output stream.

  244.     */

  245.     void write_longlong_array (long[] seq, int offset, int length);

  246. 

  247.     /** 

  248.     * Writes the array of IDL floats from offset for length elements to the

  249.     * output stream.  

  250.     * @param seq The array to be written.

  251.     * @param offset The index into seq of the first element to write to the

  252.     * output stream.

  253.     * @param length The number of elements to write to the output stream.

  254.     */

  255.     void write_float_array (float[] seq, int offset, int length);

  256. 

  257.     /** 

  258.     * Writes the array of IDL doubles from offset for length elements to the

  259.     * output stream.  

  260.     * @param seq The array to be written.

  261.     * @param offset The index into seq of the first element to write to the

  262.     * output stream.

  263.     * @param length The number of elements to write to the output stream.

  264.     */

  265.     void write_double_array (double[] seq, int offset, int length);

  266. } // interface DataOutputStream