JAL-3541 removed clover report generation debug flag (utf-8 encoding enforcement...
[jalview.git] / src / jalview / datamodel / SearchResults.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.datamodel;
22
23 import java.util.ArrayList;
24 import java.util.BitSet;
25 import java.util.List;
26
27 /**
28  * Holds a list of search result matches, where each match is a contiguous
29  * stretch of a single sequence.
30  * 
31  * @author gmcarstairs amwaterhouse
32  *
33  */
34 public class SearchResults implements SearchResultsI
35 {
36
37   private List<SearchResultMatchI> matches = new ArrayList<>();
38
39   /**
40    * One match consists of a sequence reference, start and end positions.
41    * Discontiguous ranges in a sequence require two or more Match objects.
42    */
43   public class Match implements SearchResultMatchI
44   {
45     final SequenceI sequence;
46
47     /**
48      * Start position of match in sequence (base 1)
49      */
50     final int start;
51
52     /**
53      * End position (inclusive) (base 1)
54      */
55     final int end;
56
57     /**
58      * create a Match on a range of sequence. Match always holds region in
59      * forwards order, even if given in reverse order (such as from a mapping to
60      * a reverse strand); this avoids trouble for routines that highlight search
61      * results etc
62      * 
63      * @param seq
64      *          a sequence
65      * @param start
66      *          start position of matched range (base 1)
67      * @param end
68      *          end of matched range (inclusive, base 1)
69      */
70     public Match(SequenceI seq, int start, int end)
71     {
72       sequence = seq;
73
74       /*
75        * always hold in forwards order, even if given in reverse order
76        * (such as from a mapping to a reverse strand); this avoids
77        * trouble for routines that highlight search results etc
78        */
79       if (start <= end)
80       {
81         this.start = start;
82         this.end = end;
83       }
84       else
85       {
86         // TODO: JBP could mark match as being specified in reverse direction
87         // for use
88         // by caller ? e.g. visualizing reverse strand highlight
89         this.start = end;
90         this.end = start;
91       }
92     }
93
94     @Override
95     public SequenceI getSequence()
96     {
97       return sequence;
98     }
99
100     @Override
101     public int getStart()
102     {
103       return start;
104     }
105
106     @Override
107     public int getEnd()
108     {
109       return end;
110     }
111
112     /**
113      * Returns a representation as "seqid/start-end"
114      */
115     @Override
116     public String toString()
117     {
118       StringBuilder sb = new StringBuilder();
119       if (sequence != null)
120       {
121         sb.append(sequence.getName()).append("/");
122       }
123       sb.append(start).append("-").append(end);
124       return sb.toString();
125     }
126
127     /**
128      * Hashcode is the hashcode of the matched sequence plus a hash of start and
129      * end positions. Match objects that pass the test for equals are guaranteed
130      * to have the same hashcode.
131      */
132     @Override
133     public int hashCode()
134     {
135       int hash = sequence == null ? 0 : sequence.hashCode();
136       hash += 31 * start;
137       hash += 67 * end;
138       return hash;
139     }
140
141     /**
142      * Two Match objects are equal if they are for the same sequence, start and
143      * end positions
144      */
145     @Override
146     public boolean equals(Object obj)
147     {
148       if (obj == null || !(obj instanceof SearchResultMatchI))
149       {
150         return false;
151       }
152       SearchResultMatchI m = (SearchResultMatchI) obj;
153       return (sequence == m.getSequence() && start == m.getStart()
154               && end == m.getEnd());
155     }
156
157     @Override
158     public boolean contains(SequenceI seq, int from, int to)
159     {
160       return (sequence == seq && start <= from && end >= to);
161     }
162   }
163
164   @Override
165   public SearchResultMatchI addResult(SequenceI seq, int start, int end)
166   {
167     Match m = new Match(seq, start, end);
168     if (!matches.contains(m))
169     {
170       matches.add(m);
171     }
172     return m;
173   }
174
175   @Override
176   public boolean involvesSequence(SequenceI sequence)
177   {
178     SequenceI ds = sequence.getDatasetSequence();
179     for (SearchResultMatchI _m : matches)
180     {
181       SequenceI matched = _m.getSequence();
182       if (matched != null && (matched == sequence || matched == ds))
183       {
184         return true;
185       }
186     }
187     return false;
188   }
189
190   @Override
191   public int[] getResults(SequenceI sequence, int start, int end)
192   {
193     if (matches.isEmpty())
194     {
195       return null;
196     }
197
198     int[] result = null;
199     int[] tmp = null;
200     int resultLength, matchStart = 0, matchEnd = 0;
201     boolean mfound;
202     Match m;
203     for (SearchResultMatchI _m : matches)
204     {
205       m = (Match) _m;
206
207       mfound = false;
208       if (m.sequence == sequence
209               || m.sequence == sequence.getDatasetSequence())
210       {
211         mfound = true;
212         matchStart = sequence.findIndex(m.start) - 1;
213         matchEnd = m.start == m.end ? matchStart : sequence
214                 .findIndex(m.end) - 1;
215       }
216
217       if (mfound)
218       {
219         if (matchStart <= end && matchEnd >= start)
220         {
221           if (matchStart < start)
222           {
223             matchStart = start;
224           }
225
226           if (matchEnd > end)
227           {
228             matchEnd = end;
229           }
230
231           if (result == null)
232           {
233             result = new int[] { matchStart, matchEnd };
234           }
235           else
236           {
237             resultLength = result.length;
238             tmp = new int[resultLength + 2];
239             System.arraycopy(result, 0, tmp, 0, resultLength);
240             result = tmp;
241             result[resultLength] = matchStart;
242             result[resultLength + 1] = matchEnd;
243           }
244         }
245         else
246         {
247           // debug
248           // System.err.println("Outwith bounds!" + matchStart+">"+end +" or "
249           // + matchEnd+"<"+start);
250         }
251       }
252     }
253     return result;
254   }
255
256   @Override
257   public int markColumns(SequenceCollectionI sqcol, BitSet bs)
258   {
259     int count = 0;
260     BitSet mask = new BitSet();
261     int startRes = sqcol.getStartRes();
262     int endRes = sqcol.getEndRes();
263
264     for (SequenceI s : sqcol.getSequences())
265     {
266       int[] cols = getResults(s, startRes, endRes);
267       if (cols != null)
268       {
269         for (int pair = 0; pair < cols.length; pair += 2)
270         {
271           mask.set(cols[pair], cols[pair + 1] + 1);
272         }
273       }
274     }
275     // compute columns that were newly selected
276     BitSet original = (BitSet) bs.clone();
277     original.and(mask);
278     count = mask.cardinality() - original.cardinality();
279     // and mark ranges not already marked
280     bs.or(mask);
281     return count;
282   }
283
284   @Override
285   public int getSize()
286   {
287     return matches.size();
288   }
289
290   @Override
291   public boolean isEmpty()
292   {
293     return matches.isEmpty();
294   }
295
296   @Override
297   public List<SearchResultMatchI> getResults()
298   {
299     return matches;
300   }
301
302   /**
303    * Return the results as a list of matches [seq1/from-to, seq2/from-to, ...]
304    * 
305    * @return
306    */
307   @Override
308   public String toString()
309   {
310     return matches == null ? "" : matches.toString();
311   }
312
313   /**
314    * Hashcode is derived from the list of matches. This ensures that when two
315    * SearchResults objects satisfy the test for equals(), then they have the
316    * same hashcode.
317    * 
318    * @see Match#hashCode()
319    * @see java.util.AbstractList#hashCode()
320    */
321   @Override
322   public int hashCode()
323   {
324     return matches.hashCode();
325   }
326
327   /**
328    * Two SearchResults are considered equal if they contain the same matches in
329    * the same order.
330    */
331   @Override
332   public boolean equals(Object obj)
333   {
334     if (obj == null || !(obj instanceof SearchResultsI))
335     {
336       return false;
337     }
338     SearchResultsI sr = (SearchResultsI) obj;
339     return matches.equals(sr.getResults());
340   }
341
342   @Override
343   public void addSearchResults(SearchResultsI toAdd)
344   {
345     matches.addAll(toAdd.getResults());
346   }
347 }