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