001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: *
017: */
018:
019: package org.apache.tools.ant.taskdefs.optional.ssh;
020:
021: import java.util.ArrayList;
022: import java.util.Iterator;
023: import java.util.StringTokenizer;
024: import java.io.File;
025:
026: /**
027: * A helper object for Scp representing a directory in a file system.
028: */
029: public class Directory {
030:
031: private File directory;
032: private ArrayList childDirectories;
033: private ArrayList files;
034: private Directory parent;
035:
036: /**
037: * Constructor for a Directory.
038: * @param directory a directory.
039: */
040: public Directory(File directory) {
041: this (directory, null);
042: }
043:
044: /**
045: * Constructor for a Directory.
046: * @param directory a directory
047: * @param parent a parent Directory
048: */
049: public Directory(File directory, Directory parent) {
050: this .parent = parent;
051: this .childDirectories = new ArrayList();
052: this .files = new ArrayList();
053: this .directory = directory;
054: }
055:
056: /**
057: * Add a directory to the child directories.
058: * @param directory a Directory
059: */
060: public void addDirectory(Directory directory) {
061: if (!childDirectories.contains(directory)) {
062: childDirectories.add(directory);
063: }
064: }
065:
066: /**
067: * Add a file to the list of files.
068: * @param file a file to add
069: */
070: public void addFile(File file) {
071: files.add(file);
072: }
073:
074: /**
075: * Get an iterator over the child Directories.
076: * @return an iterator
077: */
078: public Iterator directoryIterator() {
079: return childDirectories.iterator();
080: }
081:
082: /**
083: * Get an iterator over the files.
084: * @return an iterator
085: */
086: public Iterator filesIterator() {
087: return files.iterator();
088: }
089:
090: /**
091: * Get the parent Directory.
092: * @return the parent Directory.
093: */
094: public Directory getParent() {
095: return parent;
096: }
097:
098: /**
099: * Is this a root Directory?
100: * @return true if there is no parent Directory
101: */
102: public boolean isRoot() {
103: return parent == null;
104: }
105:
106: /**
107: * Get the directory file.
108: * @return the directory file
109: */
110: public File getDirectory() {
111: return directory;
112: }
113:
114: /**
115: * Get a child directory of this directory.
116: * @param dir the directory to look for
117: * @return the child directory, or null if not found
118: */
119: public Directory getChild(File dir) {
120: for (int i = 0; i < childDirectories.size(); i++) {
121: Directory current = (Directory) childDirectories.get(i);
122: if (current.getDirectory().equals(dir)) {
123: return current;
124: }
125: }
126:
127: return null;
128: }
129:
130: /**
131: * The equality method.
132: * This checks if the directory field is the same.
133: * @param obj the object to compare to
134: * @return true if this object has an equal directory field as the other object
135: */
136: public boolean equals(Object obj) {
137: if (obj == this ) {
138: return true;
139: }
140:
141: if (!(obj instanceof Directory)) {
142: return false;
143: }
144:
145: Directory d = (Directory) obj;
146:
147: return this .directory.equals(d.directory);
148: }
149:
150: /**
151: * The hashcode method.
152: * @return the hash code of the directory field
153: */
154: public int hashCode() {
155: return directory.hashCode();
156: }
157:
158: /**
159: * Get the path components of this directory.
160: * @return the path components as an array of strings.
161: */
162: public String[] getPath() {
163: return getPath(directory.getAbsolutePath());
164: }
165:
166: /**
167: * Convert a file path to an array of path components.
168: * This uses File.sepatator to split the file path string.
169: * @param thePath the file path string to convert
170: * @return an array of path components
171: */
172: public static String[] getPath(String thePath) {
173: StringTokenizer tokenizer = new StringTokenizer(thePath,
174: File.separator);
175: String[] path = new String[tokenizer.countTokens()];
176:
177: int i = 0;
178: while (tokenizer.hasMoreTokens()) {
179: path[i] = tokenizer.nextToken();
180: i++;
181: }
182:
183: return path;
184: }
185:
186: /**
187: * Get the number of files in the files attribute.
188: * @return the number of files
189: */
190: public int fileSize() {
191: return files.size();
192: }
193: }
|