Clover icon

jalviewX

  1. Project Clover database Wed Oct 31 2018 15:13:58 GMT
  2. Package jalview.analysis

File Finder.java

 

Coverage histogram

../../img/srcFileCovDistChart8.png
19% of files have more coverage

Code metrics

42
96
20
1
398
242
56
0.58
4.8
20
2.8

Classes

Class Line # Actions
Finder 37 96 56 38
0.7594936575.9%
 

Contributing tests

This file is covered by 8 tests. .

Source view

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  15 toggle public Finder(AlignmentI alignment, SequenceGroup selection)
64    {
65  15 this.alignment = alignment;
66  15 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  3 toggle public Finder(AlignmentI alignment, SequenceGroup selectionGroup,
79    int seqIndex, int resIndex)
80    {
81  3 this(alignment, selectionGroup);
82  3 this.seqIndex = seqIndex;
83  3 this.resIndex = resIndex;
84    }
85   
 
86  15 toggle public boolean find(String searchString)
87    {
88  15 boolean hasResults = false;
89  15 if (!caseSensitive)
90    {
91  11 searchString = searchString.toUpperCase();
92    }
93  15 regex = new Regex(searchString);
94  15 regex.setIgnoreCase(!caseSensitive);
95  15 searchResults = new SearchResults();
96  15 idMatch = new Vector<SequenceI>();
97  15 String item = null;
98  15 boolean found = false;
99  15 int end = alignment.getHeight();
100   
101    // /////////////////////////////////////////////
102   
103  15 if (selection != null)
104    {
105  0 if ((selection.getSize() < 1)
106    || ((selection.getEndRes() - selection.getStartRes()) < 2))
107    {
108  0 selection = null;
109    }
110    }
111  15 SearchResultMatchI lastm = null;
112   
113  66 while (!found && (seqIndex < end))
114    {
115  53 SequenceI seq = alignment.getSequenceAt(seqIndex);
116   
117  53 if ((selection != null && selection.getSize() > 0)
118    && !selection.getSequences(null).contains(seq))
119    {
120  0 seqIndex++;
121  0 resIndex = -1;
122   
123  0 continue;
124    }
125  53 if (resIndex < 0)
126    {
127  51 resIndex = 0;
128    // test for one off matches - sequence position and sequence ID
129    // //// is the searchString a residue number?
130  51 try
131    {
132  51 int res = Integer.parseInt(searchString);
133    // possibly a residue number - check if valid for seq
134  4 if (seq.getEnd() >= res)
135    {
136  2 searchResults.addResult(seq, res, res);
137  2 hasResults = true;
138    // resIndex=seq.getLength();
139    // seqIndex++;
140  2 if (!findAll)
141    {
142  0 found = true;
143  0 break;
144    }
145    }
146    } catch (NumberFormatException ex)
147    {
148    }
149   
150  51 if (regex.search(seq.getName()) && !idMatch.contains(seq))
151    {
152  6 idMatch.addElement(seq);
153  6 hasResults = true;
154  6 if (!findAll)
155    {
156    // stop and return the match
157  2 found = true;
158  2 break;
159    }
160    }
161   
162  49 if (isIncludeDescription() && seq.getDescription() != null
163    && regex.search(seq.getDescription())
164    && !idMatch.contains(seq))
165    {
166  3 idMatch.addElement(seq);
167  3 hasResults = true;
168  3 if (!findAll)
169    {
170    // stop and return the match
171  0 found = true;
172  0 break;
173    }
174    }
175    }
176  51 item = seq.getSequenceAsString();
177   
178  51 if ((selection != null)
179    && (selection.getEndRes() < alignment.getWidth() - 1))
180    {
181  0 item = item.substring(0, selection.getEndRes() + 1);
182    }
183   
184    // /Shall we ignore gaps???? - JBPNote: Add Flag for forcing this or not
185  51 StringBuilder noGapsSB = new StringBuilder();
186  51 int insertCount = 0;
187  51 List<Integer> spaces = new ArrayList<Integer>();
188   
189  647 for (int j = 0; j < item.length(); j++)
190    {
191  596 if (!Comparison.isGap(item.charAt(j)))
192    {
193  482 noGapsSB.append(item.charAt(j));
194  482 spaces.add(Integer.valueOf(insertCount));
195    }
196    else
197    {
198  114 insertCount++;
199    }
200    }
201   
202  51 String noGaps = noGapsSB.toString();
203  81 for (int r = resIndex; r < noGaps.length(); r++)
204    {
205   
206  81 if (regex.searchFrom(noGaps, r))
207    {
208  31 resIndex = regex.matchedFrom();
209   
210  31 if ((selection != null && selection.getSize() > 0) && (resIndex
211    + spaces.get(resIndex) < selection.getStartRes()))
212    {
213  0 continue;
214    }
215    // if invalid string used, then regex has no matched to/from
216  31 int sres = seq.findPosition(resIndex + spaces.get(resIndex));
217  31 int eres = seq.findPosition(regex.matchedTo() - 1
218    + (spaces.get(regex.matchedTo() - 1)));
219    // only add result if not contained in previous result
220  31 if (lastm == null || (lastm.getSequence() != seq
221    || (!(lastm.getStart() <= sres
222    && lastm.getEnd() >= eres))))
223    {
224  15 lastm = searchResults.addResult(seq, sres, eres);
225    }
226  31 hasResults = true;
227  31 if (!findAll)
228    {
229    // thats enough, break and display the result
230  1 found = true;
231  1 resIndex++;
232   
233  1 break;
234    }
235   
236  30 r = resIndex;
237    }
238    else
239    {
240  50 break;
241    }
242    }
243   
244  51 if (!found)
245    {
246  50 seqIndex++;
247  50 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  15 return hasResults;
258    }
259   
260    /**
261    * @return the alignment
262    */
 
263  0 toggle public AlignmentI getAlignment()
264    {
265  0 return alignment;
266    }
267   
268    /**
269    * @param alignment
270    * the alignment to set
271    */
 
272  0 toggle public void setAlignment(AlignmentI alignment)
273    {
274  0 this.alignment = alignment;
275    }
276   
277    /**
278    * @return the caseSensitive
279    */
 
280  0 toggle public boolean isCaseSensitive()
281    {
282  0 return caseSensitive;
283    }
284   
285    /**
286    * @param caseSensitive
287    * the caseSensitive to set
288    */
 
289  4 toggle public void setCaseSensitive(boolean caseSensitive)
290    {
291  4 this.caseSensitive = caseSensitive;
292    }
293   
294    /**
295    * @return the findAll
296    */
 
297  0 toggle public boolean isFindAll()
298    {
299  0 return findAll;
300    }
301   
302    /**
303    * @param findAll
304    * the findAll to set
305    */
 
306  12 toggle public void setFindAll(boolean findAll)
307    {
308  12 this.findAll = findAll;
309    }
310   
311    /**
312    * @return the selection
313    */
 
314  0 toggle public jalview.datamodel.SequenceGroup getSelection()
315    {
316  0 return selection;
317    }
318   
319    /**
320    * @param selection
321    * the selection to set
322    */
 
323  0 toggle public void setSelection(jalview.datamodel.SequenceGroup selection)
324    {
325  0 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  17 toggle public Vector<SequenceI> getIdMatch()
335    {
336  17 return idMatch;
337    }
338   
339    /**
340    * @return the regex
341    */
 
342  0 toggle public com.stevesoft.pat.Regex getRegex()
343    {
344  0 return regex;
345    }
346   
347    /**
348    * @return the searchResults
349    */
 
350  19 toggle public SearchResultsI getSearchResults()
351    {
352  19 return searchResults;
353    }
354   
355    /**
356    * @return the resIndex
357    */
 
358  2 toggle public int getResIndex()
359    {
360  2 return resIndex;
361    }
362   
363    /**
364    * @param resIndex
365    * the resIndex to set
366    */
 
367  0 toggle public void setResIndex(int resIndex)
368    {
369  0 this.resIndex = resIndex;
370    }
371   
372    /**
373    * @return the seqIndex
374    */
 
375  1 toggle public int getSeqIndex()
376    {
377  1 return seqIndex;
378    }
379   
380    /**
381    * @param seqIndex
382    * the seqIndex to set
383    */
 
384  0 toggle public void setSeqIndex(int seqIndex)
385    {
386  0 this.seqIndex = seqIndex;
387    }
388   
 
389  49 toggle public boolean isIncludeDescription()
390    {
391  49 return includeDescription;
392    }
393   
 
394  3 toggle public void setIncludeDescription(boolean includeDescription)
395    {
396  3 this.includeDescription = includeDescription;
397    }
398    }
  • Report generated by OpenClover v 4.2.1 on Wed Oct 31 2018 15:15:54 GMT using coverage data from Wed Oct 31 2018 15:15:47 GMT.
  • Clover free edition.