875322b6c090c6351268bc9c3184d95a30881ef0
[jalview.git] / 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.SearchResults;
25 import jalview.datamodel.Sequence;
26 import jalview.datamodel.SequenceGroup;
27
28 import java.util.Vector;
29
30 public class Finder
31 {
32   /**
33    * Implements the search algorithms for the Find dialog box.
34    */
35   SearchResults searchResults;
36
37   AlignmentI alignment;
38
39   jalview.datamodel.SequenceGroup selection = null;
40
41   Vector idMatch = null;
42
43   boolean caseSensitive = false;
44
45   private boolean includeDescription = false;
46
47   boolean findAll = false;
48
49   com.stevesoft.pat.Regex regex = null;
50
51   /**
52    * hold's last-searched position between calles to find(false)
53    */
54   int seqIndex = 0, resIndex = -1;
55
56   public Finder(AlignmentI alignment, SequenceGroup selection)
57   {
58     this.alignment = alignment;
59     this.selection = selection;
60   }
61
62   /**
63    * restart search at given sequence and residue on alignment and (optionally)
64    * contained in selection
65    * 
66    * @param alignment
67    * @param selectionGroup
68    * @param seqIndex
69    * @param resIndex
70    */
71   public Finder(AlignmentI alignment, SequenceGroup selectionGroup,
72           int seqIndex, int resIndex)
73   {
74     this(alignment, selectionGroup);
75     this.seqIndex = seqIndex;
76     this.resIndex = resIndex;
77   }
78
79   public boolean find(String searchString)
80   {
81     boolean hasResults = false;
82     if (!caseSensitive)
83     {
84       searchString = searchString.toUpperCase();
85     }
86     regex = new com.stevesoft.pat.Regex(searchString);
87     regex.setIgnoreCase(!caseSensitive);
88     searchResults = new SearchResults();
89     idMatch = new Vector();
90     Sequence seq;
91     String item = null;
92     boolean found = false;
93     int end = alignment.getHeight();
94
95     // /////////////////////////////////////////////
96
97     if (selection != null)
98     {
99       if ((selection.getSize() < 1)
100               || ((selection.getEndRes() - selection.getStartRes()) < 2))
101       {
102         selection = null;
103       }
104     }
105
106     while (!found && (seqIndex < end))
107     {
108       seq = (Sequence) alignment.getSequenceAt(seqIndex);
109
110       if ((selection != null && selection.getSize() > 0)
111               && !selection.getSequences(null).contains(seq))
112       {
113         seqIndex++;
114         resIndex = -1;
115
116         continue;
117       }
118       if (resIndex < 0)
119       {
120         resIndex = 0;
121         // test for one off matches - sequence position and sequence ID
122         // //// is the searchString a residue number?
123         try
124         {
125           int res = Integer.parseInt(searchString);
126           // possibly a residue number - check if valid for seq
127           if (seq.getEnd() >= res)
128           {
129             searchResults.addResult(seq, res, res);
130             hasResults = true;
131             // resIndex=seq.getLength();
132             // seqIndex++;
133             if (!findAll)
134             {
135               found = true;
136               break;
137             }
138           }
139         } catch (NumberFormatException ex)
140         {
141         }
142
143         if (regex.search(seq.getName()))
144         {
145           idMatch.addElement(seq);
146           hasResults = true;
147           if (!findAll)
148           {
149             // stop and return the match
150             found = true;
151             break;
152           }
153         }
154
155         if (isIncludeDescription() && seq.getDescription() != null
156                 && regex.search(seq.getDescription()))
157         {
158           idMatch.addElement(seq);
159           hasResults = true;
160           if (!findAll)
161           {
162             // stop and return the match
163             found = true;
164             break;
165           }
166         }
167       }
168       item = seq.getSequenceAsString();
169
170       if ((selection != null)
171               && (selection.getEndRes() < alignment.getWidth() - 1))
172       {
173         item = item.substring(0, selection.getEndRes() + 1);
174       }
175
176       // /Shall we ignore gaps???? - JBPNote: Add Flag for forcing this or not
177       StringBuffer noGapsSB = new StringBuffer();
178       int insertCount = 0;
179       Vector spaces = new Vector();
180
181       for (int j = 0; j < item.length(); j++)
182       {
183         if (!jalview.util.Comparison.isGap(item.charAt(j)))
184         {
185           noGapsSB.append(item.charAt(j));
186           spaces.addElement(new Integer(insertCount));
187         }
188         else
189         {
190           insertCount++;
191         }
192       }
193
194       String noGaps = noGapsSB.toString();
195
196       for (int r = resIndex; r < noGaps.length(); r++)
197       {
198
199         if (regex.searchFrom(noGaps, r))
200         {
201           resIndex = regex.matchedFrom();
202
203           if ((selection != null && selection.getSize() > 0)
204                   && ((resIndex + Integer.parseInt(spaces.elementAt(
205                           resIndex).toString())) < selection.getStartRes()))
206           {
207             continue;
208           }
209 // if invalid string used, then regex has no matched to/from
210           int sres = seq
211                   .findPosition(resIndex
212                           + Integer.parseInt(spaces.elementAt(resIndex)
213                                   .toString()));
214           int eres = seq.findPosition(regex.matchedTo()
215                   - 1
216                   + Integer.parseInt(spaces
217                           .elementAt(regex.matchedTo() - 1).toString()));
218
219           searchResults.addResult(seq, sres, eres);
220           hasResults = true;
221           if (!findAll)
222           {
223             // thats enough, break and display the result
224             found = true;
225             resIndex++;
226
227             break;
228           }
229
230           r = resIndex;
231         }
232         else
233         {
234           break;
235         }
236       }
237
238       if (!found)
239       {
240         seqIndex++;
241         resIndex = -1;
242       }
243     }
244
245     /**
246      * We now search the Id string in the main search loop. for (int id = 0; id
247      * < alignment.getHeight(); id++) { if
248      * (regex.search(alignment.getSequenceAt(id).getName())) {
249      * idMatch.addElement(alignment.getSequenceAt(id)); hasResults = true; } }
250      */
251     return hasResults;
252   }
253
254   /**
255    * @return the alignment
256    */
257   public AlignmentI getAlignment()
258   {
259     return alignment;
260   }
261
262   /**
263    * @param alignment
264    *          the alignment to set
265    */
266   public void setAlignment(AlignmentI alignment)
267   {
268     this.alignment = alignment;
269   }
270
271   /**
272    * @return the caseSensitive
273    */
274   public boolean isCaseSensitive()
275   {
276     return caseSensitive;
277   }
278
279   /**
280    * @param caseSensitive
281    *          the caseSensitive to set
282    */
283   public void setCaseSensitive(boolean caseSensitive)
284   {
285     this.caseSensitive = caseSensitive;
286   }
287
288   /**
289    * @return the findAll
290    */
291   public boolean isFindAll()
292   {
293     return findAll;
294   }
295
296   /**
297    * @param findAll
298    *          the findAll to set
299    */
300   public void setFindAll(boolean findAll)
301   {
302     this.findAll = findAll;
303   }
304
305   /**
306    * @return the selection
307    */
308   public jalview.datamodel.SequenceGroup getSelection()
309   {
310     return selection;
311   }
312
313   /**
314    * @param selection
315    *          the selection to set
316    */
317   public void setSelection(jalview.datamodel.SequenceGroup selection)
318   {
319     this.selection = selection;
320   }
321
322   /**
323    * @return the idMatch
324    */
325   public Vector getIdMatch()
326   {
327     return idMatch;
328   }
329
330   /**
331    * @return the regex
332    */
333   public com.stevesoft.pat.Regex getRegex()
334   {
335     return regex;
336   }
337
338   /**
339    * @return the searchResults
340    */
341   public SearchResults getSearchResults()
342   {
343     return searchResults;
344   }
345
346   /**
347    * @return the resIndex
348    */
349   public int getResIndex()
350   {
351     return resIndex;
352   }
353
354   /**
355    * @param resIndex
356    *          the resIndex to set
357    */
358   public void setResIndex(int resIndex)
359   {
360     this.resIndex = resIndex;
361   }
362
363   /**
364    * @return the seqIndex
365    */
366   public int getSeqIndex()
367   {
368     return seqIndex;
369   }
370
371   /**
372    * @param seqIndex
373    *          the seqIndex to set
374    */
375   public void setSeqIndex(int seqIndex)
376   {
377     this.seqIndex = seqIndex;
378   }
379
380   public boolean isIncludeDescription()
381   {
382     return includeDescription;
383   }
384
385   public void setIncludeDescription(boolean includeDescription)
386   {
387     this.includeDescription = includeDescription;
388   }
389 }