src/main/java/net/pterodactylus/sone/data/Album.java

   1 /*
   2  * Sone - Album.java - Copyright © 2011–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.data;
  19
  20 import static java.util.Arrays.asList;
  21 import static java.util.Collections.emptyList;
  22
  23 import java.util.ArrayList;
  24 import java.util.Collections;
  25 import java.util.Comparator;
  26 import java.util.List;
  27 import javax.annotation.Nonnull;
  28
  29 import net.pterodactylus.sone.database.AlbumBuilder;
  30 import net.pterodactylus.sone.database.ImageBuilder;
  31
  32 import com.google.common.base.Function;
  33 import com.google.common.base.Optional;
  34 import com.google.common.base.Predicate;
  35 import com.google.common.collect.FluentIterable;
  36 import com.google.common.collect.ImmutableList;
  37
  38 /**
  39  * Container for images that can also contain nested {@link Album}s.
  40  *
  41  * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
  42  */
  43 public interface Album extends Identified, Fingerprintable {
  44
  45         /** Compares two {@link Album}s by {@link #getTitle()}. */
  46         Comparator<Album> TITLE_COMPARATOR = new Comparator<Album>() {
  47
  48                 @Override
  49                 public int compare(Album leftAlbum, Album rightAlbum) {
  50                         return leftAlbum.getTitle().compareToIgnoreCase(rightAlbum.getTitle());
  51                 }
  52         };
  53
  54         /** Function that flattens the given album and all albums beneath it. */
  55         Function<Album, List<Album>> FLATTENER = new Function<Album, List<Album>>() {
  56
  57                 @Override
  58                 @Nonnull
  59                 public List<Album> apply(Album album) {
  60                         if (album == null) {
  61                                 return emptyList();
  62                         }
  63                         List<Album> albums = new ArrayList<Album>();
  64                         albums.add(album);
  65                         for (Album subAlbum : album.getAlbums()) {
  66                                 albums.addAll(FluentIterable.from(ImmutableList.of(subAlbum)).transformAndConcat(FLATTENER).toList());
  67                         }
  68                         return albums;
  69                 }
  70         };
  71
  72         /** Function that transforms an album into the images it contains. */
  73         Function<Album, List<Image>> IMAGES = new Function<Album, List<Image>>() {
  74
  75                 @Override
  76                 @Nonnull
  77                 public List<Image> apply(Album album) {
  78                         return (album != null) ? album.getImages() : Collections.<Image>emptyList();
  79                 }
  80         };
  81
  82         /**
  83          * Filter that removes all albums that do not have any images in any album
  84          * below it.
  85          */
  86         Predicate<Album> NOT_EMPTY = new Predicate<Album>() {
  87
  88                 @Override
  89                 public boolean apply(Album album) {
  90                         /* so, we flatten all albums below the given one and check whether at least one album… */
  91                         return FluentIterable.from(asList(album)).transformAndConcat(FLATTENER).anyMatch(new Predicate<Album>() {
  92
  93                                 @Override
  94                                 public boolean apply(Album album) {
  95                                         /* …contains any inserted images. */
  96                                         return !album.getImages().isEmpty() && FluentIterable.from(album.getImages()).allMatch(new Predicate<Image>() {
  97
  98                                                 @Override
  99                                                 public boolean apply(Image input) {
 100                                                         return input.isInserted();
 101                                                 }
 102                                         });
 103                                 }
 104                         });
 105                 }
 106         };
 107
 108         /**
 109          * Returns the ID of this album.
 110          *
 111          * @return The ID of this album
 112          */
 113         String getId();
 114
 115         /**
 116          * Returns the Sone this album belongs to.
 117          *
 118          * @return The Sone this album belongs to
 119          */
 120         Sone getSone();
 121
 122         List<Album> getAlbums();
 123
 124         /**
 125          * Returns the images in this album.
 126          *
 127          * @return The images in this album
 128          */
 129         List<Image> getImages();
 130
 131         Optional<Image> getAlbumImage();
 132
 133         /**
 134          * Returns whether this album contains any other albums or images.
 135          *
 136          * @return {@code true} if this album is empty, {@code false} otherwise
 137          */
 138         boolean isEmpty();
 139
 140         /**
 141          * Returns whether this album is an identitiy’s root album.
 142          *
 143          * @return {@code true} if this album is an identity’s root album, {@code
 144          *         false} otherwise
 145          */
 146         boolean isRoot();
 147
 148         /**
 149          * Returns the parent album of this album.
 150          *
 151          * @return The parent album of this album, or {@code null} if this album does
 152          *         not have a parent
 153          */
 154         Album getParent();
 155
 156         /**
 157          * Returns the title of this album.
 158          *
 159          * @return The title of this album
 160          */
 161         String getTitle();
 162
 163         /**
 164          * Returns the description of this album.
 165          *
 166          * @return The description of this album
 167          */
 168         String getDescription();
 169
 170         AlbumBuilder newAlbumBuilder() throws IllegalStateException;
 171
 172         ImageBuilder newImageBuilder() throws IllegalStateException;
 173
 174         /**
 175          * Returns a modifier for this album.
 176          *
 177          * @return A modifier for this album
 178          * @throws IllegalStateException
 179          *              if this album can not be modified
 180          */
 181         Modifier modify() throws IllegalStateException;
 182
 183         void moveUp();
 184
 185         void moveDown();
 186
 187         void remove() throws IllegalStateException;
 188
 189         /**
 190          * Allows modifying an album. Modifications are only performed once {@link
 191          * #update()} has succesfully returned a new album with the modifications
 192          * made.
 193          *
 194          * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
 195          */
 196         interface Modifier {
 197
 198                 Modifier setTitle(String title);
 199
 200                 Modifier setDescription(String description);
 201
 202                 Modifier setAlbumImage(String imageId);
 203
 204                 Album update() throws IllegalStateException;
 205
 206         }
 207
 208 }