File

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (File, B)

def /(child: File): File

def /(child: Directory): Directory

def /(child: Path): Path

Creates a new Path with the specified path appended.

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def addExtension(ext: String): File

def appendAll(strings: String*): Unit

def applyReader[T](f: (BufferedReader) ⇒ T): T

Creates a BufferedReader and applies the closure, automatically closing it on completion.

final def asInstanceOf[T0]: T0

def bufferedInput(): BufferedInputStream

def bufferedOutput(append: Boolean = false): BufferedOutputStream

def bufferedReader(codec: Codec): BufferedReader

def bufferedReader(): BufferedReader

Wraps a BufferedReader around the result of reader().

def bufferedWriter(append: Boolean, codec: Codec): BufferedWriter

def bufferedWriter(append: Boolean): BufferedWriter

def bufferedWriter(): BufferedWriter

Wraps a BufferedWriter around the result of writer().

def bytes(): Iterator[Byte]

def bytesAsInts(): Iterator[Int]

def canRead: Boolean

def canWrite: Boolean

def changeExtension(ext: String): Path

def chars(codec: Codec): BufferedSource

def chars(): BufferedSource

def clone(): AnyRef

def copyTo(destPath: Path, preserveFileDate: Boolean = false): Boolean

def createDirectory(force: Boolean = true, failIfExists: Boolean = false): Directory

def createFile(failIfExists: Boolean = false): File

val creationCodec: Codec

Calls to methods requiring byte<->char transformations should be offered in a form which allows specifying the codec.

def delete(): Boolean

def deleteIfExists(): Boolean

def deleteRecursively(): Boolean

Deletes the path recursively.

def endsWith(other: Path): Boolean

def ensuring(cond: (File) ⇒ Boolean, msg: ⇒ Any): File

def ensuring(cond: (File) ⇒ Boolean): File

def ensuring(cond: Boolean, msg: ⇒ Any): File

def ensuring(cond: Boolean): File

final def eq(arg0: AnyRef): Boolean

def equals(other: Any): Boolean

def exists: Boolean

def extension: String

def finalize(): Unit

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hasExtension(ext: String, exts: String*): Boolean

def hashCode(): Int

def ifDirectory[T](f: (Directory) ⇒ T): Option[T]

def ifFile[T](f: (File) ⇒ T): Option[T]

def inputStream(): FileInputStream

Obtains an InputStream.

def isAbsolute: Boolean

def isDirectory: Boolean

def isEmpty: Boolean

def isFile: Boolean

def isFresher(other: Path): Boolean

def isHidden: Boolean

final def isInstanceOf[T0]: Boolean

def isRootPath: Boolean

def isSame(other: Path): Boolean

def isValid: Boolean

def lastModified: Long

def lastModified_=(time: Long): Boolean

def length: Long

def lines(codec: Codec): Iterator[String]

def lines(): Iterator[String]

def name: String

final def ne(arg0: AnyRef): Boolean

def normalize: File

def notExists: Boolean

final def notify(): Unit

final def notifyAll(): Unit

def outputStream(append: Boolean = false): FileOutputStream

Obtains a OutputStream.

def parent: Directory

def parents: List[Directory]

def path: String

def printStream(append: Boolean = false): PrintStream

def printWriter(append: Boolean): PrintWriter

def printWriter(): PrintWriter

def printlnAll(strings: String*): Unit

Calls println on each string (so it adds a newline in the PrintWriter fashion.

def reader(codec: Codec): InputStreamReader

def reader(): InputStreamReader

Obtains an InputStreamReader wrapped around a FileInputStream.

def relativize(other: Path): Path

def resolve(other: Path): Path

def root: Option[Path]

def safeSlurp(): Option[String]

def segments: List[String]

val self: Any

val self: Any

val separator: Char

val separatorStr: String

def setExecutable(executable: Boolean, ownerOnly: Boolean = true): Boolean

Reflection since we're into the java 6+ API.

def slurp(codec: Codec): String

def slurp(): String

Convenience function to import entire file into a String.

def startsWith(other: Path): Boolean

def stripExtension: String

final def synchronized[T0](arg0: ⇒ T0): T0

def toAbsolute: File

def toAbsoluteWithRoot(root: Path): Path

If this path is absolute, returns it: otherwise, returns an absolute path made up of root / this.

def toByteArray(): Array[Byte]

This method aspires to be the fastest way to read a stream of known length into memory.

def toCanonical: Path

def toDirectory: Directory

def toFile: File

def toString(): String

def toURI: URI

def toURL: URL

def touch(modTime: Long = System.currentTimeMillis): AnyVal

def truncate(): Boolean

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def walk: Iterator[Path]

Equivalent to walkFilter(_ => false).

def walkFilter(cond: (Path) ⇒ Boolean): Iterator[Path]

If this path is a container, recursively iterate over its contents.

def withCodec(codec: Codec): File

def writeAll(strings: String*): Unit

Creates a new file and writes all the Strings to it.

def writeBytes(bytes: Array[Byte]): Unit

def writer(append: Boolean, codec: Codec): OutputStreamWriter

def writer(append: Boolean): OutputStreamWriter

def writer(): OutputStreamWriter

Obtains an OutputStreamWriter wrapped around a FileOutputStream.

def →[B](y: B): (File, B)

def x: File

def x: File