OutputStream.java revision 608:7e06bf1dcb09 
1/*
2 * Copyright (c) 1997, 2004, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.  Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
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 */
25package org.omg.CORBA.portable;
26
27import org.omg.CORBA.TypeCode;
28import org.omg.CORBA.Principal;
29import org.omg.CORBA.Any;
30
31/**
32 * OuputStream is the Java API for writing IDL types
33 * to CDR marshal streams. These methods are used by the ORB to
34 * marshal IDL types as well as to insert IDL types into Anys.
35 * The <code>_array</code> versions of the methods can be directly
36 * used to write sequences and arrays of IDL types.
37 *
38 * @since   JDK1.2
39 */
40
41
42public abstract class OutputStream extends java.io.OutputStream
43{
44    /**
45     * Returns an input stream with the same buffer.
46     *@return an input stream with the same buffer.
47     */
48    public abstract InputStream create_input_stream();
49
50    /**
51     * Writes a boolean value to this stream.
52     * @param value the value to be written.
53     */
54    public abstract void write_boolean(boolean value);
55    /**
56     * Writes a char value to this stream.
57     * @param value the value to be written.
58     */
59    public abstract void write_char(char value);
60    /**
61     * Writes a wide char value to this stream.
62     * @param value the value to be written.
63     */
64    public abstract void write_wchar(char value);
65    /**
66     * Writes a CORBA octet (i.e. byte) value to this stream.
67     * @param value the value to be written.
68     */
69    public abstract void write_octet(byte value);
70    /**
71     * Writes a short value to this stream.
72     * @param value the value to be written.
73     */
74    public abstract void write_short(short value);
75    /**
76     * Writes an unsigned short value to this stream.
77     * @param value the value to be written.
78     */
79    public abstract void write_ushort(short value);
80    /**
81     * Writes a CORBA long (i.e. Java int) value to this stream.
82     * @param value the value to be written.
83     */
84    public abstract void write_long(int value);
85    /**
86     * Writes an unsigned CORBA long (i.e. Java int) value to this stream.
87     * @param value the value to be written.
88     */
89    public abstract void write_ulong(int value);
90    /**
91     * Writes a CORBA longlong (i.e. Java long) value to this stream.
92     * @param value the value to be written.
93     */
94    public abstract void write_longlong(long value);
95    /**
96     * Writes an unsigned CORBA longlong (i.e. Java long) value to this stream.
97     * @param value the value to be written.
98     */
99    public abstract void write_ulonglong(long value);
100    /**
101     * Writes a float value to this stream.
102     * @param value the value to be written.
103     */
104    public abstract void write_float(float value);
105    /**
106     * Writes a double value to this stream.
107     * @param value the value to be written.
108     */
109    public abstract void write_double(double value);
110    /**
111     * Writes a string value to this stream.
112     * @param value the value to be written.
113     */
114    public abstract void write_string(String value);
115    /**
116     * Writes a wide string value to this stream.
117     * @param value the value to be written.
118     */
119    public abstract void write_wstring(String value);
120
121    /**
122     * Writes an array of booleans on this output stream.
123     * @param value the array to be written.
124     * @param offset offset on the stream.
125     * @param length length of buffer to write.
126     */
127    public abstract void write_boolean_array(boolean[] value, int offset,
128                                             int length);
129    /**
130     * Writes an array of chars on this output stream.
131     * @param value the array to be written.
132     * @param offset offset on the stream.
133     * @param length length of buffer to write.
134     */
135    public abstract void write_char_array(char[] value, int offset,
136                                          int length);
137    /**
138     * Writes an array of wide chars on this output stream.
139     * @param value the array to be written.
140     * @param offset offset on the stream.
141     * @param length length of buffer to write.
142     */
143    public abstract void write_wchar_array(char[] value, int offset,
144                                           int length);
145    /**
146     * Writes an array of CORBA octets (bytes) on this output stream.
147     * @param value the array to be written.
148     * @param offset offset on the stream.
149     * @param length length of buffer to write.
150     */
151    public abstract void write_octet_array(byte[] value, int offset,
152                                           int length);
153    /**
154     * Writes an array of shorts on this output stream.
155     * @param value the array to be written.
156     * @param offset offset on the stream.
157     * @param length length of buffer to write.
158     */
159    public abstract void write_short_array(short[] value, int offset,
160                                           int length);
161    /**
162     * Writes an array of unsigned shorts on this output stream.
163     * @param value the array to be written.
164     * @param offset offset on the stream.
165     * @param length length of buffer to write.
166     */
167    public abstract void write_ushort_array(short[] value, int offset,
168                                            int length);
169    /**
170     * Writes an array of CORBA longs (i.e. Java ints) on this output stream.
171     * @param value the array to be written.
172     * @param offset offset on the stream.
173     * @param length length of buffer to write.
174     */
175    public abstract void write_long_array(int[] value, int offset,
176                                          int length);
177    /**
178     * Writes an array of unsigned CORBA longs (i.e. Java ints) on this output stream.
179     * @param value the array to be written.
180     * @param offset offset on the stream.
181     * @param length length of buffer to write.
182     */
183    public abstract void write_ulong_array(int[] value, int offset,
184                                           int length);
185    /**
186     * Writes an array of CORBA longlongs (i.e. Java longs) on this output stream.
187     * @param value the array to be written.
188     * @param offset offset on the stream.
189     * @param length length of buffer to write.
190     */
191    public abstract void write_longlong_array(long[] value, int offset,
192                                              int length);
193    /**
194     * Writes an array of unsigned CORBA longlongs (i.e. Java ints) on this output stream.
195     * @param value the array to be written.
196     * @param offset offset on the stream.
197     * @param length length of buffer to write.
198     */
199    public abstract void write_ulonglong_array(long[] value, int offset,
200                                               int length);
201    /**
202     * Writes an array of floats on this output stream.
203     * @param value the array to be written.
204     * @param offset offset on the stream.
205     * @param length length of buffer to write.
206     */
207    public abstract void write_float_array(float[] value, int offset,
208                                           int length);
209    /**
210     * Writes an array of doubles on this output stream.
211     * @param value the array to be written.
212     * @param offset offset on the stream.
213     * @param length length of buffer to write.
214     */
215    public abstract void write_double_array(double[] value, int offset,
216                                            int length);
217    /**
218     * Writes a CORBA Object on this output stream.
219     * @param value the value to be written.
220     */
221    public abstract void write_Object(org.omg.CORBA.Object value);
222    /**
223     * Writes a TypeCode on this output stream.
224     * @param value the value to be written.
225     */
226    public abstract void write_TypeCode(TypeCode value);
227    /**
228     * Writes an Any on this output stream.
229     * @param value the value to be written.
230     */
231    public abstract void write_any(Any value);
232
233    /**
234     * Writes a Principle on this output stream.
235     * @param value the value to be written.
236     * @deprecated Deprecated by CORBA 2.2.
237     */
238    @Deprecated
239    public void write_Principal(Principal value) {
240        throw new org.omg.CORBA.NO_IMPLEMENT();
241    }
242
243    /**
244     * Writes an integer (length of arrays) onto this stream.
245     * @param b the value to be written.
246     * @throws java.io.IOException if there is an input/output error
247     * @see <a href="package-summary.html#unimpl"><code>portable</code>
248     * package comments for unimplemented features</a>
249     */
250    public void write(int b) throws java.io.IOException {
251        throw new org.omg.CORBA.NO_IMPLEMENT();
252    }
253
254    /**
255     * Writes a BigDecimal number.
256     * @param value a BidDecimal--value to be written.
257     */
258    public void write_fixed(java.math.BigDecimal value) {
259        throw new org.omg.CORBA.NO_IMPLEMENT();
260    }
261
262    /**
263     * Writes a CORBA context on this stream. The
264     * Context is marshaled as a sequence of strings.
265     * Only those Context values specified in the contexts
266     * parameter are actually written.
267     * @param ctx a CORBA context
268     * @param contexts a <code>ContextList</code> object containing the list of contexts
269     *        to be written
270     * @see <a href="package-summary.html#unimpl"><code>portable</code>
271     * package comments for unimplemented features</a>
272     */
273    public void write_Context(org.omg.CORBA.Context ctx,
274                              org.omg.CORBA.ContextList contexts) {
275        throw new org.omg.CORBA.NO_IMPLEMENT();
276    }
277
278    /**
279     * Returns the ORB that created this OutputStream.
280     * @return the ORB that created this OutputStream
281     * @see <a href="package-summary.html#unimpl"><code>portable</code>
282     * package comments for unimplemented features</a>
283     */
284    public org.omg.CORBA.ORB orb() {
285        throw new org.omg.CORBA.NO_IMPLEMENT();
286    }
287}
288