X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FSequence.java;h=796937d73e22045e6e2cce84a7f3da025d6682e3;hb=d3dd5dd279c8253afa522f11b3e944ba422d12d3;hp=cc4a0dca39ce909e4b3eb97f7029f903fce14aa6;hpb=bf1f3d11a1915e63b11852a1eb63824f984a4342;p=jalview.git

diff --git a/src/jalview/datamodel/Sequence.java b/src/jalview/datamodel/Sequence.java
index cc4a0dc..796937d 100755
--- a/src/jalview/datamodel/Sequence.java
+++ b/src/jalview/datamodel/Sequence.java
@@ -31,9 +31,11 @@ import jalview.util.StringUtils;
 
 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;
@@ -87,7 +89,7 @@ public class Sequence extends ASequence implements SequenceI
    */
   int index = -1;
 
-  private SequenceFeatures sequenceFeatureStore;
+  private SequenceFeaturesI sequenceFeatureStore;
 
   /*
    * A cursor holding the approximate current view position to the sequence,
@@ -153,8 +155,8 @@ public class Sequence extends ASequence implements SequenceI
   {
     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?
@@ -258,9 +260,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)
@@ -561,7 +562,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);
   }
 
   /*
@@ -664,50 +667,73 @@ public class Sequence extends ASequence implements SequenceI
     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);
   }
 
   /**
@@ -721,7 +747,7 @@ public class Sequence extends ASequence implements SequenceI
    */
   protected int findIndex(int pos, SequenceCursor curs)
   {
-    if (curs.sequence != this || curs.token != changeCount)
+    if (!isValidCursor(curs))
     {
       /*
        * wrong or invalidated cursor, compute de novo
@@ -756,45 +782,113 @@ public class Sequence extends ASequence implements SequenceI
     }
 
     col++; // convert back to base 1
-    updateCursor(pos, col);
+    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.
@@ -805,7 +899,7 @@ public class Sequence extends ASequence implements SequenceI
    */
   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
@@ -815,16 +909,41 @@ public class Sequence extends ASequence implements SequenceI
 
     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)
     {
@@ -837,14 +956,26 @@ public class Sequence extends ASequence implements SequenceI
       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++;
     }
@@ -856,164 +987,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 (toColumn < fromColumn || fromColumn < 1)
     {
-      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);
   }
 
   /**
@@ -1100,6 +1114,40 @@ public class Sequence extends ASequence implements SequenceI
   }
 
   @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;
@@ -1316,8 +1364,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
@@ -1398,7 +1447,7 @@ public class Sequence extends ASequence implements SequenceI
 
   private boolean _isNa;
 
-  private long _seqhash = 0;
+  private int _seqhash = 0;
 
   /**
    * Answers false if the sequence is more than 85% nucleotide (ACGTU), else
@@ -1429,8 +1478,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;
@@ -1572,7 +1622,7 @@ public class Sequence extends ASequence implements SequenceI
       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)
         {
@@ -1729,8 +1779,8 @@ 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 (DBRefUtils.getCanonicalName(DBRefSource.PDB)
+                .equals(DBRefUtils.getCanonicalName(ref.getSource())))
         {
           // PDB dbrefs imply there should be a PDBEntry associated
           // TODO: tighten PDB dbrefs
@@ -1762,14 +1812,54 @@ public class Sequence extends ASequence implements SequenceI
    * {@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;
   }
 
   /**
@@ -1781,4 +1871,34 @@ 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;
+  }
 }