emailsubscriptionlist.java

### File Source: emailsubscriptionlist.java

         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 org.apache.commons.logging.Log;
        35  import org.apache.commons.logging.LogFactory;
        36  import net.sourceforge.pebble.domain.Blog;
        37  import net.sourceforge.pebble.domain.Tag;
        38  import net.sourceforge.pebble.domain.BlogEntry;
        39
        40  import java.util.*;
        41  import java.io.*;
        42
        43  /**
        44   * Represents the tag index for a blog.
        45   *
        46   * @author    Simon Brown
        47   */
        48  public class EmailSubscriptionList {
        49
               /*
        P/P     *  Method: net.sourceforge.pebble.index.EmailSubscriptionList__static_init
                *
                *  Postconditions:
                *    init'ed(log)
                */
        50    private static final Log log = LogFactory.getLog(EmailSubscriptionList.class);
        51
        52    private Blog blog;
        53
        54    /** the list of e-mail addresses */
        55    private List<String> emailAddresses = new LinkedList<String>();
        56
               /*
        P/P     *  Method: void net.sourceforge.pebble.index.EmailSubscriptionList(Blog)
                *
                *  Preconditions:
                *    blog != null
                *
                *  Postconditions:
                *    this.blog == blog
                *    this.blog != null
                *    this.emailAddresses == &new LinkedList(EmailSubscriptionList#1)
                *    new LinkedList(EmailSubscriptionList#1) num objects == 1
                */
        57    public EmailSubscriptionList(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.emailAddresses == &new LinkedList(clear#1)
                  *    new LinkedList(clear#1) num objects == 1
                  */
        67      emailAddresses = new LinkedList<String>();
        68      writeIndex();
        69    }
        70
        71    /**
        72     * Adds an e-mail address.
        73     *
        74     * @param emailAddress    an e-mail address
        75     */
        76    public synchronized void addEmailAddress(String emailAddress) {
                 /*
        P/P       *  Method: void addEmailAddress(String)
                  *
                  *  Preconditions:
                  *    this.emailAddresses != null
                  *    (soft) this.blog != null
                  *
                  *  Test Vectors:
                  *    java.util.List:contains(...)@77: {1}, {0}
                  */
        77      if (!emailAddresses.contains(emailAddress)) {
        78        emailAddresses.add(emailAddress);
        79        writeIndex();
        80      }
        81    }
        82
        83    /**
        84     * Removes an e-mail address.
        85     *
        86     * @param emailAddress    an e-mail address
        87     */
        88    public synchronized void removeEmailAddress(String emailAddress) {
                 /*
        P/P       *  Method: void removeEmailAddress(String)
                  *
                  *  Preconditions:
                  *    this.emailAddresses != null
                  *    (soft) this.blog != null
                  */
        89      emailAddresses.remove(emailAddress);
        90      writeIndex();
        91    }
        92
        93    /**
        94     * Helper method to load the index.
        95     */
        96    private void readIndex() {
                 /*
        P/P       *  Method: void readIndex()
                  *
                  *  Preconditions:
                  *    this.blog != null
                  *    (soft) this.emailAddresses != null
                  *
                  *  Presumptions:
                  *    org.apache.commons.logging.LogFactory:getLog(...)@50 != null
                  *
                  *  Test Vectors:
                  *    java.io.File:exists(...)@98: {0}, {1}
                  */
        97      File indexFile = new File(blog.getIndexesDirectory(), "email-subscriptions.index");
        98      if (indexFile.exists()) {
        99        try {
       100          BufferedReader reader = new BufferedReader(new FileReader(indexFile));
       101          String emailAddress = reader.readLine();
       102          while (emailAddress != null) {
       103            emailAddresses.add(emailAddress);
       104            emailAddress = reader.readLine();
       105          }
       106
       107          reader.close();
       108        } catch (Exception e) {
       109          log.error("Error while reading index", e);
       110        }
       111      }
       112    }
       113
       114    /**
       115     * Helper method to write out the index to disk.
       116     */
       117    private void writeIndex() {
       118      try {
                   /*
        P/P         *  Method: void writeIndex()
                    *
                    *  Preconditions:
                    *    (soft) this.blog != null
                    *    (soft) this.emailAddresses != null
                    *
                    *  Presumptions:
                    *    org.apache.commons.logging.LogFactory:getLog(...)@50 != null
                    *
                    *  Test Vectors:
                    *    java.util.Iterator:hasNext(...)@122: {1}, {0}
                    */
       119        File indexFile = new File(blog.getIndexesDirectory(), "email-subscriptions.index");
       120        BufferedWriter writer = new BufferedWriter(new FileWriter(indexFile));
       121
       122        for (String emailAddress : emailAddresses) {
       123          writer.write(emailAddress);
       124          writer.newLine();
       125        }
       126
       127        writer.flush();
       128        writer.close();
       129      } catch (Exception e) {
       130        log.error("Error while writing index", e);
       131      }
       132    }
       133
       134    /**
       135     * Gets the list of e-mail addresses.
       136     */
       137    public List<String> getEmailAddresses() {
                 /*
        P/P       *  Method: List getEmailAddresses()
                  *
                  *  Preconditions:
                  *    init'ed(this.emailAddresses)
                  *
                  *  Postconditions:
                  *    return_value == &new ArrayList(getEmailAddresses#1)
                  *    new ArrayList(getEmailAddresses#1) num objects == 1
                  */
       138      List list = new ArrayList<String>(emailAddresses);
       139      Collections.sort(list);
       140      return list;
       141    }
       142
       143  }

SofCheck Inspector Build Version : 2.22510

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