import java.util.ArrayList;
import java.util.Arrays;
+import java.util.BitSet;
import java.util.Collections;
import java.util.Enumeration;
import java.util.List;
+import java.util.ListIterator;
import java.util.Vector;
import com.stevesoft.pat.Regex;
{
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?
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)
@Override
public char[] getSequence()
{
- return sequence;
+ // return sequence;
+ return sequence == null ? null : Arrays.copyOf(sequence,
+ sequence.length);
}
/*
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++;
return end + 1;
}
- updateCursor(pos, i);
+ updateCursor(pos, i, startColumn);
return i;
}
* (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);
}
/**
}
col++; // convert back to base 1
- updateCursor(pos, col);
+ updateCursor(pos, col, curs.firstColumnPosition);
return col;
}
{
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;
{
lastPosFound = pos;
lastPosFoundColumn = j;
+ if (pos == this.start)
+ {
+ firstResidueColumn = j;
+ }
pos++;
}
j++;
{
lastPosFound = pos;
lastPosFoundColumn = j;
+ if (pos == this.start)
+ {
+ firstResidueColumn = j;
+ }
}
/*
*/
if (lastPosFound != 0)
{
- updateCursor(lastPosFound, lastPosFoundColumn + 1);
+ updateCursor(lastPosFound, lastPosFoundColumn + 1,
+ firstResidueColumn + 1);
}
return pos;
/*
* sanity check against range
*/
- if (curs.columnPosition < 0 || curs.columnPosition >= sequence.length)
+ if (curs.columnPosition < 0 || curs.columnPosition > sequence.length)
{
return false;
}
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;
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);
}
/*
* {@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
+ * find the first non-gapped position, if any
*/
- 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))
+ int firstPosition = 0;
+ int col = fromColumn - 1;
+ int length = sequence.length;
+ while (col < length && col < toColumn)
{
- /*
- * wrong or invalidated cursor, compute de novo
- */
- return findPositions(fromCol, toCol);
- }
-
- /*
- * keep this simple...first step from cursor to fromCol...
- */
- final int seqlen = sequence.length;
- int resNo = curs.residuePosition;
- int col = curs.columnPosition - 1; // from base 1 to base 0
- if (col != fromCol)
- {
- 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]))
- {
- resNo--;
- }
- else if (curs.columnPosition > fromCol)
+ int lastPosition = firstPosition;
+ while (col < length && col < toColumn)
{
- 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);
}
/**
}
@Override
+ 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(int i, int j)
{
int newstart = start, newend = end;
@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
private boolean _isNa;
- private long _seqhash = 0;
+ private int _seqhash = 0;
/**
* Answers false if the sequence is more than 85% nucleotide (ACGTU), else
{
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;
List<SequenceFeature> 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)
{
}
}
// 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 (DBRefUtils.getCanonicalName(DBRefSource.PDB)
+ .equals(DBRefUtils.getCanonicalName(ref.getSource())))
{
// PDB dbrefs imply there should be a PDBEntry associated
// TODO: tighten PDB dbrefs
* {@inheritDoc}
*/
@Override
- public List<SequenceFeature> findFeatures(int from, int to,
+ public List<SequenceFeature> findFeatures(int fromColumn, int toColumn,
String... types)
{
- if (datasetSequence != null)
+ 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 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
+ */
+ if (endPos > this.end || Comparison.isGap(sequence[toColumn - 1]))
{
- return datasetSequence.findFeatures(from, to, types);
+ 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;
+ }
}
git://source.jalview.org / jalview.git / blobdiff