1. /*

  2.  * @(#)DataOutputStream.java	1.8 00/02/02

  3.  *

  4.  * Copyright 1997-2000 Sun Microsystems, Inc. All Rights Reserved.

  5.  * 

  6.  * This software is the proprietary information of Sun Microsystems, Inc.  

  7.  * Use is subject to license terms.

  8.  * 

  9.  */

  10. 

  11. package org.omg.CORBA;

  12. 

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

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

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

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

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

  18. * @version 1.8 02/02/00

  19. */

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

  21. {

  22.     /** 

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

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

  25.     */

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

  27. 

  28.     /** 

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

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

  31.     */

  32.     void write_boolean (boolean value);

  33. 

  34.     /** 

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

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

  37.     */

  38.     void write_char (char value);

  39. 

  40.     /** 

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

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

  43.     */

  44.     void write_wchar (char value);

  45. 

  46.     /** 

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

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

  49.     */

  50.     void write_octet (byte value);

  51. 

  52.     /** 

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

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

  55.     */

  56.     void write_short (short value);

  57. 

  58.     /** 

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

  60.     * value) to the output stream.

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

  62.     */

  63.     void write_ushort (short value);

  64. 

  65.     /** 

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

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

  68.     */

  69.     void write_long (int value);

  70. 

  71.     /** 

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

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

  74.     */

  75.     void write_ulong (int value);

  76. 

  77.     /** 

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

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

  80.     */

  81.     void write_longlong (long value);

  82. 

  83.     /** 

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

  85.     * to the output stream.

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

  87.     */

  88.     void write_ulonglong (long value);

  89. 

  90.     /** 

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

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

  93.     */

  94.     void write_float (float value);

  95. 

  96.     /** 

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

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

  99.     */

  100.     void write_double (double value);

  101. 

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

  103. 

  104.     /** 

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

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

  107.     */

  108.     void write_string (String value);

  109. 

  110.     /** 

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

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

  113.     */

  114.     void write_wstring (String value);

  115. 

  116.     /** 

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

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

  119.     */

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

  121. 

  122.     /** 

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

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

  125.     */

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

  127. 

  128.     /** 

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

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

  131.     */

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

  133. 

  134.     /** 

  135.     * Writes the typecode to the output stream.

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

  137.     */

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

  139.     

  140.     /** 

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

  142.     * output stream.  

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

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

  145.     * output stream.

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

  147.     */

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

  149. 

  150.     /** 

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

  152.     * output stream.  

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

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

  155.     * output stream.

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

  157.     */

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

  159. 

  160.     /** 

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

  162.     * output stream.  

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

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

  165.     * output stream.

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

  167.     */

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

  169. 

  170.     /** 

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

  172.     * output stream.  

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

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

  175.     * output stream.

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

  177.     */

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

  179. 

  180.     /** 

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

  182.     * output stream.  

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

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

  185.     * output stream.

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

  187.     */

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

  189. 

  190.     /** 

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

  192.     * output stream.  

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

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

  195.     * output stream.

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

  197.     */

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

  199. 

  200.     /** 

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

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

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

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

  205.     * output stream.

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

  207.     */

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

  209. 

  210.     /** 

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

  212.     * output stream.  

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

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

  215.     * output stream.

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

  217.     */

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

  219. 

  220.     /** 

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

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

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

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

  225.     * output stream.

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

  227.     */

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

  229. 

  230.     /** 

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

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

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

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

  235.     * output stream.

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

  237.     */

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

  239. 

  240.     /** 

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

  242.     * output stream.  

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

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

  245.     * output stream.

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

  247.     */

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

  249. 

  250.     /** 

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

  252.     * output stream.  

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

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

  255.     * output stream.

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

  257.     */

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

  259. 

  260.     /** 

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

  262.     * output stream.  

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

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

  265.     * output stream.

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

  267.     */

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

  269. } // interface DataOutputStream