convenience method to discover all Jmols
[jalview.git] / src / jalview / io / FileParse.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.6)
3  * Copyright (C) 2010 J Procter, AM Waterhouse, G Barton, M Clamp, S Searle
4  * 
5  * This file is part of Jalview.
6  * 
7  * Jalview is free software: you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License 
9  * as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
10  * 
11  * Jalview is distributed in the hope that it will be useful, but 
12  * WITHOUT ANY WARRANTY; without even the implied warranty 
13  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
14  * PURPOSE.  See the GNU General Public License for more details.
15  * 
16  * You should have received a copy of the GNU General Public License along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
17  */
18 package jalview.io;
19
20 import java.io.*;
21 import java.net.*;
22
23 /**
24  * implements a random access wrapper around a particular datasource, for
25  * passing to identifyFile and AlignFile objects.
26  */
27 public class FileParse
28 {
29   /**
30    * text specifying source of data. usually filename or url.
31    */
32   private String dataName = "unknown source";
33
34   public File inFile = null;
35
36   public int index = 1; // sequence counter for FileParse object created from
37
38   // same data source
39
40   protected char suffixSeparator = '#';
41   /**
42    * character used to write newlines 
43    */
44   protected String newline = System.getProperty("line.separator");
45   public void setNewlineString(String nl)
46   {
47     newline = nl;
48   }
49   public String getNewlineString()
50   {
51     return newline;
52   }
53   /**
54    * '#' separated string tagged on to end of filename or url that was clipped
55    * off to resolve to valid filename
56    */
57   protected String suffix = null;
58
59   protected String type = null;
60
61   protected BufferedReader dataIn = null;
62
63   protected String errormessage = "UNITIALISED SOURCE";
64
65   protected boolean error = true;
66
67   protected String warningMessage = null;
68
69   /**
70    * size of readahead buffer used for when initial stream position is marked.
71    */
72   final int READAHEAD_LIMIT = 2048;
73
74   public FileParse()
75   {
76   }
77
78   /**
79    * Create a new FileParse instance reading from the same datasource starting
80    * at the current position. WARNING! Subsequent reads from either object will
81    * affect the read position of the other, but not the error state.
82    * 
83    * @param from
84    */
85   public FileParse(FileParse from) throws IOException
86   {
87     if (from == null)
88     {
89       throw new Error(
90               "Implementation error. Null FileParse in copy constructor");
91     }
92     if (from == this)
93       return;
94     index = ++from.index;
95     inFile = from.inFile;
96     suffixSeparator = from.suffixSeparator;
97     suffix = from.suffix;
98     errormessage = from.errormessage; // inherit potential error messages
99     error = false; // reset any error condition.
100     type = from.type;
101     dataIn = from.dataIn;
102     if (dataIn != null)
103     {
104       mark();
105     }
106     dataName = from.dataName;
107   }
108
109   /**
110    * Attempt to open a file as a datasource. Sets error and errormessage if
111    * fileStr was invalid.
112    * 
113    * @param fileStr
114    * @return this.error (true if the source was invalid)
115    */
116   private boolean checkFileSource(String fileStr) throws IOException
117   {
118     error = false;
119     this.inFile = new File(fileStr);
120     // check to see if it's a Jar file in disguise.
121     if (!inFile.exists())
122     {
123       errormessage = "FILE NOT FOUND";
124       error = true;
125     }
126     if (!inFile.canRead())
127     {
128       errormessage = "FILE CANNOT BE OPENED FOR READING";
129       error = true;
130     }
131     if (inFile.isDirectory())
132     {
133       // this is really a 'complex' filetype - but we don't handle directory
134       // reads yet.
135       errormessage = "FILE IS A DIRECTORY";
136       error = true;
137     }
138     if (!error)
139     {
140       dataIn = new BufferedReader(new FileReader(fileStr));
141       dataName = fileStr;
142     }
143     return error;
144   }
145
146   private boolean checkURLSource(String fileStr) throws IOException,
147           MalformedURLException
148   {
149     errormessage = "URL NOT FOUND";
150     URL url = new URL(fileStr);
151     dataIn = new BufferedReader(new InputStreamReader(url.openStream()));
152     // record URL as name of datasource.
153     dataName = fileStr;
154     return false;
155   }
156
157   /**
158    * sets the suffix string (if any) and returns remainder (if suffix was
159    * detected)
160    * 
161    * @param fileStr
162    * @return truncated fileStr or null
163    */
164   private String extractSuffix(String fileStr)
165   {
166     // first check that there wasn't a suffix string tagged on.
167     int sfpos = fileStr.lastIndexOf(suffixSeparator);
168     if (sfpos > -1 && sfpos < fileStr.length() - 1)
169     {
170       suffix = fileStr.substring(sfpos + 1);
171       // System.err.println("DEBUG: Found Suffix:"+suffix);
172       return fileStr.substring(0, sfpos);
173     }
174     return null;
175   }
176
177   /**
178    * Create a datasource for input to Jalview. See AppletFormatAdapter for the
179    * types of sources that are handled.
180    * 
181    * @param fileStr
182    *          - datasource locator/content
183    * @param type
184    *          - protocol of source
185    * @throws MalformedURLException
186    * @throws IOException
187    */
188   public FileParse(String fileStr, String type)
189           throws MalformedURLException, IOException
190   {
191     this.type = type;
192     error = false;
193
194     if (type.equals(AppletFormatAdapter.FILE))
195     {
196       if (checkFileSource(fileStr))
197       {
198         String suffixLess = extractSuffix(fileStr);
199         if (suffixLess != null)
200         {
201           if (checkFileSource(suffixLess))
202           {
203             throw new IOException("Problem opening " + inFile
204                     + " (also tried " + suffixLess + ") : " + errormessage);
205           }
206         }
207         else
208         {
209           throw new IOException("Problem opening " + inFile + " : "
210                   + errormessage);
211         }
212       }
213     }
214     else if (type.equals(AppletFormatAdapter.URL))
215     {
216       try
217       {
218         try
219         {
220           checkURLSource(fileStr);
221           if (suffixSeparator == '#')
222             extractSuffix(fileStr); // URL lref is stored for later reference.
223         } catch (IOException e)
224         {
225           String suffixLess = extractSuffix(fileStr);
226           if (suffixLess == null)
227           {
228             throw (e);
229           }
230           else
231           {
232             try
233             {
234               checkURLSource(suffixLess);
235             } catch (IOException e2)
236             {
237               errormessage = "BAD URL WITH OR WITHOUT SUFFIX";
238               throw (e); // just pass back original - everything was wrong.
239             }
240           }
241         }
242       } catch (Exception e)
243       {
244         errormessage = "CANNOT ACCESS DATA AT URL '" + fileStr + "' ("
245                 + e.getMessage() + ")";
246         error = true;
247       }
248     }
249     else if (type.equals(AppletFormatAdapter.PASTE))
250     {
251       errormessage = "PASTE INACCESSIBLE!";
252       dataIn = new BufferedReader(new StringReader(fileStr));
253       dataName = "Paste";
254     }
255     else if (type.equals(AppletFormatAdapter.CLASSLOADER))
256     {
257       errormessage = "RESOURCE CANNOT BE LOCATED";
258       java.io.InputStream is = getClass()
259               .getResourceAsStream("/" + fileStr);
260       if (is == null)
261       {
262         String suffixLess = extractSuffix(fileStr);
263         if (suffixLess != null)
264           is = getClass().getResourceAsStream("/" + suffixLess);
265       }
266       if (is != null)
267       {
268         dataIn = new BufferedReader(new java.io.InputStreamReader(is));
269         dataName = fileStr;
270       }
271       else
272       {
273         error = true;
274       }
275     }
276     else
277     {
278       errormessage = "PROBABLE IMPLEMENTATION ERROR : Datasource Type given as '"
279               + (type != null ? type : "null") + "'";
280       error = true;
281     }
282     if (dataIn == null || error)
283     {
284       // pass up the reason why we have no source to read from
285       throw new IOException("Failed to read data from source:\n"
286               + errormessage);
287     }
288     error = false;
289     dataIn.mark(READAHEAD_LIMIT);
290   }
291
292   /**
293    * mark the current position in the source as start for the purposes of it
294    * being analysed by IdentifyFile().identify
295    * 
296    * @throws IOException
297    */
298   public void mark() throws IOException
299   {
300     if (dataIn != null)
301     {
302       dataIn.mark(READAHEAD_LIMIT);
303     }
304     else
305     {
306       throw new IOException("Unitialised Source Stream");
307     }
308   }
309
310   public String nextLine() throws IOException
311   {
312     if (!error)
313       return dataIn.readLine();
314     throw new IOException("Invalid Source Stream:" + errormessage);
315   }
316
317   public boolean isValid()
318   {
319     return !error;
320   }
321
322   /**
323    * closes the datasource and tidies up. source will be left in an error state
324    */
325   public void close() throws IOException
326   {
327     errormessage = "EXCEPTION ON CLOSE";
328     error = true;
329     dataIn.close();
330     dataIn = null;
331     errormessage = "SOURCE IS CLOSED";
332   }
333
334   /**
335    * rewinds the datasource the beginning.
336    * 
337    */
338   public void reset() throws IOException
339   {
340     if (dataIn != null && !error)
341     {
342       dataIn.reset();
343     }
344     else
345     {
346       throw new IOException(
347               "Implementation Error: Reset called for invalid source.");
348     }
349   }
350
351   /**
352    * 
353    * @return true if there is a warning for the user
354    */
355   public boolean hasWarningMessage()
356   {
357     return (warningMessage != null && warningMessage.length() > 0);
358   }
359
360   /**
361    * 
362    * @return empty string or warning message about file that was just parsed.
363    */
364   public String getWarningMessage()
365   {
366     return warningMessage;
367   }
368
369   public String getInFile()
370   {
371     if (inFile != null)
372     {
373       return inFile.getAbsolutePath() + " (" + index + ")";
374     }
375     else
376     {
377       return "From Paste + (" + index + ")";
378     }
379   }
380
381   /**
382    * @return the dataName
383    */
384   public String getDataName()
385   {
386     return dataName;
387   }
388   /**
389    * set the (human readable) name or URI for this datasource
390    * @param dataname
391    */
392   protected void setDataName(String dataname) {
393     dataName = dataname;
394   }
395   
396
397   /**
398    * get the underlying bufferedReader for this data source.
399    * @return null if no reader available
400    * @throws IOException
401    */
402   public Reader getReader()
403   {
404     if (dataIn != null) // Probably don't need to test for readiness && dataIn.ready())
405     {
406       return dataIn;
407     }
408     return null;
409   }
410 }