/* 
    P/P   *  Method: net.sourceforge.pebble.index.IndexedTag__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.index;
    33  
    34  import net.sourceforge.pebble.domain.Blog;
    35  import net.sourceforge.pebble.domain.Tag;
    36  import net.sourceforge.pebble.comparator.ReverseBlogEntryIdComparator;
    37  
    38  import java.util.ArrayList;
    39  import java.util.List;
    40  import java.util.Collections;
    41  
    42  /**
    43   * Represents a tag.
    44   *
    45   * @author    Simon Brown
    46   */
    47  public class IndexedTag extends Tag {
    48  
    49    /** the blog entries associated with this tag */
    50    private List<String> blogEntries = new ArrayList<String>();
    51  
    52    /**
    53     * Creates a new tag with the specified properties.
    54     *
    55     * @param name    the name
    56     * @param blog    a Blog instance
    57     */
    58    public IndexedTag(String name, Blog blog) {
             /* 
    P/P       *  Method: void net.sourceforge.pebble.index.IndexedTag(String, Blog)
              * 
              *  Postconditions:
              *    this.blog == blog
              *    init'ed(this.blog)
              *    this.blogEntries == &new ArrayList(IndexedTag#1)
              *    this.name != null
              *    new ArrayList(IndexedTag#1) num objects == 1
              */
    59      super(name, blog);
    60    }
    61  
    62    /**
    63     * Gets the blog entries associated with this tag.
    64     *
    65     * @return  a Collection of BlogEntry instances
    66     */
    67    public List<String> getBlogEntries() {
             /* 
    P/P       *  Method: List getBlogEntries()
              * 
              *  Preconditions:
              *    init'ed(this.blogEntries)
              * 
              *  Postconditions:
              *    return_value == &new ArrayList(getBlogEntries#1)
              *    new ArrayList(getBlogEntries#1) num objects == 1
              */
    68      return new ArrayList<String>(blogEntries);
    69    }
    70  
    71    /**
    72     * Adds a blog entry to this tag.
    73     *
    74     * @param blogEntryId   a blog entry ID
    75     */
    76    public synchronized void addBlogEntry(String blogEntryId) {
             /* 
    P/P       *  Method: void addBlogEntry(String)
              * 
              *  Preconditions:
              *    (soft) this.blogEntries != null
              * 
              *  Test Vectors:
              *    blogEntryId: Addr_Set{null}, Inverse{null}
              *    java.util.List:contains(...)@77: {1}, {0}
              */
    77      if (blogEntryId != null && !blogEntries.contains(blogEntryId)) {
    78        blogEntries.add(blogEntryId);
    79        Collections.sort(blogEntries, new ReverseBlogEntryIdComparator());
    80      }
    81    }
    82  
    83    /**
    84     * Removes a blog entry to this tag.
    85     *
    86     * @param blogEntryId   a blog entry ID
    87     */
    88    public synchronized void removeBlogEntry(String blogEntryId) {
             /* 
    P/P       *  Method: void removeBlogEntry(String)
              * 
              *  Preconditions:
              *    (soft) this.blogEntries != null
              * 
              *  Test Vectors:
              *    blogEntryId: Addr_Set{null}, Inverse{null}
              */
    89      if (blogEntryId != null) {
    90        blogEntries.remove(blogEntryId);
    91      }
    92    }
    93  
    94    /**
    95     * Gets the number of blog entries associated with this tag.
    96     *
    97     * @return  an int
    98     */
    99    public int getNumberOfBlogEntries() {
             /* 
    P/P       *  Method: int getNumberOfBlogEntries()
              * 
              *  Preconditions:
              *    this.blogEntries != null
              * 
              *  Postconditions:
              *    init'ed(return_value)
              */
   100      return blogEntries.size();
   101    }
   102  
   103    /**
   104     * Gets the rank for this tag.
   105     *
   106     * @return  an int between 1 and 10;
   107     */
   108    public int getRank() {
             /* 
    P/P       *  Method: int getRank()
              * 
              *  Preconditions:
              *    init'ed(this.rank)
              * 
              *  Postconditions:
              *    return_value == this.rank
              *    init'ed(return_value)
              */
   109      return this.rank;
   110    }
   111  
   112    /**
   113     * Sets the rank for this tag.
   114     *
   115     */
   116    void calculateRank(int[] thresholds) {
             /* 
    P/P       *  Method: void calculateRank(int[])
              * 
              *  Preconditions:
              *    thresholds != null
              *    (soft) this.blogEntries != null
              *    (soft) thresholds.length <= 232-1
              *    (soft) init'ed(thresholds[...])
              * 
              *  Postconditions:
              *    possibly_updated(this.rank)
              */
   117      for (int i = 0; i < thresholds.length; i++) {
   118        int numberOfBlogEntries = getNumberOfBlogEntries();
   119        if (numberOfBlogEntries <= thresholds[i]) {
   120          this.rank = i+1;
   121          return;
   122        }
   123      }
   124    }
   125  
   126  }