001 /**
002 * jline - Java console input library
003 * Copyright (c) 2002,2003 Marc Prud'hommeaux mwp1@cornell.edu
004 *
005 * This library is free software; you can redistribute it and/or
006 * modify it under the terms of the GNU Lesser General Public
007 * License as published by the Free Software Foundation; either
008 * version 2.1 of the License, or (at your option) any later version.
009 *
010 * This library is distributed in the hope that it will be useful,
011 * but WITHOUT ANY WARRANTY; without even the implied warranty of
012 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
013 * Lesser General Public License for more details.
014 *
015 * You should have received a copy of the GNU Lesser General Public
016 * License along with this library; if not, write to the Free Software
017 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
018 */
019 package jline;
020
021 import java.io.*;
022 import java.util.*;
023
024
025 /**
026 * A command history buffer.
027 *
028 * @author <a href="mailto:mwp1@cornell.edu">Marc Prud'hommeaux</a>
029 */
030 public class History
031 {
032 private List history = new ArrayList ();
033 private PrintWriter output = null;
034 private int maxSize = 500;
035 private int currentIndex = 0;
036
037
038 /**
039 * Construstor: initialize a blank history.
040 */
041 public History ()
042 {
043 }
044
045
046 /**
047 * Construstor: initialize History object the the specified
048 * {@link File} for storage.
049 */
050 public History (final File historyFile)
051 throws IOException
052 {
053 setHistoryFile (historyFile);
054 }
055
056
057 public void setHistoryFile (final File historyFile)
058 throws IOException
059 {
060 if (historyFile.isFile ())
061 load (new FileInputStream (historyFile));
062 setOutput (new PrintWriter (new FileWriter (historyFile), true));
063 flushBuffer ();
064 }
065
066
067 /**
068 * Load the history buffer from the specified InputStream.
069 */
070 public void load (final InputStream in)
071 throws IOException
072 {
073 load (new InputStreamReader (in));
074 }
075
076
077 /**
078 * Load the history buffer from the specified Reader.
079 */
080 public void load (final Reader reader)
081 throws IOException
082 {
083 BufferedReader breader = new BufferedReader (reader);
084 List lines = new ArrayList ();
085 String line;
086 while ((line = breader.readLine ()) != null)
087 {
088 lines.add (line);
089 }
090
091 for (Iterator i = lines.iterator (); i.hasNext (); )
092 addToHistory ((String)i.next ());
093 }
094
095
096 public int size ()
097 {
098 return history.size ();
099 }
100
101
102 /**
103 * Clear the history buffer
104 */
105 public void clear ()
106 {
107 history.clear ();
108 currentIndex = 0;
109 }
110
111
112 /**
113 * Add the specified buffer to the end of the history. The pointer is
114 * set to the end of the history buffer.
115 */
116 public void addToHistory (final String buffer)
117 {
118 // don't append duplicates to the end of the buffer
119 if (history.size () != 0 && buffer.equals (
120 history.get (history.size () - 1)))
121 return;
122
123 history.add (buffer);
124 while (history.size () > getMaxSize ())
125 history.remove (0);
126
127 currentIndex = history.size ();
128
129 if (getOutput () != null)
130 {
131 getOutput ().println (buffer);
132 getOutput ().flush ();
133 }
134 }
135
136
137 /**
138 * Flush the entire history buffer to the output PrintWriter.
139 */
140 public void flushBuffer ()
141 throws IOException
142 {
143 if (getOutput () != null)
144 {
145 for (Iterator i = history.iterator (); i.hasNext ();
146 getOutput ().println ((String)i.next ()));
147
148 getOutput ().flush ();
149 }
150 }
151
152
153 /**
154 * Move to the end of the history buffer.
155 */
156 public void moveToEnd ()
157 {
158 currentIndex = history.size ();
159 }
160
161
162 /**
163 * Set the maximum size that the history buffer will store.
164 */
165 public void setMaxSize (final int maxSize)
166 {
167 this.maxSize = maxSize;
168 }
169
170
171 /**
172 * Get the maximum size that the history buffer will store.
173 */
174 public int getMaxSize ()
175 {
176 return this.maxSize;
177 }
178
179
180 /**
181 * The output to which all history elements will be written (or null
182 * of history is not saved to a buffer).
183 */
184 public void setOutput (final PrintWriter output)
185 {
186 this.output = output;
187 }
188
189
190 /**
191 * Returns the PrintWriter that is used to store history elements.
192 */
193 public PrintWriter getOutput ()
194 {
195 return this.output;
196 }
197
198
199 /**
200 * Returns the current history index.
201 */
202 public int getCurrentIndex ()
203 {
204 return this.currentIndex;
205 }
206
207
208 /**
209 * Return the content of the current buffer.
210 */
211 public String current ()
212 {
213 if (currentIndex >= history.size ())
214 return "";
215
216 return (String)history.get (currentIndex);
217 }
218
219
220 /**
221 * Move the pointer to the previous element in the buffer.
222 *
223 * @return true if we successfully went to the previous element
224 */
225 public boolean previous ()
226 {
227 if (currentIndex <= 0)
228 return false;
229
230 currentIndex--;
231 return true;
232 }
233
234
235 /**
236 * Move the pointer to the next element in the buffer.
237 *
238 * @return true if we successfully went to the next element
239 */
240 public boolean next ()
241 {
242 if (currentIndex >= history.size ())
243 return false;
244
245 currentIndex++;
246 return true;
247 }
248
249
250 /**
251 * Returns an immutable list of the history buffer.
252 */
253 public List getHistoryList ()
254 {
255 return Collections.unmodifiableList (history);
256 }
257
258
259 /**
260 * Returns the standard {@link AbstractCollection#toString} representation
261 * of the history list.
262 */
263 public String toString ()
264 {
265 return history.toString ();
266 }
267 }
268