JAL-1140 reinstate the simpler version of parsing code from annotate3d update
[jalview.git] / src / jalview / io / AppletFormatAdapter.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8)
3  * Copyright (C) 2012 J Procter, AM Waterhouse, LM Lui, J Engelhardt, 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.File;
21 import java.io.InputStream;
22
23 import jalview.datamodel.*;
24
25 /**
26  * A low level class for alignment and feature IO with alignment formatting
27  * methods used by both applet and application for generating flat alignment
28  * files. It also holds the lists of magic format names that the applet and
29  * application will allow the user to read or write files with.
30  * 
31  * @author $author$
32  * @version $Revision$
33  */
34 public class AppletFormatAdapter
35 {
36   /**
37    * List of valid format strings used in the isValidFormat method
38    */
39   public static final String[] READABLE_FORMATS = new String[]
40   { "BLC", "CLUSTAL", "FASTA", "MSF", "PileUp", "PIR", "PFAM", "STH",
41       "PDB", "JnetFile" , "RNAML"}; // , "SimpleBLAST" };
42
43   /**
44    * List of valid format strings for use by callers of the formatSequences
45    * method
46    */
47   public static final String[] WRITEABLE_FORMATS = new String[]
48   { "BLC", "CLUSTAL", "FASTA", "MSF", "PileUp", "PIR", "PFAM", "AMSA" };
49
50   /**
51    * List of extensions corresponding to file format types in WRITABLE_FNAMES
52    * that are writable by the application.
53    */
54   public static final String[] WRITABLE_EXTENSIONS = new String[]
55   { "fa,faa,fasta,fastq", "aln", "pfam", "msf", "pir", "blc", "amsa", "jar" };
56
57   /**
58    * List of writable formats by the application. Order must correspond with the
59    * WRITABLE_EXTENSIONS list of formats.
60    */
61   public static final String[] WRITABLE_FNAMES = new String[]
62   { "Fasta", "Clustal", "PFAM", "MSF", "PIR", "BLC", "AMSA", "Jalview" };
63
64   /**
65    * List of readable format file extensions by application in order
66    * corresponding to READABLE_FNAMES
67    */
68   public static final String[] READABLE_EXTENSIONS = new String[]
69   { "fa,faa,fasta,fastq", "aln", "pfam", "msf", "pir", "blc", "amsa", "jar",
70       "sto,stk","xml,rnaml" }; // ,
71
72   // ".blast"
73   // };
74
75   /**
76    * List of readable formats by application in order corresponding to
77    * READABLE_EXTENSIONS
78    */
79   public static final String[] READABLE_FNAMES = new String[]
80   { "Fasta", "Clustal", "PFAM", "MSF", "PIR", "BLC", "AMSA", "Jalview",
81       "Stockholm","RNAML" };// ,
82
83   // "SimpleBLAST"
84   // };
85
86   public static String INVALID_CHARACTERS = "Contains invalid characters";
87
88   // TODO: make these messages dynamic
89   public static String SUPPORTED_FORMATS = "Formats currently supported are\n"
90           + prettyPrint(READABLE_FORMATS);
91
92   /**
93    * 
94    * @param els
95    * @return grammatically correct(ish) list consisting of els elements.
96    */
97   public static String prettyPrint(String[] els)
98   {
99     StringBuffer list = new StringBuffer();
100     for (int i = 0, iSize = els.length - 1; i < iSize; i++)
101     {
102       list.append(els[i]);
103       list.append(",");
104     }
105     list.append(" and " + els[els.length - 1] + ".");
106     return list.toString();
107   }
108
109   public static String FILE = "File";
110
111   public static String URL = "URL";
112
113   public static String PASTE = "Paste";
114
115   public static String CLASSLOADER = "ClassLoader";
116
117   AlignFile afile = null;
118
119   String inFile;
120
121   /**
122    * character used to write newlines
123    */
124   protected String newline = System.getProperty("line.separator");
125
126   public void setNewlineString(String nl)
127   {
128     newline = nl;
129   }
130
131   public String getNewlineString()
132   {
133     return newline;
134   }
135
136   /**
137    * check that this format is valid for reading
138    * 
139    * @param format
140    *          a format string to be compared with READABLE_FORMATS
141    * @return true if format is readable
142    */
143   public static final boolean isValidFormat(String format)
144   {
145     return isValidFormat(format, false);
146   }
147
148   /**
149    * validate format is valid for IO
150    * 
151    * @param format
152    *          a format string to be compared with either READABLE_FORMATS or
153    *          WRITEABLE_FORMATS
154    * @param forwriting
155    *          when true, format is checked for containment in WRITEABLE_FORMATS
156    * @return true if format is valid
157    */
158   public static final boolean isValidFormat(String format,
159           boolean forwriting)
160   {
161     boolean valid = false;
162     String[] format_list = (forwriting) ? WRITEABLE_FORMATS
163             : READABLE_FORMATS;
164     for (int i = 0; i < format_list.length; i++)
165     {
166       if (format_list[i].equalsIgnoreCase(format))
167       {
168         return true;
169       }
170     }
171
172     return valid;
173   }
174
175   /**
176    * Constructs the correct filetype parser for a characterised datasource
177    * 
178    * @param inFile
179    *          data/data location
180    * @param type
181    *          type of datasource
182    * @param format
183    *          File format of data provided by datasource
184    * 
185    * @return DOCUMENT ME!
186    */
187   public Alignment readFile(String inFile, String type, String format)
188           throws java.io.IOException
189   {
190     // TODO: generalise mapping between format string and io. class instances
191     // using Constructor.invoke reflection
192     this.inFile = inFile;
193     try
194     {
195       if (format.equals("FASTA"))
196       {
197         afile = new FastaFile(inFile, type);
198       }
199       else if (format.equals("MSF"))
200       {
201         afile = new MSFfile(inFile, type);
202       }
203       else if (format.equals("PileUp"))
204       {
205         afile = new PileUpfile(inFile, type);
206       }
207       else if (format.equals("CLUSTAL"))
208       {
209         afile = new ClustalFile(inFile, type);
210       }
211       else if (format.equals("BLC"))
212       {
213         afile = new BLCFile(inFile, type);
214       }
215       else if (format.equals("PIR"))
216       {
217         afile = new PIRFile(inFile, type);
218       }
219       else if (format.equals("PFAM"))
220       {
221         afile = new PfamFile(inFile, type);
222       }
223       else if (format.equals("JnetFile"))
224       {
225         afile = new JPredFile(inFile, type);
226         ((JPredFile) afile).removeNonSequences();
227       }
228       else if (format.equals("PDB"))
229       {
230         afile = new MCview.PDBfile(inFile, type);        
231         // Uncomment to test Jmol data based PDB processing: JAL-1213
232         // afile = new jalview.ext.jmol.PDBFileWithJmol(inFile, type);
233       }
234       else if (format.equals("STH"))
235       {
236         afile = new StockholmFile(inFile, type);
237       }
238       else if (format.equals("SimpleBLAST"))
239       {
240         afile = new SimpleBlastFile(inFile, type);
241       }
242       else if (format.equals("RNAML"))
243       {
244         afile = new RnamlFile(inFile, type);
245       }
246       
247       Alignment al = new Alignment(afile.getSeqsAsArray());
248
249       afile.addAnnotations(al);
250
251       return al;
252     } catch (Exception e)
253     {
254       e.printStackTrace();
255       System.err.println("Failed to read alignment using the '" + format
256               + "' reader.\n" + e);
257
258       if (e.getMessage() != null
259               && e.getMessage().startsWith(INVALID_CHARACTERS))
260       {
261         throw new java.io.IOException(e.getMessage());
262       }
263
264       // Finally test if the user has pasted just the sequence, no id
265       if (type.equalsIgnoreCase("Paste"))
266       {
267         try
268         {
269           // Possible sequence is just residues with no label
270           afile = new FastaFile(">UNKNOWN\n" + inFile, "Paste");
271           Alignment al = new Alignment(afile.getSeqsAsArray());
272           afile.addAnnotations(al);
273           return al;
274
275         } catch (Exception ex)
276         {
277           if (ex.toString().startsWith(INVALID_CHARACTERS))
278           {
279             throw new java.io.IOException(e.getMessage());
280           }
281
282           ex.printStackTrace();
283         }
284       }
285
286       // If we get to this stage, the format was not supported
287       throw new java.io.IOException(SUPPORTED_FORMATS);
288     }
289   }
290
291   /**
292    * Constructs the correct filetype parser for an already open datasource
293    * 
294    * @param source
295    *          an existing datasource
296    * @param format
297    *          File format of data that will be provided by datasource
298    * 
299    * @return DOCUMENT ME!
300    */
301   public AlignmentI readFromFile(FileParse source, String format)
302           throws java.io.IOException
303   {
304     // TODO: generalise mapping between format string and io. class instances
305     // using Constructor.invoke reflection
306     // This is exactly the same as the readFile method except we substitute
307     // 'inFile, type' with 'source'
308     this.inFile = source.getInFile();
309     String type = source.type;
310     try
311     {
312       if (format.equals("FASTA"))
313       {
314         afile = new FastaFile(source);
315       }
316       else if (format.equals("MSF"))
317       {
318         afile = new MSFfile(source);
319       }
320       else if (format.equals("PileUp"))
321       {
322         afile = new PileUpfile(source);
323       }
324       else if (format.equals("CLUSTAL"))
325       {
326         afile = new ClustalFile(source);
327       }
328       else if (format.equals("BLC"))
329       {
330         afile = new BLCFile(source);
331       }
332       else if (format.equals("PIR"))
333       {
334         afile = new PIRFile(source);
335       }
336       else if (format.equals("PFAM"))
337       {
338         afile = new PfamFile(source);
339       }
340       else if (format.equals("JnetFile"))
341       {
342         afile = new JPredFile(source);
343         ((JPredFile) afile).removeNonSequences();
344       }
345       else if (format.equals("PDB"))
346       {
347         afile = new MCview.PDBfile(source);
348       }
349       else if (format.equals("STH"))
350       {
351         afile = new StockholmFile(source);
352       }
353       else if (format.equals("RNAML"))
354       {
355         afile = new RnamlFile(source);
356       }
357       else if (format.equals("SimpleBLAST"))
358       {
359         afile = new SimpleBlastFile(source);
360       }
361
362       Alignment al = new Alignment(afile.getSeqsAsArray());
363
364       afile.addAnnotations(al);
365
366       return al;
367     } catch (Exception e)
368     {
369       e.printStackTrace();
370       System.err.println("Failed to read alignment using the '" + format
371               + "' reader.\n" + e);
372
373       if (e.getMessage() != null
374               && e.getMessage().startsWith(INVALID_CHARACTERS))
375       {
376         throw new java.io.IOException(e.getMessage());
377       }
378
379       // Finally test if the user has pasted just the sequence, no id
380       if (type.equalsIgnoreCase("Paste"))
381       {
382         try
383         {
384           // Possible sequence is just residues with no label
385           afile = new FastaFile(">UNKNOWN\n" + inFile, "Paste");
386           Alignment al = new Alignment(afile.getSeqsAsArray());
387           afile.addAnnotations(al);
388           return al;
389
390         } catch (Exception ex)
391         {
392           if (ex.toString().startsWith(INVALID_CHARACTERS))
393           {
394             throw new java.io.IOException(e.getMessage());
395           }
396
397           ex.printStackTrace();
398         }
399       }
400
401       // If we get to this stage, the format was not supported
402       throw new java.io.IOException(SUPPORTED_FORMATS);
403     }
404   }
405
406   /**
407    * Construct an output class for an alignment in a particular filetype TODO:
408    * allow caller to detect errors and warnings encountered when generating
409    * output
410    * 
411    * @param format
412    *          string name of alignment format
413    * @param alignment
414    *          the alignment to be written out
415    * @param jvsuffix
416    *          passed to AlnFile class controls whether /START-END is added to
417    *          sequence names
418    * 
419    * @return alignment flat file contents
420    */
421   public String formatSequences(String format, AlignmentI alignment,
422           boolean jvsuffix)
423   {
424     try
425     {
426       AlignFile afile = null;
427
428       if (format.equalsIgnoreCase("FASTA"))
429       {
430         afile = new FastaFile();
431       }
432       else if (format.equalsIgnoreCase("MSF"))
433       {
434         afile = new MSFfile();
435       }
436       else if (format.equalsIgnoreCase("PileUp"))
437       {
438         afile = new PileUpfile();
439       }
440       else if (format.equalsIgnoreCase("CLUSTAL"))
441       {
442         afile = new ClustalFile();
443       }
444       else if (format.equalsIgnoreCase("BLC"))
445       {
446         afile = new BLCFile();
447       }
448       else if (format.equalsIgnoreCase("PIR"))
449       {
450         afile = new PIRFile();
451       }
452       else if (format.equalsIgnoreCase("PFAM"))
453       {
454         afile = new PfamFile();
455       }
456       else if (format.equalsIgnoreCase("STH"))
457       {
458         afile = new StockholmFile();
459       }
460       else if (format.equalsIgnoreCase("AMSA"))
461       {
462         afile = new AMSAFile(alignment);
463       }
464       else if (format.equalsIgnoreCase("RNAML"))
465       {
466         afile = new RnamlFile();
467       }
468       
469       else
470       {
471         throw new Exception(
472                 "Implementation error: Unknown file format string");
473       }
474       afile.setNewlineString(newline);
475       afile.addJVSuffix(jvsuffix);
476
477       afile.setSeqs(alignment.getSequencesArray());
478
479       String afileresp = afile.print();
480       if (afile.hasWarningMessage())
481       {
482         System.err.println("Warning raised when writing as " + format
483                 + " : " + afile.getWarningMessage());
484       }
485       return afileresp;
486     } catch (Exception e)
487     {
488       System.err.println("Failed to write alignment as a '" + format
489               + "' file\n");
490       e.printStackTrace();
491     }
492
493     return null;
494   }
495
496   public static String checkProtocol(String file)
497   {
498     String protocol = FILE;
499     String ft = file.toLowerCase().trim();
500     if (ft.indexOf("http:") == 0 || ft.indexOf("https:") == 0
501             || ft.indexOf("file:") == 0)
502     {
503       protocol = URL;
504     }
505     return protocol;
506   }
507
508   public static void main(String[] args)
509   {
510     int i = 0;
511     while (i < args.length)
512     {
513       File f = new File(args[i]);
514       if (f.exists())
515       {
516         try
517         {
518           System.out.println("Reading file: " + f);
519           AppletFormatAdapter afa = new AppletFormatAdapter();
520           Runtime r = Runtime.getRuntime();
521           System.gc();
522           long memf = -r.totalMemory() + r.freeMemory();
523           long t1 = -System.currentTimeMillis();
524           Alignment al = afa.readFile(args[i], FILE,
525                   new IdentifyFile().Identify(args[i], FILE));
526           t1 += System.currentTimeMillis();
527           System.gc();
528           memf += r.totalMemory() - r.freeMemory();
529           if (al != null)
530           {
531             System.out.println("Alignment contains " + al.getHeight()
532                     + " sequences and " + al.getWidth() + " columns.");
533             try
534             {
535               System.out.println(new AppletFormatAdapter().formatSequences(
536                       "FASTA", al, true));
537             } catch (Exception e)
538             {
539               System.err
540                       .println("Couln't format the alignment for output as a FASTA file.");
541               e.printStackTrace(System.err);
542             }
543           }
544           else
545           {
546             System.out.println("Couldn't read alignment");
547           }
548           System.out.println("Read took " + (t1 / 1000.0) + " seconds.");
549           System.out
550                   .println("Difference between free memory now and before is "
551                           + (memf / (1024.0 * 1024.0) * 1.0) + " MB");
552
553         } catch (Exception e)
554         {
555           System.err.println("Exception when dealing with " + i
556                   + "'th argument: " + args[i] + "\n" + e);
557         }
558       }
559       else
560       {
561         System.err.println("Ignoring argument '" + args[i] + "' (" + i
562                 + "'th)- not a readable file.");
563       }
564       i++;
565     }
566   }
567
568   /**
569    * try to discover how to access the given file as a valid datasource that
570    * will be identified as the given type.
571    * 
572    * @param file
573    * @param format
574    * @return protocol that yields the data parsable as the given type
575    */
576   public static String resolveProtocol(String file, String format)
577   {
578     return resolveProtocol(file, format, false);
579   }
580
581   public static String resolveProtocol(String file, String format,
582           boolean debug)
583   {
584     // TODO: test thoroughly!
585     String protocol = null;
586     if (debug)
587     {
588       System.out.println("resolving datasource started with:\n>>file\n"
589               + file + ">>endfile");
590     }
591
592     // This might throw a security exception in certain browsers
593     // Netscape Communicator for instance.
594     try
595     {
596       boolean rtn = false;
597       InputStream is = System.getSecurityManager().getClass()
598               .getResourceAsStream("/" + file);
599       if (is != null)
600       {
601         rtn = true;
602         is.close();
603       }
604       if (debug)
605       {
606         System.err.println("Resource '" + file + "' was "
607                 + (rtn ? "" : "not") + " located by classloader.");
608       }
609       ;
610       if (rtn)
611       {
612         protocol = AppletFormatAdapter.CLASSLOADER;
613       }
614
615     } catch (Exception ex)
616     {
617       System.err
618               .println("Exception checking resources: " + file + " " + ex);
619     }
620
621     if (file.indexOf("://") > -1)
622     {
623       protocol = AppletFormatAdapter.URL;
624     }
625     else
626     {
627       // skipping codebase prepend check.
628       protocol = AppletFormatAdapter.FILE;
629     }
630     FileParse fp = null;
631     try
632     {
633       if (debug)
634       {
635         System.out.println("Trying to get contents of resource as "
636                 + protocol + ":");
637       }
638       fp = new FileParse(file, protocol);
639       if (!fp.isValid())
640       {
641         fp = null;
642       }
643       else
644       {
645         if (debug)
646         {
647           System.out.println("Successful.");
648         }
649       }
650     } catch (Exception e)
651     {
652       if (debug)
653       {
654         System.err.println("Exception when accessing content: " + e);
655       }
656       fp = null;
657     }
658     if (fp == null)
659     {
660       if (debug)
661       {
662         System.out.println("Accessing as paste.");
663       }
664       protocol = AppletFormatAdapter.PASTE;
665       fp = null;
666       try
667       {
668         fp = new FileParse(file, protocol);
669         if (!fp.isValid())
670         {
671           fp = null;
672         }
673       } catch (Exception e)
674       {
675         System.err.println("Failed to access content as paste!");
676         e.printStackTrace();
677         fp = null;
678       }
679     }
680     if (fp == null)
681     {
682       return null;
683     }
684     if (format == null || format.length() == 0)
685     {
686       return protocol;
687     }
688     else
689     {
690       try
691       {
692         String idformat = new jalview.io.IdentifyFile().Identify(file,
693                 protocol);
694         if (idformat == null)
695         {
696           if (debug)
697           {
698             System.out.println("Format not identified. Inaccessible file.");
699           }
700           return null;
701         }
702         if (debug)
703         {
704           System.out.println("Format identified as " + idformat
705                   + "and expected as " + format);
706         }
707         if (idformat.equals(format))
708         {
709           if (debug)
710           {
711             System.out.println("Protocol identified as " + protocol);
712           }
713           return protocol;
714         }
715         else
716         {
717           if (debug)
718           {
719             System.out
720                     .println("File deemed not accessible via " + protocol);
721           }
722           fp.close();
723           return null;
724         }
725       } catch (Exception e)
726       {
727         if (debug)
728         {
729           System.err.println("File deemed not accessible via " + protocol);
730           e.printStackTrace();
731         }
732         ;
733
734       }
735     }
736     return null;
737   }
738 }