X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FAlignment.java;h=f14539b2e5b837b18e95a07ca13774271f70da37;hb=1f959f4a5bc07769cde4c2577022ad64e55b4a1a;hp=f9de1156ee4d9e6ec0aea5fb99009c7d137858c6;hpb=d6509fcf3a8cc90616e18cb22cec97f85c722bb8;p=jalview.git diff --git a/src/jalview/datamodel/Alignment.java b/src/jalview/datamodel/Alignment.java index f9de115..f14539b 100755 --- a/src/jalview/datamodel/Alignment.java +++ b/src/jalview/datamodel/Alignment.java @@ -1,25 +1,40 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer (Version 2.7) - * Copyright (C) 2011 J Procter, AM Waterhouse, J Engelhardt, LM Lui, G Barton, M Clamp, S Searle + * 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. - * + * 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 Jalview. If not, see . + * 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.datamodel; -import java.util.*; - -import jalview.analysis.*; +import jalview.analysis.AlignmentUtils; +import jalview.io.FastaFile; +import jalview.util.Comparison; +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.Iterator; +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 @@ -34,8 +49,7 @@ public class Alignment implements AlignmentI protected List sequences; - protected List groups = java.util.Collections - .synchronizedList(new ArrayList()); + protected List groups; protected char gapCharacter = '-'; @@ -44,21 +58,24 @@ public class Alignment implements AlignmentI public static final int PROTEIN = 0; public static final int NUCLEOTIDE = 1; - + public boolean hasRNAStructure = false; - /** DOCUMENT ME!! */ 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; } @@ -67,10 +84,9 @@ public class Alignment implements AlignmentI type = PROTEIN; } - sequences = java.util.Collections - .synchronizedList(new ArrayList()); + sequences = Collections.synchronizedList(new ArrayList()); - for (i = 0; i < seqs.length; i++) + for (int i = 0; i < seqs.length; i++) { sequences.add(seqs[i]); } @@ -78,6 +94,26 @@ public class Alignment implements AlignmentI } /** + * 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++) + { + seqs[i] = new Sequence(seqs[i]); + } + + initAlignment(seqs); + + /* + * Share the same dataset sequence mappings (if any). + */ + this.setCodonFrames(al.getCodonFrames()); + } + + /** * Make an alignment from an array of Sequences. * * @param sequences @@ -111,32 +147,34 @@ public class Alignment implements AlignmentI */ 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! - */ @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. + // 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; + } synchronized (sequences) { return sequences.toArray(new SequenceI[sequences.size()]); @@ -144,6 +182,17 @@ public class Alignment implements AlignmentI } /** + * Returns a map of lists of sequences keyed by sequence name. + * + * @return + */ + @Override + public Map> getSequencesByName() + { + return AlignmentUtils.getSequencesByName(this); + } + + /** * DOCUMENT ME! * * @param i @@ -151,6 +200,7 @@ public class Alignment implements AlignmentI * * @return DOCUMENT ME! */ + @Override public SequenceI getSequenceAt(int i) { synchronized (sequences) @@ -168,6 +218,7 @@ public class Alignment implements AlignmentI * * @param snew */ + @Override public void addSequence(SequenceI snew) { if (dataset != null) @@ -187,8 +238,7 @@ public class Alignment implements AlignmentI } if (sequences == null) { - initAlignment(new SequenceI[] - { snew }); + initAlignment(new SequenceI[] { snew }); } else { @@ -198,7 +248,9 @@ public class Alignment implements AlignmentI } } if (hiddenSequences != null) + { hiddenSequences.adjustHeightSequenceAdded(); + } } /** @@ -206,12 +258,12 @@ public class Alignment implements AlignmentI * * @param snew */ + @Override public void setSequenceAt(int i, SequenceI snew) { - SequenceI oldseq = getSequenceAt(i); - deleteSequence(i); synchronized (sequences) { + deleteSequence(i); sequences.set(i, snew); } } @@ -221,15 +273,19 @@ public class Alignment implements AlignmentI * * @return DOCUMENT ME! */ - public Vector getGroups() + @Override + public List getGroups() { return groups; } + @Override public void finalize() { if (getDataset() != null) + { getDataset().removeAlignmentRef(); + } dataset = null; sequences = null; @@ -256,6 +312,7 @@ public class Alignment implements AlignmentI * @param s * DOCUMENT ME! */ + @Override public void deleteSequence(SequenceI s) { deleteSequence(findIndex(s)); @@ -267,6 +324,7 @@ public class Alignment implements AlignmentI * @param i * DOCUMENT ME! */ + @Override public void deleteSequence(int i) { if (i > -1 && i < getHeight()) @@ -274,14 +332,14 @@ public class Alignment implements AlignmentI synchronized (sequences) { sequences.remove(i); + hiddenSequences.adjustHeightSequenceDeleted(i); } - hiddenSequences.adjustHeightSequenceDeleted(i); } } /* * (non-Javadoc) - * + * * @see jalview.datamodel.AlignmentI#findGroup(jalview.datamodel.SequenceI) */ @Override @@ -302,14 +360,13 @@ public class Alignment implements AlignmentI 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) { ArrayList temp = new ArrayList(); @@ -320,14 +377,14 @@ public class Alignment implements AlignmentI for (int i = 0; i < gSize; i++) { SequenceGroup sg = groups.get(i); - if (sg == null || sg.getSequences(null) == null) + if (sg == null || sg.getSequences() == null) { this.deleteGroup(sg); gSize--; continue; } - if (sg.getSequences(null).contains(s)) + if (sg.getSequences().contains(s)) { temp.add(sg); } @@ -338,6 +395,7 @@ public class Alignment implements AlignmentI } /** */ + @Override public void addGroup(SequenceGroup sg) { synchronized (groups) @@ -362,7 +420,7 @@ public class Alignment implements AlignmentI return; } } - + sg.setContext(this); groups.add(sg); } } @@ -428,6 +486,7 @@ public class Alignment implements AlignmentI } } + @Override public void deleteAllGroups() { synchronized (groups) @@ -436,11 +495,16 @@ public class Alignment implements AlignmentI { removeAnnotationForGroup(null); } + for (SequenceGroup sg : groups) + { + sg.setContext(null); + } groups.clear(); } } /** */ + @Override public void deleteGroup(SequenceGroup g) { synchronized (groups) @@ -449,11 +513,13 @@ public class Alignment implements AlignmentI { removeAnnotationForGroup(g); groups.remove(g); + g.setContext(null); } } } /** */ + @Override public SequenceI findName(String name) { return findName(name, false); @@ -464,6 +530,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); @@ -475,6 +542,7 @@ public class Alignment implements AlignmentI * @see jalview.datamodel.AlignmentI#findName(SequenceI, java.lang.String, * boolean) */ + @Override public SequenceI findName(SequenceI startAfter, String token, boolean b) { @@ -515,6 +583,7 @@ public class Alignment implements AlignmentI return null; } + @Override public SequenceI[] findSequenceMatch(String name) { Vector matches = new Vector(); @@ -544,6 +613,7 @@ public class Alignment implements AlignmentI * * @see jalview.datamodel.AlignmentI#findIndex(jalview.datamodel.SequenceI) */ + @Override public int findIndex(SequenceI s) { int i = 0; @@ -567,6 +637,7 @@ public class Alignment implements AlignmentI * @see * jalview.datamodel.AlignmentI#findIndex(jalview.datamodel.SearchResults) */ + @Override public int findIndex(SearchResults results) { int i = 0; @@ -587,6 +658,7 @@ public class Alignment implements AlignmentI * * @return DOCUMENT ME! */ + @Override public int getHeight() { return sequences.size(); @@ -597,6 +669,7 @@ public class Alignment implements AlignmentI * * @return DOCUMENT ME! */ + @Override public int getWidth() { int maxLength = -1; @@ -618,6 +691,7 @@ public class Alignment implements AlignmentI * @param gc * DOCUMENT ME! */ + @Override public void setGapCharacter(char gc) { gapCharacter = gc; @@ -636,6 +710,7 @@ public class Alignment implements AlignmentI * * @return DOCUMENT ME! */ + @Override public char getGapCharacter() { return gapCharacter; @@ -646,6 +721,7 @@ public class Alignment implements AlignmentI * * @see jalview.datamodel.AlignmentI#isAligned() */ + @Override public boolean isAligned() { return isAligned(false); @@ -656,6 +732,7 @@ public class Alignment implements AlignmentI * * @see jalview.datamodel.AlignmentI#isAligned(boolean) */ + @Override public boolean isAligned(boolean includeHidden) { int width = getWidth(); @@ -677,17 +754,41 @@ public class Alignment implements AlignmentI return true; } + /** + * 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; @@ -715,13 +816,16 @@ public class Alignment implements AlignmentI continue; } if (tIndex < temp.length) + { temp[tIndex++] = annotations[i]; + } } if (swap) { annotations = temp; - if (unhook) { + if (unhook) + { unhookAnnotation(aa); } } @@ -752,6 +856,7 @@ public class Alignment implements AlignmentI * @seejalview.datamodel.AlignmentI#addAnnotation(jalview.datamodel. * AlignmentAnnotation) */ + @Override public void addAnnotation(AlignmentAnnotation aa) { addAnnotation(aa, -1); @@ -763,12 +868,14 @@ public class Alignment implements AlignmentI * @seejalview.datamodel.AlignmentI#addAnnotation(jalview.datamodel. * AlignmentAnnotation, int) */ + @Override public void addAnnotation(AlignmentAnnotation aa, int pos) { - if(aa.getRNAStruc()!= null){ - hasRNAStructure=true; + if (aa.getRNAStruc() != null) + { + hasRNAStructure = true; } - + int aSize = 1; if (annotations != null) { @@ -804,6 +911,7 @@ public class Alignment implements AlignmentI annotations = temp; } + @Override public void setAnnotationIndex(AlignmentAnnotation aa, int index) { if (aa == null || annotations == null || annotations.length - 1 < index) @@ -845,6 +953,7 @@ public class Alignment implements AlignmentI return annotations; } + @Override public void setNucleotide(boolean b) { if (b) @@ -857,6 +966,7 @@ public class Alignment implements AlignmentI } } + @Override public boolean isNucleotide() { if (type == NUCLEOTIDE) @@ -868,41 +978,78 @@ public class Alignment implements AlignmentI return false; } } - - public boolean hasRNAStructure(){ - //TODO can it happen that structure is removed from alignment? + + @Override + public boolean hasRNAStructure() + { + // TODO can it happen that structure is removed from alignment? return hasRNAStructure; } + @Override public void setDataset(Alignment 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 - SequenceI[] seqs = new SequenceI[getHeight()]; - SequenceI currentSeq; + createDatasetAlignment(); + } + else if (dataset == null && data != null) + { + dataset = 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] = currentSeq.createDatasetSequence(); + while (dsq.getDatasetSequence() != null) + { + dsq = dsq.getDatasetSequence(); + } + if (dataset.findIndex(dsq) == -1) + { + dataset.addSequence(dsq); + } } } + } + dataset.addAlignmentRef(); + } - dataset = new Alignment(seqs); + /** + * 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; } - else if (dataset == null && data != null) + SequenceI[] seqs = new SequenceI[getHeight()]; + SequenceI currentSeq; + for (int i = 0; i < getHeight(); i++) { - dataset = data; + currentSeq = getSequenceAt(i); + if (currentSeq.getDatasetSequence() != null) + { + seqs[i] = currentSeq.getDatasetSequence(); + } + else + { + seqs[i] = currentSeq.createDatasetSequence(); + } } - dataset.addAlignmentRef(); + + dataset = new Alignment(seqs); + // move mappings to the dataset alignment + dataset.codonFrameList = this.codonFrameList; + this.codonFrameList = null; } /** @@ -918,11 +1065,13 @@ public class Alignment implements AlignmentI alignmentRefs++; } + @Override public Alignment getDataset() { return dataset; } + @Override public boolean padGaps() { boolean modified = false; @@ -974,6 +1123,7 @@ public class Alignment implements AlignmentI * 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; @@ -1071,11 +1221,13 @@ public class Alignment implements AlignmentI return modified; } + @Override public HiddenSequences getHiddenSequences() { return hiddenSequences; } + @Override public CigarArray getCompactAlignment() { synchronized (sequences) @@ -1096,57 +1248,60 @@ public class Alignment implements AlignmentI public void setProperty(Object key, Object value) { if (alignmentProperties == null) + { alignmentProperties = new Hashtable(); + } alignmentProperties.put(key, value); } + @Override public Object getProperty(Object key) { 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) + /** + * adds a set of mappings (while ignoring any duplicates) */ - public AlignedCodonFrame getCodonFrame(int index) + @Override + public void addCodonFrames(Iterable codons) { - return codonFrameList[index]; + if (codons != null) + { + Iterator it = codons.iterator(); + while (it.hasNext()) + { + addCodonFrame(it.next()); + } + } } /* @@ -1155,65 +1310,72 @@ public class Alignment implements AlignmentI * @see * jalview.datamodel.AlignmentI#getCodonFrame(jalview.datamodel.SequenceI) */ - public AlignedCodonFrame[] getCodonFrame(SequenceI seq) + @Override + public List getCodonFrame(SequenceI seq) { - if (seq == null || codonFrameList == null) + if (seq == null) + { return null; - Vector cframes = new Vector(); - for (int f = 0; f < codonFrameList.length; f++) + } + List cframes = new ArrayList(); + for (AlignedCodonFrame acf : getCodonFrames()) + { + if (acf.involvesSequence(seq)) + { + cframes.add(acf); + } + } + return cframes; + } + + /** + * 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() + */ + @Override + public void setCodonFrames(List acfs) + { + if (dataset != null) { - if (codonFrameList[f].involvesSequence(seq)) - cframes.addElement(codonFrameList[f]); + dataset.setCodonFrames(acfs); + } + else + { + this.codonFrameList = acfs; } - if (cframes.size() == 0) - return null; - AlignedCodonFrame[] cfr = new AlignedCodonFrame[cframes.size()]; - cframes.copyInto(cfr); - return cfr; } - /* - * (non-Javadoc) + /** + * Returns the set of codon frame mappings. Any changes to the returned set + * will affect the alignment. The mappings are held on (and read from) the + * dataset alignment if there is one. * * @see jalview.datamodel.AlignmentI#getCodonFrames() */ - public AlignedCodonFrame[] getCodonFrames() + @Override + public List getCodonFrames() { - return codonFrameList; + return dataset != null ? dataset.getCodonFrames() : codonFrameList; } - /* - * (non-Javadoc) - * - * @seejalview.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) - return false; - boolean removed = false; - int i = 0, iSize = codonFrameList.length; - while (i < iSize) + List acfs = getCodonFrames(); + if (codons == null || acfs == null) { - if (codonFrameList[i] == codons) - { - removed = true; - if (i + 1 < iSize) - { - System.arraycopy(codonFrameList, i + 1, codonFrameList, i, iSize - - i - 1); - } - iSize--; - } - else - { - i++; - } + return false; } - return removed; + return acfs.remove(codons); } + @Override public void append(AlignmentI toappend) { if (toappend == this) @@ -1255,15 +1417,13 @@ public class Alignment implements AlignmentI { addAnnotation(alan[a]); } - AlignedCodonFrame[] acod = toappend.getCodonFrames(); - for (int a = 0; acod != null && a < acod.length; a++) - { - this.addCodonFrame(acod[a]); - } + + getCodonFrames().addAll(toappend.getCodonFrames()); + List sg = toappend.getGroups(); if (sg != null) { - for (SequenceGroup _sg:sg) + for (SequenceGroup _sg : sg) { addGroup(_sg); } @@ -1333,23 +1493,28 @@ public class Alignment implements AlignmentI } @Override - public AlignmentAnnotation findOrCreateAnnotation(String name, boolean autoCalc, - SequenceI seqRef, SequenceGroup groupRef) + public AlignmentAnnotation findOrCreateAnnotation(String name, + String calcId, boolean autoCalc, SequenceI seqRef, + SequenceGroup groupRef) { - for (AlignmentAnnotation annot : - getAlignmentAnnotation()) + assert (name != null); + if (annotations != null) { - if (annot.autoCalculated == autoCalc - && annot.getCalcId().equals(name) - && annot.sequenceRef == seqRef && annot.groupRef == groupRef) + for (AlignmentAnnotation annot : getAlignmentAnnotation()) { - return annot; + if (annot.autoCalculated == autoCalc && (name.equals(annot.label)) + && (calcId == null || annot.getCalcId().equals(calcId)) + && annot.sequenceRef == seqRef + && annot.groupRef == groupRef) + { + return annot; + } } } AlignmentAnnotation annot = new AlignmentAnnotation(name, name, new Annotation[1], 0f, 0f, AlignmentAnnotation.BAR_GRAPH); annot.hasText = false; - annot.setCalcId(new String(name)); + annot.setCalcId(new String(calcId)); annot.autoCalculated = autoCalc; if (seqRef != null) { @@ -1364,10 +1529,12 @@ public class Alignment implements AlignmentI @Override public Iterable findAnnotation(String calcId) { - ArrayList aa=new ArrayList(); - for (AlignmentAnnotation a:getAlignmentAnnotation()) + ArrayList aa = new ArrayList(); + for (AlignmentAnnotation a : getAlignmentAnnotation()) { - if (a.getCalcId()==calcId || (a.getCalcId()!=null && calcId!=null && a.getCalcId().equals(calcId))) + if (a.getCalcId() == calcId + || (a.getCalcId() != null && calcId != null && a.getCalcId() + .equals(calcId))) { aa.add(a); } @@ -1375,4 +1542,308 @@ public class Alignment implements AlignmentI return aa; } + /** + * Returns an iterable collection of any annotations that match on given + * sequence ref, calcId and label (ignoring null values). + */ + @Override + public Iterable findAnnotations(SequenceI seq, + String calcId, String label) + { + ArrayList aa = new ArrayList(); + for (AlignmentAnnotation ann : getAlignmentAnnotation()) + { + if (ann.getCalcId() != null && ann.getCalcId().equals(calcId) + && ann.sequenceRef != null && ann.sequenceRef == seq + && ann.label != null && ann.label.equals(label)) + { + aa.add(ann); + } + } + return aa; + } + + @Override + public void moveSelectedSequencesByOne(SequenceGroup sg, + Map map, boolean up) + { + synchronized (sequences) + { + if (up) + { + + for (int i = 1, iSize = sequences.size(); i < iSize; i++) + { + SequenceI seq = sequences.get(i); + if (!sg.getSequences(map).contains(seq)) + { + continue; + } + + SequenceI temp = sequences.get(i - 1); + if (sg.getSequences(null).contains(temp)) + { + continue; + } + + sequences.set(i, temp); + sequences.set(i - 1, seq); + } + } + else + { + for (int i = sequences.size() - 2; i > -1; i--) + { + SequenceI seq = sequences.get(i); + if (!sg.getSequences(map).contains(seq)) + { + continue; + } + + SequenceI temp = sequences.get(i + 1); + if (sg.getSequences(map).contains(temp)) + { + continue; + } + + sequences.set(i, temp); + sequences.set(i + 1, seq); + } + } + + } + } + + @Override + public void validateAnnotation(AlignmentAnnotation alignmentAnnotation) + { + alignmentAnnotation.validateRangeAndDisplay(); + if (isNucleotide() && alignmentAnnotation.isValidStruc()) + { + hasRNAStructure = true; + } + } + + private SequenceI seqrep = null; + + /** + * + * @return the representative sequence for this group + */ + @Override + public SequenceI getSeqrep() + { + return seqrep; + } + + /** + * set the representative sequence for this group. Note - this affects the + * interpretation of the Hidereps attribute. + * + * @param seqrep + * the seqrep to set (null means no sequence representative) + */ + @Override + public void setSeqrep(SequenceI seqrep) + { + this.seqrep = seqrep; + } + + /** + * + * @return true if group has a sequence representative + */ + @Override + public boolean hasSeqrep() + { + return seqrep != null; + } + + @Override + public int getEndRes() + { + return getWidth() - 1; + } + + @Override + public int getStartRes() + { + return 0; + } + + /* + * In the case of AlignmentI - returns the dataset for the alignment, if set + * (non-Javadoc) + * + * @see jalview.datamodel.AnnotatedCollectionI#getContext() + */ + @Override + public AnnotatedCollectionI getContext() + { + return dataset; + } + + /** + * Align this alignment like the given (mapped) one. + */ + @Override + public int alignAs(AlignmentI al) + { + /* + * Currently retains unmapped gaps (in introns), regaps mapped regions + * (exons) + */ + return alignAs(al, false, true); + } + + /** + * Align this alignment 'the same as' the given one. Mapped sequences only are + * realigned. If both of the same type (nucleotide/protein) then align both + * identically. If this is nucleotide and the other is protein, make 3 gaps + * for each gap in the protein sequences. If this is protein and the other is + * nucleotide, insert a gap for each 3 gaps (or part thereof) between + * nucleotide bases. If this is protein and the other is nucleotide, gaps + * protein to match the relative ordering of codons in the nucleotide. + * + * Parameters control whether gaps in exon (mapped) and intron (unmapped) + * regions are preserved. Gaps that connect introns to exons are treated + * conservatively, i.e. only preserved if both intron and exon gaps are + * preserved. + * + * @param al + * @param preserveMappedGaps + * if true, gaps within and between mapped codons are preserved + * @param preserveUnmappedGaps + * if true, gaps within and between unmapped codons are preserved + */ + // @Override + public int alignAs(AlignmentI al, boolean preserveMappedGaps, + boolean preserveUnmappedGaps) + { + // TODO should this method signature be the one in the interface? + boolean thisIsNucleotide = this.isNucleotide(); + boolean thatIsProtein = !al.isNucleotide(); + if (!thatIsProtein && !thisIsNucleotide) + { + return AlignmentUtils.alignProteinAsDna(this, al); + } + return AlignmentUtils.alignAs(this, al); + } + + /** + * Returns the alignment in Fasta format. Behaviour of this method is not + * guaranteed between versions. + */ + @Override + public String toString() + { + return new FastaFile().print(getSequencesArray()); + } + + /** + * Returns the set of distinct sequence names. No ordering is guaranteed. + */ + @Override + public Set getSequenceNames() + { + Set names = new HashSet(); + for (SequenceI seq : getSequences()) + { + names.add(seq.getName()); + } + return names; + } + + @Override + public boolean hasValidSequence() + { + boolean hasValidSeq = false; + for (SequenceI seq : getSequences()) + { + if ((seq.getEnd() - seq.getStart()) > 0) + { + hasValidSeq = true; + break; + } + } + return hasValidSeq; + } + + /** + * Update any mappings to 'virtual' sequences to compatible real ones, if + * present in the added sequences. Returns a count of mappings updated. + * + * @param seqs + * @return + */ + @Override + public int realiseMappings(List seqs) + { + int count = 0; + for (SequenceI seq : seqs) + { + for (AlignedCodonFrame mapping : getCodonFrames()) + { + count += mapping.realiseWith(seq); + } + } + return count; + } + + /** + * Returns the first AlignedCodonFrame that has a mapping between the given + * dataset sequences + * + * @param mapFrom + * @param mapTo + * @return + */ + @Override + public AlignedCodonFrame getMapping(SequenceI mapFrom, SequenceI mapTo) + { + for (AlignedCodonFrame acf : getCodonFrames()) + { + if (acf.getAaForDnaSeq(mapFrom) == mapTo) + { + return acf; + } + } + return null; + } + + @Override + public int[] getVisibleStartAndEndIndex(List hiddenCols) + { + int[] alignmentStartEnd = new int[] { 0, getWidth() - 1 }; + int startPos = alignmentStartEnd[0]; + int endPos = alignmentStartEnd[1]; + + int[] lowestRange = new int[] { -1, -1 }; + int[] higestRange = new int[] { -1, -1 }; + + for (int[] hiddenCol : hiddenCols) + { + lowestRange = (hiddenCol[0] <= startPos) ? hiddenCol : lowestRange; + higestRange = (hiddenCol[1] >= endPos) ? hiddenCol : higestRange; + } + + if (lowestRange[0] == -1 && lowestRange[1] == -1) + { + startPos = alignmentStartEnd[0]; + } + else + { + startPos = lowestRange[1] + 1; + } + + if (higestRange[0] == -1 && higestRange[1] == -1) + { + endPos = alignmentStartEnd[1]; + } + else + { + endPos = higestRange[0] - 1; + } + return new int[] { startPos, endPos }; + } }