X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fio%2FAlignFile.java;h=a603ccac45d6d9577a076be41a481c2bf253230c;hb=3d0101179759ef157b088ea135423cd909512d9f;hp=7a469dd8b49ae67d5cfea66d7ac3612277cb118d;hpb=2de8acfae59aced665e4c37ad0f7dcc2ed68818e;p=jalview.git diff --git a/src/jalview/io/AlignFile.java b/src/jalview/io/AlignFile.java index 7a469dd..a603cca 100755 --- a/src/jalview/io/AlignFile.java +++ b/src/jalview/io/AlignFile.java @@ -1,27 +1,38 @@ /* - * 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-Rel$$) + * Copyright (C) $$Year-Rel$$ 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 + * along with Jalview. If not, see . + * The Jalview Authors are detailed in the 'AUTHORS' file. */ package jalview.io; -import java.io.*; -import java.util.*; +import jalview.datamodel.AlignmentAnnotation; +import jalview.datamodel.AlignmentI; +import jalview.datamodel.Sequence; +import jalview.datamodel.SequenceGroup; +import jalview.datamodel.SequenceI; +import jalview.util.MessageManager; -import jalview.datamodel.*; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Enumeration; +import java.util.Hashtable; +import java.util.List; +import java.util.Vector; /** * DOCUMENT ME! @@ -30,54 +41,91 @@ import jalview.datamodel.*; * @version $Revision$ */ public abstract class AlignFile extends FileParse + implements AlignmentFileReaderI, AlignmentFileWriterI { int noSeqs = 0; int maxLength = 0; /** - * Sequences to be added to form a new alignment. + * Sequences to be added to form a new alignment. TODO: remove vector in this + * class */ - protected Vector seqs; + protected Vector seqs; /** * annotation to be added to generated alignment object */ - protected Vector annotations; + protected Vector annotations; + + /** + * SequenceGroups to be added to the alignment object + */ + protected List seqGroups; /** * Properties to be added to generated alignment object */ - protected Hashtable properties; + private Hashtable properties; long start; long end; - boolean jvSuffix = true; + private boolean parseCalled; /** * Creates a new AlignFile object. */ public AlignFile() { + // Shouldn't we init data structures (JBPNote: not sure - initData is for + // initialising the structures used for reading from a datasource, and the + // bare constructor hasn't got any datasource) + initData(); + } + + public AlignFile(SequenceI[] seqs) + { + this(); + setSeqs(seqs); } /** * Constructor which parses the data from a file of some specified type. * - * @param inFile - * Filename to read from. - * @param type - * What type of file to read from (File, URL) + * @param dataObject + * Filename, URL or Pasted String to read from. + * @param sourceType + * What type of file to read from (File, URL, Pasted String) */ - public AlignFile(String inFile, String type) throws IOException + public AlignFile(String dataObject, DataSourceType sourceType) + throws IOException { - super(inFile, type); + this(true, dataObject, sourceType); + } + /** + * Constructor which (optionally delays) parsing of data from a file of some + * specified type. + * + * @param parseImmediately + * if false, need to call 'doParse()' to begin parsing data + * @param dataObject + * Filename, URL or Pasted String to read from. + * @param sourceType + * What type of file to read from (File, URL) + * @throws IOException + */ + public AlignFile(boolean parseImmediately, String dataObject, + DataSourceType sourceType) throws IOException + { + super(dataObject, sourceType); initData(); - - parse(); + if (parseImmediately) + { + doParse(); + } } /** @@ -89,29 +137,74 @@ public abstract class AlignFile extends FileParse */ public AlignFile(FileParse source) throws IOException { + this(true, source); + } + + /** + * Construct a new parser to read from the position where some other parsing + * process left + * + * @param parseImmediately + * if false, need to call 'doParse()' to begin parsing data + * @param source + */ + public AlignFile(boolean parseImmediately, FileParse source) + throws IOException + { super(source); initData(); + if (parseImmediately) + { + doParse(); + } + } + + /** + * called if parsing was delayed till after parser was constructed + * + * @throws IOException + */ + public void doParse() throws IOException + { + if (parseCalled) + { + throw new IOException( + "Implementation error: Parser called twice for same data.\n" + + "Need to call initData() again before parsing can be reattempted."); + } + parseCalled = true; parse(); + // sets the index of each sequence in the alignment + for (int i = 0, c = seqs.size(); i < c; i++) + { + seqs.get(i).setIndex(i); + } } /** * Return the seqs Vector */ - public Vector getSeqs() + public Vector getSeqs() { return seqs; } + public List getSeqGroups() + { + return seqGroups; + } + /** * Return the Sequences in the seqs Vector as an array of Sequences */ + @Override public SequenceI[] getSeqsAsArray() { SequenceI[] s = new SequenceI[seqs.size()]; for (int i = 0; i < seqs.size(); i++) { - s[i] = (SequenceI) seqs.elementAt(i); + s[i] = seqs.elementAt(i); } return s; @@ -123,24 +216,45 @@ public abstract class AlignFile extends FileParse * * @param al */ - public void addAnnotations(Alignment al) + @Override + public void addAnnotations(AlignmentI al) { addProperties(al); for (int i = 0; i < annotations.size(); i++) { - al.addAnnotation((AlignmentAnnotation) annotations.elementAt(i)); + // detect if annotations.elementAt(i) rna secondary structure + // if so then do: + /* + * SequenceFeature[] pairArray = + * Rna.GetBasePairsFromAlignmentAnnotation(annotations.elementAt(i)); + * Rna.HelixMap(pairArray); + */ + AlignmentAnnotation an = annotations.elementAt(i); + an.validateRangeAndDisplay(); + al.addAnnotation(an); } } /** + * register sequence groups on the alignment for **output** + * + * @param al + */ + public void addSeqGroups(AlignmentI al) + { + this.seqGroups = al.getGroups(); + + } + + /** * Add any additional information extracted from the file to the alignment * properties. * * @note implicitly called by addAnnotations() * @param al */ - public void addProperties(Alignment al) + public void addProperties(AlignmentI al) { if (properties != null && properties.size() > 0) { @@ -158,17 +272,17 @@ public abstract class AlignFile extends FileParse * properties note: null keys will raise an error, null values will result in * the key/value pair being silently ignored. * - * @param key - - * non-null key object - * @param value - - * non-null value + * @param key + * - non-null key object + * @param value + * - non-null value */ protected void setAlignmentProperty(Object key, Object value) { if (key == null) { - throw new Error( - "Implementation error: Cannot have null alignment property key."); + throw new Error(MessageManager.getString( + "error.implementation_error_cannot_have_null_alignment")); } if (value == null) { @@ -195,19 +309,22 @@ public abstract class AlignFile extends FileParse */ protected void initData() { - seqs = new Vector(); - annotations = new Vector(); + seqs = new Vector(); + annotations = new Vector(); + seqGroups = new ArrayList(); + parseCalled = false; } /** * DOCUMENT ME! * * @param s - * DOCUMENT ME! + * DOCUMENT ME! */ - protected void setSeqs(SequenceI[] s) + @Override + public void setSeqs(SequenceI[] s) { - seqs = new Vector(); + seqs = new Vector(); for (int i = 0; i < s.length; i++) { @@ -221,16 +338,6 @@ public abstract class AlignFile extends FileParse public abstract void parse() throws IOException; /** - * Print out in alignment file format the Sequences in the seqs Vector. - */ - public abstract String print(); - - public void addJVSuffix(boolean b) - { - jvSuffix = b; - } - - /** * A general parser for ids. * * @String id Id to be parsed @@ -243,7 +350,15 @@ public abstract class AlignFile extends FileParse if (space > -1) { seq = new Sequence(id.substring(0, space), ""); - seq.setDescription(id.substring(space + 1)); + String desc = id.substring(space + 1); + seq.setDescription(desc); + + /* + * it is tempting to parse Ensembl style gene description e.g. + * chromosome:GRCh38:7:140696688:140721955:1 and set the + * start position of the sequence, but this causes much confusion + * for reverse strand feature locations + */ } else { @@ -254,38 +369,54 @@ public abstract class AlignFile extends FileParse } /** - * Creates the output id. Adds prefix Uniprot format source|id And suffix - * Jalview /start-end + * Creates the output id. Adds prefix Uniprot format source|id and optionally + * suffix Jalview /start-end + * + * @param jvsuffix * * @String id Id to be parsed */ + String printId(SequenceI seq, boolean jvsuffix) + { + return seq.getDisplayId(jvsuffix); + } + String printId(SequenceI seq) { - return seq.getDisplayId(jvSuffix); + return printId(seq, true); } /** * vector of String[] treeName, newickString pairs */ - Vector newickStrings = null; + Vector newickStrings = null; protected void addNewickTree(String treeName, String newickString) { if (newickStrings == null) { - newickStrings = new Vector(); + newickStrings = new Vector(); } - newickStrings.addElement(new String[] - { treeName, newickString }); + newickStrings.addElement(new String[] { treeName, newickString }); } protected int getTreeCount() { - if (newickStrings == null) + return newickStrings == null ? 0 : newickStrings.size(); + } + + @Override + public void addGroups(AlignmentI al) + { + + for (SequenceGroup sg : getSeqGroups()) { - return 0; + al.addGroup(sg); } - return newickStrings.size(); } + protected void addSequence(SequenceI seq) + { + seqs.add(seq); + } }