Use SHA-256 hashes for fingerprinting.
[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                 elements.remove(element);
145                 if (elements.isEmpty()) {
146                         dismiss();
147                 }
148                 touch();
149         }
150
151         //
152         // ABSTRACTNOTIFICATION METHODS
153         //
154
155         /**
156          * {@inheritDoc}
157          */
158         @Override
159         public void dismiss() {
160                 super.dismiss();
161                 elements.clear();
162         }
163
164         //
165         // OBJECT METHODS
166         //
167
168         /**
169          * {@inheritDoc}
170          */
171         @Override
172         public int hashCode() {
173                 int hashCode = super.hashCode();
174                 for (T element : elements) {
175                         hashCode ^= element.hashCode();
176                 }
177                 return hashCode;
178         }
179
180         /**
181          * {@inheritDoc}
182          */
183         @Override
184         public boolean equals(Object object) {
185                 if (!(object instanceof ListNotification)) {
186                         return false;
187                 }
188                 ListNotification<?> listNotification = (ListNotification<?>) object;
189                 if (!super.equals(listNotification)) {
190                         return false;
191                 }
192                 if (!key.equals(listNotification.key)) {
193                         return false;
194                 }
195                 if (elements.size() != listNotification.elements.size()) {
196                         return false;
197                 }
198                 for (int index = 0; index < elements.size(); ++index) {
199                         if (!elements.get(index).equals(listNotification.elements.get(index))) {
200                                 return false;
201                         }
202                 }
203                 return true;
204         }
205
206 }