blob: b5088a7d5f4e8f11086181a2143e81b86cbb440e (
plain)
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
|
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.apache.tools.ant.taskdefs.optional.ssh;
import java.io.File;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.StringTokenizer;
/**
* A helper object for Scp representing a directory in a file system.
*/
public class Directory {
private File directory;
private Set childDirectories;
private ArrayList files;
private Directory parent;
/**
* Constructor for a Directory.
* @param directory a directory.
*/
public Directory(File directory) {
this(directory, null);
}
/**
* Constructor for a Directory.
* @param directory a directory
* @param parent a parent Directory
*/
public Directory(File directory , Directory parent) {
this.parent = parent;
this.childDirectories = new LinkedHashSet();
this.files = new ArrayList();
this.directory = directory;
}
/**
* Add a directory to the child directories.
* @param directory a Directory
*/
public void addDirectory(Directory directory) {
if (!childDirectories.contains(directory)) {
childDirectories.add(directory);
}
}
/**
* Add a file to the list of files.
* @param file a file to add
*/
public void addFile(File file) {
files.add(file);
}
/**
* Get an iterator over the child Directories.
* @return an iterator
*/
public Iterator directoryIterator() {
return childDirectories.iterator();
}
/**
* Get an iterator over the files.
* @return an iterator
*/
public Iterator filesIterator() {
return files.iterator();
}
/**
* Get the parent Directory.
* @return the parent Directory.
*/
public Directory getParent() {
return parent;
}
/**
* Is this a root Directory?
* @return true if there is no parent Directory
*/
public boolean isRoot() {
return parent == null;
}
/**
* Get the directory file.
* @return the directory file
*/
public File getDirectory() {
return directory;
}
/**
* Get a child directory of this directory.
* @param dir the directory to look for
* @return the child directory, or null if not found
*/
public Directory getChild(File dir) {
for (Iterator i = childDirectories.iterator(); i.hasNext();) {
Directory current = (Directory) i.next();
if (current.getDirectory().equals(dir)) {
return current;
}
}
return null;
}
/**
* The equality method.
* This checks if the directory field is the same.
* @param obj the object to compare to
* @return true if this object has an equal directory field as the other object
*/
@Override
public boolean equals(Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof Directory)) {
return false;
}
Directory d = (Directory) obj;
return this.directory.equals(d.directory);
}
/**
* The hashcode method.
* @return the hash code of the directory field
*/
@Override
public int hashCode() {
return directory.hashCode();
}
/**
* Get the path components of this directory.
* @return the path components as an array of strings.
*/
public String[] getPath() {
return getPath(directory.getAbsolutePath());
}
/**
* Convert a file path to an array of path components.
* This uses File.separator to split the file path string.
* @param thePath the file path string to convert
* @return an array of path components
*/
public static String[] getPath(String thePath) {
StringTokenizer tokenizer = new StringTokenizer(thePath,
File.separator);
String[] path = new String[ tokenizer.countTokens() ];
int i = 0;
while (tokenizer.hasMoreTokens()) {
path[i] = tokenizer.nextToken();
i++;
}
return path;
}
/**
* Get the number of files in the files attribute.
* @return the number of files
*/
public int fileSize() {
return files.size();
}
}
|
