FSEntry

Abstract Value Members

abstract val path: Path

underlying path
abstract def withPath(p: Path): Self

Attributes
protected[sclib.io.fs]

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
lazy val absNormalizedPath: Path

absolute, normalized path
final def asInstanceOf[T0]: T0

Definition Classes
Any

def chmod(mode: String): Try[Self]

set entry permission mode

mode: : list of unix like symbolic permissions notation

Example:

chmod("a=r,u+w") -> chmod(Seq(OWNER_READ, OWNER_WRITE, GROUP_READ, OTHERS_READ))
chmod("a+x")     -> current permissions + Seq(OWNER_EXECUTE, GROUP_EXECUTE, OTHERS_EXECUTE)

def chmod(n: Int): Try[Self]

set entry permission mode

n: : unix like file permission notation

Example:

chmod(700) -> chmod(Seq(OWNER_READ, OWNER_WRITE, OWNER_EXECUTE))
chmod(644) -> chmod(Seq(OWNER_READ, OWNER_WRITE, GROUP_READ, OTHERS_READ))

def chmod(perms: PosixFilePermission*): Try[Self]

set entry permission mode

perms: : sequence of http://http://docs.oracle.com/javase/8/docs/api/java/nio/file/attribute/PosixFilePermission.html

Example:

scala> import java.nio.file.attribute.PosixFilePermission._
scala> for {
     |   wd <- dir("sclib-example")
     |   wd <- wd.createTemp
     |   fh <- file(wd, "a-file").flatMap(_.create)
     |   _ <- fh.chmod(OWNER_READ)
     |   mod <- fh.lsmod
     |   _ <- wd.deleteR()
     | } yield mod
res0: scala.util.Try[Seq[java.nio.file.attribute.PosixFilePermission]] = Success(List(OWNER_READ))

def chmodR(mode: String): Try[Self]

set entry permission mode recursive
set entry permission mode recursive
fail on any error

See also
FSEntry.chmod(mode:String)*
def chmodR(n: Int): Try[Self]

set entry permission mode recursive
set entry permission mode recursive
fail on any error

See also
FSEntry.chmod(n:Int)*
def chmodR(perms: PosixFilePermission*): Try[Self]

set entry permission mode recursive
set entry permission mode recursive
fail on any error

See also
FSEntry.chmod(perms:java\.nio\.file\.attribute\.PosixFilePermission*)*
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )

def copy(target: Self, options: CopyOption*): Try[Self]

copy the entry (file -> file, dir -> dir)

options: http://docs.oracle.com/javase/8/docs/api/java/nio/file/StandardCopyOption.html

Example:

scala> for {
     |   wd <- dir("sclib-example")
     |   wd <- wd.createTemp
     |   src <- file(wd, "a-file")
     |   _ <- src.write("content")
     |   dst <- file(wd, "b-file")
     |   _ <- src.copy(dst)
     |   c <- dst.slurp
     |   _ <- wd.deleteR
     | } yield c
res0: scala.util.Try[String] = Success(content)

def copyTo(target: FSDir, options: CopyOption*): Try[Self]

copy the entry to the given dir
copy the entry to the given dir
if the target dir doesn't exists, it's being created
use FSEntry.copyToR(target* for a recursive copy operation
def copyToR(target: FSDir, options: CopyOption*): Try[Self]

recursively copy the entry to the given dir
recursively copy the entry to the given dir
if the target dir doesn't exists, it's being created

def create(mode: String): Try[Self]

create the filesystem entry with the given permissions

the path hierarchy must exist - use FSEntry.mkDirs(attrs: FileAttribute*) to create the hierarchy at first.

mode: unix like symbolic mode

Example:

create("a=r,u+w") -> create the entry with the PosixFilePermissions: OWNER_READ, OWNER_WRITE, GROUP_READ and OTHERS_READ
scala> import scala.collection.SortedSet
scala> for {
     |   wd <- dir("/tmp/sclib")
     |   wd <- wd.createTemp
     |   fh <- file(wd, "example")
     |   _ <- fh.create("a=r,u+wx")
     |   perm <- fh.lsmod
     |   _ <- wd.deleteR
     | } yield perm.to[SortedSet]
res0: scala.util.Try[scala.collection.SortedSet[java.nio.file.attribute.PosixFilePermission]] = Success(TreeSet(OWNER_READ, OWNER_WRITE, OWNER_EXECUTE, GROUP_READ, OTHERS_READ))

def create(n: Int): Try[Self]

create the filesystem entry with the given permissions

the path hierarchy must exist - use FSEntry.mkDirs(attrs: FileAttribute*) to create the hierarchy at first.

n: unix like numeric mode

Example:

scala> import scala.collection.SortedSet
scala> for {
     |   wd <- dir("/tmp/sclib")
     |   wd <- wd.createTemp
     |   fh <- file(wd, "example")
     |   _ <- fh.create(740)
     |   perm <- fh.lsmod
     |   _ <- wd.deleteR
     | } yield perm.to[SortedSet]
res0: scala.util.Try[SortedSet[java.nio.file.attribute.PosixFilePermission]] = Success(TreeSet(OWNER_READ, OWNER_WRITE, OWNER_EXECUTE, GROUP_READ))

def create(perms: PosixFilePermission*): Try[Self]

create the filesystem entry with the given permissions
create the filesystem entry with the given permissions
the path hierarchy must exist - use FSEntry.mkDirs(attrs:java\.nio\.file\.attribute\.FileAttribute[_]*)* to create the hierarchy at first.
def create: Try[Self]

create the filesystem entry with default permissions
create the filesystem entry with default permissions
the path hierarchy must exist - use FSEntry.mkDirs(attrs:java\.nio\.file\.attribute\.FileAttribute[_]*)* to create the hierarchy at first.

def createTemp: Try[Self]

create a new temporary filesystem entry.

create a new temporary filesystem entry. the actual name is used for the prefix.

if no absolute path is given, the entry is created in the temp directory (determined by: System.getProperty("java.io.tmpdir")).

Example:

scala> for {
     |   fh <- dir("a-temp-dir")
     |   // override the original fh
     |   fh <- fh.createTemp
     |   _ <- fh.delete
     |   // fh.name is something like 'a-temp-dir7526811586167481701'
     | } yield fh.name.matches("a-temp-dir\\d+")
res0: scala.util.Try[Boolean] = Success(true)
scala> for {
     |   fh <- file("a-temp-file")
     |   // override the original fh
     |   fh <- fh.createTemp
     |   _ <- fh.delete
     |   // fh.name is something like 'a-temp-file9014711075515420555'
     | } yield fh.name.matches("a-temp-file\\d+")
res0: scala.util.Try[Boolean] = Success(true)
scala> for {
     |   fh <- file("a-temp-file.txt")
     |   // override the original fh
     |   fh <- fh.createTemp
     |   _ <- fh.delete
     |   // fh.name is something like 'a-temp-file2068553337840465580.txt'
     | } yield fh.name.matches("a-temp-file\\d+\\.txt")
res1: scala.util.Try[Boolean] = Success(true)

def delete(): Try[Unit]

delete the file
delete the file
returns a Failure if the file doesn't exist.

See also
FSEntry.deleteIfExists
def deleteIfExists(): Try[Boolean]

delete the file if it exists
delete the file if it exists
returns
true if the file was deleted, false if it doesn't exist.

def depth(other: FSEntryImpl): Int

relative depth to a given FSEntry

Example:

scala> for {
     |  a <- dir("sclib-example")
     |  b <- dir(a, "x/y/z/..")
     | } yield a.depth(b)
res0: scala.util.Try[Int] = Success(2)

final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def exists: Boolean

check if the file exists
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def isDirectory: Boolean

check if the file is a directory
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isRegularFile: Boolean

check if the file is a regular file
def lsmod: Try[Seq[PosixFilePermission]]

get entry permission mode
def mkDirs: Try[Self]

See also
FSEntry.mkDirs(attrs:java\.nio\.file\.attribute\.FileAttribute[_]*)*
def mkDirs(attrs: FileAttribute[_]*): Try[Self]

create the directories
create the directories
- when called on a FSDir, the directroy's path (inclusive parents) are created - when called on a FSFile the parent hierarchy are created
attrs
http://docs.oracle.com/javase/8/docs/api/java/nio/file/attribute/PosixFileAttributes.html
def move(target: Self, options: CopyOption*): Try[Self]

move the entry
move the entry
options
http://docs.oracle.com/javase/8/docs/api/java/nio/file/StandardCopyOption.html
def moveTo(dir: FSDir, options: CopyOption*): Try[Self]

move the entry to the given directory, and keep the name
move the entry to the given directory, and keep the name
options
http://docs.oracle.com/javase/8/docs/api/java/nio/file/StandardCopyOption.html
def mtime(millis: Long): Try[Unit]

set the modification time
set the modification time
millis
file modification time in milliseconds, since the epoch (1970-01-01T00:00:00Z)
def mtime: Try[Long]

file modification time in milliseconds, since the epoch (1970-01-01T00:00:00Z)
lazy val name: String

file / directory name
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef

def renameTo(newName: String, options: CopyOption*): Try[Self]

rename the entry

options: http://docs.oracle.com/javase/8/docs/api/java/nio/file/StandardCopyOption.html

Example:

scala> for {
     |   wd <- dir("sclib-example")
     |   wd <- wd.createTemp
     |   src <- file(wd, "a-file")
     |   _ <- src.create
     |   dst <- src.renameTo("b-file")
     |   res = (src.exists, dst.exists)
     |   _ <- wd.deleteR
     | } yield res
res0: scala.util.Try[(Boolean, Boolean)] = Success((false,true))

def size: Try[Long]

file size in bytes
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Doc: package fs

trait FSEntry[Self <: FSEntry[Self]] extends AnyRef

Abstract Value Members

abstract val path: Path

abstract def withPath(p: Path): Self

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

lazy val absNormalizedPath: Path

final def asInstanceOf[T0]: T0

def chmod(mode: String): Try[Self]

def chmod(n: Int): Try[Self]

def chmod(perms: PosixFilePermission*): Try[Self]

def chmodR(mode: String): Try[Self]

def chmodR(n: Int): Try[Self]

def chmodR(perms: PosixFilePermission*): Try[Self]

def clone(): AnyRef

def copy(target: Self, options: CopyOption*): Try[Self]

def copyTo(target: FSDir, options: CopyOption*): Try[Self]

def copyToR(target: FSDir, options: CopyOption*): Try[Self]

def create(mode: String): Try[Self]

def create(n: Int): Try[Self]

def create(perms: PosixFilePermission*): Try[Self]

def create: Try[Self]

def createTemp: Try[Self]

def delete(): Try[Unit]

def deleteIfExists(): Try[Boolean]

def depth(other: FSEntryImpl): Int

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exists: Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

def isDirectory: Boolean

final def isInstanceOf[T0]: Boolean

def isRegularFile: Boolean

def lsmod: Try[Seq[PosixFilePermission]]

def mkDirs: Try[Self]

def mkDirs(attrs: FileAttribute[_]*): Try[Self]

def move(target: Self, options: CopyOption*): Try[Self]

def moveTo(dir: FSDir, options: CopyOption*): Try[Self]

def mtime(millis: Long): Try[Unit]

def mtime: Try[Long]

lazy val name: String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def renameTo(newName: String, options: CopyOption*): Try[Self]

def size: Try[Long]

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped