/* 
    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  }