X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FSequence.java;h=6e9e1cdfba302998579a950cb1be7c34e6a4a7ef;hb=7459ed95f5ad213bafb1c691b193283850889e52;hp=ab6639ab9ed26d398f0ffec42e03694344eceeee;hpb=88694463a2aea303694231603b61970f72a5a259;p=jalview.git diff --git a/src/jalview/datamodel/Sequence.java b/src/jalview/datamodel/Sequence.java index ab6639a..6e9e1cd 100755 --- a/src/jalview/datamodel/Sequence.java +++ b/src/jalview/datamodel/Sequence.java @@ -21,41 +21,50 @@ package jalview.datamodel; import jalview.analysis.AlignSeq; -import jalview.api.DBRefEntryI; import jalview.datamodel.features.SequenceFeatures; import jalview.datamodel.features.SequenceFeaturesI; import jalview.util.Comparison; import jalview.util.DBRefUtils; import jalview.util.MapList; import jalview.util.StringUtils; +import jalview.ws.params.InvalidArgumentException; import java.util.ArrayList; import java.util.Arrays; import java.util.BitSet; import java.util.Collections; import java.util.Enumeration; +import java.util.Iterator; import java.util.List; +import java.util.ListIterator; import java.util.Vector; -import com.stevesoft.pat.Regex; - import fr.orsay.lri.varna.models.rna.RNA; /** * - * Implements the SequenceI interface for a char[] based sequence object. - * - * @author $author$ - * @version $Revision$ + * Implements the SequenceI interface for a char[] based sequence object */ public class Sequence extends ASequence implements SequenceI { - private static final Regex limitrx = new Regex( - "[/][0-9]{1,}[-][0-9]{1,}$"); - private static final Regex endrx = new Regex("[0-9]{1,}$"); + /** + * A subclass that gives us access to modCount, which tracks + * whether there have been any changes. We use this to update + * @author hansonr + * + * @param + */ + @SuppressWarnings("serial") + protected class DBModList extends ArrayList { + + protected int getModCount() { + return modCount; + } + + } - SequenceI datasetSequence; +SequenceI datasetSequence; String name; @@ -71,10 +80,17 @@ public class Sequence extends ASequence implements SequenceI String vamsasId; - DBRefEntry[] dbrefs; + private DBModList dbrefs; // controlled acces - RNA rna; + /** + * a flag to let us know that elements have changed in dbrefs + * + * @author Bob Hanson + */ + private int refModCount = 0; + RNA rna; + /** * This annotation is displayed below the alignment but the positions are tied * to the residues of this sequence @@ -83,12 +99,7 @@ public class Sequence extends ASequence implements SequenceI */ Vector annotation; - /** - * The index of the sequence in a MSA - */ - int index = -1; - - private SequenceFeatures sequenceFeatureStore; + private SequenceFeaturesI sequenceFeatureStore; /* * A cursor holding the approximate current view position to the sequence, @@ -150,25 +161,49 @@ public class Sequence extends ASequence implements SequenceI checkValidRange(); } + /** + * If 'name' ends in /i-j, where i >= j > 0 are integers, extracts i and j as + * start and end respectively and removes the suffix from the name + */ void parseId() { if (name == null) { - System.err - .println("POSSIBLE IMPLEMENTATION ERROR: null sequence name passed to constructor."); + System.err.println( + "POSSIBLE IMPLEMENTATION ERROR: null sequence name passed to constructor."); name = ""; } - // Does sequence have the /start-end signature? - if (limitrx.search(name)) + int slashPos = name.lastIndexOf('/'); + if (slashPos > -1 && slashPos < name.length() - 1) { - name = limitrx.left(); - endrx.search(limitrx.stringMatched()); - setStart(Integer.parseInt(limitrx.stringMatched().substring(1, - endrx.matchedFrom() - 1))); - setEnd(Integer.parseInt(endrx.stringMatched())); + String suffix = name.substring(slashPos + 1); + String[] range = suffix.split("-"); + if (range.length == 2) + { + try + { + int from = Integer.valueOf(range[0]); + int to = Integer.valueOf(range[1]); + if (from > 0 && to >= from) + { + name = name.substring(0, slashPos); + setStart(from); + setEnd(to); + checkValidRange(); + } + } catch (NumberFormatException e) + { + // leave name unchanged if suffix is invalid + } + } } } + /** + * Ensures that 'end' is not before the end of the sequence, that is, + * (end-start+1) is at least as long as the count of ungapped positions. Note + * that end is permitted to be beyond the end of the sequence data. + */ void checkValidRange() { // Note: JAL-774 : @@ -177,7 +212,7 @@ public class Sequence extends ASequence implements SequenceI int endRes = 0; for (int j = 0; j < sequence.length; j++) { - if (!jalview.util.Comparison.isGap(sequence[j])) + if (!Comparison.isGap(sequence[j])) { endRes++; } @@ -259,9 +294,8 @@ public class Sequence extends ASequence implements SequenceI protected void initSeqFrom(SequenceI seq, AlignmentAnnotation[] alAnnotation) { - char[] oseq = seq.getSequence(); - initSeqAndName(seq.getName(), Arrays.copyOf(oseq, oseq.length), - seq.getStart(), seq.getEnd()); + char[] oseq = seq.getSequence(); // returns a copy of the array + initSeqAndName(seq.getName(), oseq, seq.getStart(), seq.getEnd()); description = seq.getDescription(); if (seq != datasetSequence) @@ -274,12 +308,12 @@ public class Sequence extends ASequence implements SequenceI */ if (datasetSequence == null) { - if (seq.getDBRefs() != null) + List dbr = seq.getDBRefs(); + if (dbr != null) { - DBRefEntry[] dbr = seq.getDBRefs(); - for (int i = 0; i < dbr.length; i++) + for (int i = 0, n = dbr.size(); i < n; i++) { - addDBRef(new DBRefEntry(dbr[i])); + addDBRef(new DBRefEntry(dbr.get(i))); } } @@ -396,7 +430,7 @@ public class Sequence extends ASequence implements SequenceI { if (pdbIds == null) { - pdbIds = new Vector(); + pdbIds = new Vector<>(); pdbIds.add(entry); return true; } @@ -432,7 +466,7 @@ public class Sequence extends ASequence implements SequenceI @Override public Vector getAllPDBEntries() { - return pdbIds == null ? new Vector() : pdbIds; + return pdbIds == null ? new Vector<>() : pdbIds; } /** @@ -453,15 +487,15 @@ public class Sequence extends ASequence implements SequenceI } /** - * DOCUMENT ME! + * Sets the sequence name. If the name ends in /start-end, then the start-end + * values are parsed out and set, and the suffix is removed from the name. * - * @param name - * DOCUMENT ME! + * @param theName */ @Override - public void setName(String name) + public void setName(String theName) { - this.name = name; + this.name = theName; this.parseId(); } @@ -562,7 +596,9 @@ public class Sequence extends ASequence implements SequenceI @Override public char[] getSequence() { - return sequence; + // return sequence; + return sequence == null ? null : Arrays.copyOf(sequence, + sequence.length); } /* @@ -643,10 +679,10 @@ public class Sequence extends ASequence implements SequenceI } /** - * DOCUMENT ME! + * Sets the sequence description, and also parses out any special formats of + * interest * * @param desc - * DOCUMENT ME! */ @Override public void setDescription(String desc) @@ -654,10 +690,67 @@ public class Sequence extends ASequence implements SequenceI this.description = desc; } + @Override + public void setGeneLoci(String speciesId, String assemblyId, + String chromosomeId, MapList map) + { + addDBRef(new DBRefEntry(speciesId, assemblyId, DBRefEntry.CHROMOSOME + + ":" + chromosomeId, new Mapping(map))); + } + /** - * DOCUMENT ME! + * Returns the gene loci mapping for the sequence (may be null) * - * @return DOCUMENT ME! + * @return + */ + @Override + public GeneLociI getGeneLoci() + { + List refs = getDBRefs(); + if (refs != null) + { + for (final DBRefEntry ref : refs) + { + if (ref.isChromosome()) + { + return new GeneLociI() + { + @Override + public String getSpeciesId() + { + return ref.getSource(); + } + + @Override + public String getAssemblyId() + { + return ref.getVersion(); + } + + @Override + public String getChromosomeId() + { + // strip off "chromosome:" prefix to chrId + return ref.getAccessionId().substring( + DBRefEntry.CHROMOSOME.length() + 1); + } + + @Override + public MapList getMap() + { + return ref.getMap().getMap(); + } + }; + } + } + } + return null; + } + + /** + * Answers the description + * + * @return */ @Override public String getDescription() @@ -681,11 +774,20 @@ public class Sequence extends ASequence implements SequenceI int j = start; int i = 0; - // Rely on end being at least as long as the length of the sequence. + int startColumn = 0; + + /* + * traverse sequence from the start counting gaps; make a note of + * the column of the first residue to save in the cursor + */ while ((i < sequence.length) && (j <= end) && (j <= pos)) { if (!Comparison.isGap(sequence[i])) { + if (j == start) + { + startColumn = i; + } j++; } i++; @@ -696,7 +798,7 @@ public class Sequence extends ASequence implements SequenceI return end + 1; } - updateCursor(pos, i); + updateCursor(pos, i, startColumn); return i; } @@ -707,10 +809,23 @@ public class Sequence extends ASequence implements SequenceI * (start..) * @param column * (1..) + * @param startColumn + * column position of the first sequence residue */ - protected void updateCursor(int residuePos, int column) + protected void updateCursor(int residuePos, int column, int startColumn) { - cursor = new SequenceCursor(this, residuePos, column, this.changeCount); + /* + * preserve end residue column provided cursor was valid + */ + int endColumn = isValidCursor(cursor) ? cursor.lastColumnPosition : 0; + + if (residuePos == this.end) + { + endColumn = column; + } + + cursor = new SequenceCursor(this, residuePos, column, startColumn, + endColumn, this.changeCount); } /** @@ -722,7 +837,7 @@ public class Sequence extends ASequence implements SequenceI * @param curs * @return */ - protected int findIndex(int pos, SequenceCursor curs) + protected int findIndex(final int pos, SequenceCursor curs) { if (!isValidCursor(curs)) { @@ -740,16 +855,20 @@ public class Sequence extends ASequence implements SequenceI /* * move left or right to find pos from hint.position */ - int col = curs.columnPosition - 1; // convert from base 1 to 0-based array - // index + int col = curs.columnPosition - 1; // convert from base 1 to base 0 int newPos = curs.residuePosition; int delta = newPos > pos ? -1 : 1; while (newPos != pos) { col += delta; // shift one column left or right - if (col < 0 || col == sequence.length) + if (col < 0) + { + break; + } + if (col == sequence.length) { + col--; // return last column if we failed to reach pos break; } if (!Comparison.isGap(sequence[col])) @@ -759,7 +878,14 @@ public class Sequence extends ASequence implements SequenceI } col++; // convert back to base 1 - updateCursor(pos, col); + + /* + * only update cursor if we found the target position + */ + if (newPos == pos) + { + updateCursor(pos, col, curs.firstColumnPosition); + } return col; } @@ -777,13 +903,19 @@ public class Sequence extends ASequence implements SequenceI { return findPosition(column + 1, cursor); } - + // TODO recode this more naturally i.e. count residues only // as they are found, not 'in anticipation' + /* + * traverse the sequence counting gaps; note the column position + * of the first residue, to save in the cursor + */ + int firstResidueColumn = 0; int lastPosFound = 0; int lastPosFoundColumn = 0; int seqlen = sequence.length; + if (seqlen > 0 && !Comparison.isGap(sequence[0])) { lastPosFound = start; @@ -799,6 +931,10 @@ public class Sequence extends ASequence implements SequenceI { lastPosFound = pos; lastPosFoundColumn = j; + if (pos == this.start) + { + firstResidueColumn = j; + } pos++; } j++; @@ -807,6 +943,10 @@ public class Sequence extends ASequence implements SequenceI { lastPosFound = pos; lastPosFoundColumn = j; + if (pos == this.start) + { + firstResidueColumn = j; + } } /* @@ -815,7 +955,8 @@ public class Sequence extends ASequence implements SequenceI */ if (lastPosFound != 0) { - updateCursor(lastPosFound, lastPosFoundColumn + 1); + updateCursor(lastPosFound, lastPosFoundColumn + 1, + firstResidueColumn + 1); } return pos; @@ -839,7 +980,7 @@ public class Sequence extends ASequence implements SequenceI /* * sanity check against range */ - if (curs.columnPosition < 0 || curs.columnPosition >= sequence.length) + if (curs.columnPosition < 0 || curs.columnPosition > sequence.length) { return false; } @@ -875,9 +1016,31 @@ public class Sequence extends ASequence implements SequenceI return curs.residuePosition; // easy case :-) } + if (curs.lastColumnPosition > 0 && curs.lastColumnPosition < col) + { + /* + * sequence lies entirely to the left of col + * - return last residue + 1 + */ + return end + 1; + } + + if (curs.firstColumnPosition > 0 && curs.firstColumnPosition > col) + { + /* + * sequence lies entirely to the right of col + * - return first residue + */ + return start; + } + + // todo could choose closest to col out of column, + // firstColumnPosition, lastColumnPosition as a start point + /* * move left or right to find pos from cursor position */ + int firstResidueColumn = curs.firstColumnPosition; int column = curs.columnPosition - 1; // to base 0 int newPos = curs.residuePosition; int delta = curs.columnPosition > col ? -1 : 1; @@ -898,12 +1061,17 @@ public class Sequence extends ASequence implements SequenceI newPos += delta; lastFoundPosition = newPos; lastFoundPositionColumn = column + 1; + if (lastFoundPosition == this.start) + { + firstResidueColumn = column + 1; + } } } if (cursor == null || lastFoundPosition != cursor.residuePosition) { - updateCursor(lastFoundPosition, lastFoundPositionColumn); + updateCursor(lastFoundPosition, lastFoundPositionColumn, + firstResidueColumn); } /* @@ -922,164 +1090,47 @@ public class Sequence extends ASequence implements SequenceI * {@inheritDoc} */ @Override - public Range findPositions(int fromCol, int toCol) + public Range findPositions(int fromColumn, int toColumn) { - if (cursor != null && cursor.sequence == this - && cursor.token == changeCount) - { - return findPositions(fromCol, toCol, cursor); - } - - /* - * count residues before fromCol - */ - int j = 0; - int count = 0; - int seqlen = sequence.length; - while (j < fromCol && j < seqlen) - { - if (!Comparison.isGap(sequence[j])) - { - count++; - } - j++; - } - - /* - * find first and last residues between fromCol and toCol - */ - int firstPos = 0; - int lastPos = 0; - boolean foundFirst = false; - - while (j <= toCol && j < seqlen) - { - if (!Comparison.isGap(sequence[j])) - { - count++; - if (!foundFirst) - { - firstPos = count; - foundFirst = true; - } - lastPos = count; - } - j++; - } - - if (firstPos == 0) + if (toColumn < fromColumn || fromColumn < 1) { - /* - * no residues in this range - */ return null; } /* - * adjust for sequence start coordinate - */ - firstPos += start - 1; - lastPos += start - 1; - - return new Range(firstPos, lastPos); - } - - /** - * Returns the range of sequence positions included in the given alignment - * position range. If no positions are included (the range is entirely gaps), - * then returns null. The cursor parameter may provide a starting position in - * the neighbourhood of the search (which may be left of, right of, or - * overlapping the search region). - * - * @param fromCol - * start column of region (0..) - * @param toCol - * end column of region (0..) - * @param curs - * @return - */ - protected Range findPositions(int fromCol, int toCol, SequenceCursor curs) - { - if (!isValidCursor(curs)) - { - /* - * wrong or invalidated cursor, compute de novo - */ - return findPositions(fromCol, toCol); - } - - /* - * keep this simple...first step from cursor to fromCol... + * find the first non-gapped position, if any */ - final int seqlen = sequence.length; - int resNo = curs.residuePosition; - int col = curs.columnPosition - 1; // from base 1 to base 0 - if (col != fromCol) + int firstPosition = 0; + int col = fromColumn - 1; + int length = sequence.length; + while (col < length && col < toColumn) { - int delta = col > fromCol ? -1 : 1; - while (col != fromCol && col >= 0 && col < seqlen) + if (!Comparison.isGap(sequence[col])) { - if (!Comparison.isGap(sequence[col])) - { - resNo += delta; - } - col += delta; + firstPosition = findPosition(col++); + break; } + col++; } - if (col < fromCol || col == seqlen) + if (firstPosition == 0) { - /* - * sequence lies to the left of the target region - */ return null; } /* - * resNo is now the residue at fromCol (if not gapped), else the one - * before it (if delta == 1), else the one after (if delta == -1); - * we want the residue before fromCol + * find the last non-gapped position */ - if (!Comparison.isGap(sequence[fromCol])) + int lastPosition = firstPosition; + while (col < length && col < toColumn) { - resNo--; - } - else if (curs.columnPosition > fromCol) - { - resNo -= 2; - } - - /* - * now first and last residues between fromCol and toCol - */ - int firstPos = 0; - int lastPos = 0; - boolean foundFirst = false; - - while (col <= toCol && col < seqlen) - { - if (!Comparison.isGap(sequence[col])) + if (!Comparison.isGap(sequence[col++])) { - resNo++; - if (!foundFirst) - { - firstPos = resNo; - foundFirst = true; - } - lastPos = resNo; + lastPosition++; } - col++; - } - - if (firstPos == 0) - { - /* - * no residues in this range - */ - return null; } - return new Range(firstPos, lastPos); + return new Range(firstPosition, lastPosition); } /** @@ -1111,6 +1162,27 @@ public class Sequence extends ASequence implements SequenceI return map; } + /** + * Build a bitset corresponding to sequence gaps + * + * @return a BitSet where set values correspond to gaps in the sequence + */ + @Override + public BitSet gapBitset() + { + BitSet gaps = new BitSet(sequence.length); + int j = 0; + while (j < sequence.length) + { + if (jalview.util.Comparison.isGap(sequence[j])) + { + gaps.set(j); + } + j++; + } + return gaps; + } + @Override public int[] findPositionMap() { @@ -1134,7 +1206,7 @@ public class Sequence extends ASequence implements SequenceI @Override public List getInsertions() { - ArrayList map = new ArrayList(); + ArrayList map = new ArrayList<>(); int lastj = -1, j = 0; int pos = start; int seqlen = sequence.length; @@ -1200,7 +1272,7 @@ public class Sequence extends ASequence implements SequenceI } @Override - public void deleteChars(int i, int j) + public void deleteChars(final int i, final int j) { int newstart = start, newend = end; if (i >= sequence.length || i < 0) @@ -1212,62 +1284,76 @@ public class Sequence extends ASequence implements SequenceI boolean createNewDs = false; // TODO: take a (second look) at the dataset creation validation method for // the very large sequence case - int eindex = -1, sindex = -1; - boolean ecalc = false, scalc = false; - for (int s = i; s < j; s++) + + int startIndex = findIndex(start) - 1; + int endIndex = findIndex(end) - 1; + int startDeleteColumn = -1; // for dataset sequence deletions + int deleteCount = 0; + + for (int s = i; s < j && s < sequence.length; s++) { - if (jalview.schemes.ResidueProperties.aaIndex[sequence[s]] != 23) + if (Comparison.isGap(sequence[s])) + { + continue; + } + deleteCount++; + if (startDeleteColumn == -1) + { + startDeleteColumn = findPosition(s) - start; + } + if (createNewDs) { - if (createNewDs) + newend--; + } + else + { + if (startIndex == s) { - newend--; + /* + * deleting characters from start of sequence; new start is the + * sequence position of the next column (position to the right + * if the column position is gapped) + */ + newstart = findPosition(j); + break; } else { - if (!scalc) - { - sindex = findIndex(start) - 1; - scalc = true; - } - if (sindex == s) + if (endIndex < j) { - // delete characters including start of sequence - newstart = findPosition(j); - break; // don't need to search for any more residue characters. + /* + * deleting characters at end of sequence; new end is the sequence + * position of the column before the deletion; subtract 1 if this is + * gapped since findPosition returns the next sequence position + */ + newend = findPosition(i - 1); + if (Comparison.isGap(sequence[i - 1])) + { + newend--; + } + break; } else { - // delete characters after start. - if (!ecalc) - { - eindex = findIndex(end) - 1; - ecalc = true; - } - if (eindex < j) - { - // delete characters at end of sequence - newend = findPosition(i - 1); - break; // don't need to search for any more residue characters. - } - else - { - createNewDs = true; - newend--; // decrease end position by one for the deleted residue - // and search further - } + createNewDs = true; + newend--; } } } } - // deletion occured in the middle of the sequence + if (createNewDs && this.datasetSequence != null) { - // construct a new sequence + /* + * if deletion occured in the middle of the sequence, + * construct a new dataset sequence and delete the residues + * that were deleted from the aligned sequence + */ Sequence ds = new Sequence(datasetSequence); + ds.deleteChars(startDeleteColumn, startDeleteColumn + deleteCount); + datasetSequence = ds; // TODO: remove any non-inheritable properties ? // TODO: create a sequence mapping (since there is a relation here ?) - ds.deleteChars(i, j); - datasetSequence = ds; } start = newstart; end = newend; @@ -1324,24 +1410,35 @@ public class Sequence extends ASequence implements SequenceI vamsasId = id; } - @Override - public void setDBRefs(DBRefEntry[] dbref) + @SuppressWarnings("deprecation") +@Override + public void setDBRefs(List newDBrefs) throws InvalidArgumentException { if (dbrefs == null && datasetSequence != null && this != datasetSequence) { - datasetSequence.setDBRefs(dbref); + datasetSequence.setDBRefs((DBModList)newDBrefs); return; } - dbrefs = dbref; - if (dbrefs != null) - { - DBRefUtils.ensurePrimaries(this); - } + if (newDBrefs != null && !(newDBrefs instanceof DBModList)) + throw new InvalidArgumentException("DBrefs must have DBModList class"); + + dbrefs = (DBModList)newDBrefs; + refModCount = 0; + } + + @Override + public void getDBRefsFrom(SequenceI seq) { + try { + setDBRefs(seq.getDBRefs()); + } catch (InvalidArgumentException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } } @Override - public DBRefEntry[] getDBRefs() + public List getDBRefs() { if (dbrefs == null && datasetSequence != null && this != datasetSequence) @@ -1351,6 +1448,7 @@ public class Sequence extends ASequence implements SequenceI return dbrefs; } + @Override public void addDBRef(DBRefEntry entry) { @@ -1362,12 +1460,12 @@ public class Sequence extends ASequence implements SequenceI if (dbrefs == null) { - dbrefs = new DBRefEntry[0]; + dbrefs = new DBModList(); } - for (DBRefEntryI dbr : dbrefs) + for (int ib = 0, nb= dbrefs.size(); ib < nb; ib++) { - if (dbr.updateFrom(entry)) + if (dbrefs.get(ib).updateFrom(entry)) { /* * found a dbref that either matched, or could be @@ -1377,18 +1475,20 @@ public class Sequence extends ASequence implements SequenceI } } - /* - * extend the array to make room for one more - */ - // TODO use an ArrayList instead - int j = dbrefs.length; - DBRefEntry[] temp = new DBRefEntry[j + 1]; - System.arraycopy(dbrefs, 0, temp, 0, j); - temp[temp.length - 1] = entry; - - dbrefs = temp; - DBRefUtils.ensurePrimaries(this); +// /// BH OUCH! +// /* +// * extend the array to make room for one more +// */ +// // TODO use an ArrayList instead +// int j = dbrefs.length; +// List temp = new DBRefEntry[j + 1]; +// System.arraycopy(dbrefs, 0, temp, 0, j); +// temp[temp.length - 1] = entry; +// +// dbrefs = temp; + + dbrefs.add(entry); } @Override @@ -1416,8 +1516,9 @@ public class Sequence extends ASequence implements SequenceI @Override public AlignmentAnnotation[] getAnnotation() { - return annotation == null ? null : annotation - .toArray(new AlignmentAnnotation[annotation.size()]); + return annotation == null ? null + : annotation + .toArray(new AlignmentAnnotation[annotation.size()]); } @Override @@ -1431,7 +1532,7 @@ public class Sequence extends ASequence implements SequenceI { if (this.annotation == null) { - this.annotation = new Vector(); + this.annotation = new Vector<>(); } if (!this.annotation.contains(annotation)) { @@ -1498,7 +1599,9 @@ public class Sequence extends ASequence implements SequenceI private boolean _isNa; - private long _seqhash = 0; + private int _seqhash = 0; + +private List primaryRefs; /** * Answers false if the sequence is more than 85% nucleotide (ACGTU), else @@ -1529,8 +1632,9 @@ public class Sequence extends ASequence implements SequenceI { if (datasetSequence == null) { - Sequence dsseq = new Sequence(getName(), AlignSeq.extractGaps( - jalview.util.Comparison.GapChars, getSequenceAsString()), + Sequence dsseq = new Sequence(getName(), + AlignSeq.extractGaps(jalview.util.Comparison.GapChars, + getSequenceAsString()), getStart(), getEnd()); datasetSequence = dsseq; @@ -1597,7 +1701,7 @@ public class Sequence extends ASequence implements SequenceI return null; } - Vector subset = new Vector(); + Vector subset = new Vector<>(); Enumeration e = annotation.elements(); while (e.hasMoreElements()) { @@ -1630,13 +1734,14 @@ public class Sequence extends ASequence implements SequenceI // TODO: could merge DBRefs return datasetSequence.updatePDBIds(); } - if (dbrefs == null || dbrefs.length == 0) + if (dbrefs == null || dbrefs.size() == 0) { return false; } boolean added = false; - for (DBRefEntry dbr : dbrefs) + for (int ib = 0, nb = dbrefs.size(); ib < nb; ib++) { + DBRefEntry dbr = dbrefs.get(ib); if (DBRefSource.PDB.equals(dbr.getSource())) { /* @@ -1672,7 +1777,7 @@ public class Sequence extends ASequence implements SequenceI List sfs = entry.getSequenceFeatures(); for (SequenceFeature feature : sfs) { - SequenceFeature sf[] = (mp != null) ? mp.locateFeature(feature) + SequenceFeature sf[] = (mp != null) ? mp.locateFeature(feature) : new SequenceFeature[] { new SequenceFeature(feature) }; if (sf != null) { @@ -1695,12 +1800,12 @@ public class Sequence extends ASequence implements SequenceI } } // transfer database references - DBRefEntry[] entryRefs = entry.getDBRefs(); + List entryRefs = entry.getDBRefs(); if (entryRefs != null) { - for (int r = 0; r < entryRefs.length; r++) + for (int r = 0, n = entryRefs.size(); r < n; r++) { - DBRefEntry newref = new DBRefEntry(entryRefs[r]); + DBRefEntry newref = new DBRefEntry(entryRefs.get(r)); if (newref.getMap() != null && mp != null) { // remap ref using our local mapping @@ -1715,30 +1820,6 @@ public class Sequence extends ASequence implements SequenceI } } - /** - * @return The index (zero-based) on this sequence in the MSA. It returns - * {@code -1} if this information is not available. - */ - @Override - public int getIndex() - { - return index; - } - - /** - * Defines the position of this sequence in the MSA. Use the value {@code -1} - * if this information is undefined. - * - * @param The - * position for this sequence. This value is zero-based (zero for - * this first sequence) - */ - @Override - public void setIndex(int value) - { - index = value; - } - @Override public void setRNA(RNA r) { @@ -1755,7 +1836,7 @@ public class Sequence extends ASequence implements SequenceI public List getAlignmentAnnotations(String calcId, String label) { - List result = new ArrayList(); + List result = new ArrayList<>(); if (this.annotation != null) { for (AlignmentAnnotation ann : annotation) @@ -1798,6 +1879,8 @@ public class Sequence extends ASequence implements SequenceI return null; } + private List tmpList; + @Override public List getPrimaryDBRefs() { @@ -1805,16 +1888,24 @@ public class Sequence extends ASequence implements SequenceI { return datasetSequence.getPrimaryDBRefs(); } - if (dbrefs == null || dbrefs.length == 0) + if (dbrefs == null || dbrefs.size() == 0) { return Collections.emptyList(); } synchronized (dbrefs) { - List primaries = new ArrayList(); - DBRefEntry[] tmp = new DBRefEntry[1]; - for (DBRefEntry ref : dbrefs) + if (refModCount == dbrefs.getModCount() && primaryRefs != null) + return primaryRefs; // no changes + refModCount = dbrefs.getModCount(); + List primaries = (primaryRefs == null ? (primaryRefs = new ArrayList<>()) : primaryRefs); + primaries.clear(); + if (tmpList == null) { + tmpList = new ArrayList<>(); + tmpList.add(null); // for replacement + } + for (int i = 0, n = dbrefs.size(); i < n; i++) { + DBRefEntry ref = dbrefs.get(i); if (!ref.isPrimaryCandidate()) { continue; @@ -1829,8 +1920,7 @@ public class Sequence extends ASequence implements SequenceI } } // whilst it looks like it is a primary ref, we also sanity check type - if (DBRefUtils.getCanonicalName(DBRefSource.PDB).equals( - DBRefUtils.getCanonicalName(ref.getSource()))) + if (DBRefSource.PDB_CANONICAL_NAME.equals(ref.getCanonicalSourceName())) { // PDB dbrefs imply there should be a PDBEntry associated // TODO: tighten PDB dbrefs @@ -1839,21 +1929,23 @@ public class Sequence extends ASequence implements SequenceI // handle on the PDBEntry, and a real mapping between sequence and // extracted sequence from PDB file PDBEntry pdbentry = getPDBEntry(ref.getAccessionId()); - if (pdbentry != null && pdbentry.getFile() != null) + if (pdbentry == null || pdbentry.getFile() == null) { - primaries.add(ref); + continue; } - continue; - } - // check standard protein or dna sources - tmp[0] = ref; - DBRefEntry[] res = DBRefUtils.selectDbRefs(!isProtein(), tmp); - if (res != null && res[0] == tmp[0]) - { - primaries.add(ref); - continue; - } + } else { + // check standard protein or dna sources + tmpList.set(0, ref); + List res = DBRefUtils.selectDbRefs(!isProtein(), tmpList); + if (res == null || res.get(0) != tmpList.get(0)) + { + continue; + } + } + primaries.add(ref); } + + DBRefUtils.ensurePrimaries(this, primaries); return primaries; } } @@ -1862,14 +1954,65 @@ public class Sequence extends ASequence implements SequenceI * {@inheritDoc} */ @Override - public List findFeatures(int from, int to, + public List findFeatures(int fromColumn, int toColumn, String... types) { + int startPos = findPosition(fromColumn - 1); // convert base 1 to base 0 + int endPos = fromColumn == toColumn ? startPos + : findPosition(toColumn - 1); + + List result = getFeatures().findFeatures(startPos, + endPos, types); if (datasetSequence != null) { - return datasetSequence.findFeatures(from, to, types); + result = datasetSequence.getFeatures().findFeatures(startPos, endPos, + types); + } + else + { + result = sequenceFeatureStore.findFeatures(startPos, endPos, types); + } + + /* + * if end column is gapped, endPos may be to the right, + * and we may have included adjacent or enclosing features; + * remove any that are not enclosing, non-contact features + */ + boolean endColumnIsGapped = toColumn > 0 && toColumn <= sequence.length + && Comparison.isGap(sequence[toColumn - 1]); + if (endPos > this.end || endColumnIsGapped) + { + ListIterator it = result.listIterator(); + while (it.hasNext()) + { + SequenceFeature sf = it.next(); + int sfBegin = sf.getBegin(); + int sfEnd = sf.getEnd(); + int featureStartColumn = findIndex(sfBegin); + if (featureStartColumn > toColumn) + { + it.remove(); + } + else if (featureStartColumn < fromColumn) + { + int featureEndColumn = sfEnd == sfBegin ? featureStartColumn + : findIndex(sfEnd); + if (featureEndColumn < fromColumn) + { + it.remove(); + } + else if (featureEndColumn > toColumn && sf.isContactFeature()) + { + /* + * remove an enclosing feature if it is a contact feature + */ + it.remove(); + } + } + } } - return sequenceFeatureStore.findFeatures(from, to, types); + + return result; } /** @@ -1881,4 +2024,103 @@ public class Sequence extends ASequence implements SequenceI { changeCount++; } + + /** + * {@inheritDoc} + */ + @Override + public int replace(char c1, char c2) + { + if (c1 == c2) + { + return 0; + } + int count = 0; + synchronized (sequence) + { + for (int c = 0; c < sequence.length; c++) + { + if (sequence[c] == c1) + { + sequence[c] = c2; + count++; + } + } + } + if (count > 0) + { + sequenceChanged(); + } + + return count; + } + + @Override + public String getSequenceStringFromIterator(Iterator it) + { + StringBuilder newSequence = new StringBuilder(); + while (it.hasNext()) + { + int[] block = it.next(); + if (it.hasNext()) + { + newSequence.append(getSequence(block[0], block[1] + 1)); + } + else + { + newSequence.append(getSequence(block[0], block[1])); + } + } + + return newSequence.toString(); + } + + @Override + public int firstResidueOutsideIterator(Iterator regions) + { + int start = 0; + + if (!regions.hasNext()) + { + return findIndex(getStart()) - 1; + } + + // Simply walk along the sequence whilst watching for region + // boundaries + int hideStart = getLength(); + int hideEnd = -1; + boolean foundStart = false; + + // step through the non-gapped positions of the sequence + for (int i = getStart(); i <= getEnd() && (!foundStart); i++) + { + // get alignment position of this residue in the sequence + int p = findIndex(i) - 1; + + // update region start/end + while (hideEnd < p && regions.hasNext()) + { + int[] region = regions.next(); + hideStart = region[0]; + hideEnd = region[1]; + } + if (hideEnd < p) + { + hideStart = getLength(); + } + // update boundary for sequence + if (p < hideStart) + { + start = p; + foundStart = true; + } + } + + if (foundStart) + { + return start; + } + // otherwise, sequence was completely hidden + return 0; + } }