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 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 <T>
+ */
+ @SuppressWarnings("serial")
+ public class DBModList<T> extends ArrayList<DBRefEntry>
+ {
+
+ protected int getModCount()
+ {
+ return modCount;
+ }
+
+ }
SequenceI datasetSequence;
- String name;
+ private String name;
private char[] sequence;
- String description;
+ private String description;
- int start;
+ private int start;
- int end;
+ private int end;
- Vector<PDBEntry> pdbIds;
+ private Vector<PDBEntry> pdbIds;
- String vamsasId;
+ private String vamsasId;
- DBRefEntry[] dbrefs;
+ private DBModList<DBRefEntry> dbrefs; // controlled access
- RNA rna;
+ /**
+ * a flag to let us know that elements have changed in dbrefs
+ *
+ * @author Bob Hanson
+ */
+ private int refModCount = 0;
+
+ private RNA rna;
/**
* This annotation is displayed below the alignment but the positions are tied
*
* TODO: change to List<>
*/
- Vector<AlignmentAnnotation> annotation;
-
- /**
- * The index of the sequence in a MSA
- */
- int index = -1;
+ private Vector<AlignmentAnnotation> annotation;
- private SequenceFeatures sequenceFeatureStore;
+ private SequenceFeaturesI sequenceFeatureStore;
/*
* A cursor holding the approximate current view position to the sequence,
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 :
int endRes = 0;
for (int j = 0; j < sequence.length; j++)
{
- if (!jalview.util.Comparison.isGap(sequence[j]))
+ if (!Comparison.isGap(sequence[j]))
{
endRes++;
}
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)
{
setDatasetSequence(seq.getDatasetSequence());
}
-
+
/*
* only copy DBRefs and seqfeatures if we really are a dataset sequence
*/
if (datasetSequence == null)
{
- if (seq.getDBRefs() != null)
+ List<DBRefEntry> 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)));
}
}
{
if (sf.getType() == null)
{
- System.err.println("SequenceFeature type may not be null: "
- + sf.toString());
+ System.err.println(
+ "SequenceFeature type may not be null: " + sf.toString());
return false;
}
{
if (pdbIds == null)
{
- pdbIds = new Vector<PDBEntry>();
+ pdbIds = new Vector<>();
pdbIds.add(entry);
return true;
}
@Override
public Vector<PDBEntry> getAllPDBEntries()
{
- return pdbIds == null ? new Vector<PDBEntry>() : pdbIds;
+ return pdbIds == null ? new Vector<>() : pdbIds;
}
/**
}
/**
- * 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();
}
{
this.sequence = seq.toCharArray();
checkValidRange();
+ sequenceChanged();
}
@Override
@Override
public char[] getSequence()
{
- return sequence;
+ // return sequence;
+ return sequence == null ? null
+ : Arrays.copyOf(sequence, sequence.length);
}
/*
}
/**
- * 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)
this.description = desc;
}
+ @Override
+ public void setGeneLoci(String speciesId, String assemblyId,
+ String chromosomeId, MapList map)
+ {
+ addDBRef(new GeneLocus(speciesId, assemblyId, 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<DBRefEntry> refs = getDBRefs();
+ if (refs != null)
+ {
+ for (final DBRefEntry ref : refs)
+ {
+ if (ref instanceof GeneLociI)
+ {
+ return (GeneLociI) ref;
+ }
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Answers the description
+ *
+ * @return
*/
@Override
public String getDescription()
return this.description;
}
- /*
- * (non-Javadoc)
- *
- * @see jalview.datamodel.SequenceI#findIndex(int)
+ /**
+ * {@inheritDoc}
*/
@Override
public int findIndex(int pos)
{
/*
- * use a valid nearby cursor if available
+ * use a valid, hopefully nearby, cursor if available
*/
- if (cursor != null && cursor.sequence == this
- && cursor.token == changeCount)
+ if (isValidCursor(cursor))
{
return findIndex(pos, cursor);
}
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++;
}
- if ((j == end) && (j < pos))
+ if (j == end && j < pos)
{
return end + 1;
}
- else
- {
- updateCursor(pos, i);
- return i;
- }
+
+ updateCursor(pos, i, startColumn);
+ return i;
}
- protected void updateCursor(int residuePos, int column)
+ /**
+ * Updates the cursor to the latest found residue and column position
+ *
+ * @param residuePos
+ * (start..)
+ * @param column
+ * (1..)
+ * @param startColumn
+ * column position of the first sequence residue
+ */
+ protected void updateCursor(int residuePos, int column, int startColumn)
{
- // TODO probably want to synchronize this on something
- 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);
}
/**
* @param curs
* @return
*/
- protected int findIndex(int pos, SequenceCursor curs)
+ protected int findIndex(final int pos, SequenceCursor curs)
{
- if (curs.sequence != this || curs.token != changeCount)
+ if (!isValidCursor(curs))
{
/*
* wrong or invalidated cursor, compute de novo
/*
* 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]))
{
newPos += delta;
}
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;
}
+ /**
+ * {@inheritDoc}
+ */
@Override
- public int findPosition(final int i)
+ public int findPosition(final int column)
{
/*
- * use a valid nearby cursor if available
+ * use a valid, hopefully nearby, cursor if available
*/
- if (cursor != null && cursor.sequence == this
- && cursor.token == changeCount)
+ if (isValidCursor(cursor))
{
- return findPosition(i + 1, cursor);
+ 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;
+ lastPosFoundColumn = 0;
}
int j = 0;
int pos = start;
- int seqlen = sequence.length;
- while ((j < i) && (j < seqlen))
+
+ while (j < column && j < seqlen)
{
if (!Comparison.isGap(sequence[j]))
{
+ lastPosFound = pos;
+ lastPosFoundColumn = j;
+ if (pos == this.start)
+ {
+ firstResidueColumn = j;
+ }
pos++;
}
-
j++;
}
+ if (j < seqlen && !Comparison.isGap(sequence[j]))
+ {
+ lastPosFound = pos;
+ lastPosFoundColumn = j;
+ if (pos == this.start)
+ {
+ firstResidueColumn = j;
+ }
+ }
- if (j == i && !Comparison.isGap(sequence[i]))
+ /*
+ * update the cursor to the last residue position found (if any)
+ * (converting column position to base 1)
+ */
+ if (lastPosFound != 0)
{
- updateCursor(pos, i + 1);
+ updateCursor(lastPosFound, lastPosFoundColumn + 1,
+ firstResidueColumn + 1);
}
return pos;
}
/**
+ * Answers true if the given cursor is not null, is for this sequence object,
+ * and has a token value that matches this object's changeCount, else false.
+ * This allows us to ignore a cursor as 'stale' if the sequence has been
+ * modified since the cursor was created.
+ *
+ * @param curs
+ * @return
+ */
+ protected boolean isValidCursor(SequenceCursor curs)
+ {
+ if (curs == null || curs.sequence != this || curs.token != changeCount)
+ {
+ return false;
+ }
+ /*
+ * sanity check against range
+ */
+ if (curs.columnPosition < 0 || curs.columnPosition > sequence.length)
+ {
+ return false;
+ }
+ if (curs.residuePosition < start || curs.residuePosition > end)
+ {
+ return false;
+ }
+ return true;
+ }
+
+ /**
* Answers the sequence position (start..) for the given aligned column
* position (1..), given a hint of a cursor in the neighbourhood. The cursor
* may lie left of, at, or to the right of the column position.
*/
protected int findPosition(final int col, SequenceCursor curs)
{
- if (curs.sequence != this || curs.token != changeCount)
+ if (!isValidCursor(curs))
{
/*
* wrong or invalidated cursor, compute de novo
if (curs.columnPosition == col)
{
+ cursor = curs; // in case this method becomes public
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;
boolean gapped = false;
+ int lastFoundPosition = curs.residuePosition;
+ int lastFoundPositionColumn = curs.columnPosition;
while (column != col - 1)
{
if (!gapped)
{
newPos += delta;
+ lastFoundPosition = newPos;
+ lastFoundPositionColumn = column + 1;
+ if (lastFoundPosition == this.start)
+ {
+ firstResidueColumn = column + 1;
+ }
}
}
+ if (cursor == null || lastFoundPosition != cursor.residuePosition)
+ {
+ updateCursor(lastFoundPosition, lastFoundPositionColumn,
+ firstResidueColumn);
+ }
+
/*
* hack to give position to the right if on a gap
- * pending resolution of JAL-2562
+ * or beyond the length of the sequence (see JAL-2562)
*/
- if (delta > 0 && gapped)
+ if (delta > 0 && (gapped || column >= sequence.length))
{
newPos++;
}
* {@inheritDoc}
*/
@Override
- public Range findPositions(int fromCol, int toCol)
+ public ContiguousI findPositions(int fromColumn, int toColumn)
{
- if (cursor != null && cursor.sequence == this
- && cursor.token == changeCount)
+ if (toColumn < fromColumn || fromColumn < 1)
{
- 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)
- {
- /*
- * 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 (curs.sequence != this || curs.token != changeCount)
- {
- /*
- * 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);
}
/**
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()
{
@Override
public List<int[]> getInsertions()
{
- ArrayList<int[]> map = new ArrayList<int[]>();
+ ArrayList<int[]> map = new ArrayList<>();
int lastj = -1, j = 0;
- int pos = start;
+ // int pos = start;
int seqlen = sequence.length;
while ((j < seqlen))
{
}
@Override
- public void deleteChars(int i, int j)
+ public BitSet getInsertionsAsBits()
+ {
+ BitSet map = new BitSet();
+ int lastj = -1, j = 0;
+ // int pos = start;
+ int seqlen = sequence.length;
+ while ((j < seqlen))
+ {
+ if (jalview.util.Comparison.isGap(sequence[j]))
+ {
+ if (lastj == -1)
+ {
+ lastj = j;
+ }
+ }
+ else
+ {
+ if (lastj != -1)
+ {
+ map.set(lastj, j);
+ lastj = -1;
+ }
+ }
+ j++;
+ }
+ if (lastj != -1)
+ {
+ map.set(lastj, j);
+ lastj = -1;
+ }
+ return map;
+ }
+
+ @Override
+ public void deleteChars(final int i, final int j)
{
int newstart = start, newend = end;
if (i >= sequence.length || i < 0)
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]))
{
- if (createNewDs)
+ continue;
+ }
+ deleteCount++;
+ if (startDeleteColumn == -1)
+ {
+ startDeleteColumn = findPosition(s) - start;
+ }
+ 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;
sequence = tmp;
+ sequenceChanged();
}
@Override
}
sequence = tmp;
+ sequenceChanged();
}
@Override
vamsasId = id;
}
+ @Deprecated
@Override
- public void setDBRefs(DBRefEntry[] dbref)
+ public void setDBRefs(DBModList<DBRefEntry> newDBrefs)
{
if (dbrefs == null && datasetSequence != null
&& this != datasetSequence)
{
- datasetSequence.setDBRefs(dbref);
+ datasetSequence.setDBRefs(newDBrefs);
return;
}
- dbrefs = dbref;
- if (dbrefs != null)
- {
- DBRefUtils.ensurePrimaries(this);
- }
+ dbrefs = newDBrefs;
+ refModCount = 0;
}
@Override
- public DBRefEntry[] getDBRefs()
+ public DBModList<DBRefEntry> getDBRefs()
{
if (dbrefs == null && datasetSequence != null
&& this != datasetSequence)
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
}
}
- /*
- * 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;
+ // /// BH OUCH!
+ // /*
+ // * extend the array to make room for one more
+ // */
+ // // TODO use an ArrayList instead
+ // int j = dbrefs.length;
+ // List<DBRefEntry> temp = new DBRefEntry[j + 1];
+ // System.arraycopy(dbrefs, 0, temp, 0, j);
+ // temp[temp.length - 1] = entry;
+ //
+ // dbrefs = temp;
- DBRefUtils.ensurePrimaries(this);
+ dbrefs.add(entry);
}
@Override
@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
{
if (this.annotation == null)
{
- this.annotation = new Vector<AlignmentAnnotation>();
+ this.annotation = new Vector<>();
}
if (!this.annotation.contains(annotation))
{
private boolean _isNa;
- private long _seqhash = 0;
+ private int _seqhash = 0;
+
+ private List<DBRefEntry> primaryRefs;
/**
* Answers false if the sequence is more than 85% nucleotide (ACGTU), else
_isNa = Comparison.isNucleotide(this);
}
return !_isNa;
- };
+ }
/*
* (non-Javadoc)
{
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;
return null;
}
- Vector<AlignmentAnnotation> subset = new Vector<AlignmentAnnotation>();
+ Vector<AlignmentAnnotation> subset = new Vector<>();
Enumeration<AlignmentAnnotation> e = annotation.elements();
while (e.hasMoreElements())
{
// 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()))
{
/*
for (SequenceFeature feature : sfs)
{
SequenceFeature sf[] = (mp != null) ? mp.locateFeature(feature)
- : new SequenceFeature[] { new SequenceFeature(feature) };
+ : new SequenceFeature[]
+ { new SequenceFeature(feature) };
if (sf != null)
{
for (int sfi = 0; sfi < sf.length; sfi++)
}
}
// transfer database references
- DBRefEntry[] entryRefs = entry.getDBRefs();
+ List<DBRefEntry> 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
}
}
- /**
- * @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)
{
public List<AlignmentAnnotation> getAlignmentAnnotations(String calcId,
String label)
{
- List<AlignmentAnnotation> result = new ArrayList<AlignmentAnnotation>();
+ List<AlignmentAnnotation> result = new ArrayList<>();
if (this.annotation != null)
{
for (AlignmentAnnotation ann : annotation)
return null;
}
+ private List<DBRefEntry> tmpList;
+
@Override
public List<DBRefEntry> getPrimaryDBRefs()
{
{
return datasetSequence.getPrimaryDBRefs();
}
- if (dbrefs == null || dbrefs.length == 0)
+ if (dbrefs == null || dbrefs.size() == 0)
{
return Collections.emptyList();
}
synchronized (dbrefs)
{
- List<DBRefEntry> primaries = new ArrayList<DBRefEntry>();
- DBRefEntry[] tmp = new DBRefEntry[1];
- for (DBRefEntry ref : dbrefs)
+ if (refModCount == dbrefs.getModCount() && primaryRefs != null)
{
+ return primaryRefs; // no changes
+ }
+ refModCount = dbrefs.getModCount();
+ List<DBRefEntry> 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;
}
}
// 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
// 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])
+ else
{
- primaries.add(ref);
- continue;
+ // check standard protein or dna sources
+ tmpList.set(0, ref);
+ List<DBRefEntry> res = DBRefUtils.selectDbRefs(!isProtein(),
+ tmpList);
+ if (res == null || res.get(0) != tmpList.get(0))
+ {
+ continue;
+ }
}
+ primaries.add(ref);
}
+
+ // version must be not null, as otherwise it will not be a candidate,
+ // above
+ DBRefUtils.ensurePrimaries(this, primaries);
return primaries;
}
}
* {@inheritDoc}
*/
@Override
- public List<SequenceFeature> findFeatures(int from, int to,
+ public List<SequenceFeature> 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<SequenceFeature> 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<SequenceFeature> 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;
}
/**
{
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<int[]> 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<int[]> 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;
+ }
}
git://source.jalview.org / jalview.git / blobdiff