X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fanalysis%2FFinder.java;h=3cbef6d89175201f0f9029cf3dfca2260bf0295c;hb=refs%2Fheads%2Fbug%2FJAL-2839findWithHidden;hp=06d75acfff4c775f139b8130145553975ef58360;hpb=865a855a4ca87eadb3e5ff284ed32ed307d9c34b;p=jalview.git

diff --git a/src/jalview/analysis/Finder.java b/src/jalview/analysis/Finder.java
index 06d75ac..3cbef6d 100644
--- a/src/jalview/analysis/Finder.java
+++ b/src/jalview/analysis/Finder.java
@@ -1,359 +1,468 @@
 /*
- * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.0b1)
- * Copyright (C) 2014 The Jalview Authors
+ * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
+ * Copyright (C) $$Year-Rel$$ The Jalview Authors
  * 
  * This file is part of Jalview.
  * 
  * Jalview is free software: you can redistribute it and/or
  * modify it under the terms of the GNU General Public License 
- * as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+ * as published by the Free Software Foundation, either version 3
+ * of the License, or (at your option) any later version.
  *  
  * Jalview is distributed in the hope that it will be useful, but 
  * WITHOUT ANY WARRANTY; without even the implied warranty 
  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
  * PURPOSE.  See the GNU General Public License for more details.
  * 
- * You should have received a copy of the GNU General Public License along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU General Public License
+ * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  * The Jalview Authors are detailed in the 'AUTHORS' file.
  */
 package jalview.analysis;
 
-import java.util.*;
-
-import jalview.datamodel.*;
-
-public class Finder
+import jalview.api.AlignViewportI;
+import jalview.api.FinderI;
+import jalview.datamodel.AlignmentI;
+import jalview.datamodel.Range;
+import jalview.datamodel.SearchResultMatchI;
+import jalview.datamodel.SearchResults;
+import jalview.datamodel.SearchResultsI;
+import jalview.datamodel.SequenceGroup;
+import jalview.datamodel.SequenceI;
+import jalview.datamodel.VisibleContigsIterator;
+import jalview.util.Comparison;
+
+import java.util.List;
+import java.util.Vector;
+
+import com.stevesoft.pat.Regex;
+
+/**
+ * Implements the search algorithm for the Find dialog
+ */
+public class Finder implements FinderI
 {
-  /**
-   * Implements the search algorithms for the Find dialog box.
+  /*
+   * matched residue locations
    */
-  SearchResults searchResults;
-
-  AlignmentI alignment;
+  private SearchResultsI searchResults;
 
-  jalview.datamodel.SequenceGroup selection = null;
-
-  Vector idMatch = null;
+  /*
+   * sequences matched by id or description
+   */
+  private Vector<SequenceI> idMatches;
 
-  boolean caseSensitive = false;
+  /*
+   * the viewport to search over
+   */
+  private AlignViewportI viewport;
 
-  boolean findAll = false;
+  /*
+   * sequence index in alignment to search from
+   */
+  private int sequenceIndex;
 
-  com.stevesoft.pat.Regex regex = null;
+  /*
+   * column position in sequence to search from, base 0
+   * - absolute column number including any hidden columns
+   * (position after start of last match for a repeat search)
+   */
+  private int columnIndex;
 
   /**
-   * hold's last-searched position between calles to find(false)
+   * Constructor for searching a viewport
+   * 
+   * @param av
    */
-  int seqIndex = 0, resIndex = -1;
-
-  public Finder(AlignmentI alignment, SequenceGroup selection)
+  public Finder(AlignViewportI av)
   {
-    this.alignment = alignment;
-    this.selection = selection;
+    this.viewport = av;
+    this.sequenceIndex = 0;
+    this.columnIndex = -1;
   }
 
-  /**
-   * restart search at given sequence and residue on alignment and (optionally)
-   * contained in selection
-   * 
-   * @param alignment
-   * @param selectionGroup
-   * @param seqIndex
-   * @param resIndex
-   */
-  public Finder(AlignmentI alignment, SequenceGroup selectionGroup,
-          int seqIndex, int resIndex)
+  @Override
+  public void findAll(String theSearchString, boolean matchCase,
+          boolean searchDescription)
   {
-    this(alignment, selectionGroup);
-    this.seqIndex = seqIndex;
-    this.resIndex = resIndex;
+    /*
+     * search from the start
+     */
+    sequenceIndex = 0;
+    columnIndex = -1;
+
+    doFind(theSearchString, matchCase, searchDescription, true);
+
+    /*
+     * reset to start for next search
+     */
+    sequenceIndex = 0;
+    columnIndex = -1;
   }
 
-  public boolean find(String searchString)
+  @Override
+  public void findNext(String theSearchString, boolean matchCase,
+          boolean searchDescription)
   {
-    boolean hasResults = false;
-    if (!caseSensitive)
+    doFind(theSearchString, matchCase, searchDescription, false);
+    
+    if (searchResults.isEmpty() && idMatches.isEmpty())
     {
-      searchString = searchString.toUpperCase();
+      /*
+       * search failed - reset to start for next search
+       */
+      sequenceIndex = 0;
+      columnIndex = -1;
     }
-    regex = new com.stevesoft.pat.Regex(searchString);
-    regex.setIgnoreCase(!caseSensitive);
-    searchResults = new SearchResults();
-    idMatch = new Vector();
-    Sequence seq;
-    String item = null;
-    boolean found = false;
-    int end = alignment.getHeight();
+  }
 
-    // /////////////////////////////////////////////
+  /**
+   * Performs a 'find next' or 'find all'
+   * 
+   * @param theSearchString
+   * @param matchCase
+   * @param searchDescription
+   * @param findAll
+   */
+  protected void doFind(String theSearchString, boolean matchCase,
+          boolean searchDescription, boolean findAll)
+  {
+    String searchString = matchCase ? theSearchString
+            : theSearchString.toUpperCase();
+    Regex searchPattern = new Regex(searchString);
+    searchPattern.setIgnoreCase(!matchCase);
 
-    if (selection != null)
+    searchResults = new SearchResults();
+    idMatches = new Vector<>();
+
+    SequenceGroup selection = viewport.getSelectionGroup();
+    if (selection != null && selection.getSize() < 1)
     {
-      if ((selection.getSize() < 1)
-              || ((selection.getEndRes() - selection.getStartRes()) < 2))
-      {
-        selection = null;
-      }
+      selection = null; // ? ignore column-only selection
     }
 
-    while (!found && (seqIndex < end))
-    {
-      seq = (Sequence) alignment.getSequenceAt(seqIndex);
+    AlignmentI alignment = viewport.getAlignment();
+    int end = alignment.getHeight();
 
-      if ((selection != null && selection.getSize() > 0)
-              && !selection.getSequences(null).contains(seq))
+    while (sequenceIndex < end)
+    {
+      SequenceI seq = alignment.getSequenceAt(sequenceIndex);
+      boolean found = findNextMatch(seq, searchString, searchPattern,
+              searchDescription);
+      if (found && !findAll)
       {
-        seqIndex++;
-        resIndex = -1;
-
-        continue;
+        return;
       }
-      if (resIndex < 0)
+      if (!found)
       {
-        resIndex = 0;
-        // test for one off matches - sequence position and sequence ID
-        // //// is the searchString a residue number?
-        try
-        {
-          int res = Integer.parseInt(searchString);
-          // possibly a residue number - check if valid for seq
-          if (seq.getEnd() >= res)
-          {
-            searchResults.addResult(seq, res, res);
-            hasResults = true;
-            // resIndex=seq.getLength();
-            // seqIndex++;
-            if (!findAll)
-            {
-              found = true;
-              break;
-            }
-          }
-        } catch (NumberFormatException ex)
-        {
-        }
-
-        if (regex.search(seq.getName()))
-        {
-          idMatch.addElement(seq);
-          hasResults = true;
-          if (!findAll)
-          {
-            // stop and return the match
-            found = true;
-            break;
-          }
-        }
+        sequenceIndex++;
+        columnIndex = -1;
       }
-      item = seq.getSequenceAsString();
+    }
+  }
 
-      if ((selection != null)
-              && (selection.getEndRes() < alignment.getWidth() - 1))
-      {
-        item = item.substring(0, selection.getEndRes() + 1);
-      }
+  /**
+   * Answers the start-end column range of the visible region of
+   * <code>sequence</code> starting at or after the given <code>column</code>.
+   * If there are no hidden columns, this just returns the remaining width of
+   * the sequence. The range is restricted to the current <code>selection</code>
+   * if there is one. Answers null if there are no visible columns at or after
+   * <code>column</code>.
+   */
+  protected Range getNextVisibleSequenceRegion(SequenceI sequence,
+          int column)
+  {
+    int seqColStart = column;
+    int seqColEnd = sequence.getLength() - 1;
 
-      // /Shall we ignore gaps???? - JBPNote: Add Flag for forcing this or not
-      StringBuffer noGapsSB = new StringBuffer();
-      int insertCount = 0;
-      Vector spaces = new Vector();
+    /*
+     * restrict search to (next) visible column region, 
+     * in case there are hidden columns
+     */
+    AlignmentI alignment = viewport.getAlignment();
+    VisibleContigsIterator visibleRegions = alignment.getHiddenColumns()
+            .getVisContigsIterator(column, alignment.getWidth(),
+                    false);
+    int[] visible = visibleRegions.hasNext() ? visibleRegions.next() : null;
+    if (visible == null)
+    {
+      columnIndex = seqColEnd + 1;
+      return null;
+    }
+    seqColStart = Math.max(seqColStart, visible[0]);
+    seqColEnd = Math.min(seqColEnd, visible[1]);
 
-      for (int j = 0; j < item.length(); j++)
+    /*
+     * restrict search to selected region if there is one
+     */
+    SequenceGroup selection = viewport.getSelectionGroup();
+    if (selection != null)
+    {
+      int selectionStart = selection.getStartRes();
+      int selectionEnd = selection.getEndRes();
+      if (selectionStart > seqColEnd || selectionEnd < seqColStart)
       {
-        if (!jalview.util.Comparison.isGap(item.charAt(j)))
-        {
-          noGapsSB.append(item.charAt(j));
-          spaces.addElement(new Integer(insertCount));
-        }
-        else
-        {
-          insertCount++;
-        }
+        /*
+         * sequence region doesn't overlap selection region 
+         */
+        columnIndex = seqColEnd + 1;
+        return null;
       }
+      seqColStart = Math.max(seqColStart, selectionStart);
+      seqColEnd = Math.min(seqColEnd, selectionEnd);
+    }
 
-      String noGaps = noGapsSB.toString();
-
-      for (int r = resIndex; r < noGaps.length(); r++)
-      {
+    return new Range(seqColStart, seqColEnd);
+  }
 
-        if (regex.searchFrom(noGaps, r))
-        {
-          resIndex = regex.matchedFrom();
-
-          if ((selection != null && selection.getSize() > 0)
-                  && ((resIndex + Integer.parseInt(spaces.elementAt(
-                          resIndex).toString())) < selection.getStartRes()))
-          {
-            continue;
-          }
-
-          int sres = seq
-                  .findPosition(resIndex
-                          + Integer.parseInt(spaces.elementAt(resIndex)
-                                  .toString()));
-          int eres = seq.findPosition(regex.matchedTo()
-                  - 1
-                  + Integer.parseInt(spaces
-                          .elementAt(regex.matchedTo() - 1).toString()));
-
-          searchResults.addResult(seq, sres, eres);
-          hasResults = true;
-          if (!findAll)
-          {
-            // thats enough, break and display the result
-            found = true;
-            resIndex++;
-
-            break;
-          }
-
-          r = resIndex;
-        }
-        else
-        {
-          break;
-        }
-      }
+  /**
+   * Finds the next match in the given sequence, starting at column at
+   * <code>columnIndex</code>. Answers true if a match is found, else false. If
+   * a match is found, <code>columnIndex</code> is advanced to the column after
+   * the start of the matched region, ready for a search from the next position.
+   * 
+   * @param seq
+   * @param searchString
+   * @param searchPattern
+   * @param matchDescription
+   * @return
+   */
+  protected boolean findNextMatch(SequenceI seq, String searchString,
+          Regex searchPattern, boolean matchDescription)
+  {
+    SequenceGroup selection = viewport.getSelectionGroup();
+    if (selection != null && !selection.contains(seq))
+    {
+      /*
+       * this sequence is not in the selection - advance to next sequence
+       */
+      return false;
+    }
 
-      if (!found)
+    if (columnIndex < 0)
+    {
+      /*
+       * at start of sequence; try find by residue number, in sequence id,
+       * or (optionally) in sequence description
+       */
+      if (doNonMotifSearches(seq, searchString, searchPattern,
+              matchDescription))
       {
-        seqIndex++;
-        resIndex = -1;
+        return true;
       }
     }
 
-    /**
-     * We now search the Id string in the main search loop. for (int id = 0; id
-     * < alignment.getHeight(); id++) { if
-     * (regex.search(alignment.getSequenceAt(id).getName())) {
-     * idMatch.addElement(alignment.getSequenceAt(id)); hasResults = true; } }
+    /*
+     * search for next match in sequence string
      */
-    return hasResults;
-  }
-
-  /**
-   * @return the alignment
-   */
-  public AlignmentI getAlignment()
-  {
-    return alignment;
+    int end = seq.getLength();
+    while (columnIndex < end)
+    {
+      if (searchNextVisibleRegion(seq, searchPattern))
+      {
+        return true;
+      }
+    }
+    return false;
   }
 
   /**
-   * @param alignment
-   *          the alignment to set
+   * Searches the sequence, starting from <code>columnIndex</code>, and adds the
+   * next match (if any) to <code>searchResults</code>. The search is restricted
+   * to the next visible column region, and to the <code>selection</code> region
+   * if there is one. Answers true if a match is added, else false.
+   * 
+   * @param seq
+   * @param searchPattern
+   * @return
    */
-  public void setAlignment(AlignmentI alignment)
+  protected boolean searchNextVisibleRegion(SequenceI seq, Regex searchPattern)
   {
-    this.alignment = alignment;
-  }
+    Range visible = getNextVisibleSequenceRegion(seq, columnIndex);
+    if (visible == null)
+    {
+      return false;
+    }
+    String seqString = seq.getSequenceAsString(visible.start, visible.end + 1);
+    String noGaps = AlignSeq.extractGaps(Comparison.GapChars, seqString);
 
-  /**
-   * @return the caseSensitive
-   */
-  public boolean isCaseSensitive()
-  {
-    return caseSensitive;
-  }
+    if (searchPattern.search(noGaps))
+    {
+      int sequenceStartPosition = seq.findPosition(visible.start);
+      recordMatch(seq, searchPattern, sequenceStartPosition);
+      return true;
+    }
+    else
+    {
+      /*
+       * no match - advance columnIndex past this visible region
+       * so the next visible region (if any) is searched next
+       */
+      columnIndex = visible.end + 1;
+    }
 
-  /**
-   * @param caseSensitive
-   *          the caseSensitive to set
-   */
-  public void setCaseSensitive(boolean caseSensitive)
-  {
-    this.caseSensitive = caseSensitive;
+    return false;
   }
 
   /**
-   * @return the findAll
+   * Adds the match held in the <code>searchPattern</code> Regex to the
+   * <code>searchResults</code>, unless it is a subregion of the last match
+   * recorded. <code>columnIndex</code> is advanced to the position after the
+   * start of the matched region, ready for the next search. Answers true if a
+   * match was added, else false.
+   * 
+   * @param seq
+   * @param searchPattern
+   * @param firstResiduePosition
+   * @return
    */
-  public boolean isFindAll()
+  protected boolean recordMatch(SequenceI seq, Regex searchPattern,
+          int firstResiduePosition)
   {
-    return findAll;
-  }
+    /*
+     * get start/end of the match in sequence coordinates
+     */
+    int offset = searchPattern.matchedFrom();
+    int matchStartPosition = firstResiduePosition + offset;
+    int matchEndPosition = matchStartPosition
+            + searchPattern.charsMatched() - 1;
+
+    /*
+     * update columnIndex to next column after the start of the match
+     * (findIndex returns a value base 1, columnIndex is held base 0)
+     */
+    columnIndex = seq.findIndex(matchStartPosition);
 
-  /**
-   * @param findAll
-   *          the findAll to set
-   */
-  public void setFindAll(boolean findAll)
-  {
-    this.findAll = findAll;
-  }
+    /*
+     * check that this match is not a subset of the previous one (JAL-2302)
+     */
+    List<SearchResultMatchI> matches = searchResults.getResults();
+    SearchResultMatchI lastMatch = matches.isEmpty() ? null
+            : matches.get(matches.size() - 1);
 
-  /**
-   * @return the selection
-   */
-  public jalview.datamodel.SequenceGroup getSelection()
-  {
-    return selection;
-  }
+    if (lastMatch == null || !lastMatch.contains(seq, matchStartPosition,
+            matchEndPosition))
+    {
+      searchResults.addResult(seq, matchStartPosition, matchEndPosition);
+      return true;
+    }
 
-  /**
-   * @param selection
-   *          the selection to set
-   */
-  public void setSelection(jalview.datamodel.SequenceGroup selection)
-  {
-    this.selection = selection;
+    return false;
   }
 
   /**
-   * @return the idMatch
+   * Does searches other than for residue patterns. Currently this includes
+   * <ul>
+   * <li>find residue by position (if search string is a number)</li>
+   * <li>match search string to sequence id</li>
+   * <li>match search string to sequence description (optional)</li>
+   * </ul>
+   * Answers true if a match is found, else false.
+   * 
+   * @param seq
+   * @param searchString
+   * @param searchPattern
+   * @param includeDescription
+   * @return
    */
-  public Vector getIdMatch()
+  protected boolean doNonMotifSearches(SequenceI seq, String searchString,
+          Regex searchPattern, boolean includeDescription)
   {
-    return idMatch;
-  }
+    /*
+     * position sequence search to start of sequence
+     */
+    columnIndex = 0;
 
-  /**
-   * @return the regex
-   */
-  public com.stevesoft.pat.Regex getRegex()
-  {
-    return regex;
+    if (searchForResidueNumber(seq, searchString))
+    {
+      return true;
+    }
+    if (searchSequenceName(seq, searchPattern))
+    {
+      return true;
+    }
+    if (includeDescription && searchSequenceDescription(seq, searchPattern))
+    {
+      return true;
+    }
+    return false;
   }
 
   /**
-   * @return the searchResults
+   * Searches for a match with the sequence description, and if found, adds the
+   * sequence to the list of match ids (but not as a duplicate). Answers true if
+   * a match was added, else false.
+   * 
+   * @param seq
+   * @param searchPattern
+   * @return
    */
-  public SearchResults getSearchResults()
+  protected boolean searchSequenceDescription(SequenceI seq, Regex searchPattern)
   {
-    return searchResults;
+    String desc = seq.getDescription();
+    if (desc != null && searchPattern.search(desc) && !idMatches.contains(seq))
+    {
+      idMatches.addElement(seq);
+      return true;
+    }
+    return false;
   }
 
   /**
-   * @return the resIndex
+   * Searches for a match with the sequence name, and if found, adds the
+   * sequence to the list of match ids (but not as a duplicate). Answers true if
+   * a match was added, else false.
+   * 
+   * @param seq
+   * @param searchPattern
+   * @return
    */
-  public int getResIndex()
+  protected boolean searchSequenceName(SequenceI seq, Regex searchPattern)
   {
-    return resIndex;
+    if (searchPattern.search(seq.getName()) && !idMatches.contains(seq))
+    {
+      idMatches.addElement(seq);
+      return true;
+    }
+    return false;
   }
 
   /**
-   * @param resIndex
-   *          the resIndex to set
+   * Tries to interpret the search string as a residue position, and if valid,
+   * adds the position to the search results and returns true, else answers
+   * false
    */
-  public void setResIndex(int resIndex)
+  protected boolean searchForResidueNumber(SequenceI seq, String searchString)
   {
-    this.resIndex = resIndex;
+    try
+    {
+      int res = Integer.parseInt(searchString);
+      if (seq.getStart() <= res && seq.getEnd() >= res)
+      {
+        searchResults.addResult(seq, res, res);
+        return true;
+      }
+    } catch (NumberFormatException ex)
+    {
+    }
+    return false;
   }
 
-  /**
-   * @return the seqIndex
+  /* (non-Javadoc)
+   * @see jalview.analysis.FinderI#getIdMatch()
    */
-  public int getSeqIndex()
+  @Override
+  public Vector<SequenceI> getIdMatches()
   {
-    return seqIndex;
+    return idMatches;
   }
 
-  /**
-   * @param seqIndex
-   *          the seqIndex to set
+  /* (non-Javadoc)
+   * @see jalview.analysis.FinderI#getSearchResults()
    */
-  public void setSeqIndex(int seqIndex)
+  @Override
+  public SearchResultsI getSearchResults()
   {
-    this.seqIndex = seqIndex;
+    return searchResults;
   }
 }