clojure.java.io — org.clojure/clojure 1.11.4

This file defines polymorphic I/O utility functions for Clojure.

as-relative-path clj

(as-relative-path x)

Take an as-file-able thing and return a string if it is a relative path, else IllegalArgumentException.

Coercions clj protocol

Coerce between various 'resource-namish' things.

as-file clj

(as-file x)

Coerce argument to a file.

as-url clj

(as-url x)

Coerce argument to a URL.

copy clj

(copy input output & opts)

Copies input to output. Returns nil or throws IOException. Input may be an InputStream, Reader, File, byte[], char[], or String. Output may be an OutputStream, Writer, or File.

Options are key/value pairs and may be one of

:buffer-size buffer size to use, default is 1024. :encoding encoding to use if converting between byte and char streams.

Does not close any streams except those it opens itself (on a File).

default-streams-impl clj

delete-file clj

(delete-file f & [silently])

Delete file f. If silently is nil or false, raise an exception on failure, else return the value of silently.

file clj

(file arg)

(file parent child)

(file parent child & more)

Returns a java.io.File, passing each arg to as-file. Multiple-arg versions treat the first argument as parent and subsequent args as children relative to the parent.

input-stream clj

(input-stream x & opts)

Attempts to coerce its argument into an open java.io.InputStream. Default implementations always return a java.io.BufferedInputStream.

Default implementations are defined for InputStream, File, URI, URL, Socket, byte array, and String arguments.

If the argument is a String, it tries to resolve it first as a URI, then as a local file name. URIs with a 'file' protocol are converted to local file names.

Should be used inside with-open to ensure the InputStream is properly closed.

IOFactory clj protocol

Factory functions that create ready-to-use, buffered versions of the various Java I/O stream types, on top of anything that can be unequivocally converted to the requested kind of stream.

Common options include

:append true to open stream in append mode :encoding string name of encoding to use, e.g. "UTF-8".

Callers should generally prefer the higher level API provided by reader, writer, input-stream, and output-stream.

make-input-stream clj

(make-input-stream x opts)

Creates a BufferedInputStream. See also IOFactory docs.

make-output-stream clj

(make-output-stream x opts)

Creates a BufferedOutputStream. See also IOFactory docs.

make-reader clj

(make-reader x opts)

Creates a BufferedReader. See also IOFactory docs.

make-writer clj

(make-writer x opts)

Creates a BufferedWriter. See also IOFactory docs.

make-parents clj

(make-parents f & more)

Given the same arg(s) as for file, creates all parent directories of the file they represent.

output-stream clj

(output-stream x & opts)

Attempts to coerce its argument into an open java.io.OutputStream. Default implementations always return a java.io.BufferedOutputStream.

Default implementations are defined for OutputStream, File, URI, URL, Socket, and String arguments.

If the argument is a String, it tries to resolve it first as a URI, then as a local file name. URIs with a 'file' protocol are converted to local file names.

Should be used inside with-open to ensure the OutputStream is properly closed.

reader clj

(reader x & opts)

Attempts to coerce its argument into an open java.io.Reader. Default implementations always return a java.io.BufferedReader.

Default implementations are provided for Reader, BufferedReader, InputStream, File, URI, URL, Socket, byte arrays, character arrays, and String.

If argument is a String, it tries to resolve it first as a URI, then as a local file name. URIs with a 'file' protocol are converted to local file names.

Should be used inside with-open to ensure the Reader is properly closed.

resource clj

(resource n)

(resource n loader)

Returns the URL for a named resource. Use the context class loader if no loader is specified.

writer clj

(writer x & opts)

Attempts to coerce its argument into an open java.io.Writer. Default implementations always return a java.io.BufferedWriter.

Default implementations are provided for Writer, BufferedWriter, OutputStream, File, URI, URL, Socket, and String.

If the argument is a String, it tries to resolve it first as a URI, then as a local file name. URIs with a 'file' protocol are converted to local file names.

Should be used inside with-open to ensure the Writer is properly closed.