JAL-1233 JAL-1576 copy constructor to propagate helix colours and applyTo implementat...
[jalview.git] / src / jalview / io / IdentifyFile.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
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
10  * of the License, or (at your option) any later version.
11  *
12  * Jalview is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty
14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15  * PURPOSE.  See the GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
19  * The Jalview Authors are detailed in the 'AUTHORS' file.
20  */
21 package jalview.io;
22
23 import java.io.IOException;
24
25 /**
26  * DOCUMENT ME!
27  *
28  * @author $author$
29  * @version $Revision$
30  */
31 public class IdentifyFile
32 {
33   public static final String GFF3File = "GFF v2 or v3";
34
35   /**
36    * Identify a datasource's file content.
37    *
38    * @note Do not use this method for stream sources - create a FileParse object
39    *       instead.
40    *
41    * @param file
42    *          DOCUMENT ME!
43    * @param protocol
44    *          DOCUMENT ME!
45    * @return ID String
46    */
47   public String Identify(String file, String protocol)
48   {
49     String emessage = "UNIDENTIFIED FILE PARSING ERROR";
50     FileParse parser = null;
51     try
52     {
53       parser = new FileParse(file, protocol);
54       if (parser.isValid())
55       {
56         return Identify(parser);
57       }
58     } catch (Exception e)
59     {
60       System.err.println("Error whilst identifying");
61       e.printStackTrace(System.err);
62       emessage = e.getMessage();
63     }
64     if (parser != null)
65     {
66       return parser.errormessage;
67     }
68     return emessage;
69   }
70
71   public String Identify(FileParse source)
72   {
73     return Identify(source, true); // preserves original behaviour prior to
74     // version 2.3
75   }
76
77   /**
78    * Identify contents of source, closing it or resetting source to start
79    * afterwards.
80    *
81    * @param source
82    * @param closeSource
83    * @return filetype string
84    */
85   public String Identify(FileParse source, boolean closeSource)
86   {
87     String reply = "PFAM";
88     String data;
89     int length = 0;
90     boolean lineswereskipped = false;
91     boolean isBinary = false; // true if length is non-zero and non-printable
92     // characters are encountered
93     try
94     {
95       if (!closeSource)
96       {
97         source.mark();
98       }
99       while ((data = source.nextLine()) != null)
100       {
101         length += data.trim().length();
102         if (!lineswereskipped)
103         {
104           for (int i = 0; !isBinary && i < data.length(); i++)
105           {
106             char c = data.charAt(i);
107             isBinary = (c < 32 && c != '\t' && c != '\n' && c != '\r'
108                     && c != 5 && c != 27); // nominal binary character filter
109             // excluding CR, LF, tab,DEL and ^E
110             // for certain blast ids
111           }
112         }
113         if (isBinary)
114         {
115           // jar files are special - since they contain all sorts of random
116           // characters.
117           if (source.inFile != null)
118           {
119             String fileStr = source.inFile.getName();
120             // possibly a Jalview archive.
121             if (fileStr.lastIndexOf(".jar") > -1
122                     || fileStr.lastIndexOf(".zip") > -1)
123             {
124               reply = "Jalview";
125             }
126           }
127           if (!lineswereskipped && data.startsWith("PK"))
128           {
129             reply = "Jalview"; // archive.
130             break;
131           }
132         }
133         data = data.toUpperCase();
134
135         if (data.startsWith("##GFF-VERSION"))
136         {
137           reply = GFF3File;
138           break;
139         }
140         if (data.indexOf("# STOCKHOLM") > -1)
141         {
142           reply = "STH";
143           break;
144         }
145         // if (data.indexOf(">") > -1)
146         if (data.startsWith(">"))
147         {
148           // FASTA, PIR file or BLC file
149           boolean checkPIR = false, starterm = false;
150           if ((data.indexOf(">P1;") > -1) || (data.indexOf(">DL;") > -1))
151           {
152             // watch for PIR file attributes
153             checkPIR = true;
154             reply = "PIR";
155           }
156           // could also be BLC file, read next line to confirm
157           data = source.nextLine();
158
159           if (data.indexOf(">") > -1)
160           {
161             reply = "BLC";
162           }
163           else
164           {
165             // Is this a single line BLC file?
166             String data1 = source.nextLine();
167             String data2 = source.nextLine();
168             int c1;
169             if (checkPIR)
170             {
171               starterm = (data1 != null && data1.indexOf("*") > -1)
172                       || (data2 != null && data2.indexOf("*") > -1);
173             }
174             if (data2 != null && (c1 = data.indexOf("*")) > -1)
175             {
176               if (c1 == 0 && c1 == data2.indexOf("*"))
177               {
178                 reply = "BLC";
179               }
180               else
181               {
182                 reply = "FASTA"; // possibly a bad choice - may be recognised as
183                 // PIR
184               }
185               // otherwise can still possibly be a PIR file
186             }
187             else
188             {
189               reply = "FASTA";
190               // TODO : AMSA File is indicated if there is annotation in the
191               // FASTA file - but FASTA will automatically generate this at the
192               // mo.
193               if (!checkPIR)
194               {
195                 break;
196               }
197             }
198           }
199           // final check for PIR content. require
200           // >P1;title\n<blah>\nterminated sequence to occur at least once.
201
202           // TODO the PIR/fasta ambiguity may be the use case that is needed to
203           // have
204           // a 'Parse as type XXX' parameter for the applet/application.
205           if (checkPIR)
206           {
207             String dta = null;
208             if (!starterm)
209             {
210               do
211               {
212                 try
213                 {
214                   dta = source.nextLine();
215                 } catch (IOException ex)
216                 {
217                 }
218                 ;
219                 if (dta != null && dta.indexOf("*") > -1)
220                 {
221                   starterm = true;
222                 }
223               } while (dta != null && !starterm);
224             }
225             if (starterm)
226             {
227               reply = "PIR";
228               break;
229             }
230             else
231             {
232               reply = "FASTA"; // probably a bad choice!
233             }
234           }
235           // read as a FASTA (probably)
236           break;
237         }
238         if ((data.indexOf("<") > -1)) // possible Markup Language data i.e HTML,
239                                       // RNAML, XML
240         {
241           boolean identified = false;
242           do
243           {
244             if (data.matches("<(?i)html(\"[^\"]*\"|'[^']*'|[^'\">])*>"))
245             {
246               reply = HtmlFile.FILE_DESC;
247               identified = true;
248               break;
249             }
250
251             if (data.matches("<(?i)rnaml (\"[^\"]*\"|'[^']*'|[^'\">])*>"))
252             {
253               reply = "RNAML";
254               identified = true;
255               break;
256             }
257           } while ((data = source.nextLine()) != null);
258
259           if (identified)
260           {
261             break;
262           }
263         }
264
265         if (data.indexOf("{\"") > -1)
266         {
267           reply = JSONFile.FILE_DESC;
268           break;
269         }
270         if ((data.length() < 1) || (data.indexOf("#") == 0))
271         {
272           lineswereskipped = true;
273           continue;
274         }
275
276         if (data.indexOf("PILEUP") > -1)
277         {
278           reply = "PileUp";
279
280           break;
281         }
282
283         if ((data.indexOf("//") == 0)
284                 || ((data.indexOf("!!") > -1) && (data.indexOf("!!") < data
285                         .indexOf("_MULTIPLE_ALIGNMENT "))))
286         {
287           reply = "MSF";
288
289           break;
290         }
291         else if (data.indexOf("CLUSTAL") > -1)
292         {
293           reply = "CLUSTAL";
294
295           break;
296         }
297
298         else if (data.indexOf("HEADER") == 0 || data.indexOf("ATOM") == 0)
299         {
300           reply = "PDB";
301           break;
302         }
303         else if (data.matches("\\s*\\d+\\s+\\d+\\s*"))
304         {
305           reply = PhylipFile.FILE_DESC;
306           break;
307         }
308
309
310         /*
311          * // TODO comment out SimpleBLAST identification for Jalview 2.4.1 else
312          * if (!lineswereskipped && data.indexOf("BLAST")<4) { reply =
313          * "SimpleBLAST"; break;
314          *
315          * } // end comments for Jalview 2.4.1
316          */
317         else if (!lineswereskipped && data.charAt(0) != '*'
318                 && data.charAt(0) != ' '
319                 && data.indexOf(":") < data.indexOf(",")) // &&
320           // data.indexOf(",")<data.indexOf(",",
321           // data.indexOf(",")))
322         {
323           // file looks like a concise JNet file
324           reply = "JnetFile";
325           break;
326         }
327
328         lineswereskipped = true; // this means there was some junk before any
329         // key file signature
330       }
331       if (closeSource)
332       {
333         source.close();
334       }
335       else
336       {
337         source.reset(); // so the file can be parsed from the beginning again.
338       }
339     } catch (Exception ex)
340     {
341       System.err.println("File Identification failed!\n" + ex);
342       return source.errormessage;
343     }
344     if (length == 0)
345     {
346       System.err
347       .println("File Identification failed! - Empty file was read.");
348       return "EMPTY DATA FILE";
349     }
350     return reply;
351   }
352
353   public static void main(String[] args)
354   {
355
356     for (int i = 0; args != null && i < args.length; i++)
357     {
358       IdentifyFile ider = new IdentifyFile();
359       String type = ider.Identify(args[i], AppletFormatAdapter.FILE);
360       System.out.println("Type of " + args[i] + " is " + type);
361     }
362     if (args == null || args.length == 0)
363     {
364       System.err.println("Usage: <Filename> [<Filename> ...]");
365     }
366   }
367 }