src/main/java/net/pterodactylus/rhynodge/states/EpisodeState.java

   1 /*
   2  * Rhynodge - EpisodeState.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.util.ArrayList;
  21 import java.util.Collection;
  22 import java.util.Collections;
  23 import java.util.Iterator;
  24 import java.util.List;
  25
  26 import net.pterodactylus.rhynodge.State;
  27 import net.pterodactylus.rhynodge.filters.EpisodeFilter;
  28 import net.pterodactylus.rhynodge.states.EpisodeState.Episode;
  29 import net.pterodactylus.rhynodge.states.TorrentState.TorrentFile;
  30
  31 import com.fasterxml.jackson.annotation.JsonProperty;
  32 import com.google.common.base.Function;
  33
  34 /**
  35  * {@link State} implementation that stores episodes of TV shows, parsed via
  36  * {@link EpisodeFilter} from a previous {@link TorrentState}.
  37  *
  38  * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
  39  */
  40 public class EpisodeState extends AbstractState implements Iterable<Episode> {
  41
  42         /** The episodes found in the current request. */
  43         @JsonProperty
  44         private final List<Episode> episodes = new ArrayList<Episode>();
  45
  46         /**
  47          * No-arg constructor for deserialization.
  48          */
  49         @SuppressWarnings("unused")
  50         private EpisodeState() {
  51                 this(Collections.<Episode> emptySet());
  52         }
  53
  54         /**
  55          * Creates a new episode state.
  56          *
  57          * @param episodes
  58          *            The episodes of the request
  59          */
  60         public EpisodeState(Collection<Episode> episodes) {
  61                 this.episodes.addAll(episodes);
  62         }
  63
  64         //
  65         // ACCESSORS
  66         //
  67
  68         /**
  69          * Returns all episodes contained in this state.
  70          *
  71          * @return The episodes of this state
  72          */
  73         public Collection<Episode> episodes() {
  74                 return Collections.unmodifiableCollection(episodes);
  75         }
  76
  77         //
  78         // ITERABLE INTERFACE
  79         //
  80
  81         /**
  82          * {@inheritDoc}
  83          */
  84         @Override
  85         public Iterator<Episode> iterator() {
  86                 return episodes.iterator();
  87         }
  88
  89         /**
  90          * {@inheritDoc}
  91          */
  92         @Override
  93         public String toString() {
  94                 return String.format("%s[episodes=%s]", getClass().getSimpleName(), episodes);
  95         }
  96
  97         /**
  98          * Stores attributes for an episode.
  99          *
 100          * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
 101          */
 102         public static class Episode implements Comparable<Episode>, Iterable<TorrentFile> {
 103
 104                 /** Function to extract the season of an episode. */
 105                 public static final Function<Episode, Integer> BY_SEASON = new Function<Episode, Integer>() {
 106
 107                         @Override
 108                         public Integer apply(Episode episode) {
 109                                 return episode.season();
 110                         }
 111                 };
 112
 113                 /** The season of the episode. */
 114                 @JsonProperty
 115                 private final int season;
 116
 117                 /** The number of the episode. */
 118                 @JsonProperty
 119                 private final int episode;
 120
 121                 /** The torrent files for this episode. */
 122                 @JsonProperty
 123                 private final List<TorrentFile> torrentFiles = new ArrayList<TorrentFile>();
 124
 125                 /**
 126                  * No-arg constructor for deserialization.
 127                  */
 128                 @SuppressWarnings("unused")
 129                 private Episode() {
 130                         this(0, 0);
 131                 }
 132
 133                 /**
 134                  * Creates a new episode.
 135                  *
 136                  * @param season
 137                  *            The season of the episode
 138                  * @param episode
 139                  *            The number of the episode
 140                  */
 141                 public Episode(int season, int episode) {
 142                         this.season = season;
 143                         this.episode = episode;
 144                 }
 145
 146                 //
 147                 // ACCESSORS
 148                 //
 149
 150                 /**
 151                  * Returns the season of this episode.
 152                  *
 153                  * @return The season of this episode
 154                  */
 155                 public int season() {
 156                         return season;
 157                 }
 158
 159                 /**
 160                  * Returns the number of this episode.
 161                  *
 162                  * @return The number of this episode
 163                  */
 164                 public int episode() {
 165                         return episode;
 166                 }
 167
 168                 /**
 169                  * Returns the torrent files of this episode.
 170                  *
 171                  * @return The torrent files of this episode
 172                  */
 173                 public Collection<TorrentFile> torrentFiles() {
 174                         return torrentFiles;
 175                 }
 176
 177                 /**
 178                  * Returns the identifier of this episode.
 179                  *
 180                  * @return The identifier of this episode
 181                  */
 182                 public String identifier() {
 183                         return String.format("S%02dE%02d", season, episode);
 184                 }
 185
 186                 //
 187                 // ACTIONS
 188                 //
 189
 190                 /**
 191                  * Adds the given torrent file to this episode.
 192                  *
 193                  * @param torrentFile
 194                  *            The torrent file to add
 195                  */
 196                 public void addTorrentFile(TorrentFile torrentFile) {
 197                         if (!torrentFiles.contains(torrentFile)) {
 198                                 torrentFiles.add(torrentFile);
 199                         }
 200                 }
 201
 202                 //
 203                 // ITERABLE METHODS
 204                 //
 205
 206                 /**
 207                  * {@inheritDoc}
 208                  */
 209                 @Override
 210                 public Iterator<TorrentFile> iterator() {
 211                         return torrentFiles.iterator();
 212                 }
 213
 214                 /**
 215                  * {@inheritDoc}
 216                  */
 217                 @Override
 218                 public int compareTo(Episode episode) {
 219                         if (season() < episode.season()) {
 220                                 return -1;
 221                         }
 222                         if (season() > episode.season()) {
 223                                 return 1;
 224                         }
 225                         if (episode() < episode.episode()) {
 226                                 return -1;
 227                         }
 228                         if (episode() > episode.episode()) {
 229                                 return 1;
 230                         }
 231                         return 0;
 232                 }
 233
 234                 //
 235                 // OBJECT METHODS
 236                 //
 237
 238                 /**
 239                  * {@inheritDoc}
 240                  */
 241                 @Override
 242                 public int hashCode() {
 243                         return season * 65536 + episode;
 244                 }
 245
 246                 /**
 247                  * {@inheritDoc}
 248                  */
 249                 @Override
 250                 public boolean equals(Object obj) {
 251                         if (!(obj instanceof Episode)) {
 252                                 return false;
 253                         }
 254                         Episode episode = (Episode) obj;
 255                         return (season == episode.season) && (this.episode == episode.episode);
 256                 }
 257
 258                 /**
 259                  * {@inheritDoc}
 260                  */
 261                 @Override
 262                 public String toString() {
 263                         return String.format("%s[season=%d,episode=%d,torrentFiles=%s]", getClass().getSimpleName(), season, episode, torrentFiles);
 264                 }
 265
 266         }
 267
 268 }