001: /*
002: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
003: *
004: * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
005: *
006: * The contents of this file are subject to the terms of either the GNU
007: * General Public License Version 2 only ("GPL") or the Common
008: * Development and Distribution License("CDDL") (collectively, the
009: * "License"). You may not use this file except in compliance with the
010: * License. You can obtain a copy of the License at
011: * http://www.netbeans.org/cddl-gplv2.html
012: * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
013: * specific language governing permissions and limitations under the
014: * License. When distributing the software, include this License Header
015: * Notice in each file and include the License file at
016: * nbbuild/licenses/CDDL-GPL-2-CP. Sun designates this
017: * particular file as subject to the "Classpath" exception as provided
018: * by Sun in the GPL Version 2 section of the License file that
019: * accompanied this code. If applicable, add the following below the
020: * License Header, with the fields enclosed by brackets [] replaced by
021: * your own identifying information:
022: * "Portions Copyrighted [year] [name of copyright owner]"
023: *
024: * Contributor(s):
025: *
026: * The Original Software is NetBeans. The Initial Developer of the Original
027: * Software is Sun Microsystems, Inc. Portions Copyright 1997-2007 Sun
028: * Microsystems, Inc. All Rights Reserved.
029: *
030: * If you wish your version of this file to be governed by only the CDDL
031: * or only the GPL Version 2, indicate your decision by adding
032: * "[Contributor] elects to include this software in this distribution
033: * under the [CDDL or GPL Version 2] license." If you do not indicate a
034: * single choice of license, a recipient has the option to distribute
035: * your version of this file under either the CDDL, the GPL Version 2 or
036: * to extend the choice of license to its licensees as provided above.
037: * However, if you add GPL Version 2 code and therefore, elected the GPL
038: * Version 2 license, then the option applies only if the new code is
039: * made subject to such option by the copyright holder.
040: */
041:
042: package org.netbeans.modules.uml.common;
043:
044: /**
045: * @author KevinM
046: *
047: * To change the template for this generated type comment go to
048: * Window>Preferences>Java>Code Generation>Code and Comments
049: */
050: public interface IETSystemPrinter {
051: /**
052: * Flush the stream. This is done by writing any buffered output bytes to
053: * the underlying output stream and then flushing that stream.
054: *
055: * @see java.io.OutputStream#flush()
056: */
057: public void flush();
058:
059: /**
060: * Close the stream. This is done by flushing the stream and then closing
061: * the underlying output stream.
062: *
063: * @see java.io.OutputStream#close()
064: */
065: public void close();
066:
067: /**
068: * Flush the stream and check its error state. The internal error state
069: * is set to <code>true</code> when the underlying output stream throws an
070: * <code>IOException</code> other than <code>InterruptedIOException</code>,
071: * and when the <code>setError</code> method is invoked. If an operation
072: * on the underlying output stream throws an
073: * <code>InterruptedIOException</code>, then the <code>PrintStream</code>
074: * converts the exception back into an interrupt by doing:
075: * <pre>
076: * Thread.currentThread().interrupt();
077: * </pre>
078: * or the equivalent.
079: *
080: * @return True if and only if this stream has encountered an
081: * <code>IOException</code> other than
082: * <code>InterruptedIOException</code>, or the
083: * <code>setError</code> method has been invoked
084: */
085: public boolean checkError();
086:
087: /*
088: * Exception-catching, synchronized output operations,
089: * which also implement the write() methods of OutputStream
090: */
091:
092: /**
093: * Write the specified byte to this stream. If the byte is a newline and
094: * automatic flushing is enabled then the <code>flush</code> method will be
095: * invoked.
096: *
097: * <p> Note that the byte is written as given; to write a character that
098: * will be translated according to the platform's default character
099: * encoding, use the <code>print(char)</code> or <code>println(char)</code>
100: * methods.
101: *
102: * @param b The byte to be written
103: * @see #print(char)
104: * @see #println(char)
105: */
106: public void write(int b);
107:
108: /**
109: * Write <code>len</code> bytes from the specified byte array starting at
110: * offset <code>off</code> to this stream. If automatic flushing is
111: * enabled then the <code>flush</code> method will be invoked.
112: *
113: * <p> Note that the bytes will be written as given; to write characters
114: * that will be translated according to the platform's default character
115: * encoding, use the <code>print(char)</code> or <code>println(char)</code>
116: * methods.
117: *
118: * @param buf A byte array
119: * @param off Offset from which to start taking bytes
120: * @param len Number of bytes to write
121: */
122: public void write(byte buf[], int off, int len);
123:
124: /* Methods that do not terminate lines */
125:
126: /**
127: * Print a boolean value. The string produced by <code>{@link
128: * java.lang.String#valueOf(boolean)}</code> is translated into bytes
129: * according to the platform's default character encoding, and these bytes
130: * are written in exactly the manner of the
131: * <code>{@link #write(int)}</code> method.
132: *
133: * @param b The <code>boolean</code> to be printed
134: */
135: public void print(boolean b);
136:
137: /**
138: * Print a character. The character is translated into one or more bytes
139: * according to the platform's default character encoding, and these bytes
140: * are written in exactly the manner of the
141: * <code>{@link #write(int)}</code> method.
142: *
143: * @param c The <code>char</code> to be printed
144: */
145: public void print(char c);
146:
147: /**
148: * Print an integer. The string produced by <code>{@link
149: * java.lang.String#valueOf(int)}</code> is translated into bytes
150: * according to the platform's default character encoding, and these bytes
151: * are written in exactly the manner of the
152: * <code>{@link #write(int)}</code> method.
153: *
154: * @param i The <code>int</code> to be printed
155: * @see java.lang.Integer#toString(int)
156: */
157: public void print(int i);
158:
159: /**
160: * Print a long integer. The string produced by <code>{@link
161: * java.lang.String#valueOf(long)}</code> is translated into bytes
162: * according to the platform's default character encoding, and these bytes
163: * are written in exactly the manner of the
164: * <code>{@link #write(int)}</code> method.
165: *
166: * @param l The <code>long</code> to be printed
167: * @see java.lang.Long#toString(long)
168: */
169: public void print(long l);
170:
171: /**
172: * Print a floating-point number. The string produced by <code>{@link
173: * java.lang.String#valueOf(float)}</code> is translated into bytes
174: * according to the platform's default character encoding, and these bytes
175: * are written in exactly the manner of the
176: * <code>{@link #write(int)}</code> method.
177: *
178: * @param f The <code>float</code> to be printed
179: * @see java.lang.Float#toString(float)
180: */
181: public void print(float f);
182:
183: /**
184: * Print a double-precision floating-point number. The string produced by
185: * <code>{@link java.lang.String#valueOf(double)}</code> is translated into
186: * bytes according to the platform's default character encoding, and these
187: * bytes are written in exactly the manner of the <code>{@link
188: * #write(int)}</code> method.
189: *
190: * @param d The <code>double</code> to be printed
191: * @see java.lang.Double#toString(double)
192: */
193: public void print(double d);
194:
195: /**
196: * Print an array of characters. The characters are converted into bytes
197: * according to the platform's default character encoding, and these bytes
198: * are written in exactly the manner of the
199: * <code>{@link #write(int)}</code> method.
200: *
201: * @param s The array of chars to be printed
202: *
203: * @throws NullPointerException If <code>s</code> is <code>null</code>
204: */
205: public void print(char s[]);
206:
207: /**
208: * Print a string. If the argument is <code>null</code> then the string
209: * <code>"null"</code> is printed. Otherwise, the string's characters are
210: * converted into bytes according to the platform's default character
211: * encoding, and these bytes are written in exactly the manner of the
212: * <code>{@link #write(int)}</code> method.
213: *
214: * @param s The <code>String</code> to be printed
215: */
216: public void print(String s);
217:
218: /**
219: * Print an object. The string produced by the <code>{@link
220: * java.lang.String#valueOf(Object)}</code> method is translated into bytes
221: * according to the platform's default character encoding, and these bytes
222: * are written in exactly the manner of the
223: * <code>{@link #write(int)}</code> method.
224: *
225: * @param obj The <code>Object</code> to be printed
226: * @see java.lang.Object#toString()
227: */
228: public void print(Object obj);
229:
230: /* Methods that do terminate lines */
231:
232: /**
233: * Terminate the current line by writing the line separator string. The
234: * line separator string is defined by the system property
235: * <code>line.separator</code>, and is not necessarily a single newline
236: * character (<code>'\n'</code>).
237: */
238: public void println();
239:
240: /**
241: * Print a boolean and then terminate the line. This method behaves as
242: * though it invokes <code>{@link #print(boolean)}</code> and then
243: * <code>{@link #println()}</code>.
244: *
245: * @param x The <code>boolean</code> to be printed
246: */
247: public void println(boolean x);
248:
249: /**
250: * Print a character and then terminate the line. This method behaves as
251: * though it invokes <code>{@link #print(char)}</code> and then
252: * <code>{@link #println()}</code>.
253: *
254: * @param x The <code>char</code> to be printed.
255: */
256: public void println(char x);
257:
258: /**
259: * Print an integer and then terminate the line. This method behaves as
260: * though it invokes <code>{@link #print(int)}</code> and then
261: * <code>{@link #println()}</code>.
262: *
263: * @param x The <code>int</code> to be printed.
264: */
265: public void println(int x);
266:
267: /**
268: * Print a long and then terminate the line. This method behaves as
269: * though it invokes <code>{@link #print(long)}</code> and then
270: * <code>{@link #println()}</code>.
271: *
272: * @param x a The <code>long</code> to be printed.
273: */
274: public void println(long x);
275:
276: /**
277: * Print a float and then terminate the line. This method behaves as
278: * though it invokes <code>{@link #print(float)}</code> and then
279: * <code>{@link #println()}</code>.
280: *
281: * @param x The <code>float</code> to be printed.
282: */
283: public void println(float x);
284:
285: /**
286: * Print a double and then terminate the line. This method behaves as
287: * though it invokes <code>{@link #print(double)}</code> and then
288: * <code>{@link #println()}</code>.
289: *
290: * @param x The <code>double</code> to be printed.
291: */
292: public void println(double x);
293:
294: /**
295: * Print an array of characters and then terminate the line. This method
296: * behaves as though it invokes <code>{@link #print(char[])}</code> and
297: * then <code>{@link #println()}</code>.
298: *
299: * @param x an array of chars to print.
300: */
301: public void println(char x[]);
302:
303: /**
304: * Print a String and then terminate the line. This method behaves as
305: * though it invokes <code>{@link #print(String)}</code> and then
306: * <code>{@link #println()}</code>.
307: *
308: * @param x The <code>String</code> to be printed.
309: */
310: public void println(String x);
311:
312: /**
313: * Print an Object and then terminate the line. This method behaves as
314: * though it invokes <code>{@link #print(Object)}</code> and then
315: * <code>{@link #println()}</code>.
316: *
317: * @param x The <code>Object</code> to be printed.
318: */
319: public void println(Object x);
320: }
|