Directory

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (Directory, 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): Path

final def asInstanceOf[T0]: T0

def canRead: Boolean

def canWrite: Boolean

def changeExtension(ext: String): Path

def clone(): AnyRef

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

def createFile(failIfExists: Boolean = false): File

def deepDirs: Iterator[Directory]

def deepFiles: Iterator[File]

def deepList(depth: Int = 1): Iterator[Path]

If optional depth argument is not given, will recurse until it runs out of contents.

def delete(): Boolean

def deleteIfExists(): Boolean

def deleteRecursively(): Boolean

Deletes the path recursively.

def dirs: Iterator[Directory]

def endsWith(other: Path): Boolean

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

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

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

def ensuring(cond: Boolean): Directory

final def eq(arg0: AnyRef): Boolean

def equals(other: Any): Boolean

def exists: Boolean

def extension: String

def files: Iterator[File]

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 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 list: Iterator[Path]

An iterator over the contents of this directory.

def name: String

final def ne(arg0: AnyRef): Boolean

def normalize: Directory

def notExists: Boolean

final def notify(): Unit

final def notifyAll(): Unit

def parent: Directory

def parents: List[Directory]

def path: String

def relativize(other: Path): Path

def resolve(other: Path): Path

def root: Option[Path]

def segments: List[String]

val self: Any

val self: Any

val separator: Char

val separatorStr: String

def startsWith(other: Path): Boolean

def stripExtension: String

def subdirs(depth: Int = 1): Iterator[Directory]

An iterator over the directories underneath this directory, to the (optionally) given depth.

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

def toAbsolute: Directory

def toAbsoluteWithRoot(root: Path): Path

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

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 →[B](y: B): (Directory, B)

def x: Directory

def x: Directory