X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Fjalview%2Fdatamodel%2FAlignment.java;h=55538406b2598154cba3ef1197829ff1422cfccf;hb=ff450fad8709ae81919af7a15ea382af7292794c;hp=08c04f5b779f3b73c27cdba8baf081912a48d199;hpb=961b10e4c895aadb7fc9df82a641c6c53c0d5c70;p=jalview.git diff --git a/src/jalview/datamodel/Alignment.java b/src/jalview/datamodel/Alignment.java index 08c04f5..5553840 100755 --- a/src/jalview/datamodel/Alignment.java +++ b/src/jalview/datamodel/Alignment.java @@ -1,73 +1,112 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer (Version 2.4) - * Copyright (C) 2008 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.datamodel; -import java.util.*; - -import jalview.analysis.*; +import jalview.analysis.AlignmentUtils; +import jalview.datamodel.AlignedCodonFrame.SequenceToSequenceMapping; +import jalview.io.FastaFile; +import jalview.util.Comparison; +import jalview.util.LinkedIdentityHashSet; +import jalview.util.MessageManager; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.Enumeration; +import java.util.HashSet; +import java.util.Hashtable; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.Vector; /** * Data structure to hold and manipulate a multiple sequence alignment */ +/** + * @author JimP + * + */ public class Alignment implements AlignmentI { - protected Alignment dataset; + private Alignment dataset; - protected Vector sequences; + protected List sequences; - protected Vector groups = new Vector(); + protected List groups; protected char gapCharacter = '-'; - protected int type = NUCLEOTIDE; + private boolean nucleotide = true; - public static final int PROTEIN = 0; + public boolean hasRNAStructure = false; - public static final int NUCLEOTIDE = 1; - - /** DOCUMENT ME!! */ public AlignmentAnnotation[] annotations; - HiddenSequences hiddenSequences = new HiddenSequences(this); + HiddenSequences hiddenSequences; + + HiddenColumns hiddenCols; public Hashtable alignmentProperties; + private List codonFrameList; + private void initAlignment(SequenceI[] seqs) { - int i = 0; + groups = Collections.synchronizedList(new ArrayList()); + hiddenSequences = new HiddenSequences(this); + hiddenCols = new HiddenColumns(); + codonFrameList = new ArrayList<>(); + + nucleotide = Comparison.isNucleotide(seqs); + + sequences = Collections.synchronizedList(new ArrayList()); - if (jalview.util.Comparison.isNucleotide(seqs)) + for (int i = 0; i < seqs.length; i++) { - type = NUCLEOTIDE; + sequences.add(seqs[i]); } - else + + } + + /** + * Make a 'copy' alignment - sequences have new copies of features and + * annotations, but share the original dataset sequences. + */ + public Alignment(AlignmentI al) + { + SequenceI[] seqs = al.getSequencesArray(); + for (int i = 0; i < seqs.length; i++) { - type = PROTEIN; + seqs[i] = new Sequence(seqs[i]); } - sequences = new Vector(); + initAlignment(seqs); - for (i = 0; i < seqs.length; i++) + /* + * Share the same dataset sequence mappings (if any). + */ + if (dataset == null && al.getDataset() == null) { - sequences.addElement(seqs[i]); + this.setCodonFrames(al.getCodonFrames()); } - } /** @@ -84,12 +123,12 @@ public class Alignment implements AlignmentI * Make a new alignment from an array of SeqCigars * * @param seqs - * SeqCigar[] + * SeqCigar[] */ public Alignment(SeqCigar[] alseqs) { SequenceI[] seqs = SeqCigar.createAlignmentSequences(alseqs, - gapCharacter, new ColumnSelection(), null); + gapCharacter, new HiddenColumns(), null); initAlignment(seqs); } @@ -100,100 +139,153 @@ public class Alignment implements AlignmentI * appropriately. * * @param compactAlignment - * CigarArray + * CigarArray */ public static AlignmentI createAlignment(CigarArray compactAlignment) { - throw new Error("Alignment(CigarArray) not yet implemented"); + throw new Error( + MessageManager + .getString("error.alignment_cigararray_not_implemented")); // this(compactAlignment.refCigars); } - /** - * DOCUMENT ME! - * - * @return DOCUMENT ME! - */ - public Vector getSequences() + @Override + public List getSequences() + { + return sequences; + } + + @Override + public List getSequences( + Map hiddenReps) { + // TODO: in jalview 2.8 we don't do anything with hiddenreps - fix design to + // work on this. return sequences; } + @Override public SequenceI[] getSequencesArray() { if (sequences == null) + { return null; - SequenceI[] reply = new SequenceI[sequences.size()]; - for (int i = 0; i < sequences.size(); i++) + } + synchronized (sequences) { - reply[i] = (SequenceI) sequences.elementAt(i); + return sequences.toArray(new SequenceI[sequences.size()]); } - return reply; } /** - * DOCUMENT ME! + * Returns a map of lists of sequences keyed by sequence name. * - * @param i - * DOCUMENT ME! - * - * @return DOCUMENT ME! + * @return */ + @Override + public Map> getSequencesByName() + { + return AlignmentUtils.getSequencesByName(this); + } + + + @Override public SequenceI getSequenceAt(int i) { - if (i < sequences.size()) + synchronized (sequences) { - return (SequenceI) sequences.elementAt(i); + if (i > -1 && i < sequences.size()) + { + return sequences.get(i); + } } - return null; } + @Override + public SequenceI getSequenceAtAbsoluteIndex(int i) + { + SequenceI seq = null; + if (getHiddenSequences().getSize() > 0) + { + seq = getHiddenSequences().getHiddenSequence(i); + if (seq == null) + { + // didn't find the sequence in the hidden sequences, get it from the + // alignment + int index = getHiddenSequences().findIndexWithoutHiddenSeqs(i); + seq = getSequenceAt(index); + } + } + else + { + seq = getSequenceAt(i); + } + return seq; + } + /** - * Adds a sequence to the alignment. Recalculates maxLength and size. + * Adds a sequence to the alignment. Recalculates maxLength and size. Note + * this currently does not recalculate whether or not the alignment is + * nucleotide, so mixed alignments may have undefined behaviour. * * @param snew */ + @Override public void addSequence(SequenceI snew) { if (dataset != null) { + // maintain dataset integrity - if (snew.getDatasetSequence() != null) - { - getDataset().addSequence(snew.getDatasetSequence()); - } - else + SequenceI dsseq = snew.getDatasetSequence(); + if (dsseq == null) { // derive new sequence SequenceI adding = snew.deriveSequence(); - getDataset().addSequence(adding.getDatasetSequence()); snew = adding; + dsseq = snew.getDatasetSequence(); + } + if (getDataset().findIndex(dsseq) == -1) + { + getDataset().addSequence(dsseq); } + } if (sequences == null) { - initAlignment(new SequenceI[] - { snew }); + initAlignment(new SequenceI[] { snew }); } else { - sequences.addElement(snew); + synchronized (sequences) + { + sequences.add(snew); + } } if (hiddenSequences != null) + { hiddenSequences.adjustHeightSequenceAdded(); + } } - /** - * Adds a sequence to the alignment. Recalculates maxLength and size. - * - * @param snew - */ - public void setSequenceAt(int i, SequenceI snew) + @Override + public SequenceI replaceSequenceAt(int i, SequenceI snew) { - SequenceI oldseq = getSequenceAt(i); - deleteSequence(oldseq); + synchronized (sequences) + { + if (sequences.size() > i) + { + return sequences.set(i, snew); - sequences.setElementAt(snew, i); + } + else + { + sequences.add(snew); + hiddenSequences.adjustHeightSequenceAdded(); + } + return null; + } } /** @@ -201,16 +293,30 @@ public class Alignment implements AlignmentI * * @return DOCUMENT ME! */ - public Vector getGroups() + @Override + public List getGroups() { return groups; } - public void finalize() + @Override + public void finalize() throws Throwable { if (getDataset() != null) + { getDataset().removeAlignmentRef(); + } + + nullReferences(); + super.finalize(); + } + /** + * Defensively nulls out references in case this object is not garbage + * collected + */ + void nullReferences() + { dataset = null; sequences = null; groups = null; @@ -219,144 +325,237 @@ public class Alignment implements AlignmentI } /** - * decrement the alignmentRefs counter by one and call finalize if it goes to - * zero. + * decrement the alignmentRefs counter by one and null references if it goes + * to zero. + * + * @throws Throwable */ - private void removeAlignmentRef() + private void removeAlignmentRef() throws Throwable { if (--alignmentRefs == 0) { - finalize(); + nullReferences(); } } - /** - * DOCUMENT ME! - * - * @param s - * DOCUMENT ME! - */ + @Override public void deleteSequence(SequenceI s) { - deleteSequence(findIndex(s)); + synchronized (sequences) + { + deleteSequence(findIndex(s)); + } } - /** - * DOCUMENT ME! - * - * @param i - * DOCUMENT ME! - */ + @Override public void deleteSequence(int i) { - if (i > -1 && i < getHeight()) + synchronized (sequences) { - sequences.removeElementAt(i); - hiddenSequences.adjustHeightSequenceDeleted(i); + if (i > -1 && i < getHeight()) + { + sequences.remove(i); + hiddenSequences.adjustHeightSequenceDeleted(i); + } } } - /** */ - public SequenceGroup findGroup(SequenceI s) + @Override + public void deleteHiddenSequence(int i) { - for (int i = 0; i < this.groups.size(); i++) + synchronized (sequences) { - SequenceGroup sg = (SequenceGroup) groups.elementAt(i); - - if (sg.getSequences(null).contains(s)) + if (i > -1 && i < getHeight()) { - return sg; + sequences.remove(i); } } + } + /* + * (non-Javadoc) + * + * @see jalview.datamodel.AlignmentI#findGroup(jalview.datamodel.SequenceI) + */ + @Override + public SequenceGroup findGroup(SequenceI seq, int position) + { + synchronized (groups) + { + for (SequenceGroup sg : groups) + { + if (sg.getSequences(null).contains(seq)) + { + if (position >= sg.getStartRes() && position <= sg.getEndRes()) + { + return sg; + } + } + } + } return null; } - /** - * DOCUMENT ME! - * - * @param s - * DOCUMENT ME! + /* + * (non-Javadoc) * - * @return DOCUMENT ME! + * @see + * jalview.datamodel.AlignmentI#findAllGroups(jalview.datamodel.SequenceI) */ + @Override public SequenceGroup[] findAllGroups(SequenceI s) { - Vector temp = new Vector(); + ArrayList temp = new ArrayList<>(); - int gSize = groups.size(); - for (int i = 0; i < gSize; i++) + synchronized (groups) { - SequenceGroup sg = (SequenceGroup) groups.elementAt(i); - if (sg == null || sg.getSequences(null) == null) + int gSize = groups.size(); + for (int i = 0; i < gSize; i++) { - this.deleteGroup(sg); - gSize--; - continue; - } + SequenceGroup sg = groups.get(i); + if (sg == null || sg.getSequences() == null) + { + this.deleteGroup(sg); + gSize--; + continue; + } - if (sg.getSequences(null).contains(s)) - { - temp.addElement(sg); + if (sg.getSequences().contains(s)) + { + temp.add(sg); + } } } - SequenceGroup[] ret = new SequenceGroup[temp.size()]; - - for (int i = 0; i < temp.size(); i++) - { - ret[i] = (SequenceGroup) temp.elementAt(i); - } - - return ret; + return temp.toArray(ret); } /** */ + @Override public void addGroup(SequenceGroup sg) { - if (!groups.contains(sg)) + synchronized (groups) { - if (hiddenSequences.getSize() > 0) + if (!groups.contains(sg)) { - int i, iSize = sg.getSize(); - for (i = 0; i < iSize; i++) + if (hiddenSequences.getSize() > 0) { - if (!sequences.contains(sg.getSequenceAt(i))) + int i, iSize = sg.getSize(); + for (i = 0; i < iSize; i++) { - sg.deleteSequence(sg.getSequenceAt(i), false); - iSize--; - i--; + if (!sequences.contains(sg.getSequenceAt(i))) + { + sg.deleteSequence(sg.getSequenceAt(i), false); + iSize--; + i--; + } } - } - if (sg.getSize() < 1) - { - return; + if (sg.getSize() < 1) + { + return; + } } + sg.setContext(this, true); + groups.add(sg); } - - groups.addElement(sg); } } /** - * DOCUMENT ME! + * remove any annotation that references gp + * + * @param gp + * (if null, removes all group associated annotation) */ + private void removeAnnotationForGroup(SequenceGroup gp) + { + if (annotations == null || annotations.length == 0) + { + return; + } + // remove annotation very quickly + AlignmentAnnotation[] t, todelete = new AlignmentAnnotation[annotations.length], tokeep = new AlignmentAnnotation[annotations.length]; + int i, p, k; + if (gp == null) + { + for (i = 0, p = 0, k = 0; i < annotations.length; i++) + { + if (annotations[i].groupRef != null) + { + todelete[p++] = annotations[i]; + } + else + { + tokeep[k++] = annotations[i]; + } + } + } + else + { + for (i = 0, p = 0, k = 0; i < annotations.length; i++) + { + if (annotations[i].groupRef == gp) + { + todelete[p++] = annotations[i]; + } + else + { + tokeep[k++] = annotations[i]; + } + } + } + if (p > 0) + { + // clear out the group associated annotation. + for (i = 0; i < p; i++) + { + unhookAnnotation(todelete[i]); + todelete[i] = null; + } + t = new AlignmentAnnotation[k]; + for (i = 0; i < k; i++) + { + t[i] = tokeep[i]; + } + annotations = t; + } + } + + @Override public void deleteAllGroups() { - groups.removeAllElements(); + synchronized (groups) + { + if (annotations != null) + { + removeAnnotationForGroup(null); + } + for (SequenceGroup sg : groups) + { + sg.setContext(null, false); + } + groups.clear(); + } } /** */ + @Override public void deleteGroup(SequenceGroup g) { - if (groups.contains(g)) + synchronized (groups) { - groups.removeElement(g); + if (groups.contains(g)) + { + removeAnnotationForGroup(g); + groups.remove(g); + g.setContext(null, false); + } } } /** */ + @Override public SequenceI findName(String name) { return findName(name, false); @@ -367,6 +566,7 @@ public class Alignment implements AlignmentI * * @see jalview.datamodel.AlignmentI#findName(java.lang.String, boolean) */ + @Override public SequenceI findName(String token, boolean b) { return findName(null, token, b); @@ -376,8 +576,9 @@ public class Alignment implements AlignmentI * (non-Javadoc) * * @see jalview.datamodel.AlignmentI#findName(SequenceI, java.lang.String, - * boolean) + * boolean) */ + @Override public SequenceI findName(SequenceI startAfter, String token, boolean b) { @@ -418,6 +619,7 @@ public class Alignment implements AlignmentI return null; } + @Override public SequenceI[] findSequenceMatch(String name) { Vector matches = new Vector(); @@ -441,9 +643,13 @@ public class Alignment implements AlignmentI return result; } - /* (non-Javadoc) + + /* + * (non-Javadoc) + * * @see jalview.datamodel.AlignmentI#findIndex(jalview.datamodel.SequenceI) */ + @Override public int findIndex(SequenceI s) { int i = 0; @@ -460,14 +666,19 @@ public class Alignment implements AlignmentI return -1; } - /* (non-Javadoc) - * @see jalview.datamodel.AlignmentI#findIndex(jalview.datamodel.SearchResults) + + /* + * (non-Javadoc) + * + * @see + * jalview.datamodel.AlignmentI#findIndex(jalview.datamodel.SearchResults) */ - public int findIndex(SearchResults results) + @Override + public int findIndex(SearchResultsI results) { - int i=0; - - while (i