blob: 3431a49e2c9a0ffb9e2ab594e3ddce07ee03a8aa (
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
|
/* __ *\
** ________ ___ / / ___ Scala API **
** / __/ __// _ | / / / _ | (c) 2003-2010, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
** /____/\___/_/ |_/____/_/ | | **
** |/ **
\* */
package scala.tools.nsc
package io
import java.io.{ File => JFile }
import collection.Traversable
object Directory
{
def apply(path: Path) = path.toDirectory
// Like File.makeTemp but creates a directory instead
def makeTemp(prefix: String = Path.randomPrefix, suffix: String = null, dir: JFile = null): Directory = {
val path = File.makeTemp(prefix, suffix, dir)
path.delete()
path.createDirectory()
}
}
import Path._
/** An abstraction for directories.
*
* @author Paul Phillips
* @since 2.8
*/
class Directory(jfile: JFile) extends Path(jfile)
{
override def toDirectory: Directory = this
override def toFile: File = new File(jfile)
override def isValid = jfile.isDirectory() || !jfile.exists()
/** An iterator over the contents of this directory.
*/
def list: Iterator[Path] =
jfile.listFiles match {
case null => Iterator.empty
case xs => xs.iterator map Path.apply
}
def dirs: Iterator[Directory] = list partialMap { case x: Directory => x }
def files: Iterator[File] = list partialMap { case x: File => x }
/** If optional depth argument is not given, will recurse
* until it runs out of contents.
*/
def deepList(depth: Int = -1): Iterator[Path] =
if (depth < 0) list ++ (dirs flatMap (_ deepList (depth)))
else if (depth == 0) Iterator.empty
else list ++ (dirs flatMap (_ deepList (depth - 1)))
/** An iterator over the directories underneath this directory,
* to the (optionally) given depth.
*/
def subdirs(depth: Int = 1): Iterator[Directory] =
deepList(depth) partialMap { case x: Directory => x }
/** Deletes the directory recursively. Returns false on failure.
* Use with caution!
*/
def deleteRecursively(): Boolean = deleteRecursively(jfile)
private def deleteRecursively(f: JFile): Boolean = {
if (f.isDirectory) f.listFiles match {
case null =>
case xs => xs foreach deleteRecursively
}
f.delete()
}
override def toString() = "Directory(%s)".format(path)
}
|
