IOGroovyMethods (Groovy 4.0.24)

org.codehaus.groovy.runtime.IOGroovyMethods

```
public class IOGroovyMethods
extends DefaultGroovyMethodsSupport
```
This class defines new groovy methods for Readers, Writers, InputStreams and OutputStreams which appear on normal JDK classes inside the Groovy environment. Static methods are used with the first parameter being the destination class, i.e. public static T eachLine(InputStream self, Closure c) provides a eachLine(Closure c) method for InputStream.
NOTE: While this class contains many 'public' static methods, it is primarily regarded as an internal class (its internal package name suggests this also). We value backwards compatibility of these methods when used within Groovy but value less backwards compatibility at the Java method call level. I.e. future versions of Groovy may remove or move a method call in this file but would normally aim to keep the method available from within Groovy.

Methods Summary

Methods
Type Params	Return Type	Name and description
	`public static void`	`eachByte(InputStream is, Closure closure)` Traverse through each byte of the specified stream.
	`public static void`	`eachByte(InputStream is, int bufferLen, Closure closure)` Traverse through each the specified stream reading bytes into a buffer and calling the 2 parameter closure with this buffer and the number of bytes.
`<T>`	`public static T`	`eachLine(InputStream stream, String charset, Closure<T> closure)` Iterates through this stream reading with the provided charset, passing each line to the given 1 or 2 arg closure.
`<T>`	`public static T`	`eachLine(InputStream stream, String charset, int firstLine, Closure<T> closure)` Iterates through this stream reading with the provided charset, passing each line to the given 1 or 2 arg closure.
`<T>`	`public static T`	`eachLine(InputStream stream, Closure<T> closure)` Iterates through this stream, passing each line to the given 1 or 2 arg closure.
`<T>`	`public static T`	`eachLine(InputStream stream, int firstLine, Closure<T> closure)` Iterates through this stream, passing each line to the given 1 or 2 arg closure.
`<T>`	`public static T`	`eachLine(Reader self, Closure<T> closure)` Iterates through the given reader line by line.
`<T>`	`public static T`	`eachLine(Reader self, int firstLine, Closure<T> closure)` Iterates through the given reader line by line.
	`public static void`	`eachObject(ObjectInputStream ois, Closure closure)` Iterates through the given object stream object by object.
	`public static void`	`filterLine(Reader reader, Writer writer, Closure closure)` Filter the lines from a reader and write them on the writer, according to a closure which returns true if the line should be included.
	`public static Writable`	`filterLine(Reader reader, Closure closure)` Filter the lines from this Reader, and return a Writable which can be used to stream the filtered lines to a destination.
	`public static Writable`	`filterLine(InputStream self, Closure predicate)` Filter lines from an input stream using a closure predicate.
	`public static Writable`	`filterLine(InputStream self, String charset, Closure predicate)` Filter lines from an input stream using a closure predicate.
	`public static void`	`filterLine(InputStream self, Writer writer, Closure predicate)` Uses a closure to filter lines from this InputStream and pass them to the given writer.
	`public static void`	`filterLine(InputStream self, Writer writer, String charset, Closure predicate)` Uses a closure to filter lines from this InputStream and pass them to the given writer.
	`public static byte[]`	`getBytes(InputStream is)` Read the content of this InputStream and return it as a byte[].
	`public static String`	`getText(InputStream is)` Read the content of this InputStream and return it as a String.
	`public static String`	`getText(InputStream is, String charset)` Read the content of this InputStream using specified charset and return it as a String.
	`public static String`	`getText(Reader reader)` Read the content of the Reader and return it as a String.
	`public static String`	`getText(BufferedReader reader)` Read the content of the BufferedReader and return it as a String.
	`public boolean`	`hasNext()`
	`public boolean`	`hasNext()`
	`public static Iterator<String>`	`iterator(Reader self)` Creates an iterator which will traverse through the reader a line at a time.
	`public static Iterator<Byte>`	`iterator(InputStream self)` Standard iterator for an input stream which iterates through the stream content in a byte-based fashion.
	`public static Iterator<Byte>`	`iterator(DataInputStream self)` Standard iterator for a data input stream which iterates through the stream content a Byte at a time.
	`public static Writer`	`leftShift(Writer self, Object value)` Overloads the leftShift operator for Writer to allow an object to be written using Groovy's default representation for the object.
	`public static Appendable`	`leftShift(Appendable self, Object value)` Overloads the leftShift operator for Appendable to allow an object to be appended using Groovy's default representation for the object.
	`public static Writer`	`leftShift(OutputStream self, Object value)`
	`public static void`	`leftShift(ObjectOutputStream self, Object value)` Overloads the leftShift operator to add objects to an ObjectOutputStream.
	`public static OutputStream`	`leftShift(OutputStream self, InputStream in)` Pipe an InputStream into an OutputStream for efficient stream copying.
	`public static OutputStream`	`leftShift(OutputStream self, byte[] value)` Overloads the leftShift operator to provide an append mechanism to add bytes to a stream.
	`public static ObjectInputStream`	`newObjectInputStream(InputStream inputStream)` Create an object input stream for this input stream.
	`public static ObjectInputStream`	`newObjectInputStream(InputStream inputStream, ClassLoader classLoader)` Create an object input stream for this input stream using the given class loader.
	`public static ObjectOutputStream`	`newObjectOutputStream(OutputStream outputStream)` Create an object output stream for this output stream.
	`public static PrintWriter`	`newPrintWriter(Writer writer)` Create a new PrintWriter for this Writer.
	`public static PrintWriter`	`newPrintWriter(OutputStream stream)` Create a new PrintWriter for this OutputStream.
	`public static BufferedReader`	`newReader(InputStream self)` Creates a reader for this input stream.
	`public static BufferedReader`	`newReader(InputStream self, String charset)` Creates a reader for this input stream, using the specified charset as the encoding.
	`public static Writer`	`newWriter(OutputStream stream)` Creates a writer for this stream.
	`public static Writer`	`newWriter(OutputStream stream, String charset)` Creates a writer for this stream using the given charset.
	`public String`	`next()`
	`public Byte`	`next()`
	`public static String`	`readLine(Reader self)` Read a single, whole line from the given Reader.
	`public static List<String>`	`readLines(InputStream stream)` Reads the stream into a list, with one element for each line.
	`public static List<String>`	`readLines(InputStream stream, String charset)` Reads the stream into a list, with one element for each line.
	`public static List<String>`	`readLines(Reader reader)` Reads the reader into a list of Strings, with one entry for each line.
	`public void`	`remove()`
	`public void`	`remove()`
	`protected Class<?>`	`resolveClass(ObjectStreamClass desc)`
	`public static void`	`setBytes(OutputStream os, byte[] bytes)` Write the byte[] to the output stream.
`<T>`	`public static T`	`splitEachLine(Reader self, String regex, Closure<T> closure)` Iterates through the given reader line by line, splitting each line using the given regex separator.
`<T>`	`public static T`	`splitEachLine(Reader self, Pattern pattern, Closure<T> closure)` Iterates through the given reader line by line, splitting each line using the given regex separator Pattern.
`<T>`	`public static T`	`splitEachLine(InputStream stream, String regex, String charset, Closure<T> closure)` Iterates through the given InputStream line by line using the specified encoding, splitting each line using the given separator.
`<T>`	`public static T`	`splitEachLine(InputStream stream, Pattern pattern, String charset, Closure<T> closure)` Iterates through the given InputStream line by line using the specified encoding, splitting each line using the given separator Pattern.
`<T>`	`public static T`	`splitEachLine(InputStream stream, String regex, Closure<T> closure)` Iterates through the given InputStream line by line, splitting each line using the given separator.
`<T>`	`public static T`	`splitEachLine(InputStream stream, Pattern pattern, Closure<T> closure)` Iterates through the given InputStream line by line, splitting each line using the given separator Pattern.
	`public String`	`toString()`
	`public static void`	`transformChar(Reader self, Writer writer, Closure closure)` Transforms each character from this reader by passing it to the given closure.
	`public static void`	`transformLine(Reader reader, Writer writer, Closure closure)` Transforms the lines from a reader with a Closure and write them to a writer.
`<T, U extends Closeable>`	`public static T`	`withCloseable(U self, Closure<T> action)` Allows this closeable to be used within the closure, ensuring that it is closed once the closure has been executed and before this method returns.
`<T, U extends AutoCloseable>`	`public static T`	`withCloseable(U self, Closure<T> action)` Allows this AutoCloseable to be used within the closure, ensuring that it is closed once the closure has been executed and before this method returns.
	`public static Appendable`	`withFormatter(Appendable self, Closure closure)` Invokes a Closure that uses a Formatter taking care of resource handling.
	`public static Appendable`	`withFormatter(Appendable self, Locale locale, Closure closure)` Invokes a Closure that uses a Formatter taking care of resource handling.
`<T>`	`public static T`	`withObjectInputStream(InputStream inputStream, Closure<T> closure)` Create a new ObjectInputStream for this input stream and pass it to the closure.
`<T>`	`public static T`	`withObjectInputStream(InputStream inputStream, ClassLoader classLoader, Closure<T> closure)` Create a new ObjectInputStream for this input stream and pass it to the closure.
`<T>`	`public static T`	`withObjectOutputStream(OutputStream outputStream, Closure<T> closure)` Create a new ObjectOutputStream for this output stream and then pass it to the closure.
`<T>`	`public static T`	`withPrintWriter(Writer writer, Closure<T> closure)` Create a new PrintWriter for this Writer.
`<T>`	`public static T`	`withPrintWriter(OutputStream stream, Closure<T> closure)` Create a new PrintWriter for this OutputStream.
`<T>`	`public static T`	`withReader(Reader reader, Closure<T> closure)` Allows this reader to be used within the closure, ensuring that it is closed before this method returns.
`<T>`	`public static T`	`withReader(InputStream in, Closure<T> closure)` Helper method to create a new Reader for a stream and then passes it into the closure.
`<T>`	`public static T`	`withReader(InputStream in, String charset, Closure<T> closure)` Helper method to create a new Reader for a stream and then passes it into the closure.
`<T, U extends InputStream>`	`public static T`	`withStream(U stream, Closure<T> closure)` Allows this input stream to be used within the closure, ensuring that it is flushed and closed before this method returns.
`<T, U extends OutputStream>`	`public static T`	`withStream(U os, Closure<T> closure)` Passes this OutputStream to the closure, ensuring that the stream is closed after the closure returns, regardless of errors.
`<T>`	`public static T`	`withWriter(Writer writer, Closure<T> closure)` Allows this writer to be used within the closure, ensuring that it is flushed and closed before this method returns.
`<T>`	`public static T`	`withWriter(OutputStream stream, Closure<T> closure)` Creates a writer from this stream, passing it to the given closure.
`<T>`	`public static T`	`withWriter(OutputStream stream, String charset, Closure<T> closure)` Creates a writer from this stream, passing it to the given closure.
	`public static void`	`write(Writer self, Writable writable)` A helper method so that dynamic dispatch of the writer.write(object) method will always use the more efficient Writable.writeTo(writer) mechanism if the object implements the Writable interface.
	`public static void`	`writeLine(BufferedWriter writer, String line)` Write the text and append a newline (using the platform's line-ending).
	`public Writer`	`writeTo(Writer out)`

Inherited Methods Summary

Inherited Methods
Methods inherited from class	Name
`class DefaultGroovyMethodsSupport`	`cloneSimilarCollection, cloneSimilarMap, closeQuietly, closeWithWarning, createSimilarArray, createSimilarCollection, createSimilarCollection, createSimilarCollection, createSimilarList, createSimilarMap, createSimilarOrDefaultCollection, createSimilarQueue, createSimilarSet, normaliseIndex, sameType, subListBorders, subListBorders, subListRange, writeUTF16BomIfRequired, writeUTF16BomIfRequired, writeUTF16BomIfRequired, writeUTF16BomIfRequired`

- Method Detail
  - public static void eachByte(InputStream is, @ClosureParams(value=SimpleType.class, options="byte")
    Closure closure)
    
    Traverse through each byte of the specified stream. The stream is closed after the closure returns.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    is - stream to iterate over, closed after the method call
    closure - closure to apply to each byte
    Since:
    1.0
  - public static void eachByte(InputStream is, int bufferLen, @ClosureParams(value=FromString.class, options="byte[],Integer")
    Closure closure)
    
    Traverse through each the specified stream reading bytes into a buffer and calling the 2 parameter closure with this buffer and the number of bytes.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    is - stream to iterate over, closed after the method call.
    bufferLen - the length of the buffer to use.
    closure - a 2 parameter closure which is passed the byte[] and a number of bytes successfully read.
    Since:
    1.8
  - <T> public static T eachLine(InputStream stream, String charset, @ClosureParams(value=FromString.class,options={"String","String,Integer"})
    Closure<T> closure)
    
    Iterates through this stream reading with the provided charset, passing each line to the given 1 or 2 arg closure. The stream is closed before this method returns.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    stream - a stream
    charset - opens the stream with a specified charset
    closure - a closure (arg 1 is line, optional arg 2 is line number starting at line 1)
    Returns:
    the last value returned by the closure
    See Also:
    eachLine(java.io.InputStream, java.lang.String, int, groovy.lang.Closure)
    Since:
    1.5.5
  - <T> public static T eachLine(InputStream stream, String charset, int firstLine, @ClosureParams(value=FromString.class,options={"String","String,Integer"})
    Closure<T> closure)
    
    Iterates through this stream reading with the provided charset, passing each line to the given 1 or 2 arg closure. The stream is closed after this method returns.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    stream - a stream
    charset - opens the stream with a specified charset
    firstLine - the line number value used for the first line (default is 1, set to 0 to start counting from 0)
    closure - a closure (arg 1 is line, optional arg 2 is line number)
    Returns:
    the last value returned by the closure
    See Also:
    eachLine(java.io.Reader, int, groovy.lang.Closure)
    Since:
    1.5.7
  - <T> public static T eachLine(InputStream stream, @ClosureParams(value=FromString.class,options={"String","String,Integer"})
    Closure<T> closure)
    
    Iterates through this stream, passing each line to the given 1 or 2 arg closure. The stream is closed before this method returns.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    stream - a stream
    closure - a closure (arg 1 is line, optional arg 2 is line number starting at line 1)
    Returns:
    the last value returned by the closure
    See Also:
    eachLine(java.io.InputStream, int, groovy.lang.Closure)
    Since:
    1.5.6
  - <T> public static T eachLine(InputStream stream, int firstLine, @ClosureParams(value=FromString.class,options={"String","String,Integer"})
    Closure<T> closure)
    
    Iterates through this stream, passing each line to the given 1 or 2 arg closure. The stream is closed before this method returns.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    stream - a stream
    firstLine - the line number value used for the first line (default is 1, set to 0 to start counting from 0)
    closure - a closure (arg 1 is line, optional arg 2 is line number)
    Returns:
    the last value returned by the closure
    See Also:
    eachLine(java.io.Reader, int, groovy.lang.Closure)
    Since:
    1.5.7
  - <T> public static T eachLine(Reader self, @ClosureParams(value=FromString.class,options={"String","String,Integer"})
    Closure<T> closure)
    
    Iterates through the given reader line by line. Each line is passed to the given 1 or 2 arg closure. If the closure has two arguments, the line count is passed as the second argument. The Reader is closed before this method returns.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    self - a Reader, closed after the method returns
    closure - a closure (arg 1 is line, optional arg 2 is line number starting at line 1)
    Returns:
    the last value returned by the closure
    See Also:
    eachLine(java.io.Reader, int, groovy.lang.Closure)
    Since:
    1.5.6
  - <T> public static T eachLine(Reader self, int firstLine, @ClosureParams(value=FromString.class,options={"String","String,Integer"})
    Closure<T> closure)
    
    Iterates through the given reader line by line. Each line is passed to the given 1 or 2 arg closure. If the closure has two arguments, the line count is passed as the second argument. The Reader is closed before this method returns.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    self - a Reader, closed after the method returns
    firstLine - the line number value used for the first line (default is 1, set to 0 to start counting from 0)
    closure - a closure which will be passed each line (or for 2 arg closures the line and line count)
    Returns:
    the last value returned by the closure
    Since:
    1.5.7
  - public static void eachObject(ObjectInputStream ois, Closure closure)
    
    Iterates through the given object stream object by object. The ObjectInputStream is closed afterwards.
    throws:
    IOException if an IOException occurs.
    throws:
    ClassNotFoundException if the class is not found.
    
    Parameters:
    ois - an ObjectInputStream, closed after the operation
    closure - a closure
    Since:
    1.0
  - public static void filterLine(Reader reader, Writer writer, @ClosureParams(value=SimpleType.class, options="java.lang.String")
    Closure closure)
    
    Filter the lines from a reader and write them on the writer, according to a closure which returns true if the line should be included. Both Reader and Writer are closed after the operation.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    reader - a reader, closed after the call
    writer - a writer, closed after the call
    closure - the closure which returns booleans
    Since:
    1.0
  - public static Writable filterLine(Reader reader, @ClosureParams(value=SimpleType.class, options="java.lang.String")
    Closure closure)
    
    Filter the lines from this Reader, and return a Writable which can be used to stream the filtered lines to a destination. The closure should return true if the line should be passed to the writer.
    Parameters:
    reader - this reader
    closure - a closure used for filtering
    Returns:
    a Writable which will use the closure to filter each line from the reader when the Writable#writeTo(Writer) is called.
    Since:
    1.0
  - public static Writable filterLine(InputStream self, @ClosureParams(value=SimpleType.class, options="java.lang.String")
    Closure predicate)
    
    Filter lines from an input stream using a closure predicate. The closure will be passed each line as a String, and it should return true if the line should be passed to the writer.
    Parameters:
    self - an input stream
    predicate - a closure which returns boolean and takes a line
    Returns:
    a writable which writes out the filtered lines
    See Also:
    filterLine(java.io.Reader, groovy.lang.Closure)
    Since:
    1.0
  - public static Writable filterLine(InputStream self, String charset, @ClosureParams(value=SimpleType.class, options="java.lang.String")
    Closure predicate)
    
    Filter lines from an input stream using a closure predicate. The closure will be passed each line as a String, and it should return true if the line should be passed to the writer.
    throws:
    UnsupportedEncodingException if the encoding specified is not supported
    
    Parameters:
    self - an input stream
    charset - opens the stream with a specified charset
    predicate - a closure which returns boolean and takes a line
    Returns:
    a writable which writes out the filtered lines
    See Also:
    filterLine(java.io.Reader, groovy.lang.Closure)
    Since:
    1.6.8
  - public static void filterLine(InputStream self, Writer writer, @ClosureParams(value=SimpleType.class, options="java.lang.String")
    Closure predicate)
    
    Uses a closure to filter lines from this InputStream and pass them to the given writer. The closure will be passed each line as a String, and it should return true if the line should be passed to the writer.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    self - the InputStream
    writer - a writer to write output to
    predicate - a closure which returns true if a line should be accepted
    See Also:
    filterLine(java.io.Reader, java.io.Writer, groovy.lang.Closure)
    Since:
    1.0
  - public static void filterLine(InputStream self, Writer writer, String charset, @ClosureParams(value=SimpleType.class, options="java.lang.String")
    Closure predicate)
    
    Uses a closure to filter lines from this InputStream and pass them to the given writer. The closure will be passed each line as a String, and it should return true if the line should be passed to the writer.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    self - the InputStream
    writer - a writer to write output to
    charset - opens the stream with a specified charset
    predicate - a closure which returns true if a line should be accepted
    See Also:
    filterLine(java.io.Reader, java.io.Writer, groovy.lang.Closure)
    Since:
    1.6.8
  - public static byte[] getBytes(InputStream is)
    
    Read the content of this InputStream and return it as a byte[]. The stream is closed before this method returns.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    is - an input stream
    Returns:
    the byte[] from that InputStream
    Since:
    1.7.1
  - public static String getText(InputStream is)
    
    Read the content of this InputStream and return it as a String. The stream is closed before this method returns.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    is - an input stream
    Returns:
    the text from that URL
    Since:
    1.0
  - public static String getText(InputStream is, String charset)
    
    Read the content of this InputStream using specified charset and return it as a String. The stream is closed before this method returns.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    is - an input stream
    charset - opens the stream with a specified charset
    Returns:
    the text from that URL
    Since:
    1.0
  - public static String getText(Reader reader)
    
    Read the content of the Reader and return it as a String. The reader is closed before this method returns.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    reader - a Reader whose content we want to read
    Returns:
    a String containing the content of the buffered reader
    See Also:
    getText(java.io.BufferedReader)
    Since:
    1.0
  - public static String getText(BufferedReader reader)
    
    Read the content of the BufferedReader and return it as a String. The BufferedReader is closed afterwards.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    reader - a BufferedReader whose content we want to read
    Returns:
    a String containing the content of the buffered reader
    Since:
    1.0
  - @Override
    public boolean hasNext()
  - @Override
    public boolean hasNext()
  - public static Iterator<String> iterator(Reader self)
    
    Creates an iterator which will traverse through the reader a line at a time.
    Parameters:
    self - a Reader object
    Returns:
    an Iterator for the Reader
    See Also:
    BufferedReader.readLine
    Since:
    1.5.0
  - public static Iterator<Byte> iterator(InputStream self)
    
    Standard iterator for an input stream which iterates through the stream content in a byte-based fashion.
    Parameters:
    self - an InputStream object
    Returns:
    an Iterator for the InputStream
    Since:
    1.5.0
  - public static Iterator<Byte> iterator(DataInputStream self)
    
    Standard iterator for a data input stream which iterates through the stream content a Byte at a time.
    Parameters:
    self - a DataInputStream object
    Returns:
    an Iterator for the DataInputStream
    Since:
    1.5.0
  - public static Writer leftShift(Writer self, Object value)
    
    Overloads the leftShift operator for Writer to allow an object to be written using Groovy's default representation for the object.
    throws:
    IOException if an I/O error occurs.
    
    Parameters:
    self - a Writer
    value - an Object whose default representation will be written to the Writer
    Returns:
    the writer on which this operation was invoked
    Since:
    1.0
  - public static Appendable leftShift(Appendable self, Object value)
    
    Overloads the leftShift operator for Appendable to allow an object to be appended using Groovy's default representation for the object.
    throws:
    IOException if an I/O error occurs.
    
    Parameters:
    self - an Appendable
    value - an Object whose default representation will be appended to the Appendable
    Returns:
    the Appendable on which this operation was invoked
    Since:
    2.1.0
  - public static Writer leftShift(OutputStream self, Object value)
  - public static void leftShift(ObjectOutputStream self, Object value)
    
    Overloads the leftShift operator to add objects to an ObjectOutputStream.
    throws:
    IOException if an I/O error occurs.
    
    Parameters:
    self - an ObjectOutputStream
    value - an object to write to the stream
    Since:
    1.5.0
  - public static OutputStream leftShift(OutputStream self, InputStream in)
    
    Pipe an InputStream into an OutputStream for efficient stream copying.
    throws:
    IOException if an I/O error occurs.
    
    Parameters:
    self - stream on which to write
    in - stream to read from
    Returns:
    the outputstream itself
    Since:
    1.0
  - public static OutputStream leftShift(OutputStream self, byte[] value)
    
    Overloads the leftShift operator to provide an append mechanism to add bytes to a stream.
    throws:
    IOException if an I/O error occurs.
    
    Parameters:
    self - an OutputStream
    value - a value to append
    Returns:
    an OutputStream
    Since:
    1.0
  - public static ObjectInputStream newObjectInputStream(InputStream inputStream)
    
    Create an object input stream for this input stream.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    inputStream - an input stream
    Returns:
    an object input stream
    Since:
    1.5.0
  - public static ObjectInputStream newObjectInputStream(InputStream inputStream, ClassLoader classLoader)
    
    Create an object input stream for this input stream using the given class loader.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    inputStream - an input stream
    classLoader - the class loader to use when loading the class
    Returns:
    an object input stream
    Since:
    1.5.0
  - public static ObjectOutputStream newObjectOutputStream(OutputStream outputStream)
    
    Create an object output stream for this output stream.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    outputStream - an output stream
    Returns:
    an object output stream
    Since:
    1.5.0
  - public static PrintWriter newPrintWriter(Writer writer)
    
    Create a new PrintWriter for this Writer.
    Parameters:
    writer - a Writer
    Returns:
    a PrintWriter
    Since:
    1.6.0
  - public static PrintWriter newPrintWriter(OutputStream stream)
    
    Create a new PrintWriter for this OutputStream.
    Parameters:
    stream - an OutputStream
    Returns:
    a PrintWriter
    Since:
    2.2.0
  - public static BufferedReader newReader(InputStream self)
    
    Creates a reader for this input stream.
    Parameters:
    self - an input stream
    Returns:
    a reader
    Since:
    1.0
  - public static BufferedReader newReader(InputStream self, String charset)
    
    Creates a reader for this input stream, using the specified charset as the encoding.
    throws:
    UnsupportedEncodingException if the encoding specified is not supported
    
    Parameters:
    self - an input stream
    charset - the charset for this input stream
    Returns:
    a reader
    Since:
    1.6.0
  - public static Writer newWriter(OutputStream stream)
    
    Creates a writer for this stream.
    Parameters:
    stream - the stream which is used and then closed
    Returns:
    the newly created Writer
    Since:
    2.2.0
  - public static Writer newWriter(OutputStream stream, String charset)
    
    Creates a writer for this stream using the given charset.
    throws:
    UnsupportedEncodingException if an encoding exception occurs.
    
    Parameters:
    stream - the stream which is used and then closed
    charset - the charset used
    Returns:
    the newly created Writer
    Since:
    2.2.0
  - @Override
    public String next()
  - @Override
    public Byte next()
  - public static String readLine(Reader self)
    
    Read a single, whole line from the given Reader. This method is designed for use with Readers that support the mark() operation like BufferReader. It has a fallback behavior for Readers that don't support mark() but the behavior doesn't correctly detect multi-character line termination (e.g. carriage return followed by linefeed). We recommend for Readers that don't support mark() you consider using one of the following methods instead: eachLine, readLines, or iterator.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    self - a Reader
    Returns:
    a line
    See Also:
    readLines(java.io.Reader)
    iterator(java.io.Reader)
    eachLine(java.io.Reader, groovy.lang.Closure)
    Since:
    1.0
  - public static List<String> readLines(InputStream stream)
    
    Reads the stream into a list, with one element for each line.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    stream - a stream
    Returns:
    a List of lines
    See Also:
    readLines(java.io.Reader)
    Since:
    1.0
  - public static List<String> readLines(InputStream stream, String charset)
    
    Reads the stream into a list, with one element for each line.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    stream - a stream
    charset - opens the stream with a specified charset
    Returns:
    a List of lines
    See Also:
    readLines(java.io.Reader)
    Since:
    1.6.8
  - public static List<String> readLines(Reader reader)
    
    Reads the reader into a list of Strings, with one entry for each line. The reader is closed before this method returns.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    reader - a Reader
    Returns:
    a List of lines
    Since:
    1.0
  - @Override
    public void remove()
  - @Override
    public void remove()
  - @Override
    protected Class<?> resolveClass(ObjectStreamClass desc)
  - public static void setBytes(OutputStream os, byte[] bytes)
    
    Write the byte[] to the output stream. The stream is closed before this method returns.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    os - an output stream
    bytes - the byte[] to write to the output stream
    Since:
    1.7.1
  - <T> public static T splitEachLine(Reader self, String regex, @ClosureParams(value=FromString.class,options={"List","String[]"},conflictResolutionStrategy=PickFirstResolver.class)
    Closure<T> closure)
    
    Iterates through the given reader line by line, splitting each line using the given regex separator. For each line, the given closure is called with a single parameter being the list of strings computed by splitting the line around matches of the given regular expression. The Reader is closed afterwards.
    Here is an example:
```
 def s = 'The 3 quick\nbrown 4 fox'
 def result = ''
 new StringReader(s).splitEachLine(/\d/){ parts ->
     result += "${parts[0]}_${parts[1]}|"
 }
 assert result == 'The _ quick|brown _ fox|'
 
```
    throws:
    IOException if an IOException occurs.
    throws:
    java.util.regex.PatternSyntaxException if the regular expression's syntax is invalid
    
    Parameters:
    self - a Reader, closed after the method returns
    regex - the delimiting regular expression
    closure - a closure
    Returns:
    the last value returned by the closure
    See Also:
    String.split
    Since:
    1.5.5
  - <T> public static T splitEachLine(Reader self, Pattern pattern, @ClosureParams(value=FromString.class,options={"List","String[]"},conflictResolutionStrategy=PickFirstResolver.class)
    Closure<T> closure)
    
    Iterates through the given reader line by line, splitting each line using the given regex separator Pattern. For each line, the given closure is called with a single parameter being the list of strings computed by splitting the line around matches of the given regular expression. The Reader is closed afterwards.
    Here is an example:
```
 def s = 'The 3 quick\nbrown 4 fox'
 def result = ''
 new StringReader(s).splitEachLine(~/\d/){ parts ->
     result += "${parts[0]}_${parts[1]}|"
 }
 assert result == 'The _ quick|brown _ fox|'
 
```
    throws:
    IOException if an IOException occurs.
    throws:
    java.util.regex.PatternSyntaxException if the regular expression's syntax is invalid
    
    Parameters:
    self - a Reader, closed after the method returns
    pattern - the regular expression Pattern for the delimiter
    closure - a closure
    Returns:
    the last value returned by the closure
    See Also:
    String.split
    Since:
    1.6.8
  - <T> public static T splitEachLine(InputStream stream, String regex, String charset, @ClosureParams(value=FromString.class,options={"List","String[]"},conflictResolutionStrategy=PickFirstResolver.class)
    Closure<T> closure)
    
    Iterates through the given InputStream line by line using the specified encoding, splitting each line using the given separator. The list of tokens for each line is then passed to the given closure. Finally, the stream is closed.
    throws:
    IOException if an IOException occurs.
    throws:
    java.util.regex.PatternSyntaxException if the regular expression's syntax is invalid
    
    Parameters:
    stream - an InputStream
    regex - the delimiting regular expression
    charset - opens the stream with a specified charset
    closure - a closure
    Returns:
    the last value returned by the closure
    See Also:
    splitEachLine(java.io.Reader, java.lang.String, groovy.lang.Closure)
    Since:
    1.5.5
  - <T> public static T splitEachLine(InputStream stream, Pattern pattern, String charset, @ClosureParams(value=FromString.class,options={"List","String[]"},conflictResolutionStrategy=PickFirstResolver.class)
    Closure<T> closure)
    
    Iterates through the given InputStream line by line using the specified encoding, splitting each line using the given separator Pattern. The list of tokens for each line is then passed to the given closure. Finally, the stream is closed.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    stream - an InputStream
    pattern - the regular expression Pattern for the delimiter
    charset - opens the stream with a specified charset
    closure - a closure
    Returns:
    the last value returned by the closure
    See Also:
    splitEachLine(java.io.Reader, java.util.regex.Pattern, groovy.lang.Closure)
    Since:
    1.6.8
  - <T> public static T splitEachLine(InputStream stream, String regex, @ClosureParams(value=FromString.class,options={"List","String[]"},conflictResolutionStrategy=PickFirstResolver.class)
    Closure<T> closure)
    
    Iterates through the given InputStream line by line, splitting each line using the given separator. The list of tokens for each line is then passed to the given closure. The stream is closed before the method returns.
    throws:
    IOException if an IOException occurs.
    throws:
    java.util.regex.PatternSyntaxException if the regular expression's syntax is invalid
    
    Parameters:
    stream - an InputStream
    regex - the delimiting regular expression
    closure - a closure
    Returns:
    the last value returned by the closure
    See Also:
    splitEachLine(java.io.Reader, java.lang.String, groovy.lang.Closure)
    Since:
    1.5.6
  - <T> public static T splitEachLine(InputStream stream, Pattern pattern, @ClosureParams(value=FromString.class,options={"List","String[]"},conflictResolutionStrategy=PickFirstResolver.class)
    Closure<T> closure)
    
    Iterates through the given InputStream line by line, splitting each line using the given separator Pattern. The list of tokens for each line is then passed to the given closure. The stream is closed before the method returns.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    stream - an InputStream
    pattern - the regular expression Pattern for the delimiter
    closure - a closure
    Returns:
    the last value returned by the closure
    See Also:
    splitEachLine(java.io.Reader, java.util.regex.Pattern, groovy.lang.Closure)
    Since:
    1.6.8
  - @Override
    public String toString()
  - public static void transformChar(Reader self, Writer writer, @ClosureParams(value=SimpleType.class, options="java.lang.String")
    Closure closure)
    
    Transforms each character from this reader by passing it to the given closure. The Closure should return each transformed character, which will be passed to the Writer. The reader and writer will both be closed before this method returns.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    self - a Reader object
    writer - a Writer to receive the transformed characters
    closure - a closure that performs the required transformation
    Since:
    1.5.0
  - public static void transformLine(Reader reader, Writer writer, @ClosureParams(value=SimpleType.class, options="java.lang.String")
    Closure closure)
    
    Transforms the lines from a reader with a Closure and write them to a writer. Both Reader and Writer are closed after the operation.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    reader - Lines of text to be transformed. Reader is closed afterwards.
    writer - Where transformed lines are written. Writer is closed afterwards.
    closure - Single parameter closure that is called to transform each line of text from the reader, before writing it to the writer.
    Since:
    1.0
  - <T, U extends Closeable> public static T withCloseable(U self, @ClosureParams(value=FirstParam.class)
    Closure<T> action)
    
    Allows this closeable to be used within the closure, ensuring that it is closed once the closure has been executed and before this method returns.
    As with the try-with-resources statement, if multiple exceptions are thrown the exception from the closure will be returned and the exception from closing will be added as a suppressed exception.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    self - the Closeable
    action - the closure taking the Closeable as parameter
    Returns:
    the value returned by the closure
    Since:
    2.4.0
  - <T, U extends AutoCloseable> public static T withCloseable(U self, @ClosureParams(value=FirstParam.class)
    Closure<T> action)
    
    Allows this AutoCloseable to be used within the closure, ensuring that it is closed once the closure has been executed and before this method returns.
    As with the try-with-resources statement, if multiple exceptions are thrown the exception from the closure will be returned and the exception from closing will be added as a suppressed exception.
    throws:
    Exception if an Exception occurs.
    
    Parameters:
    self - the AutoCloseable
    action - the closure taking the AutoCloseable as parameter
    Returns:
    the value returned by the closure
    Since:
    2.5.0
  - public static Appendable withFormatter(Appendable self, @ClosureParams(value=SimpleType.class, options="java.util.Formatter")
    Closure closure)
    
    Invokes a Closure that uses a Formatter taking care of resource handling. A Formatter is created and passed to the Closure as its argument. After the Closure executes, the Formatter is flushed and closed releasing any associated resources.
    Parameters:
    self - an Appendable
    closure - a 1-arg Closure which will be called with a Formatter as its argument
    Returns:
    the Appendable on which this operation was invoked
    Since:
    2.1.0
  - public static Appendable withFormatter(Appendable self, Locale locale, @ClosureParams(value=SimpleType.class, options="java.util.Formatter")
    Closure closure)
    
    Invokes a Closure that uses a Formatter taking care of resource handling. A Formatter is created using the given Locale and passed to the Closure as its argument. After the Closure executes, the Formatter is flushed and closed releasing any associated resources.
    Parameters:
    self - an Appendable
    locale - a Locale used when creating the Formatter
    closure - a 1-arg Closure which will be called with a Formatter as its argument
    Returns:
    the Appendable on which this operation was invoked
    Since:
    2.1.0
  - <T> public static T withObjectInputStream(InputStream inputStream, @ClosureParams(value=SimpleType.class, options="java.io.ObjectInputStream")
    Closure<T> closure)
    
    Create a new ObjectInputStream for this input stream and pass it to the closure. This method ensures the stream is closed after the closure returns.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    inputStream - an input stream
    closure - a closure
    Returns:
    the value returned by the closure
    See Also:
    withStream(java.io.InputStream, groovy.lang.Closure)
    Since:
    1.5.0
  - <T> public static T withObjectInputStream(InputStream inputStream, ClassLoader classLoader, @ClosureParams(value=SimpleType.class, options="java.io.ObjectInputStream")
    Closure<T> closure)
    
    Create a new ObjectInputStream for this input stream and pass it to the closure. This method ensures the stream is closed after the closure returns.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    inputStream - an input stream
    classLoader - the class loader to use when loading the class
    closure - a closure
    Returns:
    the value returned by the closure
    See Also:
    withStream(java.io.InputStream, groovy.lang.Closure)
    Since:
    1.5.0
  - <T> public static T withObjectOutputStream(OutputStream outputStream, @ClosureParams(value=SimpleType.class, options="java.io.ObjectOutputStream")
    Closure<T> closure)
    
    Create a new ObjectOutputStream for this output stream and then pass it to the closure. This method ensures the stream is closed after the closure returns.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    outputStream - am output stream
    closure - a closure
    Returns:
    the value returned by the closure
    See Also:
    withStream(java.io.OutputStream, groovy.lang.Closure)
    Since:
    1.5.0
  - <T> public static T withPrintWriter(Writer writer, @ClosureParams(value=SimpleType.class, options="java.io.PrintWriter")
    Closure<T> closure)
    
    Create a new PrintWriter for this Writer. The writer is passed to the closure, and will be closed before this method returns.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    writer - a writer
    closure - the closure to invoke with the PrintWriter
    Returns:
    the value returned by the closure
    Since:
    1.6.0
  - <T> public static T withPrintWriter(OutputStream stream, @ClosureParams(value=SimpleType.class, options="java.io.PrintWriter")
    Closure<T> closure)
    
    Create a new PrintWriter for this OutputStream. The writer is passed to the closure, and will be closed before this method returns.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    stream - an OutputStream
    closure - the closure to invoke with the PrintWriter
    Returns:
    the value returned by the closure
    Since:
    2.2.0
  - <T> public static T withReader(Reader reader, @ClosureParams(FirstParam.class)
    Closure<T> closure)
    
    Allows this reader to be used within the closure, ensuring that it is closed before this method returns.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    reader - the reader which is used and then closed
    closure - the closure that the writer is passed into
    Returns:
    the value returned by the closure
    Since:
    1.5.2
  - <T> public static T withReader(InputStream in, @ClosureParams(value=SimpleType.class, options="java.io.Reader")
    Closure<T> closure)
    
    Helper method to create a new Reader for a stream and then passes it into the closure. The reader (and this stream) is closed after the closure returns.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    in - a stream
    closure - the closure to invoke with the InputStream
    Returns:
    the value returned by the closure
    See Also:
    InputStreamReader
    Since:
    1.5.2
  - <T> public static T withReader(InputStream in, String charset, @ClosureParams(value=SimpleType.class, options="java.io.Reader")
    Closure<T> closure)
    
    Helper method to create a new Reader for a stream and then passes it into the closure. The reader (and this stream) is closed after the closure returns.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    in - a stream
    charset - the charset used to decode the stream
    closure - the closure to invoke with the reader
    Returns:
    the value returned by the closure
    See Also:
    InputStreamReader
    Since:
    1.5.6
  - <T, U extends InputStream> public static T withStream(U stream, @ClosureParams(value=FirstParam.class)
    Closure<T> closure)
    
    Allows this input stream to be used within the closure, ensuring that it is flushed and closed before this method returns.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    stream - the stream which is used and then closed
    closure - the closure that the stream is passed into
    Returns:
    the value returned by the closure
    Since:
    1.5.2
  - <T, U extends OutputStream> public static T withStream(U os, @ClosureParams(value=FirstParam.class)
    Closure<T> closure)
    
    Passes this OutputStream to the closure, ensuring that the stream is closed after the closure returns, regardless of errors.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    os - the stream which is used and then closed
    closure - the closure that the stream is passed into
    Returns:
    the value returned by the closure
    Since:
    1.5.2
  - <T> public static T withWriter(Writer writer, @ClosureParams(FirstParam.class)
    Closure<T> closure)
    
    Allows this writer to be used within the closure, ensuring that it is flushed and closed before this method returns.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    writer - the writer which is used and then closed
    closure - the closure that the writer is passed into
    Returns:
    the value returned by the closure
    Since:
    1.5.2
  - <T> public static T withWriter(OutputStream stream, @ClosureParams(value=SimpleType.class, options="java.io.Writer")
    Closure<T> closure)
    
    Creates a writer from this stream, passing it to the given closure. This method ensures the stream is closed after the closure returns.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    stream - the stream which is used and then closed
    closure - the closure that the writer is passed into
    Returns:
    the value returned by the closure
    See Also:
    withWriter(java.io.Writer, groovy.lang.Closure)
    Since:
    1.5.2
  - <T> public static T withWriter(OutputStream stream, String charset, @ClosureParams(value=SimpleType.class, options="java.io.Writer")
    Closure<T> closure)
    
    Creates a writer from this stream, passing it to the given closure. This method ensures the stream is closed after the closure returns.
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    stream - the stream which is used and then closed
    charset - the charset used
    closure - the closure that the writer is passed into
    Returns:
    the value returned by the closure
    See Also:
    withWriter(java.io.Writer, groovy.lang.Closure)
    Since:
    1.5.2
  - public static void write(Writer self, Writable writable)
    
    A helper method so that dynamic dispatch of the writer.write(object) method will always use the more efficient Writable.writeTo(writer) mechanism if the object implements the Writable interface.
    throws:
    IOException if an I/O error occurs.
    
    Parameters:
    self - a Writer
    writable - an object implementing the Writable interface
    Since:
    1.0
  - public static void writeLine(BufferedWriter writer, String line)
    
    Write the text and append a newline (using the platform's line-ending).
    throws:
    IOException if an IOException occurs.
    
    Parameters:
    writer - a BufferedWriter
    line - the line to write
    Since:
    1.0
  - @Override
    public Writer writeTo(Writer out)

Summary:
Method

| Detail:
Method

[Java] Class IOGroovyMethods

Methods Summary

Inherited Methods Summary

Method Detail

public static void eachByte(InputStream is, @ClosureParams(value=SimpleType.class, options="byte")Closure closure)

public static void eachByte(InputStream is, int bufferLen, @ClosureParams(value=FromString.class, options="byte[],Integer")Closure closure)

<T> public static T eachLine(InputStream stream, String charset, @ClosureParams(value=FromString.class,options={"String","String,Integer"})Closure<T> closure)

<T> public static T eachLine(InputStream stream, String charset, int firstLine, @ClosureParams(value=FromString.class,options={"String","String,Integer"})Closure<T> closure)

<T> public static T eachLine(InputStream stream, @ClosureParams(value=FromString.class,options={"String","String,Integer"})Closure<T> closure)

<T> public static T eachLine(InputStream stream, int firstLine, @ClosureParams(value=FromString.class,options={"String","String,Integer"})Closure<T> closure)

<T> public static T eachLine(Reader self, @ClosureParams(value=FromString.class,options={"String","String,Integer"})Closure<T> closure)

<T> public static T eachLine(Reader self, int firstLine, @ClosureParams(value=FromString.class,options={"String","String,Integer"})Closure<T> closure)

public static void eachObject(ObjectInputStream ois, Closure closure)

public static void filterLine(Reader reader, Writer writer, @ClosureParams(value=SimpleType.class, options="java.lang.String")Closure closure)

public static Writable filterLine(Reader reader, @ClosureParams(value=SimpleType.class, options="java.lang.String")Closure closure)

public static Writable filterLine(InputStream self, @ClosureParams(value=SimpleType.class, options="java.lang.String")Closure predicate)

public static Writable filterLine(InputStream self, String charset, @ClosureParams(value=SimpleType.class, options="java.lang.String")Closure predicate)

public static void filterLine(InputStream self, Writer writer, @ClosureParams(value=SimpleType.class, options="java.lang.String")Closure predicate)

public static void filterLine(InputStream self, Writer writer, String charset, @ClosureParams(value=SimpleType.class, options="java.lang.String")Closure predicate)

public static byte[] getBytes(InputStream is)

public static String getText(InputStream is)

public static String getText(InputStream is, String charset)

public static String getText(Reader reader)

public static String getText(BufferedReader reader)

@Overridepublic boolean hasNext()

@Overridepublic boolean hasNext()

public static Iterator<String> iterator(Reader self)

public static Iterator<Byte> iterator(InputStream self)

public static Iterator<Byte> iterator(DataInputStream self)

public static Writer leftShift(Writer self, Object value)

public static Appendable leftShift(Appendable self, Object value)

public static Writer leftShift(OutputStream self, Object value)

public static void leftShift(ObjectOutputStream self, Object value)

public static OutputStream leftShift(OutputStream self, InputStream in)

public static OutputStream leftShift(OutputStream self, byte[] value)

public static ObjectInputStream newObjectInputStream(InputStream inputStream)

public static ObjectInputStream newObjectInputStream(InputStream inputStream, ClassLoader classLoader)

public static ObjectOutputStream newObjectOutputStream(OutputStream outputStream)

public static PrintWriter newPrintWriter(Writer writer)

public static PrintWriter newPrintWriter(OutputStream stream)

public static BufferedReader newReader(InputStream self)

public static BufferedReader newReader(InputStream self, String charset)

public static Writer newWriter(OutputStream stream)

public static Writer newWriter(OutputStream stream, String charset)

@Overridepublic String next()

@Overridepublic Byte next()

public static String readLine(Reader self)

public static List<String> readLines(InputStream stream)

public static List<String> readLines(InputStream stream, String charset)

public static List<String> readLines(Reader reader)

@Overridepublic void remove()

@Overridepublic void remove()

@Overrideprotected Class<?> resolveClass(ObjectStreamClass desc)

public static void setBytes(OutputStream os, byte[] bytes)

<T> public static T splitEachLine(Reader self, String regex, @ClosureParams(value=FromString.class,options={"List","String[]"},conflictResolutionStrategy=PickFirstResolver.class)Closure<T> closure)

<T> public static T splitEachLine(Reader self, Pattern pattern, @ClosureParams(value=FromString.class,options={"List","String[]"},conflictResolutionStrategy=PickFirstResolver.class)Closure<T> closure)

<T> public static T splitEachLine(InputStream stream, String regex, String charset, @ClosureParams(value=FromString.class,options={"List","String[]"},conflictResolutionStrategy=PickFirstResolver.class)Closure<T> closure)

<T> public static T splitEachLine(InputStream stream, Pattern pattern, String charset, @ClosureParams(value=FromString.class,options={"List","String[]"},conflictResolutionStrategy=PickFirstResolver.class)Closure<T> closure)

<T> public static T splitEachLine(InputStream stream, String regex, @ClosureParams(value=FromString.class,options={"List","String[]"},conflictResolutionStrategy=PickFirstResolver.class)Closure<T> closure)

<T> public static T splitEachLine(InputStream stream, Pattern pattern, @ClosureParams(value=FromString.class,options={"List","String[]"},conflictResolutionStrategy=PickFirstResolver.class)Closure<T> closure)

@Overridepublic String toString()

public static void transformChar(Reader self, Writer writer, @ClosureParams(value=SimpleType.class, options="java.lang.String")Closure closure)

public static void transformLine(Reader reader, Writer writer, @ClosureParams(value=SimpleType.class, options="java.lang.String")Closure closure)

<T, U extends Closeable> public static T withCloseable(U self, @ClosureParams(value=FirstParam.class)Closure<T> action)

<T, U extends AutoCloseable> public static T withCloseable(U self, @ClosureParams(value=FirstParam.class)Closure<T> action)

public static Appendable withFormatter(Appendable self, @ClosureParams(value=SimpleType.class, options="java.util.Formatter")Closure closure)

public static Appendable withFormatter(Appendable self, Locale locale, @ClosureParams(value=SimpleType.class, options="java.util.Formatter")Closure closure)

<T> public static T withObjectInputStream(InputStream inputStream, @ClosureParams(value=SimpleType.class, options="java.io.ObjectInputStream")Closure<T> closure)

<T> public static T withObjectInputStream(InputStream inputStream, ClassLoader classLoader, @ClosureParams(value=SimpleType.class, options="java.io.ObjectInputStream")Closure<T> closure)

<T> public static T withObjectOutputStream(OutputStream outputStream, @ClosureParams(value=SimpleType.class, options="java.io.ObjectOutputStream")Closure<T> closure)

<T> public static T withPrintWriter(Writer writer, @ClosureParams(value=SimpleType.class, options="java.io.PrintWriter")Closure<T> closure)

<T> public static T withPrintWriter(OutputStream stream, @ClosureParams(value=SimpleType.class, options="java.io.PrintWriter")Closure<T> closure)

<T> public static T withReader(Reader reader, @ClosureParams(FirstParam.class)Closure<T> closure)

<T> public static T withReader(InputStream in, @ClosureParams(value=SimpleType.class, options="java.io.Reader")Closure<T> closure)

<T> public static T withReader(InputStream in, String charset, @ClosureParams(value=SimpleType.class, options="java.io.Reader")Closure<T> closure)

<T, U extends InputStream> public static T withStream(U stream, @ClosureParams(value=FirstParam.class)Closure<T> closure)

<T, U extends OutputStream> public static T withStream(U os, @ClosureParams(value=FirstParam.class)Closure<T> closure)

<T> public static T withWriter(Writer writer, @ClosureParams(FirstParam.class)Closure<T> closure)

<T> public static T withWriter(OutputStream stream, @ClosureParams(value=SimpleType.class, options="java.io.Writer")Closure<T> closure)

<T> public static T withWriter(OutputStream stream, String charset, @ClosureParams(value=SimpleType.class, options="java.io.Writer")Closure<T> closure)

public static void eachByte(InputStream is, @ClosureParams(value=SimpleType.class, options="byte")
Closure closure)

public static void eachByte(InputStream is, int bufferLen, @ClosureParams(value=FromString.class, options="byte[],Integer")
Closure closure)

<T> public static T eachLine(InputStream stream, String charset, @ClosureParams(value=FromString.class,options={"String","String,Integer"})
Closure<T> closure)

<T> public static T eachLine(InputStream stream, String charset, int firstLine, @ClosureParams(value=FromString.class,options={"String","String,Integer"})
Closure<T> closure)

<T> public static T eachLine(InputStream stream, @ClosureParams(value=FromString.class,options={"String","String,Integer"})
Closure<T> closure)

<T> public static T eachLine(InputStream stream, int firstLine, @ClosureParams(value=FromString.class,options={"String","String,Integer"})
Closure<T> closure)

<T> public static T eachLine(Reader self, @ClosureParams(value=FromString.class,options={"String","String,Integer"})
Closure<T> closure)

<T> public static T eachLine(Reader self, int firstLine, @ClosureParams(value=FromString.class,options={"String","String,Integer"})
Closure<T> closure)

public static void filterLine(Reader reader, Writer writer, @ClosureParams(value=SimpleType.class, options="java.lang.String")
Closure closure)

public static Writable filterLine(Reader reader, @ClosureParams(value=SimpleType.class, options="java.lang.String")
Closure closure)

public static Writable filterLine(InputStream self, @ClosureParams(value=SimpleType.class, options="java.lang.String")
Closure predicate)

public static Writable filterLine(InputStream self, String charset, @ClosureParams(value=SimpleType.class, options="java.lang.String")
Closure predicate)

public static void filterLine(InputStream self, Writer writer, @ClosureParams(value=SimpleType.class, options="java.lang.String")
Closure predicate)

public static void filterLine(InputStream self, Writer writer, String charset, @ClosureParams(value=SimpleType.class, options="java.lang.String")
Closure predicate)

@Override
public boolean hasNext()

@Override
public boolean hasNext()

@Override
public String next()

@Override
public Byte next()

@Override
public void remove()

@Override
public void remove()

@Override
protected Class<?> resolveClass(ObjectStreamClass desc)

<T> public static T splitEachLine(Reader self, String regex, @ClosureParams(value=FromString.class,options={"List","String[]"},conflictResolutionStrategy=PickFirstResolver.class)
Closure<T> closure)

<T> public static T splitEachLine(Reader self, Pattern pattern, @ClosureParams(value=FromString.class,options={"List","String[]"},conflictResolutionStrategy=PickFirstResolver.class)
Closure<T> closure)

<T> public static T splitEachLine(InputStream stream, String regex, String charset, @ClosureParams(value=FromString.class,options={"List","String[]"},conflictResolutionStrategy=PickFirstResolver.class)
Closure<T> closure)

<T> public static T splitEachLine(InputStream stream, Pattern pattern, String charset, @ClosureParams(value=FromString.class,options={"List","String[]"},conflictResolutionStrategy=PickFirstResolver.class)
Closure<T> closure)

<T> public static T splitEachLine(InputStream stream, String regex, @ClosureParams(value=FromString.class,options={"List","String[]"},conflictResolutionStrategy=PickFirstResolver.class)
Closure<T> closure)

<T> public static T splitEachLine(InputStream stream, Pattern pattern, @ClosureParams(value=FromString.class,options={"List","String[]"},conflictResolutionStrategy=PickFirstResolver.class)
Closure<T> closure)

@Override
public String toString()

public static void transformChar(Reader self, Writer writer, @ClosureParams(value=SimpleType.class, options="java.lang.String")
Closure closure)

public static void transformLine(Reader reader, Writer writer, @ClosureParams(value=SimpleType.class, options="java.lang.String")
Closure closure)

<T, U extends Closeable> public static T withCloseable(U self, @ClosureParams(value=FirstParam.class)
Closure<T> action)

<T, U extends AutoCloseable> public static T withCloseable(U self, @ClosureParams(value=FirstParam.class)
Closure<T> action)

public static Appendable withFormatter(Appendable self, @ClosureParams(value=SimpleType.class, options="java.util.Formatter")
Closure closure)

public static Appendable withFormatter(Appendable self, Locale locale, @ClosureParams(value=SimpleType.class, options="java.util.Formatter")
Closure closure)

<T> public static T withObjectInputStream(InputStream inputStream, @ClosureParams(value=SimpleType.class, options="java.io.ObjectInputStream")
Closure<T> closure)

<T> public static T withObjectInputStream(InputStream inputStream, ClassLoader classLoader, @ClosureParams(value=SimpleType.class, options="java.io.ObjectInputStream")
Closure<T> closure)

<T> public static T withObjectOutputStream(OutputStream outputStream, @ClosureParams(value=SimpleType.class, options="java.io.ObjectOutputStream")
Closure<T> closure)

<T> public static T withPrintWriter(Writer writer, @ClosureParams(value=SimpleType.class, options="java.io.PrintWriter")
Closure<T> closure)

<T> public static T withPrintWriter(OutputStream stream, @ClosureParams(value=SimpleType.class, options="java.io.PrintWriter")
Closure<T> closure)

<T> public static T withReader(Reader reader, @ClosureParams(FirstParam.class)
Closure<T> closure)

<T> public static T withReader(InputStream in, @ClosureParams(value=SimpleType.class, options="java.io.Reader")
Closure<T> closure)

<T> public static T withReader(InputStream in, String charset, @ClosureParams(value=SimpleType.class, options="java.io.Reader")
Closure<T> closure)

<T, U extends InputStream> public static T withStream(U stream, @ClosureParams(value=FirstParam.class)
Closure<T> closure)

<T, U extends OutputStream> public static T withStream(U os, @ClosureParams(value=FirstParam.class)
Closure<T> closure)

<T> public static T withWriter(Writer writer, @ClosureParams(FirstParam.class)
Closure<T> closure)

<T> public static T withWriter(OutputStream stream, @ClosureParams(value=SimpleType.class, options="java.io.Writer")
Closure<T> closure)

<T> public static T withWriter(OutputStream stream, String charset, @ClosureParams(value=SimpleType.class, options="java.io.Writer")
Closure<T> closure)

@Override
public Writer writeTo(Writer out)