blob: 8f24d844883814776945c7a351c2e6459dcb0691 (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
/* NSC -- new Scala compiler
* Copyright 2005-2013 LAMP/EPFL
* @author Martin Odersky
*/
package scala
package reflect
package io
import java.io.{ FileInputStream, FileOutputStream, IOException }
/** ''Note: This library is considered experimental and should not be used unless you know what you are doing.'' */
class PlainDirectory(givenPath: Directory) extends PlainFile(givenPath) {
override def isDirectory = true
override def iterator = givenPath.list filter (_.exists) map (x => new PlainFile(x))
override def delete(): Unit = givenPath.deleteRecursively()
}
/** This class implements an abstract file backed by a File.
*
* ''Note: This library is considered experimental and should not be used unless you know what you are doing.''
*/
class PlainFile(val givenPath: Path) extends AbstractFile {
assert(path ne null)
val file = givenPath.jfile
override def underlyingSource = Some(this)
private val fpath = givenPath.toAbsolute
/** Returns the name of this abstract file. */
def name = givenPath.name
/** Returns the path of this abstract file. */
def path = givenPath.path
/** The absolute file. */
def absolute = new PlainFile(givenPath.toAbsolute)
override def container: AbstractFile = new PlainFile(givenPath.parent)
override def input = givenPath.toFile.inputStream()
override def output = givenPath.toFile.outputStream()
override def sizeOption = Some(givenPath.length.toInt)
override def toString = path
override def hashCode(): Int = fpath.hashCode()
override def equals(that: Any): Boolean = that match {
case x: PlainFile => fpath == x.fpath
case _ => false
}
/** Is this abstract file a directory? */
def isDirectory: Boolean = givenPath.isDirectory
/** Returns the time that this abstract file was last modified. */
def lastModified: Long = givenPath.lastModified
/** Returns all abstract subfiles of this abstract directory. */
def iterator: Iterator[AbstractFile] = {
// Optimization: Assume that the file was not deleted and did not have permissions changed
// between the call to `list` and the iteration. This saves a call to `exists`.
def existsFast(path: Path) = path match {
case (_: Directory | _: io.File) => true
case _ => path.exists
}
if (!isDirectory) Iterator.empty
else givenPath.toDirectory.list filter existsFast map (new PlainFile(_))
}
/**
* Returns the abstract file in this abstract directory with the
* specified name. If there is no such file, returns null. The
* argument "directory" tells whether to look for a directory or
* or a regular file.
*/
def lookupName(name: String, directory: Boolean): AbstractFile = {
val child = givenPath / name
if ((child.isDirectory && directory) || (child.isFile && !directory)) new PlainFile(child)
else null
}
/** Does this abstract file denote an existing file? */
def create(): Unit = if (!exists) givenPath.createFile()
/** Delete the underlying file or directory (recursively). */
def delete(): Unit =
if (givenPath.isFile) givenPath.delete()
else if (givenPath.isDirectory) givenPath.toDirectory.deleteRecursively()
/** Returns a plain file with the given name. It does not
* check that it exists.
*/
def lookupNameUnchecked(name: String, directory: Boolean): AbstractFile =
new PlainFile(givenPath / name)
}
|
