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.comparator.ReverseBlogEntryIdComparator;
    35  import net.sourceforge.pebble.domain.Blog;
    36  import net.sourceforge.pebble.domain.BlogEntry;
    37  import org.apache.commons.logging.Log;
    38  import org.apache.commons.logging.LogFactory;
    39  
    40  import java.io.*;
    41  import java.util.*;
    42  
    43  /**
    44   * Keeps an index of all blog entries from a specific author, allowing efficient access at runtime.
    45   *
    46   * @author    Simon Brown
    47   */
    48  public class AuthorIndex {
    49  
           /* 
    P/P     *  Method: net.sourceforge.pebble.index.AuthorIndex__static_init
            * 
            *  Postconditions:
            *    init'ed(log)
            */
    50    private static final Log log = LogFactory.getLog(AuthorIndex.class);
    51  
    52    private Blog blog;
    53  
    54    /** the map containing the tags */
    55    private Map<String,List<String>> authors = new HashMap<String,List<String>>();
    56  
           /* 
    P/P     *  Method: void net.sourceforge.pebble.index.AuthorIndex(Blog)
            * 
            *  Preconditions:
            *    blog != null
            * 
            *  Postconditions:
            *    this.authors == &new HashMap(AuthorIndex#1)
            *    this.blog == blog
            *    this.blog != null
            *    new HashMap(AuthorIndex#1) num objects == 1
            */
    57    public AuthorIndex(Blog blog) {
    58      this.blog = blog;
    59  
    60      readIndex();
    61    }
    62  
    63    /**
    64     * Clears the index.
    65     */
    66    public void clear() {
             /* 
    P/P       *  Method: void clear()
              * 
              *  Preconditions:
              *    (soft) this.blog != null
              * 
              *  Postconditions:
              *    this.authors == &new HashMap(clear#1)
              *    new HashMap(clear#1) num objects == 1
              */
    67      authors = new HashMap<String,List<String>>();
    68      writeIndex();
    69    }
    70  
    71    /**
    72     * Indexes one or more blog entries.
    73     *
    74     * @param blogEntries   a List of BlogEntry instances
    75     */
    76    public synchronized void index(Collection<BlogEntry> blogEntries) {
             /* 
    P/P       *  Method: void index(Collection)
              * 
              *  Preconditions:
              *    blogEntries != null
              *    (soft) net.sourceforge.pebble.domain.State__static_init.new State(State__static_init#5).name != null
              *    (soft) this.authors != null
              *    (soft) this.blog != null
              * 
              *  Presumptions:
              *    blogEntry.state@77 != null
              *    java.util.Iterator:next(...)@77 != null
              * 
              *  Test Vectors:
              *    java.util.Iterator:hasNext(...)@77: {1}, {0}
              */
    77      for (BlogEntry blogEntry : blogEntries) {
    78        if (blogEntry.isPublished()) {
    79          List<String> blogEntryIds = getBlogEntries(blogEntry.getAuthor());
    80          blogEntryIds.add(blogEntry.getId());
    81          Collections.sort(blogEntryIds, new ReverseBlogEntryIdComparator());
    82        }
    83      }
    84  
    85      writeIndex();
    86    }
    87  
    88    /**
    89     * Indexes a single blog entry.
    90     *
    91     * @param blogEntry   a BlogEntry instance
    92     */
    93    public synchronized void index(BlogEntry blogEntry) {
             /* 
    P/P       *  Method: void index(BlogEntry)
              * 
              *  Preconditions:
              *    blogEntry != null
              *    blogEntry.state != null
              *    (soft) init'ed(blogEntry.author)
              *    (soft) init'ed(blogEntry.id)
              *    (soft) init'ed(blogEntry.state.name)
              *    (soft) net.sourceforge.pebble.domain.State__static_init.new State(State__static_init#5).name != null
              *    (soft) this.authors != null
              *    (soft) this.blog != null
              */
    94      if (blogEntry.isPublished()) {
    95        List<String> blogEntryIds = getBlogEntries(blogEntry.getAuthor());
    96        blogEntryIds.add(blogEntry.getId());
    97        Collections.sort(blogEntryIds, new ReverseBlogEntryIdComparator());
    98  
    99        writeIndex();
   100      }
   101    }
   102  
   103    /**
   104     * Unindexes a single blog entry.
   105     *
   106     * @param blogEntry   a BlogEntry instance
   107     */
   108    public synchronized void unindex(BlogEntry blogEntry) {
             /* 
    P/P       *  Method: void unindex(BlogEntry)
              * 
              *  Preconditions:
              *    blogEntry != null
              *    init'ed(blogEntry.author)
              *    this.authors != null
              *    (soft) init'ed(blogEntry.id)
              *    (soft) this.blog != null
              * 
              *  Test Vectors:
              *    java.util.List:isEmpty(...)@113: {0}, {1}
              *    java.util.Map:get(...)@109: Addr_Set{null}, Inverse{null}
              */
   109      List<String> blogEntries = authors.get(blogEntry.getAuthor());
   110      if (blogEntries != null) {
   111        blogEntries.remove(blogEntry.getId());
   112  
   113        if (blogEntries.isEmpty()) {
   114          authors.remove(blogEntry.getAuthor());
   115        }
   116      }
   117  
   118      writeIndex();
   119    }
   120  
   121    /**
   122     * Helper method to load the index.
   123     */
   124    private void readIndex() {
             /* 
    P/P       *  Method: void readIndex()
              * 
              *  Preconditions:
              *    this.blog != null
              *    (soft) this.authors != null
              * 
              *  Presumptions:
              *    blogEntryIds.length@136 <= 232-1
              *    org.apache.commons.logging.LogFactory:getLog(...)@50 != null
              *    tuple.length@131 >= 1
              * 
              *  Test Vectors:
              *    java.io.File:exists(...)@126: {0}, {1}
              *    tuple.length@131: {1}, {2..+Inf}
              *    tuple[1]@131: Addr_Set{null}, Inverse{null}
              */
   125      File indexFile = new File(blog.getIndexesDirectory(), "authors.index");
   126      if (indexFile.exists()) {
   127        try {
   128          BufferedReader reader = new BufferedReader(new FileReader(indexFile));
   129          String indexEntry = reader.readLine();
   130          while (indexEntry != null) {
   131            String[] tuple = indexEntry.split("=");
   132            String author = tuple[0];
   133            List<String> blogEntries = getBlogEntries(author);
   134  
   135            if (tuple.length > 1 && tuple[1] != null) {
   136              String[] blogEntryIds = tuple[1].split(",");
   137              for (String blogEntry : blogEntryIds) {
   138                blogEntries.add(blogEntry);
   139              }
   140            }
   141  
   142            indexEntry = reader.readLine();
   143          }
   144  
   145          reader.close();
   146        } catch (Exception e) {
   147          log.error("Error while reading index", e);
   148        }
   149      }
   150    }
   151  
   152    /**
   153     * Helper method to write out the index to disk.
   154     */
   155    private void writeIndex() {
   156      try {
               /* 
    P/P         *  Method: void writeIndex()
                * 
                *  Preconditions:
                *    (soft) this.authors != null
                *    (soft) this.blog != null
                * 
                *  Presumptions:
                *    java.util.Map:keySet(...)@160 != null
                *    org.apache.commons.logging.LogFactory:getLog(...)@50 != null
                * 
                *  Test Vectors:
                *    java.util.Iterator:hasNext(...)@160: {1}, {0}
                *    java.util.Iterator:hasNext(...)@165: {1}, {0}
                *    java.util.Map:get(...)@163: Addr_Set{null}, Inverse{null}
                */
   157        File indexFile = new File(blog.getIndexesDirectory(), "authors.index");
   158        BufferedWriter writer = new BufferedWriter(new FileWriter(indexFile));
   159  
   160        for (String author : authors.keySet()) {
   161          writer.write(author);
   162          writer.write("=");
   163          List<String> blogEntries = authors.get(author);
   164          if (blogEntries != null) {
   165            for (String blogEntry : blogEntries) {
   166              writer.write(blogEntry);
   167              writer.write(",");
   168            }
   169          }
   170          writer.newLine();
   171        }
   172  
   173        writer.flush();
   174        writer.close();
   175      } catch (Exception e) {
   176        log.error("Error while writing index", e);
   177      }
   178    }
   179  
   180    private synchronized List<String> getBlogEntries(String author) {
             /* 
    P/P       *  Method: List getBlogEntries(String)
              * 
              *  Preconditions:
              *    this.authors != null
              * 
              *  Postconditions:
              *    return_value != null
              *    new LinkedList(getBlogEntries#1) num objects <= 1
              * 
              *  Test Vectors:
              *    java.util.Map:get(...)@181: Inverse{null}, Addr_Set{null}
              */
   181      List<String> blogEntries = authors.get(author);
   182      if (blogEntries == null) {
   183        blogEntries = new LinkedList<String>();
   184        authors.put(author, blogEntries);
   185      }
   186  
   187      return blogEntries;
   188    }
   189  
   190    /**
   191     * Gets the list of authors associated with this blog.
   192     */
   193    public List<String> getAuthors() {
             /* 
    P/P       *  Method: List getAuthors()
              * 
              *  Preconditions:
              *    this.authors != null
              * 
              *  Postconditions:
              *    return_value == &new LinkedList(getAuthors#1)
              *    new LinkedList(getAuthors#1) num objects == 1
              */
   194      return new LinkedList<String>(authors.keySet());
   195    }
   196  
   197    /**
   198     * Gets the blog entries for a given author.
   199     *
   200     * @param username    a username (String)
   201     * @return  a List of blog entry IDs
   202     */
   203    public List<String> getRecentBlogEntries(String username) {
             /* 
    P/P       *  Method: List getRecentBlogEntries(String)
              * 
              *  Preconditions:
              *    this.authors != null
              * 
              *  Postconditions:
              *    return_value in Addr_Set{&new LinkedList(getRecentBlogEntries#2),&new LinkedList(getRecentBlogEntries#1)}
              *    new LinkedList(getRecentBlogEntries#1) num objects <= 1
              *    new LinkedList(getRecentBlogEntries#2) num objects <= 1
              * 
              *  Test Vectors:
              *    java.util.Map:get(...)@204: Inverse{null}, Addr_Set{null}
              */
   204      List<String> blogEntries = authors.get(username);
   205      if (blogEntries == null) {
   206        return new LinkedList<String>();
   207      } else {
   208        return new LinkedList<String>(blogEntries);
   209      }
   210    }
   211  
   212  }