1 files changed, 290 insertions, 0 deletions
diff --git a/app/src/main/java/org/apache/commons/net/ftp/FTPListParseEngine.java b/app/src/main/java/org/apache/commons/net/ftp/FTPListParseEngine.java
new file mode 100644
index 0000000..468bf39
--- /dev/null
+++ b/app/src/main/java/org/apache/commons/net/ftp/FTPListParseEngine.java
@@ -0,0 +1,290 @@
+/*
+ * 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.commons.net.ftp;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.ListIterator;
+
+
+/**
+ * This class handles the entire process of parsing a listing of
+ * file entries from the server.
+ * <p>
+ * This object defines a two-part parsing mechanism.
+ * <p>
+ * The first part is comprised of reading the raw input into an internal
+ * list of strings.  Every item in this list corresponds to an actual
+ * file.  All extraneous matter emitted by the server will have been
+ * removed by the end of this phase.  This is accomplished in conjunction
+ * with the FTPFileEntryParser associated with this engine, by calling
+ * its methods <code>readNextEntry()</code> - which handles the issue of
+ * what delimits one entry from another, usually but not always a line
+ * feed and <code>preParse()</code> - which handles removal of
+ * extraneous matter such as the preliminary lines of a listing, removal
+ * of duplicates on versioning systems, etc.
+ * <p>
+ * The second part is composed of the actual parsing, again in conjunction
+ * with the particular parser used by this engine.  This is controlled
+ * by an iterator over the internal list of strings.  This may be done
+ * either in block mode, by calling the <code>getNext()</code> and
+ * <code>getPrevious()</code> methods to provide "paged" output of less
+ * than the whole list at one time, or by calling the
+ * <code>getFiles()</code> method to return the entire list.
+ * <p>
+ * Examples:
+ * <p>
+ * Paged access:
+ * <pre>
+ *    FTPClient f=FTPClient();
+ *    f.connect(server);
+ *    f.login(username, password);
+ *    FTPListParseEngine engine = f.initiateListParsing(directory);
+ *
+ *    while (engine.hasNext()) {
+ *       FTPFile[] files = engine.getNext(25);  // "page size" you want
+ *       //do whatever you want with these files, display them, etc.
+ *       //expensive FTPFile objects not created until needed.
+ *    }
+ * </pre>
+ * <p>
+ * For unpaged access, simply use FTPClient.listFiles().  That method
+ * uses this class transparently.
+ * @version $Id: FTPListParseEngine.java 658518 2008-05-21 01:04:30Z sebb $
+ */
+public class FTPListParseEngine {
+    private List<String> entries = new LinkedList<String>();
+    private ListIterator<String> _internalIterator = entries.listIterator();
+
+    FTPFileEntryParser parser = null;
+
+    public FTPListParseEngine(FTPFileEntryParser parser) {
+        this.parser = parser;
+    }
+
+    /**
+     * handle the iniitial reading and preparsing of the list returned by
+     * the server.  After this method has completed, this object will contain
+     * a list of unparsed entries (Strings) each referring to a unique file
+     * on the server.
+     *
+     * @param stream input stream provided by the server socket.
+     *
+     * @exception IOException
+     *                   thrown on any failure to read from the sever.
+     */
+    public void readServerList(InputStream stream, String encoding)
+    throws IOException
+    {
+        this.entries = new LinkedList<String>();
+        readStream(stream, encoding);
+        this.parser.preParse(this.entries);
+        resetIterator();
+    }
+    
+    /**
+     * handle the iniitial reading and preparsing of the list returned by
+     * the server.  After this method has completed, this object will contain
+     * a list of unparsed entries (Strings) each referring to a unique file
+     * on the server.
+     *
+     * @param stream input stream provided by the server socket.
+     *
+     * @exception IOException
+     *                   thrown on any failure to read from the sever.
+     *
+     * @deprecated The version of this method which takes an encoding should be used.
+    */
+    public void readServerList(InputStream stream)
+    throws IOException
+    {
+        readServerList(stream, null);
+    }
+    
+
+
+    /**
+     * Internal method for reading the input into the <code>entries</code> list.
+     * After this method has completed, <code>entries</code> will contain a
+     * collection of entries (as defined by
+     * <code>FTPFileEntryParser.readNextEntry()</code>), but this may contain
+     * various non-entry preliminary lines from the server output, duplicates,
+     * and other data that will not be part of the final listing.
+     *
+     * @param stream The socket stream on which the input will be read.
+     * @param encoding The encoding to use.
+     *
+     * @exception IOException
+     *                   thrown on any failure to read the stream
+     */
+    private void readStream(InputStream stream, String encoding) throws IOException
+    {
+        BufferedReader reader;
+        if (encoding == null)
+        {
+            reader = new BufferedReader(new InputStreamReader(stream));
+        }
+        else
+        {
+            reader = new BufferedReader(new InputStreamReader(stream, encoding));
+        }
+        
+        String line = this.parser.readNextEntry(reader);
+
+        while (line != null)
+        {
+            this.entries.add(line);
+            line = this.parser.readNextEntry(reader);
+        }
+        reader.close();
+    }
+
+    /**
+     * Returns an array of at most <code>quantityRequested</code> FTPFile
+     * objects starting at this object's internal iterator's current position.
+     * If fewer than <code>quantityRequested</code> such
+     * elements are available, the returned array will have a length equal
+     * to the number of entries at and after after the current position.
+     * If no such entries are found, this array will have a length of 0.
+     *
+     * After this method is called this object's internal iterator is advanced
+     * by a number of positions equal to the size of the array returned.
+     *
+     * @param quantityRequested
+     * the maximum number of entries we want to get.
+     *
+     * @return an array of at most <code>quantityRequested</code> FTPFile
+     * objects starting at the current position of this iterator within its
+     * list and at least the number of elements which  exist in the list at
+     * and after its current position.
+     * <p><b> 
+     * NOTE:</b> This array may contain null members if any of the 
+     * individual file listings failed to parse.  The caller should 
+     * check each entry for null before referencing it.
+     */
+    public FTPFile[] getNext(int quantityRequested) {
+        List<FTPFile> tmpResults = new LinkedList<FTPFile>();
+        int count = quantityRequested;
+        while (count > 0 && this._internalIterator.hasNext()) {
+            String entry = this._internalIterator.next();
+            FTPFile temp = this.parser.parseFTPEntry(entry);
+            tmpResults.add(temp);
+            count--;
+        }
+        return tmpResults.toArray(new FTPFile[0]);
+
+    }
+
+    /**
+     * Returns an array of at most <code>quantityRequested</code> FTPFile
+     * objects starting at this object's internal iterator's current position,
+     * and working back toward the beginning.
+     *
+     * If fewer than <code>quantityRequested</code> such
+     * elements are available, the returned array will have a length equal
+     * to the number of entries at and after after the current position.
+     * If no such entries are found, this array will have a length of 0.
+     *
+     * After this method is called this object's internal iterator is moved
+     * back by a number of positions equal to the size of the array returned.
+     *
+     * @param quantityRequested
+     * the maximum number of entries we want to get.
+     *
+     * @return an array of at most <code>quantityRequested</code> FTPFile
+     * objects starting at the current position of this iterator within its
+     * list and at least the number of elements which  exist in the list at
+     * and after its current position.  This array will be in the same order
+     * as the underlying list (not reversed).
+     * <p><b> 
+     * NOTE:</b> This array may contain null members if any of the 
+     * individual file listings failed to parse.  The caller should 
+     * check each entry for null before referencing it.
+     */
+    public FTPFile[] getPrevious(int quantityRequested) {
+        List<FTPFile> tmpResults = new LinkedList<FTPFile>();
+        int count = quantityRequested;
+        while (count > 0 && this._internalIterator.hasPrevious()) {
+            String entry = this._internalIterator.previous();
+            FTPFile temp = this.parser.parseFTPEntry(entry);
+            tmpResults.add(0,temp);
+            count--;
+        }
+        return tmpResults.toArray(new FTPFile[0]);
+    }
+
+    /**
+     * Returns an array of FTPFile objects containing the whole list of
+     * files returned by the server as read by this object's parser.
+     *
+     * @return an array of FTPFile objects containing the whole list of
+     *         files returned by the server as read by this object's parser.
+     * <p><b> 
+     * NOTE:</b> This array may contain null members if any of the 
+     * individual file listings failed to parse.  The caller should 
+     * check each entry for null before referencing it.
+     * @exception IOException
+     */
+    public FTPFile[] getFiles()
+    throws IOException
+    {
+        List<FTPFile> tmpResults = new LinkedList<FTPFile>();
+        Iterator<String> iter = this.entries.iterator();
+        while (iter.hasNext()) {
+            String entry = iter.next();
+            FTPFile temp = this.parser.parseFTPEntry(entry);
+            tmpResults.add(temp);
+        }
+        return tmpResults.toArray(new FTPFile[0]);
+
+    }
+
+    /**
+     * convenience method to allow clients to know whether this object's
+     * internal iterator's current position is at the end of the list.
+     *
+     * @return true if internal iterator is not at end of list, false
+     * otherwise.
+     */
+    public boolean hasNext() {
+        return _internalIterator.hasNext();
+    }
+
+    /**
+     * convenience method to allow clients to know whether this object's
+     * internal iterator's current position is at the beginning of the list.
+     *
+     * @return true if internal iterator is not at beginning of list, false
+     * otherwise.
+     */
+    public boolean hasPrevious() {
+        return _internalIterator.hasPrevious();
+    }
+
+    /**
+     * resets this object's internal iterator to the beginning of the list.
+     */
+    public void resetIterator() {
+        this._internalIterator = this.entries.listIterator();
+    }
+}