X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FAlignment.java;h=2289ac6314196fe08a62aa4797c8ef5897f0cc58;hb=37de9310bec3501cbc6381e0c3dcb282fcaad812;hp=ba65fd796566b6be25324a2ead43af927325d2af;hpb=e5edd3d9da88468dc7143f7e46cf2ebbe4e3393c;p=jalview.git diff --git a/src/jalview/datamodel/Alignment.java b/src/jalview/datamodel/Alignment.java index ba65fd7..2289ac6 100755 --- a/src/jalview/datamodel/Alignment.java +++ b/src/jalview/datamodel/Alignment.java @@ -1,52 +1,82 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer - * Copyright (C) 2007 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle - * - * 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 + * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$) + * Copyright (C) $$Year-Rel$$ The Jalview Authors + * + * 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 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.datamodel; -import java.util.*; - -import jalview.analysis.*; - -/** Data structure to hold and manipulate a multiple sequence alignment +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 */ -public class Alignment - implements AlignmentI +/** + * @author JimP + * + */ +public class Alignment implements AlignmentI { - protected Alignment dataset; - protected Vector sequences; - protected Vector groups = new Vector(); + private Alignment dataset; + + protected List sequences; + + protected List groups; + protected char gapCharacter = '-'; + protected int type = NUCLEOTIDE; + public static final int PROTEIN = 0; + public static final int NUCLEOTIDE = 1; - /** DOCUMENT ME!! */ + public boolean hasRNAStructure = false; + public AlignmentAnnotation[] annotations; - HiddenSequences hiddenSequences = new HiddenSequences(this); + HiddenSequences hiddenSequences; public Hashtable alignmentProperties; + private List codonFrameList; + private void initAlignment(SequenceI[] seqs) { - int i = 0; + groups = Collections.synchronizedList(new ArrayList()); + hiddenSequences = new HiddenSequences(this); + codonFrameList = new ArrayList(); - if (jalview.util.Comparison.isNucleotide(seqs)) + if (Comparison.isNucleotide(seqs)) { type = NUCLEOTIDE; } @@ -55,17 +85,41 @@ public class Alignment type = PROTEIN; } - sequences = new Vector(); + sequences = Collections.synchronizedList(new ArrayList()); + + for (int i = 0; i < seqs.length; i++) + { + sequences.add(seqs[i]); + } + + } - for (i = 0; i < seqs.length; i++) + /** + * 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++) { - sequences.addElement(seqs[i]); + seqs[i] = new Sequence(seqs[i]); } + initAlignment(seqs); + + /* + * Share the same dataset sequence mappings (if any). + */ + if (dataset == null && al.getDataset() == null) + { + this.setCodonFrames(al.getCodonFrames()); + } } - /** Make an alignment from an array of Sequences. - * + /** + * Make an alignment from an array of Sequences. + * * @param sequences */ public Alignment(SequenceI[] seqs) @@ -75,123 +129,185 @@ public class Alignment /** * Make a new alignment from an array of SeqCigars - * @param seqs SeqCigar[] + * + * @param seqs + * SeqCigar[] */ public Alignment(SeqCigar[] alseqs) { - SequenceI[] seqs = SeqCigar.createAlignmentSequences(alseqs, gapCharacter, - new ColumnSelection(), null); + SequenceI[] seqs = SeqCigar.createAlignmentSequences(alseqs, + gapCharacter, new ColumnSelection(), null); initAlignment(seqs); } /** - * Make a new alignment from an CigarArray - * JBPNote - can only do this when compactAlignment does not contain hidden regions. - * JBPNote - must also check that compactAlignment resolves to a set of SeqCigars - or construct them appropriately. - * @param compactAlignment CigarArray + * Make a new alignment from an CigarArray JBPNote - can only do this when + * compactAlignment does not contain hidden regions. JBPNote - must also check + * that compactAlignment resolves to a set of SeqCigars - or construct them + * appropriately. + * + * @param compactAlignment + * 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) + 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; + } + + /** + * Returns a map of lists of sequences keyed by sequence name. + * + * @return + */ + @Override + public Map> getSequencesByName() + { + return AlignmentUtils.getSequencesByName(this); } /** * DOCUMENT ME! - * - * @param i DOCUMENT ME! - * + * + * @param i + * DOCUMENT ME! + * * @return DOCUMENT ME! */ + @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; } - /** Adds a sequence to the alignment. Recalculates maxLength and size. - * + /** + * Adds a sequence to the alignment. Recalculates maxLength and size. + * * @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) { + if (sequences == null) + { initAlignment(new SequenceI[] { snew }); - } else { - sequences.addElement(snew); } - if (hiddenSequences!=null) + else + { + 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; + } } /** * DOCUMENT ME! - * + * * @return DOCUMENT ME! */ - public Vector getGroups() + @Override + public List getGroups() { return groups; } - public void finalize() + @Override + public void finalize() throws Throwable { - if(getDataset()!=null) + 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; @@ -200,21 +316,26 @@ public class Alignment } /** - * 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) + if (--alignmentRefs == 0) { - finalize(); + nullReferences(); } } /** * DOCUMENT ME! - * - * @param s DOCUMENT ME! + * + * @param s + * DOCUMENT ME! */ + @Override public void deleteSequence(SequenceI s) { deleteSequence(findIndex(s)); @@ -222,125 +343,259 @@ public class Alignment /** * DOCUMENT ME! - * - * @param i DOCUMENT ME! + * + * @param i + * DOCUMENT ME! */ + @Override public void deleteSequence(int i) { if (i > -1 && i < getHeight()) { - sequences.removeElementAt(i); - hiddenSequences.adjustHeightSequenceDeleted(i); + synchronized (sequences) + { + sequences.remove(i); + hiddenSequences.adjustHeightSequenceDeleted(i); + } } } - /** */ + /* + * (non-Javadoc) + * + * @see jalview.datamodel.AlignmentI#findGroup(jalview.datamodel.SequenceI) + */ + @Override public SequenceGroup findGroup(SequenceI s) { - for (int i = 0; i < this.groups.size(); i++) + synchronized (groups) { - SequenceGroup sg = (SequenceGroup) groups.elementAt(i); - - if (sg.getSequences(null).contains(s)) + for (int i = 0; i < this.groups.size(); i++) { - return sg; + SequenceGroup sg = groups.get(i); + + if (sg.getSequences(null).contains(s)) + { + return sg; + } } } - return null; } - /** - * DOCUMENT ME! - * - * @param s DOCUMENT ME! - * - * @return DOCUMENT ME! + /* + * (non-Javadoc) + * + * @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); + 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); + } + 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); + } } } /** */ + @Override public SequenceI findName(String name) { - int i = 0; + return findName(name, false); + } + + /* + * (non-Javadoc) + * + * @see jalview.datamodel.AlignmentI#findName(java.lang.String, boolean) + */ + @Override + public SequenceI findName(String token, boolean b) + { + return findName(null, token, b); + } + /* + * (non-Javadoc) + * + * @see jalview.datamodel.AlignmentI#findName(SequenceI, java.lang.String, + * boolean) + */ + @Override + public SequenceI findName(SequenceI startAfter, String token, boolean b) + { + + int i = 0; + SequenceI sq = null; + String sqname = null; + if (startAfter != null) + { + // try to find the sequence in the alignment + boolean matched = false; + while (i < sequences.size()) + { + if (getSequenceAt(i++) == startAfter) + { + matched = true; + break; + } + } + if (!matched) + { + i = 0; + } + } while (i < sequences.size()) { - if (getSequenceAt(i).getName().equals(name)) + sq = getSequenceAt(i); + sqname = sq.getName(); + if (sqname.equals(token) // exact match + || (b && // allow imperfect matches - case varies + (sqname.equalsIgnoreCase(token)))) { return getSequenceAt(i); } @@ -351,6 +606,7 @@ public class Alignment return null; } + @Override public SequenceI[] findSequenceMatch(String name) { Vector matches = new Vector(); @@ -375,7 +631,12 @@ public class Alignment } - /** */ + /* + * (non-Javadoc) + * + * @see jalview.datamodel.AlignmentI#findIndex(jalview.datamodel.SequenceI) + */ + @Override public int findIndex(SequenceI s) { int i = 0; @@ -393,11 +654,34 @@ public class Alignment return -1; } + /* + * (non-Javadoc) + * + * @see + * jalview.datamodel.AlignmentI#findIndex(jalview.datamodel.SearchResults) + */ + @Override + public int findIndex(SearchResults results) + { + int i = 0; + + while (i < sequences.size()) + { + if (results.involvesSequence(getSequenceAt(i))) + { + return i; + } + i++; + } + return -1; + } + /** * DOCUMENT ME! - * + * * @return DOCUMENT ME! */ + @Override public int getHeight() { return sequences.size(); @@ -405,9 +689,10 @@ public class Alignment /** * DOCUMENT ME! - * + * * @return DOCUMENT ME! */ + @Override public int getWidth() { int maxLength = -1; @@ -425,58 +710,110 @@ public class Alignment /** * DOCUMENT ME! - * - * @param gc DOCUMENT ME! + * + * @param gc + * DOCUMENT ME! */ + @Override public void setGapCharacter(char gc) { gapCharacter = gc; - - for (int i = 0; i < sequences.size(); i++) + synchronized (sequences) { - Sequence seq = (Sequence) sequences.elementAt(i); - seq.setSequence(seq.getSequenceAsString() - .replace('.', gc) - .replace('-', gc) - .replace(' ', gc) - ); + for (SequenceI seq : sequences) + { + seq.setSequence(seq.getSequenceAsString().replace('.', gc) + .replace('-', gc).replace(' ', gc)); + } } } /** * DOCUMENT ME! - * + * * @return DOCUMENT ME! */ + @Override public char getGapCharacter() { return gapCharacter; } - /** - * DOCUMENT ME! - * - * @return DOCUMENT ME! + /* + * (non-Javadoc) + * + * @see jalview.datamodel.AlignmentI#isAligned() */ + @Override public boolean isAligned() { - int width = getWidth(); + return isAligned(false); + } + /* + * (non-Javadoc) + * + * @see jalview.datamodel.AlignmentI#isAligned(boolean) + */ + @Override + public boolean isAligned(boolean includeHidden) + { + int width = getWidth(); + if (hiddenSequences == null || hiddenSequences.getSize() == 0) + { + includeHidden = true; // no hidden sequences to check against. + } for (int i = 0; i < sequences.size(); i++) { - if (getSequenceAt(i).getLength() != width) + if (includeHidden || !hiddenSequences.isHidden(getSequenceAt(i))) { - return false; + if (getSequenceAt(i).getLength() != width) + { + return false; + } } } return true; } - /* (non-Javadoc) - * @see jalview.datamodel.AlignmentI#deleteAnnotation(jalview.datamodel.AlignmentAnnotation) + + /** + * Delete all annotations, including auto-calculated if the flag is set true. + * Returns true if at least one annotation was deleted, else false. + * + * @param includingAutoCalculated + * @return + */ + @Override + public boolean deleteAllAnnotations(boolean includingAutoCalculated) + { + boolean result = false; + for (AlignmentAnnotation alan : getAlignmentAnnotation()) + { + if (!alan.autoCalculated || includingAutoCalculated) + { + deleteAnnotation(alan); + result = true; + } + } + return result; + } + + /* + * (non-Javadoc) + * + * @seejalview.datamodel.AlignmentI#deleteAnnotation(jalview.datamodel. + * AlignmentAnnotation) */ + @Override public boolean deleteAnnotation(AlignmentAnnotation aa) { + return deleteAnnotation(aa, true); + } + + @Override + public boolean deleteAnnotation(AlignmentAnnotation aa, boolean unhook) + { int aSize = 1; if (annotations != null) @@ -491,36 +828,77 @@ public class Alignment AlignmentAnnotation[] temp = new AlignmentAnnotation[aSize - 1]; - boolean swap=false; + boolean swap = false; int tIndex = 0; for (int i = 0; i < aSize; i++) { if (annotations[i] == aa) { - swap=true; + swap = true; continue; } - if (tIndex= aSize) + { + temp[aSize - 1] = aa; + } + else + { + temp[pos] = aa; + } if (aSize > 1) { - for (i = 0; i < (aSize - 1); i++) + int p = 0; + for (i = 0; i < (aSize - 1); i++, p++) { - temp[i] = annotations[i]; + if (p == pos) + { + p++; + } + if (p < temp.length) + { + temp[p] = annotations[i]; + } } } annotations = temp; } + @Override public void setAnnotationIndex(AlignmentAnnotation aa, int index) { if (aa == null || annotations == null || annotations.length - 1 < index) @@ -576,16 +967,16 @@ public class Alignment annotations = temp; } + @Override /** - * DOCUMENT ME! - * - * @return DOCUMENT ME! + * returns all annotation on the alignment */ public AlignmentAnnotation[] getAlignmentAnnotation() { return annotations; } + @Override public void setNucleotide(boolean b) { if (b) @@ -598,6 +989,7 @@ public class Alignment } } + @Override public boolean isNucleotide() { if (type == NUCLEOTIDE) @@ -610,50 +1002,163 @@ public class Alignment } } - public void setDataset(Alignment data) + @Override + public boolean hasRNAStructure() + { + // TODO can it happen that structure is removed from alignment? + return hasRNAStructure; + } + + @Override + public void setDataset(AlignmentI data) { if (dataset == null && data == null) { - // Create a new dataset for this alignment. - // Can only be done once, if dataset is not null - // This will not be performed - Sequence[] seqs = new Sequence[getHeight()]; - SequenceI currentSeq; + createDatasetAlignment(); + } + else if (dataset == null && data != null) + { + if (!(data instanceof Alignment)) + { + throw new Error( + "Implementation Error: jalview.datamodel.Alignment does not yet support other implementations of AlignmentI as its dataset reference"); + } + dataset = (Alignment) data; for (int i = 0; i < getHeight(); i++) { - currentSeq = getSequenceAt(i); - if (currentSeq.getDatasetSequence() != null) + SequenceI currentSeq = getSequenceAt(i); + SequenceI dsq = currentSeq.getDatasetSequence(); + if (dsq == null) { - seqs[i] = (Sequence) currentSeq.getDatasetSequence(); + dsq = currentSeq.createDatasetSequence(); + dataset.addSequence(dsq); } else { - seqs[i] = new Sequence(currentSeq.getName(), - AlignSeq.extractGaps( - jalview.util.Comparison.GapChars, - currentSeq.getSequenceAsString() - ), - currentSeq.getStart(), - currentSeq.getEnd()); - seqs[i].sequenceFeatures = currentSeq.getSequenceFeatures(); - seqs[i].setDescription(currentSeq.getDescription()); - getSequenceAt(i).setSequenceFeatures(null); - getSequenceAt(i).setDatasetSequence(seqs[i]); - } + while (dsq.getDatasetSequence() != null) + { + dsq = dsq.getDatasetSequence(); + } + if (dataset.findIndex(dsq) == -1) + { + dataset.addSequence(dsq); + } + } } + } + dataset.addAlignmentRef(); + } - dataset = new Alignment(seqs); + /** + * add dataset sequences to seq for currentSeq and any sequences it references + */ + private void resolveAndAddDatasetSeq(SequenceI currentSeq, + Set seqs, boolean createDatasetSequence) + { + SequenceI alignedSeq = currentSeq; + if (currentSeq.getDatasetSequence() != null) + { + currentSeq = currentSeq.getDatasetSequence(); } - else if (dataset == null && data != null) + else + { + if (createDatasetSequence) + { + currentSeq = currentSeq.createDatasetSequence(); + } + } + if (seqs.contains(currentSeq)) { - dataset = data; + return; + } + List toProcess = new ArrayList(); + toProcess.add(currentSeq); + while (toProcess.size() > 0) + { + // use a queue ? + SequenceI curDs = toProcess.remove(0); + if (seqs.contains(curDs)) + { + continue; + } + seqs.add(curDs); + // iterate over database references, making sure we add forward referenced + // sequences + if (curDs.getDBRefs() != null) + { + for (DBRefEntry dbr : curDs.getDBRefs()) + { + if (dbr.getMap() != null && dbr.getMap().getTo() != null) + { + if (dbr.getMap().getTo() == alignedSeq) + { + /* + * update mapping to be to the newly created dataset sequence + */ + dbr.getMap().setTo(currentSeq); + } + if (dbr.getMap().getTo().getDatasetSequence() != null) + { + throw new Error( + "Implementation error: Map.getTo() for dbref " + dbr + + " from " + curDs.getName() + + " is not a dataset sequence."); + } + // we recurse to add all forward references to dataset sequences via + // DBRefs/etc + toProcess.add(dbr.getMap().getTo()); + } + } + } } - dataset.addAlignmentRef(); } + + /** + * Creates a new dataset for this alignment. Can only be done once - if + * dataset is not null this will not be performed. + */ + public void createDatasetAlignment() + { + if (dataset != null) + { + return; + } + // try to avoid using SequenceI.equals at this stage, it will be expensive + Set seqs = new LinkedIdentityHashSet(); + + for (int i = 0; i < getHeight(); i++) + { + SequenceI currentSeq = getSequenceAt(i); + resolveAndAddDatasetSeq(currentSeq, seqs, true); + } + + // verify all mappings are in dataset + for (AlignedCodonFrame cf : codonFrameList) + { + for (SequenceToSequenceMapping ssm : cf.getMappings()) + { + if (!seqs.contains(ssm.getFromSeq())) + { + resolveAndAddDatasetSeq(ssm.getFromSeq(), seqs, false); + } + if (!seqs.contains(ssm.getMapping().getTo())) + { + resolveAndAddDatasetSeq(ssm.getMapping().getTo(), seqs, false); + } + } + } + // finally construct dataset + dataset = new Alignment(seqs.toArray(new SequenceI[seqs.size()])); + // move mappings to the dataset alignment + dataset.codonFrameList = this.codonFrameList; + this.codonFrameList = null; + } + /** * reference count for number of alignments referencing this one. */ - int alignmentRefs=0; + int alignmentRefs = 0; + /** * increase reference count to this alignment. */ @@ -662,16 +1167,18 @@ public class Alignment alignmentRefs++; } + @Override public Alignment getDataset() { return dataset; } + @Override public boolean padGaps() { boolean modified = false; - //Remove excess gaps from the end of alignment + // Remove excess gaps from the end of alignment int maxLength = -1; SequenceI current; @@ -680,8 +1187,8 @@ public class Alignment current = getSequenceAt(i); for (int j = current.getLength(); j > maxLength; j--) { - if (j > maxLength && !jalview.util.Comparison.isGap( - current.getCharAt(j))) + if (j > maxLength + && !jalview.util.Comparison.isGap(current.getCharAt(j))) { maxLength = j; break; @@ -692,16 +1199,14 @@ public class Alignment maxLength++; int cLength; - for (int i = 0; i < sequences.size(); - i++) + for (int i = 0; i < sequences.size(); i++) { current = getSequenceAt(i); cLength = current.getLength(); if (cLength < maxLength) { - current.insertCharAt(cLength, - maxLength - cLength, gapCharacter); + current.insertCharAt(cLength, maxLength - cLength, gapCharacter); modified = true; } else if (current.getLength() > maxLength) @@ -712,123 +1217,733 @@ public class Alignment return modified; } + /** + * Justify the sequences to the left or right by deleting and inserting gaps + * before the initial residue or after the terminal residue + * + * @param right + * true if alignment padded to right, false to justify to left + * @return true if alignment was changed + */ + @Override + public boolean justify(boolean right) + { + boolean modified = false; + + // Remove excess gaps from the end of alignment + int maxLength = -1; + int ends[] = new int[sequences.size() * 2]; + SequenceI current; + for (int i = 0; i < sequences.size(); i++) + { + current = getSequenceAt(i); + // This should really be a sequence method + ends[i * 2] = current.findIndex(current.getStart()); + ends[i * 2 + 1] = current.findIndex(current.getStart() + + current.getLength()); + boolean hitres = false; + for (int j = 0, rs = 0, ssiz = current.getLength(); j < ssiz; j++) + { + if (!jalview.util.Comparison.isGap(current.getCharAt(j))) + { + if (!hitres) + { + ends[i * 2] = j; + hitres = true; + } + else + { + ends[i * 2 + 1] = j; + if (j - ends[i * 2] > maxLength) + { + maxLength = j - ends[i * 2]; + } + } + } + } + } + + maxLength++; + // now edit the flanking gaps to justify to either left or right + int cLength, extent, diff; + for (int i = 0; i < sequences.size(); i++) + { + current = getSequenceAt(i); + + cLength = 1 + ends[i * 2 + 1] - ends[i * 2]; + diff = maxLength - cLength; // number of gaps to indent + extent = current.getLength(); + if (right) + { + // right justify + if (extent > ends[i * 2 + 1]) + { + current.deleteChars(ends[i * 2 + 1] + 1, extent); + modified = true; + } + if (ends[i * 2] > diff) + { + current.deleteChars(0, ends[i * 2] - diff); + modified = true; + } + else + { + if (ends[i * 2] < diff) + { + current.insertCharAt(0, diff - ends[i * 2], gapCharacter); + modified = true; + } + } + } + else + { + // left justify + if (ends[i * 2] > 0) + { + current.deleteChars(0, ends[i * 2]); + modified = true; + ends[i * 2 + 1] -= ends[i * 2]; + extent -= ends[i * 2]; + } + if (extent > maxLength) + { + current.deleteChars(maxLength + 1, extent); + modified = true; + } + else + { + if (extent < maxLength) + { + current.insertCharAt(extent, maxLength - extent, gapCharacter); + modified = true; + } + } + } + } + return modified; + } + + @Override public HiddenSequences getHiddenSequences() { return hiddenSequences; } + @Override public CigarArray getCompactAlignment() { - SeqCigar alseqs[] = new SeqCigar[sequences.size()]; - for (int i = 0; i < sequences.size(); i++) + synchronized (sequences) { - alseqs[i] = new SeqCigar( (SequenceI) sequences.elementAt(i)); + SeqCigar alseqs[] = new SeqCigar[sequences.size()]; + int i = 0; + for (SequenceI seq : sequences) + { + alseqs[i++] = new SeqCigar(seq); + } + CigarArray cal = new CigarArray(alseqs); + cal.addOperation(CigarArray.M, getWidth()); + return cal; } - CigarArray cal = new CigarArray(alseqs); - cal.addOperation(CigarArray.M, getWidth()); - return cal; } + @Override public void setProperty(Object key, Object value) { - if(alignmentProperties==null) + if (alignmentProperties == null) + { alignmentProperties = new Hashtable(); + } - alignmentProperties.put(key,value); + alignmentProperties.put(key, value); } + @Override public Object getProperty(Object key) { - if(alignmentProperties!=null) + if (alignmentProperties != null) + { return alignmentProperties.get(key); + } else + { return null; + } } + @Override public Hashtable getProperties() { return alignmentProperties; } - AlignedCodonFrame[] codonFrameList=null; - /* (non-Javadoc) - * @see jalview.datamodel.AlignmentI#addCodonFrame(jalview.datamodel.AlignedCodonFrame) + + /** + * Adds the given mapping to the stored set. Note this may be held on the + * dataset alignment. */ + @Override public void addCodonFrame(AlignedCodonFrame codons) { - if (codons==null) - return; - if (codonFrameList==null) + List acfs = getCodonFrames(); + if (codons != null && acfs != null && !acfs.contains(codons)) { - codonFrameList = new AlignedCodonFrame[] { codons }; - return; + acfs.add(codons); } - AlignedCodonFrame[] t = new AlignedCodonFrame[codonFrameList.length+1]; - System.arraycopy(codonFrameList, 0, t, 0, codonFrameList.length); - t[codonFrameList.length] = codons; - codonFrameList = t; } - /* (non-Javadoc) - * @see jalview.datamodel.AlignmentI#getCodonFrame(int) + /* + * (non-Javadoc) + * + * @see + * jalview.datamodel.AlignmentI#getCodonFrame(jalview.datamodel.SequenceI) */ - public AlignedCodonFrame getCodonFrame(int index) + @Override + public List getCodonFrame(SequenceI seq) { - return codonFrameList[index]; + if (seq == null) + { + return null; + } + List cframes = new ArrayList(); + for (AlignedCodonFrame acf : getCodonFrames()) + { + if (acf.involvesSequence(seq)) + { + cframes.add(acf); + } + } + return cframes; } - /* (non-Javadoc) - * @see jalview.datamodel.AlignmentI#getCodonFrame(jalview.datamodel.SequenceI) + /** + * Sets the codon frame mappings (replacing any existing mappings). Note the + * mappings are set on the dataset alignment instead if there is one. + * + * @see jalview.datamodel.AlignmentI#setCodonFrames() */ - public AlignedCodonFrame[] getCodonFrame(SequenceI seq) + @Override + public void setCodonFrames(List acfs) { - if (seq==null || codonFrameList==null) - return null; - Vector cframes=new Vector(); - for (int f=0;f getCodonFrames() { - return codonFrameList; + // TODO: Fix this method to fix failing AlignedCodonFrame tests + // this behaviour is currently incorrect. method should return codon frames + // for just the alignment, + // selected from dataset + return dataset != null ? dataset.getCodonFrames() : codonFrameList; } - /* (non-Javadoc) - * @see jalview.datamodel.AlignmentI#removeCodonFrame(jalview.datamodel.AlignedCodonFrame) + /** + * Removes the given mapping from the stored set. Note that the mappings are + * held on the dataset alignment if there is one. */ + @Override public boolean removeCodonFrame(AlignedCodonFrame codons) { - if (codons==null || codonFrameList==null) + List acfs = getCodonFrames(); + if (codons == null || acfs == null) + { return false; - boolean removed=false; - int i=0,iSize=codonFrameList.length; - while (i