JAL-2069 typo
[jalview.git] / src / jalview / analysis / Finder.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
4  * 
5  * This file is part of Jalview.
6  * 
7  * Jalview is free software: you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License 
9  * as published by the Free Software Foundation, either version 3
10  * of the License, or (at your option) any later version.
11  *  
12  * Jalview is distributed in the hope that it will be useful, but 
13  * WITHOUT ANY WARRANTY; without even the implied warranty 
14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
15  * PURPOSE.  See the GNU General Public License for more details.
16  * 
17  * You should have received a copy of the GNU General Public License
18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
19  * The Jalview Authors are detailed in the 'AUTHORS' file.
20  */
21 package jalview.analysis;
22
23 import jalview.datamodel.AlignmentI;
24 import jalview.datamodel.SearchResultMatchI;
25 import jalview.datamodel.SearchResults;
26 import jalview.datamodel.SearchResultsI;
27 import jalview.datamodel.SequenceGroup;
28 import jalview.datamodel.SequenceI;
29 import jalview.util.Comparison;
30
31 import java.util.ArrayList;
32 import java.util.List;
33 import java.util.Vector;
34
35 import com.stevesoft.pat.Regex;
36
37 public class Finder
38 {
39   /**
40    * Implements the search algorithms for the Find dialog box.
41    */
42   SearchResultsI searchResults;
43
44   AlignmentI alignment;
45
46   SequenceGroup selection = null;
47
48   Vector<SequenceI> idMatch = null;
49
50   boolean caseSensitive = false;
51
52   private boolean includeDescription = false;
53
54   boolean findAll = false;
55
56   Regex regex = null;
57
58   /**
59    * holds last-searched position between calls to find(false)
60    */
61   int seqIndex = 0, resIndex = -1;
62
63   public Finder(AlignmentI alignment, SequenceGroup selection)
64   {
65     this.alignment = alignment;
66     this.selection = selection;
67   }
68
69   /**
70    * restart search at given sequence and residue on alignment and (optionally)
71    * contained in selection
72    * 
73    * @param alignment
74    * @param selectionGroup
75    * @param seqIndex
76    * @param resIndex
77    */
78   public Finder(AlignmentI alignment, SequenceGroup selectionGroup,
79           int seqIndex, int resIndex)
80   {
81     this(alignment, selectionGroup);
82     this.seqIndex = seqIndex;
83     this.resIndex = resIndex;
84   }
85
86   public boolean find(String searchString)
87   {
88     boolean hasResults = false;
89     if (!caseSensitive)
90     {
91       searchString = searchString.toUpperCase();
92     }
93     regex = new Regex(searchString);
94     regex.setIgnoreCase(!caseSensitive);
95     searchResults = new SearchResults();
96     idMatch = new Vector<SequenceI>();
97     String item = null;
98     boolean found = false;
99     int end = alignment.getHeight();
100
101     // /////////////////////////////////////////////
102
103     if (selection != null)
104     {
105       if ((selection.getSize() < 1)
106               || ((selection.getEndRes() - selection.getStartRes()) < 2))
107       {
108         selection = null;
109       }
110     }
111     SearchResultMatchI lastm = null;
112
113     while (!found && (seqIndex < end))
114     {
115       SequenceI seq = alignment.getSequenceAt(seqIndex);
116
117       if ((selection != null && selection.getSize() > 0)
118               && !selection.getSequences(null).contains(seq))
119       {
120         seqIndex++;
121         resIndex = -1;
122
123         continue;
124       }
125       if (resIndex < 0)
126       {
127         resIndex = 0;
128         // test for one off matches - sequence position and sequence ID
129         // //// is the searchString a residue number?
130         try
131         {
132           int res = Integer.parseInt(searchString);
133           // possibly a residue number - check if valid for seq
134           if (seq.getEnd() >= res)
135           {
136             searchResults.addResult(seq, res, res);
137             hasResults = true;
138             // resIndex=seq.getLength();
139             // seqIndex++;
140             if (!findAll)
141             {
142               found = true;
143               break;
144             }
145           }
146         } catch (NumberFormatException ex)
147         {
148         }
149
150         if (regex.search(seq.getName()) && !idMatch.contains(seq))
151         {
152           idMatch.addElement(seq);
153           hasResults = true;
154           if (!findAll)
155           {
156             // stop and return the match
157             found = true;
158             break;
159           }
160         }
161
162         if (isIncludeDescription() && seq.getDescription() != null
163                 && regex.search(seq.getDescription())
164                 && !idMatch.contains(seq))
165         {
166           idMatch.addElement(seq);
167           hasResults = true;
168           if (!findAll)
169           {
170             // stop and return the match
171             found = true;
172             break;
173           }
174         }
175       }
176       item = seq.getSequenceAsString();
177
178       if ((selection != null)
179               && (selection.getEndRes() < alignment.getWidth() - 1))
180       {
181         item = item.substring(0, selection.getEndRes() + 1);
182       }
183
184       // /Shall we ignore gaps???? - JBPNote: Add Flag for forcing this or not
185       StringBuilder noGapsSB = new StringBuilder();
186       int insertCount = 0;
187       List<Integer> spaces = new ArrayList<Integer>();
188
189       for (int j = 0; j < item.length(); j++)
190       {
191         if (!Comparison.isGap(item.charAt(j)))
192         {
193           noGapsSB.append(item.charAt(j));
194           spaces.add(Integer.valueOf(insertCount));
195         }
196         else
197         {
198           insertCount++;
199         }
200       }
201
202       String noGaps = noGapsSB.toString();
203       for (int r = resIndex; r < noGaps.length(); r++)
204       {
205
206         if (regex.searchFrom(noGaps, r))
207         {
208           resIndex = regex.matchedFrom();
209
210           if ((selection != null && selection.getSize() > 0) && (resIndex
211                   + spaces.get(resIndex) < selection.getStartRes()))
212           {
213             continue;
214           }
215           // if invalid string used, then regex has no matched to/from
216           int sres = seq.findPosition(resIndex + spaces.get(resIndex));
217           int eres = seq.findPosition(regex.matchedTo() - 1
218                   + (spaces.get(regex.matchedTo() - 1)));
219           // only add result if not contained in previous result
220           if (lastm == null || (lastm.getSequence() != seq
221                   || (!(lastm.getStart() <= sres
222                           && lastm.getEnd() >= eres))))
223           {
224             lastm = searchResults.addResult(seq, sres, eres);
225           }
226           hasResults = true;
227           if (!findAll)
228           {
229             // thats enough, break and display the result
230             found = true;
231             resIndex++;
232
233             break;
234           }
235
236           r = resIndex;
237         }
238         else
239         {
240           break;
241         }
242       }
243
244       if (!found)
245       {
246         seqIndex++;
247         resIndex = -1;
248       }
249     }
250
251     /**
252      * We now search the Id string in the main search loop. for (int id = 0; id
253      * < alignment.getHeight(); id++) { if
254      * (regex.search(alignment.getSequenceAt(id).getName())) {
255      * idMatch.addElement(alignment.getSequenceAt(id)); hasResults = true; } }
256      */
257     return hasResults;
258   }
259
260   /**
261    * @return the alignment
262    */
263   public AlignmentI getAlignment()
264   {
265     return alignment;
266   }
267
268   /**
269    * @param alignment
270    *          the alignment to set
271    */
272   public void setAlignment(AlignmentI alignment)
273   {
274     this.alignment = alignment;
275   }
276
277   /**
278    * @return the caseSensitive
279    */
280   public boolean isCaseSensitive()
281   {
282     return caseSensitive;
283   }
284
285   /**
286    * @param caseSensitive
287    *          the caseSensitive to set
288    */
289   public void setCaseSensitive(boolean caseSensitive)
290   {
291     this.caseSensitive = caseSensitive;
292   }
293
294   /**
295    * @return the findAll
296    */
297   public boolean isFindAll()
298   {
299     return findAll;
300   }
301
302   /**
303    * @param findAll
304    *          the findAll to set
305    */
306   public void setFindAll(boolean findAll)
307   {
308     this.findAll = findAll;
309   }
310
311   /**
312    * @return the selection
313    */
314   public jalview.datamodel.SequenceGroup getSelection()
315   {
316     return selection;
317   }
318
319   /**
320    * @param selection
321    *          the selection to set
322    */
323   public void setSelection(jalview.datamodel.SequenceGroup selection)
324   {
325     this.selection = selection;
326   }
327
328   /**
329    * Returns the (possibly empty) list of matching sequences (when search
330    * includes searching sequence names)
331    * 
332    * @return
333    */
334   public Vector<SequenceI> getIdMatch()
335   {
336     return idMatch;
337   }
338
339   /**
340    * @return the regex
341    */
342   public com.stevesoft.pat.Regex getRegex()
343   {
344     return regex;
345   }
346
347   /**
348    * @return the searchResults
349    */
350   public SearchResultsI getSearchResults()
351   {
352     return searchResults;
353   }
354
355   /**
356    * @return the resIndex
357    */
358   public int getResIndex()
359   {
360     return resIndex;
361   }
362
363   /**
364    * @param resIndex
365    *          the resIndex to set
366    */
367   public void setResIndex(int resIndex)
368   {
369     this.resIndex = resIndex;
370   }
371
372   /**
373    * @return the seqIndex
374    */
375   public int getSeqIndex()
376   {
377     return seqIndex;
378   }
379
380   /**
381    * @param seqIndex
382    *          the seqIndex to set
383    */
384   public void setSeqIndex(int seqIndex)
385   {
386     this.seqIndex = seqIndex;
387   }
388
389   public boolean isIncludeDescription()
390   {
391     return includeDescription;
392   }
393
394   public void setIncludeDescription(boolean includeDescription)
395   {
396     this.includeDescription = includeDescription;
397   }
398 }