JAL-3949 fixed failing commandlinetests due to more output and line count limit
[jalview.git] / src / jalview / io / FileFormat.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 import jalview.datamodel.AlignmentI;
26 import jalview.datamodel.DBRefSource;
27 import jalview.datamodel.PDBEntry;
28 import jalview.ext.jmol.JmolParser;
29 import jalview.structure.StructureImportSettings;
30
31 public enum FileFormat implements FileFormatI
32 {
33   Fasta("Fasta", "fa, fasta, mfa, fastq", true, true)
34   {
35     @Override
36     public AlignmentFileReaderI getReader(FileParse source)
37             throws IOException
38     {
39       return new FastaFile(source);
40     }
41
42     @Override
43     public AlignmentFileWriterI getWriter(AlignmentI al)
44     {
45       return new FastaFile();
46     }
47   },
48   Pfam("PFAM", "pfam", true, true)
49   {
50     @Override
51     public AlignmentFileReaderI getReader(FileParse source)
52             throws IOException
53     {
54       return new PfamFile(source);
55     }
56
57     @Override
58     public AlignmentFileWriterI getWriter(AlignmentI al)
59     {
60       return new PfamFile();
61     }
62   },
63   Stockholm("Stockholm", "sto,stk", true, true)
64   {
65     @Override
66     public AlignmentFileReaderI getReader(FileParse source)
67             throws IOException
68     {
69       return new StockholmFile(source);
70     }
71
72     @Override
73     public AlignmentFileWriterI getWriter(AlignmentI al)
74     {
75       return new StockholmFile(al);
76     }
77
78   },
79
80   PIR("PIR", "pir", true, true)
81   {
82     @Override
83     public AlignmentFileReaderI getReader(FileParse source)
84             throws IOException
85     {
86       return new PIRFile(source);
87     }
88
89     @Override
90     public AlignmentFileWriterI getWriter(AlignmentI al)
91     {
92       return new PIRFile();
93     }
94   },
95   BLC("BLC", "BLC", true, true)
96   {
97     @Override
98     public AlignmentFileReaderI getReader(FileParse source)
99             throws IOException
100     {
101       return new BLCFile(source);
102     }
103
104     @Override
105     public AlignmentFileWriterI getWriter(AlignmentI al)
106     {
107       return new BLCFile();
108     }
109   },
110   AMSA("AMSA", "amsa", true, true)
111   {
112     @Override
113     public AlignmentFileReaderI getReader(FileParse source)
114             throws IOException
115     {
116       return new AMSAFile(source);
117     }
118
119     @Override
120     public AlignmentFileWriterI getWriter(AlignmentI al)
121     {
122       return new AMSAFile(al);
123     }
124   },
125   Html("HTML", "html", true, false)
126   {
127     @Override
128     public AlignmentFileReaderI getReader(FileParse source)
129             throws IOException
130     {
131       return new HtmlFile(source);
132     }
133
134     @Override
135     public AlignmentFileWriterI getWriter(AlignmentI al)
136     {
137       return new HtmlFile();
138     }
139
140     @Override
141     public boolean isComplexAlignFile()
142     {
143       return true;
144     }
145
146   },
147   Rnaml("RNAML", "xml,rnaml", true, false)
148   {
149     @Override
150     public AlignmentFileReaderI getReader(FileParse source)
151             throws IOException
152     {
153       return new RnamlFile(source);
154     }
155
156     @Override
157     public AlignmentFileWriterI getWriter(AlignmentI al)
158     {
159       return new RnamlFile();
160     }
161
162   },
163   Json("JSON", "json", true, true)
164   {
165     @Override
166     public AlignmentFileReaderI getReader(FileParse source)
167             throws IOException
168     {
169       return new JSONFile(source);
170     }
171
172     @Override
173     public AlignmentFileWriterI getWriter(AlignmentI al)
174     {
175       return new JSONFile();
176     }
177
178     @Override
179     public boolean isComplexAlignFile()
180     {
181       return true;
182     }
183
184   },
185   Pileup("PileUp", "pileup", true, true)
186   {
187     @Override
188     public AlignmentFileReaderI getReader(FileParse source)
189             throws IOException
190     {
191       return new PileUpfile(source);
192     }
193
194     @Override
195     public AlignmentFileWriterI getWriter(AlignmentI al)
196     {
197       return new PileUpfile();
198     }
199
200   },
201   MSF("MSF", "msf", true, true)
202   {
203     @Override
204     public AlignmentFileReaderI getReader(FileParse source)
205             throws IOException
206     {
207       return new MSFfile(source);
208     }
209
210     @Override
211     public AlignmentFileWriterI getWriter(AlignmentI al)
212     {
213       return new MSFfile();
214     }
215
216   },
217   Clustal("Clustal", "aln", true, true)
218   {
219     @Override
220     public AlignmentFileReaderI getReader(FileParse source)
221             throws IOException
222     {
223       return new ClustalFile(source);
224     }
225
226     @Override
227     public AlignmentFileWriterI getWriter(AlignmentI al)
228     {
229       return new ClustalFile();
230     }
231   },
232   Phylip("PHYLIP", "phy", true, true)
233   {
234     @Override
235     public AlignmentFileReaderI getReader(FileParse source)
236             throws IOException
237     {
238       return new PhylipFile(source);
239     }
240
241     @Override
242     public AlignmentFileWriterI getWriter(AlignmentI al)
243     {
244       return new PhylipFile();
245     }
246   },
247   GenBank("GenBank Flatfile", "gb, gbk", true, false)
248   {
249     @Override
250     public AlignmentFileReaderI getReader(FileParse source)
251             throws IOException
252     {
253       return new GenBankFile(source, "GenBank");
254     }
255
256     @Override
257     public AlignmentFileWriterI getWriter(AlignmentI al)
258     {
259       return null;
260     }
261   },
262   Embl("ENA Flatfile", "txt", true, false)
263   {
264     @Override
265     public AlignmentFileReaderI getReader(FileParse source)
266             throws IOException
267     {
268       // Always assume we import from EMBL for now
269       return new EmblFlatFile(source, DBRefSource.EMBL);
270     }
271
272     @Override
273     public AlignmentFileWriterI getWriter(AlignmentI al)
274     {
275       return null;
276     }
277   },
278   Jnet("JnetFile", "", false, false)
279   {
280     @Override
281     public AlignmentFileReaderI getReader(FileParse source)
282             throws IOException
283     {
284       JPredFile af = new JPredFile(source);
285       af.removeNonSequences();
286       return af;
287     }
288
289     @Override
290     public AlignmentFileWriterI getWriter(AlignmentI al)
291     {
292       return null; // todo is this called?
293     }
294
295   },
296   Features("GFF or Jalview features", "gff2,gff3", true, false)
297   {
298     @Override
299     public AlignmentFileReaderI getReader(FileParse source)
300             throws IOException
301     {
302       return new FeaturesFile(source);
303     }
304
305     @Override
306     public AlignmentFileWriterI getWriter(AlignmentI al)
307     {
308       return new FeaturesFile();
309     }
310   },
311   ScoreMatrix("Substitution matrix", "", false, false)
312   {
313     @Override
314     public AlignmentFileReaderI getReader(FileParse source)
315             throws IOException
316     {
317       return new ScoreMatrixFile(source);
318     }
319
320     @Override
321     public AlignmentFileWriterI getWriter(AlignmentI al)
322     {
323       return null;
324     }
325   },
326   PDB("PDB", "pdb,ent", true, false)
327   {
328     @Override
329     public AlignmentFileReaderI getReader(FileParse source)
330             throws IOException
331     {
332       boolean isParseWithJMOL = StructureImportSettings
333               .getDefaultStructureFileFormat() != PDBEntry.Type.PDB;
334       if (isParseWithJMOL)
335       {
336         return new JmolParser(source);
337       }
338       else
339       {
340         StructureImportSettings.setShowSeqFeatures(true);
341         return new mc_view.PDBfile(
342                 StructureImportSettings.isVisibleChainAnnotation(),
343                 StructureImportSettings.isProcessSecondaryStructure(),
344                 StructureImportSettings.isExternalSecondaryStructure(),
345                 source);
346       }
347     }
348
349     @Override
350     public AlignmentFileWriterI getWriter(AlignmentI al)
351     {
352       return new JmolParser(); // todo or null?
353     }
354
355     @Override
356     public boolean isStructureFile()
357     {
358       return true;
359     }
360   },
361   MMCif("mmCIF", "cif", true, false)
362   {
363     @Override
364     public AlignmentFileReaderI getReader(FileParse source)
365             throws IOException
366     {
367       return new JmolParser(source);
368     }
369
370     @Override
371     public AlignmentFileWriterI getWriter(AlignmentI al)
372     {
373       return new JmolParser(); // todo or null?
374     }
375
376     @Override
377     public boolean isStructureFile()
378     {
379       return true;
380     }
381   },
382   Jalview("Jalview", "jvp, jar", true, true)
383   {
384     @Override
385     public AlignmentFileReaderI getReader(FileParse source)
386             throws IOException
387     {
388       return null;
389     }
390
391     @Override
392     public AlignmentFileWriterI getWriter(AlignmentI al)
393     {
394       return null;
395     }
396
397     @Override
398     public boolean isTextFormat()
399     {
400       return false;
401     }
402
403     @Override
404     public boolean isIdentifiable()
405     {
406       return true;
407     }
408   };
409
410   private boolean writable;
411
412   private boolean readable;
413
414   private String extensions;
415
416   private String name;
417
418   @Override
419   public boolean isComplexAlignFile()
420   {
421     return false;
422   }
423
424   @Override
425   public boolean isReadable()
426   {
427     return readable;
428   }
429
430   @Override
431   public boolean isWritable()
432   {
433     return writable;
434   }
435
436   /**
437    * Constructor
438    * 
439    * @param shortName
440    * @param extensions
441    *          comma-separated list of file extensions associated with the format
442    * @param isReadable - can be recognised by IdentifyFile and imported with the given reader
443    * @param isWritable - can be exported with the returned writer
444    */
445   private FileFormat(String shortName, String extensions,
446           boolean isReadable, boolean isWritable)
447   {
448     this.name = shortName;
449     this.extensions = extensions;
450     this.readable = isReadable;
451     this.writable = isWritable;
452   }
453
454   @Override
455   public String getExtensions()
456   {
457     return extensions;
458   }
459
460   /**
461    * Answers the display name of the file format (as for example shown in menu
462    * options). This name should not be locale (language) dependent.
463    */
464   @Override
465   public String getName()
466   {
467     return name;
468   }
469
470   @Override
471   public boolean isTextFormat()
472   {
473     return true;
474   }
475
476   @Override
477   public boolean isStructureFile()
478   {
479     return false;
480   }
481
482   /**
483    * By default, answers true, indicating the format is one that can be
484    * identified by IdentifyFile. Formats that cannot be identified should
485    * override this method to return false.
486    */
487   public boolean isIdentifiable()
488   {
489     return true;
490   }
491 }