Coverage Report

Coverage Report - net.sourceforge.pebble.domain.ResponseManager

Classes in this File

Line Coverage

Branch Coverage

Complexity

ResponseManager

0/69

0/12

1.273

 /*
  * Copyright (c) 2003-2011, Simon Brown
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *   - Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  *
  *   - Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in
  *     the documentation and/or other materials provided with the
  *     distribution.
  *
  *   - Neither the name of Pebble nor the names of its contributors may
  *     be used to endorse or promote products derived from this software
  *     without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 package net.sourceforge.pebble.domain;
 
 import net.sourceforge.pebble.comparator.ResponseByDateComparator;
 import net.sourceforge.pebble.api.event.comment.CommentEvent;
 import net.sourceforge.pebble.api.event.comment.CommentListener;
 import net.sourceforge.pebble.api.event.trackback.TrackBackEvent;
 import net.sourceforge.pebble.api.event.trackback.TrackBackListener;
 
 import java.util.*;
 
 /**
  * Internal comment and TrackBack listener used to manage the list of
  * responses for the associated blog.
  *
  * @author    Simon Brown
  */
 public class ResponseManager implements CommentListener, TrackBackListener {
 
   /** the owning blog */
   private Blog blog;
 
   /** the set of recent comments */
   private SortedSet recentComments;
 
   /** the set of recent TrackBacks */
   private SortedSet recentTrackBacks;
 
   /** the set of recent responses (comments and TrackBacks) */
   private SortedSet approvedResponses;
 
   /** the set of pending responses (comments and TrackBacks) */
   private SortedSet pendingResponses;
 
   /** the set of rejected responses (comments and TrackBacks) */
   private SortedSet rejectedResponses;
 
   /**
    * Creates a new instance associated with the specified blog.
    *
    * @param blog    a Blog instance
    */
   public ResponseManager(Blog blog) {
     this.blog = blog;
 
     recentComments = new TreeSet(new ResponseByDateComparator());
     recentTrackBacks = new TreeSet(new ResponseByDateComparator());
     approvedResponses = new TreeSet(new ResponseByDateComparator());
     pendingResponses = new TreeSet(new ResponseByDateComparator());
     rejectedResponses = new TreeSet(new ResponseByDateComparator());
   }
 
   /**
    * Gets recent comments.
    *
    * @return  a collection containing comments that have been left most recently
    */
   public Collection getRecentComments() {
     return this.recentComments;
   }
 
   /**
    * Gets recent TrackBacks.
    *
    * @return  a collection containing TrackBacks that have been left most recently
    */
   public Collection getRecentTrackBacks() {
     return this.recentTrackBacks;
   }
 
   /**
    * Gets recent responses (combined comments and TrackBacks).
    *
    * @return  a collection containing comments and TrackBacks that have been left
    *          most recently
    */
   public Collection getRecentResponses() {
     List list = new ArrayList();
     list.addAll(approvedResponses);
     return list;
   }
 
   /**
    * Gets the number of approved responses.
    *
    * @return  an int
    */
   public int getNumberOfApprovedResponses() {
     return approvedResponses.size();
   }
 
   /**
    * Gets pending responses (combined comments and TrackBacks).
    *
    * @return  a collection containing comments and TrackBacks that are pending
    */
   public Collection getPendingResponses() {
     List list = new ArrayList();
     list.addAll(pendingResponses);
     return list;
   }
 
   /**
    * Gets the number of pending responses.
    *
    * @return  an int
    */
   public int getNumberOfPendingResponses() {
     return pendingResponses.size();
   }
 
   /**
    * Gets rejected responses (combined comments and TrackBacks).
    *
    * @return  a collection containing comments and TrackBacks that are rejected
    */
   public Collection getRejectedResponses() {
     List list = new ArrayList();
     list.addAll(rejectedResponses);
     return list;
   }
 
   /**
    * Gets the number of rejected responses.
    *
    * @return  an int
    */
   public int getNumberOfRejectedResponses() {
     return rejectedResponses.size();
   }
 
   /**
    * Called when a comment has been added.
    *
    * @param comment   a Comment instance
    */
   synchronized void addRecentComment(Comment comment) {
     if (comment.isApproved()) {
       recentComments.add(comment);
       approvedResponses.add(comment);
     } else if (comment.isPending()) {
       pendingResponses.add(comment);
     } else if (comment.isRejected()) {
       rejectedResponses.add(comment);
     }
   }
 
   /**
    * Called when a comment has been removed.
    *
    * @param comment   a Comment instance
    */
   synchronized void removeRecentComment(Comment comment) {
     recentComments.remove(comment);
     approvedResponses.remove(comment);
     pendingResponses.remove(comment);
     rejectedResponses.remove(comment);
   }
 
   /**
    * Called when a TrackBack has been added.
    *
    * @param trackBack   a TrackBack instance
    */
   synchronized void addRecentTrackBack(TrackBack trackBack) {
     if (trackBack.isApproved()) {
       recentTrackBacks.add(trackBack);
       approvedResponses.add(trackBack);
     } else if (trackBack.isPending()) {
       pendingResponses.add(trackBack);
     } else if (trackBack.isRejected()) {
       rejectedResponses.add(trackBack);
     }
   }
 
   /**
    * Called when a TrackBack has been removed.
    *
    * @param trackBack   a TrackBack instance
    */
   synchronized void removeRecentTrackBack(TrackBack trackBack) {
     recentTrackBacks.remove(trackBack);
     approvedResponses.remove(trackBack);
     pendingResponses.remove(trackBack);
     rejectedResponses.remove(trackBack);
   }
 
   /**
    * Called when a comment has been added.
    *
    * @param event a CommentEvent instance
    */
   public void commentAdded(CommentEvent event) {
     addRecentComment(event.getComment());
   }
 
   /**
    * Called when a comment has been removed.
    *
    * @param event a CommentEvent instance
    */
   public void commentRemoved(CommentEvent event) {
     removeRecentComment(event.getComment());
   }
 
   /**
    * Called when a comment has been approved.
    *
    * @param event a CommentEvent instance
    */
   public void commentApproved(CommentEvent event) {
     removeRecentComment(event.getComment());
     addRecentComment(event.getComment());
   }
 
   /**
    * Called when a comment has been rejected.
    *
    * @param event a CommentEvent instance
    */
   public void commentRejected(CommentEvent event) {
     removeRecentComment(event.getComment());
     addRecentComment(event.getComment());
   }
 
   /**
    * Called when a TrackBack has been added.
    *
    * @param event a TrackBackEvent instance
    */
   public void trackBackAdded(TrackBackEvent event) {
     addRecentTrackBack(event.getTrackBack());
   }
 
   /**
    * Called when a TrackBack has been removed.
    *
    * @param event a TrackBackEvent instance
    */
   public void trackBackRemoved(TrackBackEvent event) {
     removeRecentTrackBack(event.getTrackBack());
   }
 
   /**
    * Called when a TrackBack has been approved.
    *
    * @param event a TrackBackEvent instance
    */
   public void trackBackApproved(TrackBackEvent event) {
     removeRecentTrackBack(event.getTrackBack());
     addRecentTrackBack(event.getTrackBack());
   }
 
   /**
    * Called when a TrackBack has been rejected.
    *
    * @param event a TrackBackEvent instance
    */
   public void trackBackRejected(TrackBackEvent event) {
     removeRecentTrackBack(event.getTrackBack());
     addRecentTrackBack(event.getTrackBack());
   }
 
   /**
    * Gets the number of responses.
    */
   public int getNumberOfResponses() {
     return approvedResponses.size() + pendingResponses.size() + rejectedResponses.size();
   }
 
 }

1		/*
2		* Copyright (c) 2003-2011, 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.domain;
33
34		import net.sourceforge.pebble.comparator.ResponseByDateComparator;
35		import net.sourceforge.pebble.api.event.comment.CommentEvent;
36		import net.sourceforge.pebble.api.event.comment.CommentListener;
37		import net.sourceforge.pebble.api.event.trackback.TrackBackEvent;
38		import net.sourceforge.pebble.api.event.trackback.TrackBackListener;
39
40		import java.util.*;
41
42		/**
43		* Internal comment and TrackBack listener used to manage the list of
44		* responses for the associated blog.
45		*
46		* @author Simon Brown
47		*/
48		public class ResponseManager implements CommentListener, TrackBackListener {
49
50		/** the owning blog */
51		private Blog blog;
52
53		/** the set of recent comments */
54		private SortedSet recentComments;
55
56		/** the set of recent TrackBacks */
57		private SortedSet recentTrackBacks;
58
59		/** the set of recent responses (comments and TrackBacks) */
60		private SortedSet approvedResponses;
61
62		/** the set of pending responses (comments and TrackBacks) */
63		private SortedSet pendingResponses;
64
65		/** the set of rejected responses (comments and TrackBacks) */
66		private SortedSet rejectedResponses;
67
68		/**
69		* Creates a new instance associated with the specified blog.
70		*
71		* @param blog a Blog instance
72		*/
73	0	public ResponseManager(Blog blog) {
74	0	this.blog = blog;
75
76	0	recentComments = new TreeSet(new ResponseByDateComparator());
77	0	recentTrackBacks = new TreeSet(new ResponseByDateComparator());
78	0	approvedResponses = new TreeSet(new ResponseByDateComparator());
79	0	pendingResponses = new TreeSet(new ResponseByDateComparator());
80	0	rejectedResponses = new TreeSet(new ResponseByDateComparator());
81	0	}
82
83		/**
84		* Gets recent comments.
85		*
86		* @return a collection containing comments that have been left most recently
87		*/
88		public Collection getRecentComments() {
89	0	return this.recentComments;
90		}
91
92		/**
93		* Gets recent TrackBacks.
94		*
95		* @return a collection containing TrackBacks that have been left most recently
96		*/
97		public Collection getRecentTrackBacks() {
98	0	return this.recentTrackBacks;
99		}
100
101		/**
102		* Gets recent responses (combined comments and TrackBacks).
103		*
104		* @return a collection containing comments and TrackBacks that have been left
105		* most recently
106		*/
107		public Collection getRecentResponses() {
108	0	List list = new ArrayList();
109	0	list.addAll(approvedResponses);
110	0	return list;
111		}
112
113		/**
114		* Gets the number of approved responses.
115		*
116		* @return an int
117		*/
118		public int getNumberOfApprovedResponses() {
119	0	return approvedResponses.size();
120		}
121
122		/**
123		* Gets pending responses (combined comments and TrackBacks).
124		*
125		* @return a collection containing comments and TrackBacks that are pending
126		*/
127		public Collection getPendingResponses() {
128	0	List list = new ArrayList();
129	0	list.addAll(pendingResponses);
130	0	return list;
131		}
132
133		/**
134		* Gets the number of pending responses.
135		*
136		* @return an int
137		*/
138		public int getNumberOfPendingResponses() {
139	0	return pendingResponses.size();
140		}
141
142		/**
143		* Gets rejected responses (combined comments and TrackBacks).
144		*
145		* @return a collection containing comments and TrackBacks that are rejected
146		*/
147		public Collection getRejectedResponses() {
148	0	List list = new ArrayList();
149	0	list.addAll(rejectedResponses);
150	0	return list;
151		}
152
153		/**
154		* Gets the number of rejected responses.
155		*
156		* @return an int
157		*/
158		public int getNumberOfRejectedResponses() {
159	0	return rejectedResponses.size();
160		}
161
162		/**
163		* Called when a comment has been added.
164		*
165		* @param comment a Comment instance
166		*/
167		synchronized void addRecentComment(Comment comment) {
168	0	if (comment.isApproved()) {
169	0	recentComments.add(comment);
170	0	approvedResponses.add(comment);
171	0	} else if (comment.isPending()) {
172	0	pendingResponses.add(comment);
173	0	} else if (comment.isRejected()) {
174	0	rejectedResponses.add(comment);
175		}
176	0	}
177
178		/**
179		* Called when a comment has been removed.
180		*
181		* @param comment a Comment instance
182		*/
183		synchronized void removeRecentComment(Comment comment) {
184	0	recentComments.remove(comment);
185	0	approvedResponses.remove(comment);
186	0	pendingResponses.remove(comment);
187	0	rejectedResponses.remove(comment);
188	0	}
189
190		/**
191		* Called when a TrackBack has been added.
192		*
193		* @param trackBack a TrackBack instance
194		*/
195		synchronized void addRecentTrackBack(TrackBack trackBack) {
196	0	if (trackBack.isApproved()) {
197	0	recentTrackBacks.add(trackBack);
198	0	approvedResponses.add(trackBack);
199	0	} else if (trackBack.isPending()) {
200	0	pendingResponses.add(trackBack);
201	0	} else if (trackBack.isRejected()) {
202	0	rejectedResponses.add(trackBack);
203		}
204	0	}
205
206		/**
207		* Called when a TrackBack has been removed.
208		*
209		* @param trackBack a TrackBack instance
210		*/
211		synchronized void removeRecentTrackBack(TrackBack trackBack) {
212	0	recentTrackBacks.remove(trackBack);
213	0	approvedResponses.remove(trackBack);
214	0	pendingResponses.remove(trackBack);
215	0	rejectedResponses.remove(trackBack);
216	0	}
217
218		/**
219		* Called when a comment has been added.
220		*
221		* @param event a CommentEvent instance
222		*/
223		public void commentAdded(CommentEvent event) {
224	0	addRecentComment(event.getComment());
225	0	}
226
227		/**
228		* Called when a comment has been removed.
229		*
230		* @param event a CommentEvent instance
231		*/
232		public void commentRemoved(CommentEvent event) {
233	0	removeRecentComment(event.getComment());
234	0	}
235
236		/**
237		* Called when a comment has been approved.
238		*
239		* @param event a CommentEvent instance
240		*/
241		public void commentApproved(CommentEvent event) {
242	0	removeRecentComment(event.getComment());
243	0	addRecentComment(event.getComment());
244	0	}
245
246		/**
247		* Called when a comment has been rejected.
248		*
249		* @param event a CommentEvent instance
250		*/
251		public void commentRejected(CommentEvent event) {
252	0	removeRecentComment(event.getComment());
253	0	addRecentComment(event.getComment());
254	0	}
255
256		/**
257		* Called when a TrackBack has been added.
258		*
259		* @param event a TrackBackEvent instance
260		*/
261		public void trackBackAdded(TrackBackEvent event) {
262	0	addRecentTrackBack(event.getTrackBack());
263	0	}
264
265		/**
266		* Called when a TrackBack has been removed.
267		*
268		* @param event a TrackBackEvent instance
269		*/
270		public void trackBackRemoved(TrackBackEvent event) {
271	0	removeRecentTrackBack(event.getTrackBack());
272	0	}
273
274		/**
275		* Called when a TrackBack has been approved.
276		*
277		* @param event a TrackBackEvent instance
278		*/
279		public void trackBackApproved(TrackBackEvent event) {
280	0	removeRecentTrackBack(event.getTrackBack());
281	0	addRecentTrackBack(event.getTrackBack());
282	0	}
283
284		/**
285		* Called when a TrackBack has been rejected.
286		*
287		* @param event a TrackBackEvent instance
288		*/
289		public void trackBackRejected(TrackBackEvent event) {
290	0	removeRecentTrackBack(event.getTrackBack());
291	0	addRecentTrackBack(event.getTrackBack());
292	0	}
293
294		/**
295		* Gets the number of responses.
296		*/
297		public int getNumberOfResponses() {
298	0	return approvedResponses.size() + pendingResponses.size() + rejectedResponses.size();
299		}
300
301		}