Coverage report

| %line | %branch
--- | --- | ---
org.apache.commons.net.ftp.FTPFileList |
0% |
0% |

1 |  |
     /*
2 |  |
      * Copyright 2001-2005 The Apache Software Foundation
3 |  |
      *
4 |  |
      * Licensed under the Apache License, Version 2.0 (the "License");
5 |  |
      * you may not use this file except in compliance with the License.
6 |  |
      * You may obtain a copy of the License at
7 |  |
      *
8 |  |
      *     http://www.apache.org/licenses/LICENSE-2.0
9 |  |
      *
10 |  |
      * Unless required by applicable law or agreed to in writing, software
11 |  |
      * distributed under the License is distributed on an "AS IS" BASIS,
12 |  |
      * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  |
      * See the License for the specific language governing permissions and
14 |  |
      * limitations under the License.
15 |  |
      */
16 |  |
     package org.apache.commons.net.ftp;
17 |  |
     import java.io.BufferedReader;
18 |  |
     import java.io.IOException;
19 |  |
     import java.io.InputStream;
20 |  |
     import java.io.InputStreamReader;
21 |  |
     import java.util.LinkedList;
22 |  |
     import java.util.List;
23 |  |
24 |  |
     /**
25 |  |
      * This class encapsulates a listing of files from an FTP server.  It is
26 |  |
      * initialized with an input stream which is read and the input split into
27 |  |
      * lines, each of which (after some possible initial verbiage) represents
28 |  |
      * a file on the FTP server.  A parser is also supplied, which is used to
29 |  |
      * iterate through the internal list of lines parsing each into an FTPFile
30 |  |
      * object which is returned to the caller of the iteration methods.  This
31 |  |
      * parser may be replaced with another, allowing the same list to be parsed
32 |  |
      * with different parsers.
33 |  |
      * Parsing takes place on an as-needed basis, basically, the first time a
34 |  |
      * position is iterated over.  This happens at the time of iteration, not
35 |  |
      * prior to it as the older <code>(FTPClient.listFiles()</code> methods did,
36 |  |
      * which required a bigger memory hit.
37 |  |
      *
38 |  |
      * @author <a href="mailto:scohen@apache.org">Steve Cohen</a>
39 |  |
      * @version $Id: FTPFileList.java 165675 2005-05-02 20:09:55Z rwinston $
40 |  |
      * @see org.apache.commons.net.ftp.FTPClient#createFileList
41 |  |
      * @see org.apache.commons.net.ftp.FTPFileIterator
42 |  |
      * @see org.apache.commons.net.ftp.FTPFileEntryParser
43 |  |
      * @see org.apache.commons.net.ftp.FTPListParseEngine
44 |  |
      * @deprecated This class is deprecated as of version 1.2 and will be
45 |  |
      * removed in version 2.0 -- use FTPFileParseEngine instead.
46 |  |
      */
47 |  |
     public class FTPFileList
48 |  |
     {
49 |  |
         /**
50 |  |
          * storage for the raw lines of input read from the FTP server
51 |  |
          */
52 | 0 |
         private LinkedList lines = null;
53 |  |
         /**
54 |  |
          * the FTPFileEntryParser assigned to be used with this lister
55 |  |
          */
56 |  |
         private FTPFileEntryParser parser;
57 |  |
         /**
58 |  |
          * private status code for an empty directory
59 |  |
          */
60 |  |
         private static final int EMPTY_DIR = -2;
61 |  |
62 |  |
         /**
63 |  |
          * The only constructor for FTPFileList, private because
64 |  |
          * construction only invoked at create()
65 |  |
          *
66 |  |
          * @param parser a <code>FTPFileEntryParser</code> value that knows
67 |  |
          * how to parse the entries returned by a particular FTP site.
68 |  |
          * @param encoding The encoding to use.
69 |  |
          */
70 |  |
         private FTPFileList (FTPFileEntryParser parser, String encoding)
71 | 0 |
         {
72 | 0 |
             this.parser = parser;
73 | 0 |
             this.lines = new LinkedList();
74 | 0 |
         }
75 |  |
76 |  |
         /**
77 |  |
          * The only way to create an <code>FTPFileList</code> object.  Invokes
78 |  |
          * the private constructor and then reads the stream  supplied stream to
79 |  |
          * build the intermediate array of "lines" which will later be parsed
80 |  |
          * into <code>FTPFile</code> object.
81 |  |
          *
82 |  |
          * @param stream The input stream created by reading the socket on which
83 |  |
          * the output of the LIST command was returned
84 |  |
          * @param parser the default <code>FTPFileEntryParser</code> to be used
85 |  |
          * by this object.  This may later be changed using the init() method.
86 |  |
          * @param encoding The encoding to use
87 |  |
          *
88 |  |
          * @return the <code>FTPFileList</code> created, with an initialized
89 |  |
          * of unparsed lines of output.  Will be null if the listing cannot
90 |  |
          * be read from the stream.
91 |  |
          * @exception IOException
92 |  |
          *                   Thrown on any failure to read from the socket.
93 |  |
          */
94 |  |
         public static FTPFileList create(InputStream stream,
95 |  |
                                           FTPFileEntryParser parser,
96 |  |
     									  String encoding)
97 |  |
                 throws IOException
98 |  |
         {
99 | 0 |
             FTPFileList list = new FTPFileList(parser, encoding);
100 | 0 |
             list.readStream(stream, encoding);
101 | 0 |
             parser.preParse(list.lines);
102 | 0 |
             return list;
103 |  |
         }
104 |  |
105 |  |
         /**
106 |  |
          * The only way to create an <code>FTPFileList</code> object.  Invokes
107 |  |
          * the private constructor and then reads the stream  supplied stream to
108 |  |
          * build the intermediate array of "lines" which will later be parsed
109 |  |
          * into <code>FTPFile</code> object.
110 |  |
          *
111 |  |
          * @param stream The input stream created by reading the socket on which
112 |  |
          * the output of the LIST command was returned
113 |  |
          * @param parser the default <code>FTPFileEntryParser</code> to be used
114 |  |
          * by this object.  This may later be changed using the init() method.
115 |  |
          *
116 |  |
          * @return the <code>FTPFileList</code> created, with an initialized
117 |  |
          * of unparsed lines of output.  Will be null if the listing cannot
118 |  |
          * be read from the stream.
119 |  |
          * @exception IOException
120 |  |
          *                   Thrown on any failure to read from the socket.
121 |  |
          *
122 |  |
          * @deprecated The version of this method which takes an encoding should be used.
123 |  |
         */
124 |  |
         public static FTPFileList create(InputStream stream,
125 |  |
         								  FTPFileEntryParser parser)
126 |  |
         	throws IOException
127 |  |
         {
128 | 0 |
         	return create(stream, parser, null);
129 |  |
         }
130 |  |
131 |  |
132 |  |
133 |  |
         /**
134 |  |
          * internal method for reading the input into the <code>lines</code> vector.
135 |  |
          *
136 |  |
          * @param stream The socket stream on which the input will be read.
137 |  |
          * @param encoding The encoding to use.
138 |  |
          *
139 |  |
          * @exception IOException thrown on any failure to read the stream
140 |  |
          */
141 |  |
         public void readStream(InputStream stream, String encoding) throws IOException
142 |  |
         {
143 | 0 |
             BufferedReader reader = new BufferedReader(class="keyword">new InputStreamReader(stream, encoding));
144 |  |
145 | 0 |
             String line = this.parser.readNextEntry(reader);
146 |  |
147 | 0 |
             while (line != null)
148 |  |
             {
149 | 0 |
                 this.lines.add(line);
150 | 0 |
                 line = this.parser.readNextEntry(reader);
151 |  |
             }
152 | 0 |
             reader.close();
153 | 0 |
         }
154 |  |
155 |  |
         /**
156 |  |
     	 * internal method for reading the input into the <code>lines</code> vector.
157 |  |
     	 *
158 |  |
     	 * @param stream The socket stream on which the input will be read.
159 |  |
     	 *
160 |  |
     	 * @exception IOException thrown on any failure to read the stream
161 |  |
     	 *
162 |  |
     	 * @deprecated The version of this method which takes an encoding should be used.
163 |  |
     	*/
164 |  |
     	public void readStream(InputStream stream) throws IOException
165 |  |
     	{
166 | 0 |
     	 readStream(stream, null);
167 | 0 |
     	}
168 |  |
169 |  |
170 |  |
         /**
171 |  |
          * Accessor for this object's default parser.
172 |  |
          *
173 |  |
          * @return this object's default parser.
174 |  |
          */
175 |  |
         FTPFileEntryParser getParser()
176 |  |
         {
177 | 0 |
             return this.parser;
178 |  |
         }
179 |  |
180 |  |
         /**
181 |  |
          * Package private accessor for the collection of raw input lines.
182 |  |
          *
183 |  |
          * @return vector containing all the raw input lines returned from the FTP
184 |  |
          * server
185 |  |
          */
186 |  |
         List getLines()
187 |  |
         {
188 | 0 |
             return this.lines;
189 |  |
         }
190 |  |
191 |  |
         /**
192 |  |
          * create an iterator over this list using the parser with which this list
193 |  |
          * was initally created
194 |  |
          *
195 |  |
          * @return an iterator over this list using the list's default parser.
196 |  |
          */
197 |  |
         public FTPFileIterator iterator()
198 |  |
         {
199 | 0 |
             return new FTPFileIterator(this);
200 |  |
         }
201 |  |
         /**
202 |  |
          * create an iterator over this list using the supplied parser
203 |  |
          *
204 |  |
          * @param parser The user-supplied parser with which the list is to be
205 |  |
          * iterated, may be different from this list's default parser.
206 |  |
          *
207 |  |
          * @return an iterator over this list using the supplied parser.
208 |  |
          */
209 |  |
         public FTPFileIterator iterator(FTPFileEntryParser parser)
210 |  |
         {
211 | 0 |
             return new FTPFileIterator(this, parser);
212 |  |
         }
213 |  |
214 |  |
215 |  |
         /**
216 |  |
          * returns an array of FTPFile objects for all the files in the directory
217 |  |
          * listing
218 |  |
          *
219 |  |
          * @return  an array of FTPFile objects for all the files in the directory
220 |  |
          * listinge
221 |  |
          */
222 |  |
         public FTPFile[] getFiles()
223 |  |
         {
224 | 0 |
             return iterator().getFiles();
225 |  |
         }
226 |  |
227 |  |
228 |  |
229 |  |
     }
230 |  |
231 |  |
     /* Emacs configuration
232 |  |
      * Local variables:        **
233 |  |
      * mode:             java  **
234 |  |
      * c-basic-offset:   4     **
235 |  |
      * indent-tabs-mode: nil   **
236 |  |
      * End:                    **
237 |  |
      */

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.