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<SearchResultMatchI>();
  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     SequenceI sequence;
  46
  47     /**
  48      * Start position of match in sequence (base 1)
  49      */
  50     int start;
  51
  52     /**
  53      * End position (inclusive) (base 1)
  54      */
  55     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     /* (non-Javadoc)
  95      * @see jalview.datamodel.SearchResultMatchI#getSequence()
  96      */
  97     @Override
  98     public SequenceI getSequence()
  99     {
 100       return sequence;
 101     }
 102
 103     /* (non-Javadoc)
 104      * @see jalview.datamodel.SearchResultMatchI#getStart()
 105      */
 106     @Override
 107     public int getStart()
 108     {
 109       return start;
 110     }
 111
 112     /* (non-Javadoc)
 113      * @see jalview.datamodel.SearchResultMatchI#getEnd()
 114      */
 115     @Override
 116     public int getEnd()
 117     {
 118       return end;
 119     }
 120
 121     /**
 122      * Returns a representation as "seqid/start-end"
 123      */
 124     @Override
 125     public String toString()
 126     {
 127       StringBuilder sb = new StringBuilder();
 128       if (sequence != null)
 129       {
 130         sb.append(sequence.getName()).append("/");
 131       }
 132       sb.append(start).append("-").append(end);
 133       return sb.toString();
 134     }
 135
 136     public void setSequence(SequenceI seq)
 137     {
 138       this.sequence = seq;
 139     }
 140
 141     /**
 142      * Hashcode is the hashcode of the matched sequence plus a hash of start and
 143      * end positions. Match objects that pass the test for equals are guaranteed
 144      * to have the same hashcode.
 145      */
 146     @Override
 147     public int hashCode()
 148     {
 149       int hash = sequence == null ? 0 : sequence.hashCode();
 150       hash += 31 * start;
 151       hash += 67 * end;
 152       return hash;
 153     }
 154
 155     /**
 156      * Two Match objects are equal if they are for the same sequence, start and
 157      * end positions
 158      */
 159     @Override
 160     public boolean equals(Object obj)
 161     {
 162       if (obj == null || !(obj instanceof SearchResultMatchI))
 163       {
 164         return false;
 165       }
 166       SearchResultMatchI m = (SearchResultMatchI) obj;
 167       return (sequence == m.getSequence() && start == m.getStart() && end == m
 168               .getEnd());
 169     }
 170   }
 171
 172   /* (non-Javadoc)
 173    * @see jalview.datamodel.SearchResultsI#addResult(jalview.datamodel.SequenceI, int, int)
 174    */
 175   @Override
 176   public SearchResultMatchI addResult(SequenceI seq, int start, int end)
 177   {
 178     Match m = new Match(seq, start, end);
 179     matches.add(m);
 180     return m;
 181   }
 182
 183   /* (non-Javadoc)
 184    * @see jalview.datamodel.SearchResultsI#involvesSequence(jalview.datamodel.SequenceI)
 185    */
 186   @Override
 187   public boolean involvesSequence(SequenceI sequence)
 188   {
 189     SequenceI ds = sequence.getDatasetSequence();
 190     for (SearchResultMatchI _m : matches)
 191     {
 192       SequenceI matched = _m.getSequence();
 193       if (matched != null && (matched == sequence || matched == ds))
 194       {
 195         return true;
 196       }
 197     }
 198     return false;
 199   }
 200
 201   /* (non-Javadoc)
 202    * @see jalview.datamodel.SearchResultsI#getResults(jalview.datamodel.SequenceI, int, int)
 203    */
 204   @Override
 205   public int[] getResults(SequenceI sequence, int start, int end)
 206   {
 207     if (matches.isEmpty())
 208     {
 209       return null;
 210     }
 211
 212     int[] result = null;
 213     int[] tmp = null;
 214     int resultLength, matchStart = 0, matchEnd = 0;
 215     boolean mfound;
 216     Match m;
 217     for (SearchResultMatchI _m : matches)
 218     {
 219       m = (Match) _m;
 220
 221       mfound = false;
 222       if (m.sequence == sequence)
 223       {
 224         mfound = true;
 225         // locate aligned position
 226         matchStart = sequence.findIndex(m.start) - 1;
 227         matchEnd = sequence.findIndex(m.end) - 1;
 228       }
 229       else if (m.sequence == sequence.getDatasetSequence())
 230       {
 231         mfound = true;
 232         // locate region in local context
 233         matchStart = sequence.findIndex(m.start) - 1;
 234         matchEnd = sequence.findIndex(m.end) - 1;
 235       }
 236       if (mfound)
 237       {
 238         if (matchStart <= end && matchEnd >= start)
 239         {
 240           if (matchStart < start)
 241           {
 242             matchStart = start;
 243           }
 244
 245           if (matchEnd > end)
 246           {
 247             matchEnd = end;
 248           }
 249
 250           if (result == null)
 251           {
 252             result = new int[] { matchStart, matchEnd };
 253           }
 254           else
 255           {
 256             resultLength = result.length;
 257             tmp = new int[resultLength + 2];
 258             System.arraycopy(result, 0, tmp, 0, resultLength);
 259             result = tmp;
 260             result[resultLength] = matchStart;
 261             result[resultLength + 1] = matchEnd;
 262           }
 263         }
 264         else
 265         {
 266           // debug
 267           // System.err.println("Outwith bounds!" + matchStart+">"+end +"  or "
 268           // + matchEnd+"<"+start);
 269         }
 270       }
 271     }
 272     return result;
 273   }
 274
 275   @Override
 276   public int markColumns(SequenceCollectionI sqcol, BitSet bs)
 277   {
 278     int count = 0;
 279     BitSet mask = new BitSet();
 280     for (SequenceI s : sqcol.getSequences())
 281     {
 282       int[] cols = getResults(s, sqcol.getStartRes(), sqcol.getEndRes());
 283       if (cols != null)
 284       {
 285         for (int pair = 0; pair < cols.length; pair += 2)
 286         {
 287           mask.set(cols[pair], cols[pair + 1] + 1);
 288         }
 289       }
 290     }
 291     // compute columns that were newly selected
 292     BitSet original = (BitSet) bs.clone();
 293     original.and(mask);
 294     count = mask.cardinality() - original.cardinality();
 295     // and mark ranges not already marked
 296     bs.or(mask);
 297     return count;
 298   }
 299
 300   /* (non-Javadoc)
 301    * @see jalview.datamodel.SearchResultsI#getSize()
 302    */
 303   @Override
 304   public int getSize()
 305   {
 306     return matches.size();
 307   }
 308
 309   /* (non-Javadoc)
 310    * @see jalview.datamodel.SearchResultsI#isEmpty()
 311    */
 312   @Override
 313   public boolean isEmpty()
 314   {
 315     return matches.isEmpty();
 316   }
 317
 318   /* (non-Javadoc)
 319    * @see jalview.datamodel.SearchResultsI#getResults()
 320    */
 321   @Override
 322   public List<SearchResultMatchI> getResults()
 323   {
 324     return matches;
 325   }
 326
 327   /**
 328    * Return the results as a list of matches [seq1/from-to, seq2/from-to, ...]
 329    *
 330    * @return
 331    */
 332   @Override
 333   public String toString()
 334   {
 335     return matches == null ? "" : matches.toString();
 336   }
 337
 338   /**
 339    * Hashcode is derived from the list of matches. This ensures that when two
 340    * SearchResults objects satisfy the test for equals(), then they have the
 341    * same hashcode.
 342    *
 343    * @see Match#hashCode()
 344    * @see java.util.AbstractList#hashCode()
 345    */
 346   @Override
 347   public int hashCode()
 348   {
 349     return matches.hashCode();
 350   }
 351
 352   /**
 353    * Two SearchResults are considered equal if they contain the same matches in
 354    * the same order.
 355    */
 356   @Override
 357   public boolean equals(Object obj)
 358   {
 359     if (obj == null || !(obj instanceof SearchResultsI))
 360     {
 361       return false;
 362     }
 363     SearchResultsI sr = (SearchResultsI) obj;
 364     return matches.equals(sr.getResults());
 365   }
 366 }