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