X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Fjalview%2Fio%2FAppletFormatAdapter.java;h=6ae3a37b81e6f4ca5317e5ac8c6b270839508738;hb=84684213f7f7c7b31d3c33dc49ca3b377a295438;hp=8e05b4477fd9ab5cafa693fd0f7f178da6b8bf29;hpb=aa5a15ade3b078f6c2cf78db5aa05e0dcb1ce792;p=jalview.git diff --git a/src/jalview/io/AppletFormatAdapter.java b/src/jalview/io/AppletFormatAdapter.java index 8e05b44..6ae3a37 100755 --- a/src/jalview/io/AppletFormatAdapter.java +++ b/src/jalview/io/AppletFormatAdapter.java @@ -1,24 +1,25 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer (Development Version 2.4.1) - * Copyright (C) 2009 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle + * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.1) + * Copyright (C) 2014 The Jalview Authors * - * This program 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 - * of the License, or (at your option) any later version. + * This file is part of Jalview. * - * 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 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 3 of the License, or (at your option) any later version. + * + * 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 + * You should have received a copy of the GNU General Public License along with Jalview. If not, see . + * The Jalview Authors are detailed in the 'AUTHORS' file. */ package jalview.io; import java.io.File; +import java.io.InputStream; import jalview.datamodel.*; @@ -38,42 +39,53 @@ public class AppletFormatAdapter */ public static final String[] READABLE_FORMATS = new String[] { "BLC", "CLUSTAL", "FASTA", "MSF", "PileUp", "PIR", "PFAM", "STH", - "PDB", "JnetFile" }; + "PDB", "JnetFile" }; // , "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", "STH", + "AMSA" }; /** * 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" }; /** * 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" }; /** * List of readable format file extensions by application in order * corresponding to READABLE_FNAMES */ public static final String[] READABLE_EXTENSIONS = new String[] - { "fa, fasta, fastq", "aln", "pfam", "msf", "pir", "blc", "amsa", "jar" }; + { "fa, fasta, mfa, fastq", "aln", "pfam", "msf", "pir", "blc", "amsa", "jar,jvp", + "sto,stk" }; // , + + // ".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" }; + { "Fasta", "Clustal", "PFAM", "MSF", "PIR", "BLC", "AMSA", "Jalview", + "Stockholm" };// , + + // "SimpleBLAST" + // }; public static String INVALID_CHARACTERS = "Contains invalid characters"; @@ -111,10 +123,25 @@ public class AppletFormatAdapter String inFile; /** + * character used to write newlines + */ + protected String newline = System.getProperty("line.separator"); + + public void setNewlineString(String nl) + { + newline = nl; + } + + public String getNewlineString() + { + return newline; + } + + /** * check that this format is valid for reading * * @param format - * a format string to be compared with READABLE_FORMATS + * a format string to be compared with READABLE_FORMATS * @return true if format is readable */ public static final boolean isValidFormat(String format) @@ -126,11 +153,10 @@ public class AppletFormatAdapter * validate format is valid for IO * * @param format - * a format string to be compared with either READABLE_FORMATS - * or WRITEABLE_FORMATS + * a format string to be compared with either READABLE_FORMATS or + * WRITEABLE_FORMATS * @param forwriting - * when true, format is checked for containment in - * WRITEABLE_FORMATS + * when true, format is checked for containment in WRITEABLE_FORMATS * @return true if format is valid */ public static final boolean isValidFormat(String format, @@ -154,11 +180,11 @@ public class AppletFormatAdapter * Constructs the correct filetype parser for a characterised datasource * * @param inFile - * data/data location + * data/data location * @param type - * type of datasource + * type of datasource * @param format - * File format of data provided by datasource + * File format of data provided by datasource * * @return DOCUMENT ME! */ @@ -211,6 +237,10 @@ public class AppletFormatAdapter { afile = new StockholmFile(inFile, type); } + else if (format.equals("SimpleBLAST")) + { + afile = new SimpleBlastFile(inFile, type); + } Alignment al = new Alignment(afile.getSeqsAsArray()); @@ -260,9 +290,9 @@ public class AppletFormatAdapter * Constructs the correct filetype parser for an already open datasource * * @param source - * an existing datasource + * an existing datasource * @param format - * File format of data that will be provided by datasource + * File format of data that will be provided by datasource * * @return DOCUMENT ME! */ @@ -318,6 +348,10 @@ public class AppletFormatAdapter { afile = new StockholmFile(source); } + else if (format.equals("SimpleBLAST")) + { + afile = new SimpleBlastFile(source); + } Alignment al = new Alignment(afile.getSeqsAsArray()); @@ -364,16 +398,17 @@ public class AppletFormatAdapter } /** - * Construct an output class for an alignment in a particular filetype - * TODO: allow caller to detect errors and warnings encountered when generating output - * + * 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 - * string name of alignment format + * string name of alignment format * @param alignment - * the alignment to be written out + * the alignment to be written out * @param jvsuffix - * passed to AlnFile class controls whether /START-END is added - * to sequence names + * passed to AlnFile class controls whether /START-END is added to + * sequence names * * @return alignment flat file contents */ @@ -414,7 +449,7 @@ public class AppletFormatAdapter } else if (format.equalsIgnoreCase("STH")) { - afile = new StockholmFile(); + afile = new StockholmFile(alignment); } else if (format.equalsIgnoreCase("AMSA")) { @@ -425,7 +460,7 @@ public class AppletFormatAdapter throw new Exception( "Implementation error: Unknown file format string"); } - + afile.setNewlineString(newline); afile.addJVSuffix(jvsuffix); afile.setSeqs(alignment.getSequencesArray()); @@ -433,7 +468,8 @@ public class AppletFormatAdapter String afileresp = afile.print(); if (afile.hasWarningMessage()) { - System.err.println("Warning raised when writing as "+format+" : "+afile.getWarningMessage()); + System.err.println("Warning raised when writing as " + format + + " : " + afile.getWarningMessage()); } return afileresp; } catch (Exception e) @@ -446,6 +482,18 @@ public class AppletFormatAdapter 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; @@ -458,34 +506,47 @@ public class AppletFormatAdapter { 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."); - } - else + String fName = f.getName(); { - System.out.println("Couldn't read alignment"); + 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"); } - 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 { @@ -494,6 +555,177 @@ public class AppletFormatAdapter } 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; } + }