X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fio%2FAppletFormatAdapter.java;h=81783fc5cc5841267f9dd038663443aae3146bbe;hb=ab43013b7e357b84b4abade0dba949668dfb2a0e;hp=fbfaab131fba87b73e372fff2d5513f1b4676697;hpb=7cb5308c5ec411a566d131993e63abaaf7f7c7b9;p=jalview.git diff --git a/src/jalview/io/AppletFormatAdapter.java b/src/jalview/io/AppletFormatAdapter.java index fbfaab1..81783fc 100755 --- a/src/jalview/io/AppletFormatAdapter.java +++ b/src/jalview/io/AppletFormatAdapter.java @@ -1,97 +1,193 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer - * Copyright (C) 2007 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle + * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2b1) + * Copyright (C) 2014 The Jalview Authors * - * This program is free software; you can redistribute it and/or + * This file is part of Jalview. + * + * Jalview is free software: you can redistribute it and/or * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 + * as published by the Free Software Foundation, either version 3 * of the License, or (at your option) any later version. * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. + * Jalview is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + * along with Jalview. If not, see . + * The Jalview Authors are detailed in the 'AUTHORS' file. */ package jalview.io; -import jalview.datamodel.*; +import jalview.api.AlignViewportI; +import jalview.datamodel.Alignment; +import jalview.datamodel.AlignmentAnnotation; +import jalview.datamodel.AlignmentI; +import jalview.datamodel.AlignmentView; +import jalview.util.MessageManager; + +import java.io.File; +import java.io.InputStream; +import java.util.List; /** - * DOCUMENT ME! + * A low level class for alignment and feature IO with alignment formatting + * methods used by both applet and application for generating flat alignment + * files. It also holds the lists of magic format names that the applet and + * application will allow the user to read or write files with. * * @author $author$ * @version $Revision$ */ public class AppletFormatAdapter { - /** DOCUMENT ME!! */ + /** + * List of valid format strings used in the isValidFormat method + */ public static final String[] READABLE_FORMATS = new String[] - { - "BLC", "CLUSTAL", "FASTA", "MSF", "PileUp", "PIR", "PFAM", "STH", "PDB", "JnetFile" - }; + { "BLC", "CLUSTAL", "FASTA", "MSF", "PileUp", "PIR", "PFAM", "STH", + "PDB", "JnetFile", "RNAML", PhylipFile.FILE_DESC }; // , "SimpleBLAST" }; + /** + * List of valid format strings for use by callers of the formatSequences + * method + */ public static final String[] WRITEABLE_FORMATS = new String[] - { - "BLC", "CLUSTAL", "FASTA", "MSF", "PileUp", "PIR", "PFAM" , "AMSA" - }; + { "BLC", "CLUSTAL", "FASTA", "MSF", "PileUp", "PIR", "PFAM", "AMSA", + "STH", PhylipFile.FILE_DESC }; + /** + * List of extensions corresponding to file format types in WRITABLE_FNAMES + * that are writable by the application. + */ public static final String[] WRITABLE_EXTENSIONS = new String[] - { "fa, fasta, fastq", "aln", "pfam", "msf", "pir", "blc","amsa","jar" }; + { "fa, fasta, mfa, fastq", "aln", "pfam", "msf", "pir", "blc", "amsa", + "jvp", "sto,stk", "jar", PhylipFile.FILE_EXT }; + /** + * List of writable formats by the application. Order must correspond with the + * WRITABLE_EXTENSIONS list of formats. + */ public static final String[] WRITABLE_FNAMES = new String[] - { "Fasta", "Clustal", "PFAM", "MSF", "PIR", "BLC", "AMSA", "Jalview" }; + { "Fasta", "Clustal", "PFAM", "MSF", "PIR", "BLC", "AMSA", "Jalview", + "STH", "Jalview", PhylipFile.FILE_DESC }; + + /** + * List of readable format file extensions by application in order + * corresponding to READABLE_FNAMES + */ + public static final String[] READABLE_EXTENSIONS = new String[] + { "fa, fasta, mfa, fastq", "aln", "pfam", "msf", "pir", "blc", "amsa", + "jar,jvp", "sto,stk", "xml,rnaml", PhylipFile.FILE_EXT }; // ".blast" + + /** + * List of readable formats by application in order corresponding to + * READABLE_EXTENSIONS + */ + public static final String[] READABLE_FNAMES = new String[] + { "Fasta", "Clustal", "PFAM", "MSF", "PIR", "BLC", "AMSA", "Jalview", + "Stockholm", "RNAML", PhylipFile.FILE_DESC };// , + + // "SimpleBLAST" + // }; - public static final String[] READABLE_EXTENSIONS = new String[] - { - "fa, fasta, fastq", "aln", "pfam", "msf", "pir", "blc", - "amsa","jar" - }; - public static final String[] READABLE_FNAMES = new String[] - { - "Fasta", "Clustal", "PFAM", "MSF", "PIR", "BLC", "AMSA","Jalview" - }; - public static String INVALID_CHARACTERS = "Contains invalid characters"; + // TODO: make these messages dynamic - public static String SUPPORTED_FORMATS = "Formats currently supported are\n" + - prettyPrint(READABLE_FORMATS); + public static String SUPPORTED_FORMATS = "Formats currently supported are\n" + + prettyPrint(READABLE_FORMATS); + /** - * + * * @param els * @return grammatically correct(ish) list consisting of els elements. */ - public static String prettyPrint(String[] els) { + public static String prettyPrint(String[] els) + { StringBuffer list = new StringBuffer(); - for (int i=0,iSize=els.length-1; iUNKNOWN\n" + inFile, "Paste"); + Alignment al = new Alignment(afile.getSeqsAsArray()); + afile.addAnnotations(al); + return al; + + } catch (Exception ex) { if (ex.toString().startsWith(INVALID_CHARACTERS)) { @@ -203,18 +436,52 @@ public class AppletFormatAdapter } } + /** - * Construct an output class for an alignment in a particular filetype + * create an alignment flatfile from a Jalview alignment view + * @param format + * @param jvsuffix + * @param av + * @param selectedOnly + * @return flatfile in a string + */ + public String formatSequences(String format, boolean jvsuffix, + AlignViewportI av, boolean selectedOnly) + { + + AlignmentView selvew = av.getAlignmentView(selectedOnly, false); + AlignmentI aselview = selvew.getVisibleAlignment(av + .getGapCharacter()); + List ala = (av + .getVisibleAlignmentAnnotation(selectedOnly)); + if (ala != null) + { + for (AlignmentAnnotation aa : ala) + { + aselview.addAnnotation(aa); + } + } + + return formatSequences(format, aselview, jvsuffix); + } + + /** + * Construct an output class for an alignment in a particular filetype TODO: + * allow caller to detect errors and warnings encountered when generating + * output * - * @param format DOCUMENT ME! - * @param seqs DOCUMENT ME! - * @param jvsuffix passed to AlnFile class + * @param format + * string name of alignment format + * @param alignment + * the alignment to be written out + * @param jvsuffix + * passed to AlnFile class controls whether /START-END is added to + * sequence names * * @return alignment flat file contents */ - public String formatSequences(String format, - AlignmentI alignment, - boolean jvsuffix) + public String formatSequences(String format, AlignmentI alignment, + boolean jvsuffix) { try { @@ -250,28 +517,286 @@ public class AppletFormatAdapter } else if (format.equalsIgnoreCase("STH")) { - afile = new StockholmFile(); + afile = new StockholmFile(alignment); } else if (format.equalsIgnoreCase("AMSA")) { afile = new AMSAFile(alignment); - } else { - throw new Exception("Implementation error: Unknown file format string"); + } + else if (format.equalsIgnoreCase(PhylipFile.FILE_DESC)) + { + afile = new PhylipFile(); + } + else if (format.equalsIgnoreCase("RNAML")) + { + afile = new RnamlFile(); } + else + { + throw new Exception(MessageManager.getString("error.implementation_error_unknown_file_format_string")); + } + afile.setNewlineString(newline); afile.addJVSuffix(jvsuffix); afile.setSeqs(alignment.getSequencesArray()); - return afile.print(); - } - catch (Exception e) + String afileresp = afile.print(); + if (afile.hasWarningMessage()) + { + System.err.println("Warning raised when writing as " + format + + " : " + afile.getWarningMessage()); + } + return afileresp; + } catch (Exception e) { - System.err.println("Failed to write alignment as a '" + format + - "' file\n"); + System.err.println("Failed to write alignment as a '" + format + + "' file\n"); e.printStackTrace(); } return null; } + + public static String checkProtocol(String file) + { + String protocol = FILE; + String ft = file.toLowerCase().trim(); + if (ft.indexOf("http:") == 0 || ft.indexOf("https:") == 0 + || ft.indexOf("file:") == 0) + { + protocol = URL; + } + return protocol; + } + + public static void main(String[] args) + { + int i = 0; + while (i < args.length) + { + File f = new File(args[i]); + if (f.exists()) + { + try + { + System.out.println("Reading file: " + f); + AppletFormatAdapter afa = new AppletFormatAdapter(); + Runtime r = Runtime.getRuntime(); + System.gc(); + long memf = -r.totalMemory() + r.freeMemory(); + long t1 = -System.currentTimeMillis(); + Alignment al = afa.readFile(args[i], FILE, + new IdentifyFile().Identify(args[i], FILE)); + t1 += System.currentTimeMillis(); + System.gc(); + memf += r.totalMemory() - r.freeMemory(); + if (al != null) + { + System.out.println("Alignment contains " + al.getHeight() + + " sequences and " + al.getWidth() + " columns."); + try + { + System.out.println(new AppletFormatAdapter().formatSequences( + "FASTA", al, true)); + } catch (Exception e) + { + System.err + .println("Couln't format the alignment for output as a FASTA file."); + e.printStackTrace(System.err); + } + } + else + { + System.out.println("Couldn't read alignment"); + } + System.out.println("Read took " + (t1 / 1000.0) + " seconds."); + System.out + .println("Difference between free memory now and before is " + + (memf / (1024.0 * 1024.0) * 1.0) + " MB"); + } catch (Exception e) + { + System.err.println("Exception when dealing with " + i + + "'th argument: " + args[i] + "\n" + e); + } + } + else + { + System.err.println("Ignoring argument '" + args[i] + "' (" + i + + "'th)- not a readable file."); + } + i++; + } + } + + /** + * try to discover how to access the given file as a valid datasource that + * will be identified as the given type. + * + * @param file + * @param format + * @return protocol that yields the data parsable as the given type + */ + public static String resolveProtocol(String file, String format) + { + return resolveProtocol(file, format, false); + } + + public static String resolveProtocol(String file, String format, + boolean debug) + { + // TODO: test thoroughly! + String protocol = null; + if (debug) + { + System.out.println("resolving datasource started with:\n>>file\n" + + file + ">>endfile"); + } + + // This might throw a security exception in certain browsers + // Netscape Communicator for instance. + try + { + boolean rtn = false; + InputStream is = System.getSecurityManager().getClass() + .getResourceAsStream("/" + file); + if (is != null) + { + rtn = true; + is.close(); + } + if (debug) + { + System.err.println("Resource '" + file + "' was " + + (rtn ? "" : "not") + " located by classloader."); + } + ; + if (rtn) + { + protocol = AppletFormatAdapter.CLASSLOADER; + } + + } catch (Exception ex) + { + System.err + .println("Exception checking resources: " + file + " " + ex); + } + + if (file.indexOf("://") > -1) + { + protocol = AppletFormatAdapter.URL; + } + else + { + // skipping codebase prepend check. + protocol = AppletFormatAdapter.FILE; + } + FileParse fp = null; + try + { + if (debug) + { + System.out.println("Trying to get contents of resource as " + + protocol + ":"); + } + fp = new FileParse(file, protocol); + if (!fp.isValid()) + { + fp = null; + } + else + { + if (debug) + { + System.out.println("Successful."); + } + } + } catch (Exception e) + { + if (debug) + { + System.err.println("Exception when accessing content: " + e); + } + fp = null; + } + if (fp == null) + { + if (debug) + { + System.out.println("Accessing as paste."); + } + protocol = AppletFormatAdapter.PASTE; + fp = null; + try + { + fp = new FileParse(file, protocol); + if (!fp.isValid()) + { + fp = null; + } + } catch (Exception e) + { + System.err.println("Failed to access content as paste!"); + e.printStackTrace(); + fp = null; + } + } + if (fp == null) + { + return null; + } + if (format == null || format.length() == 0) + { + return protocol; + } + else + { + try + { + String idformat = new jalview.io.IdentifyFile().Identify(file, + protocol); + if (idformat == null) + { + if (debug) + { + System.out.println("Format not identified. Inaccessible file."); + } + return null; + } + if (debug) + { + System.out.println("Format identified as " + idformat + + "and expected as " + format); + } + if (idformat.equals(format)) + { + if (debug) + { + System.out.println("Protocol identified as " + protocol); + } + return protocol; + } + else + { + if (debug) + { + System.out + .println("File deemed not accessible via " + protocol); + } + fp.close(); + return null; + } + } catch (Exception e) + { + if (debug) + { + System.err.println("File deemed not accessible via " + protocol); + e.printStackTrace(); + } + ; + + } + } + return null; + } }