searchresults.java

### File Source: searchresults.java

             /*
        P/P   *  Method: net.sourceforge.pebble.search.SearchResults__static_init
              */
         1  /*
         2   * Copyright (c) 2003-2006, Simon Brown
         3   * All rights reserved.
         4   *
         5   * Redistribution and use in source and binary forms, with or without
         6   * modification, are permitted provided that the following conditions are met:
         7   *
         8   *   - Redistributions of source code must retain the above copyright
         9   *     notice, this list of conditions and the following disclaimer.
        10   *
        11   *   - Redistributions in binary form must reproduce the above copyright
        12   *     notice, this list of conditions and the following disclaimer in
        13   *     the documentation and/or other materials provided with the
        14   *     distribution.
        15   *
        16   *   - Neither the name of Pebble nor the names of its contributors may
        17   *     be used to endorse or promote products derived from this software
        18   *     without specific prior written permission.
        19   *
        20   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
        21   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
        22   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
        23   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
        24   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
        25   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
        26   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
        27   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
        28   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
        29   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
        30   * POSSIBILITY OF SUCH DAMAGE.
        31   */
        32  package net.sourceforge.pebble.search;
        33
        34  import net.sourceforge.pebble.comparator.SearchHitByDateComparator;
        35  import net.sourceforge.pebble.comparator.SearchHitByScoreComparator;
        36  import net.sourceforge.pebble.util.StringUtils;
        37
        38  import java.util.ArrayList;
        39  import java.util.Collections;
        40  import java.util.Iterator;
        41  import java.util.List;
        42
        43  /**
        44   * A container for the results (hits) of a search.
        45   *
        46   * @author    Simon Brown
        47   */
             /*
        P/P   *  Method: void net.sourceforge.pebble.search.SearchResults()
              *
              *  Postconditions:
              *    this.hits == &new ArrayList(SearchResults#1)
              *    new ArrayList(SearchResults#1) num objects == 1
              */
        48  public class SearchResults {
        49
        50    /** the original query */
        51    private String query;
        52
        53    /** an optional message */
        54    private String message;
        55
        56    /** the collection of search results */
        57    private List hits = new ArrayList();
        58
        59    /**
        60     * Gets the query that was used to generate these results.
        61     *
        62     * @return  the original query
        63     */
        64    public String getQuery() {
                 /*
        P/P       *  Method: String getQuery()
                  *
                  *  Preconditions:
                  *    init'ed(this.query)
                  *
                  *  Postconditions:
                  *    return_value == this.query
                  *    init'ed(return_value)
                  */
        65      return this.query;
        66    }
        67
        68    /**
        69     * Sets the query that was used to generate these results.
        70     *
        71     * @param s   the original query
        72     */
        73    public void setQuery(String s) {
                 /*
        P/P       *  Method: void setQuery(String)
                  *
                  *  Postconditions:
                  *    init'ed(this.query)
                  */
        74      this.query = StringUtils.transformHTML(s);
        75    }
        76
        77    /**
        78     * Gets the message associated with these results. This may contain
        79     * information or an error message.
        80     *
        81     * @return  the message (can be null)
        82     */
        83    public String getMessage() {
                 /*
        P/P       *  Method: String getMessage()
                  *
                  *  Preconditions:
                  *    init'ed(this.message)
                  *
                  *  Postconditions:
                  *    return_value == this.message
                  *    init'ed(return_value)
                  */
        84      return this.message;
        85    }
        86
        87    /**
        88     * Gets the message associated with these results. This may contain
        89     * information or an error message.
        90     *
        91     * @param s   the message (can be null)
        92     */
        93    public void setMessage(String s) {
                 /*
        P/P       *  Method: void setMessage(String)
                  *
                  *  Postconditions:
                  *    this.message == s
                  *    init'ed(this.message)
                  */
        94      this.message = s;
        95    }
        96
        97    /**
        98     * Adds a hit to the collection of hits.
        99     *
       100     * @param hit   a SearchHit instance
       101     */
       102    public void add(SearchHit hit) {
                 /*
        P/P       *  Method: void add(SearchHit)
                  *
                  *  Preconditions:
                  *    this.hits != null
                  */
       103      hits.add(hit);
       104    }
       105
       106    /**
       107     * Gets the number of hits that the query returned.
       108     *
       109     * @return  the number of hits as an int
       110     */
       111    public int getNumberOfHits() {
                 /*
        P/P       *  Method: int getNumberOfHits()
                  *
                  *  Preconditions:
                  *    this.hits != null
                  *
                  *  Postconditions:
                  *    init'ed(return_value)
                  */
       112      return hits.size();
       113    }
       114
       115    /**
       116     * Gets a collection containing all of the hits.
       117     *
       118     * @return  a Collection of SearchHit instances
       119     */
       120    public List getHits() {
                 /*
        P/P       *  Method: List getHits()
                  *
                  *  Preconditions:
                  *    init'ed(this.hits)
                  *
                  *  Postconditions:
                  *    return_value == this.hits
                  *    init'ed(return_value)
                  */
       121      return this.hits;
       122    }
       123
       124    /**
       125     * Sorts the search results by score, in reverse order.
       126     */
       127    public void sortByScoreDescending() {
                 /*
        P/P       *  Method: void sortByScoreDescending()
                  *
                  *  Preconditions:
                  *    this.hits != null
                  *
                  *  Presumptions:
                  *    java.util.Iterator:next(...)@133 != null
                  *
                  *  Test Vectors:
                  *    java.util.Iterator:hasNext(...)@132: {1}, {0}
                  */
       128      Collections.sort(hits, new SearchHitByScoreComparator());
       129
       130      int number = 1;
       131      Iterator it = hits.iterator();
       132      while (it.hasNext()) {
       133        SearchHit hit = (SearchHit)it.next();
       134        hit.setNumber(number);
       135        number++;
       136      }
       137    }
       138
       139    /**
       140     * Sorts the search results by date, in reverse order.
       141     */
       142    public void sortByDateDescending() {
                 /*
        P/P       *  Method: void sortByDateDescending()
                  *
                  *  Preconditions:
                  *    this.hits != null
                  *
                  *  Presumptions:
                  *    java.util.Iterator:next(...)@148 != null
                  *
                  *  Test Vectors:
                  *    java.util.Iterator:hasNext(...)@147: {1}, {0}
                  */
       143      Collections.sort(hits, new SearchHitByDateComparator());
       144
       145      int number = 1;
       146      Iterator it = hits.iterator();
       147      while (it.hasNext()) {
       148        SearchHit hit = (SearchHit)it.next();
       149        hit.setNumber(number);
       150        number++;
       151      }
       152    }
       153
       154  }

SofCheck Inspector Build Version : 2.22510

searchresults.java | 2010-Jun-25 19:40:32
searchresults.class | 2010-Jul-19 20:23:38