Remove all occurences of the FCP interface from the core.
[Sone.git] / src / main / java / net / pterodactylus / sone / notify / ListNotification.java
1 /*
2  * Sone - ListNotification.java - Copyright © 2010–2013 David Roden
3  *
4  * This program is free software: you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation, either version 3 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
16  */
17
18 package net.pterodactylus.sone.notify;
19
20 import java.util.ArrayList;
21 import java.util.Collection;
22 import java.util.List;
23 import java.util.concurrent.CopyOnWriteArrayList;
24
25 import net.pterodactylus.util.notify.TemplateNotification;
26 import net.pterodactylus.util.template.Template;
27
28 /**
29  * Notification that maintains a list of new elements.
30  *
31  * @param <T>
32  *            The type of the items
33  * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
34  */
35 public class ListNotification<T> extends TemplateNotification {
36
37         /** The key under which to store the elements in the template. */
38         private final String key;
39
40         /** The list of new elements. */
41         private final List<T> elements = new CopyOnWriteArrayList<T>();
42
43         /**
44          * Creates a new list notification.
45          *
46          * @param id
47          *            The ID of the notification
48          * @param key
49          *            The key under which to store the elements in the template
50          * @param template
51          *            The template to render
52          */
53         public ListNotification(String id, String key, Template template) {
54                 this(id, key, template, true);
55         }
56
57         /**
58          * Creates a new list notification.
59          *
60          * @param id
61          *            The ID of the notification
62          * @param key
63          *            The key under which to store the elements in the template
64          * @param template
65          *            The template to render
66          * @param dismissable
67          *            {@code true} if this notification should be dismissable by the
68          *            user, {@code false} otherwise
69          */
70         public ListNotification(String id, String key, Template template, boolean dismissable) {
71                 super(id, System.currentTimeMillis(), System.currentTimeMillis(), dismissable, template);
72                 this.key = key;
73                 template.getInitialContext().set(key, elements);
74         }
75
76         /**
77          * Creates a new list notification that copies its ID and the template from
78          * the given list notification.
79          *
80          * @param listNotification
81          *            The list notification to copy
82          */
83         public ListNotification(ListNotification<T> listNotification) {
84                 super(listNotification.getId(), listNotification.getCreatedTime(), listNotification.getLastUpdatedTime(), listNotification.isDismissable(), new Template());
85                 this.key = listNotification.key;
86                 getTemplate().add(listNotification.getTemplate());
87                 getTemplate().getInitialContext().set(key, elements);
88         }
89
90         //
91         // ACTIONS
92         //
93
94         /**
95          * Returns the current list of elements.
96          *
97          * @return The current list of elements
98          */
99         public List<T> getElements() {
100                 return new ArrayList<T>(elements);
101         }
102
103         /**
104          * Sets the elements to show in this notification. This method will not call
105          * {@link #touch()}.
106          *
107          * @param elements
108          *            The elements to show
109          */
110         public void setElements(Collection<? extends T> elements) {
111                 this.elements.clear();
112                 this.elements.addAll(elements);
113                 touch();
114         }
115
116         /**
117          * Returns whether there are any new elements.
118          *
119          * @return {@code true} if there are no new elements, {@code false} if there
120          *         are new elements
121          */
122         public boolean isEmpty() {
123                 return elements.isEmpty();
124         }
125
126         /**
127          * Adds a discovered element.
128          *
129          * @param element
130          *            The new element
131          */
132         public void add(T element) {
133                 elements.add(element);
134                 touch();
135         }
136
137         /**
138          * Removes the given element from the list of new elements.
139          *
140          * @param element
141          *            The element to remove
142          */
143         public void remove(T element) {
144                 while (elements.remove(element)) {
145                         /* do nothing, just remove all instances of the element. */
146                 }
147                 if (elements.isEmpty()) {
148                         dismiss();
149                 }
150                 touch();
151         }
152
153         //
154         // ABSTRACTNOTIFICATION METHODS
155         //
156
157         /**
158          * {@inheritDoc}
159          */
160         @Override
161         public void dismiss() {
162                 super.dismiss();
163                 elements.clear();
164         }
165
166         //
167         // OBJECT METHODS
168         //
169
170         /**
171          * {@inheritDoc}
172          */
173         @Override
174         public int hashCode() {
175                 int hashCode = super.hashCode();
176                 for (T element : elements) {
177                         hashCode ^= element.hashCode();
178                 }
179                 return hashCode;
180         }
181
182         /**
183          * {@inheritDoc}
184          */
185         @Override
186         public boolean equals(Object object) {
187                 if (!(object instanceof ListNotification)) {
188                         return false;
189                 }
190                 ListNotification<?> listNotification = (ListNotification<?>) object;
191                 if (!super.equals(listNotification)) {
192                         return false;
193                 }
194                 if (!key.equals(listNotification.key)) {
195                         return false;
196                 }
197                 if (elements.size() != listNotification.elements.size()) {
198                         return false;
199                 }
200                 for (int index = 0; index < elements.size(); ++index) {
201                         if (!elements.get(index).equals(listNotification.elements.get(index))) {
202                                 return false;
203                         }
204                 }
205                 return true;
206         }
207
208 }