98578eba7dcca7870567a13c96bac38e0a414185
[rhynodge.git] / src / main / java / net / pterodactylus / rhynodge / states / TorrentState.java
1 /*
2  * Rhynodge - TorrentState.java - Copyright © 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.rhynodge.states;
19
20 import java.nio.charset.Charset;
21 import java.util.Collection;
22 import java.util.Collections;
23 import java.util.Iterator;
24 import java.util.List;
25 import java.util.Optional;
26
27 import net.pterodactylus.rhynodge.State;
28 import net.pterodactylus.rhynodge.states.TorrentState.TorrentFile;
29
30 import org.apache.http.NameValuePair;
31 import org.apache.http.client.utils.URLEncodedUtils;
32
33 import com.fasterxml.jackson.annotation.JsonProperty;
34 import com.google.common.collect.Lists;
35
36 /**
37  * {@link State} that contains information about an arbitrary number of torrent
38  * files.
39  *
40  * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
41  */
42 public class TorrentState extends AbstractState implements Iterable<TorrentFile> {
43
44         /** The torrent files. */
45         @JsonProperty
46         private List<TorrentFile> files = Lists.newArrayList();
47
48         /**
49          * Creates a new torrent state without torrent files.
50          */
51         public TorrentState() {
52                 this(Collections.<TorrentFile> emptySet());
53         }
54
55         /**
56          * Creates a new torrent state containing the given torrent files.
57          *
58          * @param torrentFiles
59          *            The torrent files
60          */
61         public TorrentState(Collection<TorrentFile> torrentFiles) {
62                 files.addAll(torrentFiles);
63         }
64
65         //
66         // ACCESSORS
67         //
68
69         @Override
70         public boolean isEmpty() {
71                 return files.isEmpty();
72         }
73
74         /**
75          * Returns all torrent files of this state.
76          *
77          * @return All torrent files of this state
78          */
79         public Collection<TorrentFile> torrentFiles() {
80                 return Collections.unmodifiableList(files);
81         }
82
83         /**
84          * Adds a torrent file to this state.
85          *
86          * @param torrentFile
87          *            The torrent file to add
88          * @return This state
89          */
90         public TorrentState addTorrentFile(TorrentFile torrentFile) {
91                 files.add(torrentFile);
92                 return this;
93         }
94
95         //
96         // ITERABLE METHODS
97         //
98
99         /**
100          * {@inheritDoc}
101          */
102         @Override
103         public Iterator<TorrentFile> iterator() {
104                 return files.iterator();
105         }
106
107         //
108         // OBJECT METHODS
109         //
110
111         /**
112          * {@inheritDoc}
113          */
114         @Override
115         public String toString() {
116                 return String.format("%s[files=%s]", getClass().getSimpleName(), files);
117         }
118
119         /**
120          * Container for torrent file data.
121          *
122          * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
123          */
124         public static class TorrentFile {
125
126                 /** The name of the file. */
127                 @JsonProperty
128                 private final String name;
129
130                 /** The size of the file. */
131                 @JsonProperty
132                 private final String size;
133
134                 /** The magnet URI of the file. */
135                 @JsonProperty
136                 private final String magnetUri;
137
138                 /** The download URI of the file. */
139                 @JsonProperty
140                 private final String downloadUri;
141
142                 /** The number of files in this torrent. */
143                 @JsonProperty
144                 private final int fileCount;
145
146                 /** The number of seeds connected to this torrent. */
147                 @JsonProperty
148                 private final int seedCount;
149
150                 /** The number of leechers connected to this torrent. */
151                 @JsonProperty
152                 private final int leechCount;
153
154                 /**
155                  * No-arg constructor for deserialization.
156                  */
157                 @SuppressWarnings("unused")
158                 private TorrentFile() {
159                         this(null, null, null, null, 0, 0, 0);
160                 }
161
162                 /**
163                  * Creates a new torrent file.
164                  *
165                  * @param name
166                  *            The name of the file
167                  * @param size
168                  *            The size of the file
169                  * @param magnetUri
170                  *            The magnet URI of the file
171                  * @param downloadUri
172                  *            The download URI of the file
173                  * @param fileCount
174                  *            The number of files
175                  * @param seedCount
176                  *            The number of connected seeds
177                  * @param leechCount
178                  *            The number of connected leechers
179                  */
180                 public TorrentFile(String name, String size, String magnetUri, String downloadUri, int fileCount, int seedCount, int leechCount) {
181                         this.name = name;
182                         this.size = size;
183                         this.magnetUri = magnetUri;
184                         this.downloadUri = downloadUri;
185                         this.fileCount = fileCount;
186                         this.seedCount = seedCount;
187                         this.leechCount = leechCount;
188                 }
189
190                 //
191                 // ACCESSORS
192                 //
193
194                 /**
195                  * Returns the name of the file.
196                  *
197                  * @return The name of the file
198                  */
199                 public String name() {
200                         return name;
201                 }
202
203                 /**
204                  * Returns the size of the file. The returned size may included
205                  * non-numeric information, such as units (e. g. “860.46 MB”).
206                  *
207                  * @return The size of the file
208                  */
209                 public String size() {
210                         return size;
211                 }
212
213                 /**
214                  * Returns the magnet URI of the file.
215                  *
216                  * @return The magnet URI of the file, or {@code null} if there is no
217                  *         magnet URI for this torrent file
218                  */
219                 public String magnetUri() {
220                         return magnetUri;
221                 }
222
223                 /**
224                  * Returns the download URI of the file.
225                  *
226                  * @return The download URI of the file, or {@code null} if there is no
227                  *         download URI for this torrent file
228                  */
229                 public String downloadUri() {
230                         return downloadUri;
231                 }
232
233                 /**
234                  * Returns the number of files in this torrent.
235                  *
236                  * @return The number of files in this torrent
237                  */
238                 public int fileCount() {
239                         return fileCount;
240                 }
241
242                 /**
243                  * Returns the number of seeds connected to this torrent.
244                  *
245                  * @return The number of connected seeds
246                  */
247                 public int seedCount() {
248                         return seedCount;
249                 }
250
251                 /**
252                  * Returns the number of leechers connected to this torrent.
253                  *
254                  * @return The number of connected leechers
255                  */
256                 public int leechCount() {
257                         return leechCount;
258                 }
259
260                 //
261                 // PRIVATE METHODS
262                 //
263
264                 /**
265                  * Generates an ID for this file. If a {@link #magnetUri} is set, an ID
266                  * is {@link #extractId(String) extracted} from it. Otherwise the magnet
267                  * URI is used. If the {@link #magnetUri} is not set, the
268                  * {@link #downloadUri} is used. If that is not set either, the name of
269                  * the file is returned.
270                  *
271                  * @return The generated ID
272                  */
273                 private String generateId() {
274                         if (magnetUri != null) {
275                                 return extractId(magnetUri).orElse(magnetUri);
276                         }
277                         return (downloadUri != null) ? downloadUri : name;
278                 }
279
280                 //
281                 // STATIC METHODS
282                 //
283
284                 /**
285                  * Tries to extract the “exact target” of a magnet URI.
286                  *
287                  * @param magnetUri
288                  *            The magnet URI to extract the “xt” from
289                  * @return The extracted ID, or {@code null} if no ID could be found
290                  */
291                 private static Optional<String> extractId(String magnetUri) {
292                         if ((magnetUri == null) || (magnetUri.length() < 8)) {
293                                 return Optional.empty();
294                         }
295                         List<NameValuePair> parameters = URLEncodedUtils.parse(magnetUri.substring("magnet:?".length()), Charset.forName("UTF-8"));
296                         for (NameValuePair parameter : parameters) {
297                                 if (parameter.getName().equals("xt")) {
298                                         return Optional.of(parameter.getValue().toLowerCase());
299                                 }
300                         }
301                         return Optional.empty();
302                 }
303
304                 //
305                 // OBJECT METHODS
306                 //
307
308                 /**
309                  * {@inheritDoc}
310                  */
311                 @Override
312                 public int hashCode() {
313                         return (generateId() != null) ? generateId().hashCode() : 0;
314                 }
315
316                 /**
317                  * {@inheritDoc}
318                  */
319                 @Override
320                 public boolean equals(Object object) {
321                         if (!(object instanceof TorrentFile)) {
322                                 return false;
323                         }
324                         if (generateId() != null) {
325                                 return generateId().equals(((TorrentFile) object).generateId());
326                         }
327                         return false;
328                 }
329
330                 /**
331                  * {@inheritDoc}
332                  */
333                 @Override
334                 public String toString() {
335                         return String.format("%s(%s,%s,%s)", name(), size(), magnetUri(), downloadUri());
336                 }
337
338         }
339
340 }