log.java

### File Source: log.java

             /*
        P/P   *  Method: net.sourceforge.pebble.logging.Log__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.logging;
        33
        34  import net.sourceforge.pebble.domain.Blog;
        35
        36  import java.util.*;
        37
        38  /**
        39   * Represents a log, containing log entries.
        40   *
        41   * @author    Simon Brown
        42   */
        43  public class Log {
        44
        45    /** the blog that this instance is associated with */
        46    protected Blog blog;
        47
        48    /** the collection of log entries */
        49    private Collection<LogEntry> logEntries;
        50
        51    /**
        52     * Creates a new log associated with the given blog.
        53     *
        54     * @param blog          a Blog instance
        55     * @param entries       a Collection of LogEntry objects
        56     */
               /*
        P/P     *  Method: void net.sourceforge.pebble.logging.Log(Blog, Collection)
                *
                *  Postconditions:
                *    this.blog == blog
                *    init'ed(this.blog)
                *    this.logEntries == One-of{entries, &new ArrayList(Log#1)}
                *    this.logEntries != null
                *    new ArrayList(Log#1) num objects <= 1
                *
                *  Test Vectors:
                *    entries: Inverse{null}, Addr_Set{null}
                */
        57    Log(Blog blog, Collection<LogEntry> entries) {
        58      this.blog = blog;
        59      this.logEntries = entries;
        60
        61      if (logEntries == null) {
        62        logEntries = new ArrayList<LogEntry>();
        63      }
        64    }
        65
        66    /**
        67     * Gets all log entries..
        68     *
        69     * @return    a collection of LogEntry instances
        70     */
        71    public Collection<LogEntry> getLogEntries() {
                 /*
        P/P       *  Method: Collection getLogEntries()
                  *
                  *  Preconditions:
                  *    init'ed(this.logEntries)
                  *
                  *  Postconditions:
                  *    init'ed(return_value)
                  */
        72      return Collections.unmodifiableCollection(logEntries);
        73    }
        74
        75    /**
        76     * Gets a list of referers.
        77     *
        78     * @return    a Collection of Referer instances
        79     */
        80    public Collection<Referer> getReferers() {
                 /*
        P/P       *  Method: Collection getReferers()
                  *
                  *  Preconditions:
                  *    this.logEntries != null
                  *
                  *  Presumptions:
                  *    java.util.Iterator:next(...)@82 != null
                  *    referer.logEntries@83 != null
                  *    referer.logEntries@86 != null
                  *
                  *  Postconditions:
                  *    init'ed(return_value)
                  *
                  *  Test Vectors:
                  *    java.util.Iterator:hasNext(...)@82: {1}, {0}
                  *    java.util.Map:get(...)@83: Inverse{null}, Addr_Set{null}
                  */
        81      Map<String,Referer> refererMap = new HashMap<String,Referer>();
        82      for (LogEntry logEntry : logEntries) {
        83        Referer referer = refererMap.get(logEntry.getReferer());
        84        if (referer == null) {
        85          referer = new Referer(logEntry.getReferer());
        86          refererMap.put(referer.getName(), referer);
        87        }
        88
        89        referer.addLogEntry(logEntry);
        90      }
        91      return refererMap.values();
        92    }
        93
        94    /**
        95     * Gets a list of referers.
        96     *
        97     * @return    a Collection of Request instances
        98     */
        99    public Collection<Request> getRequests() {
                 /*
        P/P       *  Method: Collection getRequests()
                  *
                  *  Preconditions:
                  *    this.logEntries != null
                  *    (soft) init'ed(this.blog)
                  *
                  *  Presumptions:
                  *    java.util.Iterator:next(...)@101 != null
                  *    logEntry.request@101 != null
                  *    logEntry.request@102 != null
                  *    logEntry.request@104 != null
                  *    request.logEntries@102 != null
                  *    ...
                  *
                  *  Postconditions:
                  *    init'ed(return_value)
                  *
                  *  Test Vectors:
                  *    java.util.Iterator:hasNext(...)@101: {1}, {0}
                  *    java.util.Map:get(...)@102: Inverse{null}, Addr_Set{null}
                  */
       100      Map<String,Request> requestMap = new HashMap<String,Request>();
       101      for (LogEntry logEntry : logEntries) {
       102        Request request = requestMap.get(logEntry.getRequestUri());
       103        if (request == null) {
       104          request = new Request(logEntry.getRequestUri(), blog);
       105          requestMap.put(logEntry.getRequestUri(), request);
       106        }
       107        request.addLogEntry(logEntry);
       108      }
       109      return requestMap.values();
       110    }
       111
       112    /**
       113     * Gets the total number of entries.
       114     *
       115     * @return  the total number as an int
       116     */
       117    public int getTotalLogEntries() {
                 /*
        P/P       *  Method: int getTotalLogEntries()
                  *
                  *  Preconditions:
                  *    this.logEntries != null
                  *
                  *  Postconditions:
                  *    init'ed(return_value)
                  */
       118      return logEntries.size();
       119    }
       120
       121    /**
       122     * Adds an entry to this log.
       123     *
       124     * @param logEntry    a LogEntry instance
       125     */
       126    void addLogEntry(LogEntry logEntry) {
                 /*
        P/P       *  Method: void addLogEntry(LogEntry)
                  *
                  *  Preconditions:
                  *    this.logEntries != null
                  */
       127      logEntries.add(logEntry);
       128    }
       129
       130    /**
       131     * Adds a collection of entries to this log.
       132     *
       133     * @param entries   a Collection of LogEntry instances
       134     */
       135    void addLogEntries(Collection<LogEntry> entries) {
                 /*
        P/P       *  Method: void addLogEntries(Collection)
                  *
                  *  Preconditions:
                  *    this.logEntries != null
                  */
       136      logEntries.addAll(entries);
       137    }
       138
       139  }

SofCheck Inspector Build Version : 2.22510

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