X-Git-Url: https://git.pterodactylus.net/?p=Sone.git;a=blobdiff_plain;f=src%2Fmain%2Fjava%2Fnet%2Fpterodactylus%2Fsone%2Fdata%2FAlbum.java;h=aa14edef2f2f128d9ae5067faaa675736281ac29;hp=20862a4647300e904d04995abbde7d244772ba16;hb=c2e868714435ac7c75d77d1911d0dfb00393d051;hpb=356a84e5ec2bb0936b7d1cdc635f7f051788da6a diff --git a/src/main/java/net/pterodactylus/sone/data/Album.java b/src/main/java/net/pterodactylus/sone/data/Album.java index 20862a4..aa14ede 100644 --- a/src/main/java/net/pterodactylus/sone/data/Album.java +++ b/src/main/java/net/pterodactylus/sone/data/Album.java @@ -1,5 +1,5 @@ /* - * Sone - Album.java - Copyright © 2011 David Roden + * Sone - Album.java - Copyright © 2011–2013 David Roden * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -17,11 +17,27 @@ package net.pterodactylus.sone.data; +import static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.base.Preconditions.checkState; +import static java.util.Arrays.asList; + import java.util.ArrayList; +import java.util.Comparator; +import java.util.HashMap; import java.util.List; +import java.util.Map; import java.util.UUID; -import net.pterodactylus.util.validation.Validation; +import com.google.common.base.Function; +import com.google.common.base.Optional; +import com.google.common.base.Predicate; +import com.google.common.base.Predicates; +import com.google.common.collect.Collections2; +import com.google.common.collect.FluentIterable; +import com.google.common.collect.ImmutableList; +import com.google.common.hash.Hasher; +import com.google.common.hash.Hashing; /** * Container for images that can also contain nested {@link Album}s. @@ -30,6 +46,56 @@ import net.pterodactylus.util.validation.Validation; */ public class Album implements Fingerprintable { + /** Compares two {@link Album}s by {@link #getTitle()}. */ + public static final Comparator TITLE_COMPARATOR = new Comparator() { + + @Override + public int compare(Album leftAlbum, Album rightAlbum) { + return leftAlbum.getTitle().compareToIgnoreCase(rightAlbum.getTitle()); + } + }; + + /** Function that flattens the given album and all albums beneath it. */ + public static final Function> FLATTENER = new Function>() { + + @Override + public List apply(Album album) { + List albums = new ArrayList(); + albums.add(album); + for (Album subAlbum : album.getAlbums()) { + albums.addAll(FluentIterable.from(ImmutableList.of(subAlbum)).transformAndConcat(FLATTENER).toList()); + } + return albums; + } + }; + + /** Function that transforms an album into the images it contains. */ + public static final Function> IMAGES = new Function>() { + + @Override + public List apply(Album album) { + return album.getImages(); + } + }; + + /** + * Filter that removes all albums that do not have any images in any album + * below it. + */ + public static final Predicate NOT_EMPTY = new Predicate() { + + @Override + public boolean apply(Album album) { + return FluentIterable.from(asList(album)).transformAndConcat(FLATTENER).anyMatch(new Predicate() { + + @Override + public boolean apply(Album album) { + return !album.getImages().isEmpty(); + } + }); + } + }; + /** The ID of this album. */ private final String id; @@ -39,8 +105,11 @@ public class Album implements Fingerprintable { /** Nested albums. */ private final List albums = new ArrayList(); + /** The image IDs in order. */ + private final List imageIds = new ArrayList(); + /** The images in this album. */ - private final List images = new ArrayList(); + private final Map images = new HashMap(); /** The parent album. */ private Album parent; @@ -51,8 +120,8 @@ public class Album implements Fingerprintable { /** The description of this album. */ private String description; - /** The index of the album picture. */ - private int albumImage = -1; + /** The ID of the album picture. */ + private String albumImage; /** * Creates a new album with a random ID. @@ -68,8 +137,7 @@ public class Album implements Fingerprintable { * The ID of the album */ public Album(String id) { - Validation.begin().isNotNull("Album ID", id).check(); - this.id = id; + this.id = checkNotNull(id, "id must not be null"); } // @@ -103,7 +171,8 @@ public class Album implements Fingerprintable { * @return This album */ public Album setSone(Sone sone) { - Validation.begin().isNotNull("New Album Owner", sone).isEither("Old Album Owner", this.sone, null, sone).check(); + checkNotNull(sone, "sone must not be null"); + checkState((this.sone == null) || (this.sone.equals(sone)), "album owner must not already be set to some other Sone"); this.sone = sone; return this; } @@ -124,7 +193,8 @@ public class Album implements Fingerprintable { * The album to add */ public void addAlbum(Album album) { - Validation.begin().isNotNull("Album", album).check().isEqual("Album Owner", album.sone, sone).isEither("Old Album Parent", this.parent, null, album.parent).check(); + checkNotNull(album, "album must not be null"); + checkArgument(album.getSone().equals(sone), "album must belong to the same Sone as this album"); album.setParent(this); if (!albums.contains(album)) { albums.add(album); @@ -138,18 +208,71 @@ public class Album implements Fingerprintable { * The album to remove */ public void removeAlbum(Album album) { - Validation.begin().isNotNull("Album", album).check().isEqual("Album Owner", album.sone, sone).isEqual("Album Parent", album.parent, this).check(); + checkNotNull(album, "album must not be null"); + checkArgument(album.sone.equals(sone), "album must belong this album’s Sone"); + checkArgument(equals(album.parent), "album must belong to this album"); albums.remove(album); album.removeParent(); } /** + * Moves the given album up in this album’s albums. If the album is already + * the first album, nothing happens. + * + * @param album + * The album to move up + * @return The album that the given album swapped the place with, or + * null if the album did not change its place + */ + public Album moveAlbumUp(Album album) { + checkNotNull(album, "album must not be null"); + checkArgument(album.sone.equals(sone), "album must belong to the same Sone as this album"); + checkArgument(equals(album.parent), "album must belong to this album"); + int oldIndex = albums.indexOf(album); + if (oldIndex <= 0) { + return null; + } + albums.remove(oldIndex); + albums.add(oldIndex - 1, album); + return albums.get(oldIndex); + } + + /** + * Moves the given album down in this album’s albums. If the album is + * already the last album, nothing happens. + * + * @param album + * The album to move down + * @return The album that the given album swapped the place with, or + * null if the album did not change its place + */ + public Album moveAlbumDown(Album album) { + checkNotNull(album, "album must not be null"); + checkArgument(album.sone.equals(sone), "album must belong to the same Sone as this album"); + checkArgument(equals(album.parent), "album must belong to this album"); + int oldIndex = albums.indexOf(album); + if ((oldIndex < 0) || (oldIndex >= (albums.size() - 1))) { + return null; + } + albums.remove(oldIndex); + albums.add(oldIndex + 1, album); + return albums.get(oldIndex); + } + + /** * Returns the images in this album. * * @return The images in this album */ public List getImages() { - return new ArrayList(images); + return new ArrayList(Collections2.filter(Collections2.transform(imageIds, new Function() { + + @Override + @SuppressWarnings("synthetic-access") + public Image apply(String imageId) { + return images.get(imageId); + } + }), Predicates.notNull())); } /** @@ -159,13 +282,19 @@ public class Album implements Fingerprintable { * The image to add */ public void addImage(Image image) { - Validation.begin().isNotNull("Image", image).check().isNotNull("Image Owner", image.getSone()).check().isEqual("Image Owner", image.getSone(), sone).check(); + checkNotNull(image, "image must not be null"); + checkNotNull(image.getSone(), "image must have an owner"); + checkArgument(image.getSone().equals(sone), "image must belong to the same Sone as this album"); if (image.getAlbum() != null) { image.getAlbum().removeImage(image); } image.setAlbum(this); - if (!images.contains(image)) { - images.add(image); + if (imageIds.isEmpty() && (albumImage == null)) { + albumImage = image.getId(); + } + if (!imageIds.contains(image.getId())) { + imageIds.add(image.getId()); + images.put(image.getId(), image); } } @@ -176,8 +305,64 @@ public class Album implements Fingerprintable { * The image to remove */ public void removeImage(Image image) { - Validation.begin().isNotNull("Image", image).check().isEqual("Image Owner", image.getSone(), sone).check(); - images.remove(image); + checkNotNull(image, "image must not be null"); + checkNotNull(image.getSone(), "image must have an owner"); + checkArgument(image.getSone().equals(sone), "image must belong to the same Sone as this album"); + imageIds.remove(image.getId()); + images.remove(image.getId()); + if (image.getId().equals(albumImage)) { + if (images.isEmpty()) { + albumImage = null; + } else { + albumImage = images.values().iterator().next().getId(); + } + } + } + + /** + * Moves the given image up in this album’s images. If the image is already + * the first image, nothing happens. + * + * @param image + * The image to move up + * @return The image that the given image swapped the place with, or + * null if the image did not change its place + */ + public Image moveImageUp(Image image) { + checkNotNull(image, "image must not be null"); + checkNotNull(image.getSone(), "image must have an owner"); + checkArgument(image.getSone().equals(sone), "image must belong to the same Sone as this album"); + checkArgument(image.getAlbum().equals(this), "image must belong to this album"); + int oldIndex = imageIds.indexOf(image.getId()); + if (oldIndex <= 0) { + return null; + } + imageIds.remove(image.getId()); + imageIds.add(oldIndex - 1, image.getId()); + return images.get(imageIds.get(oldIndex)); + } + + /** + * Moves the given image down in this album’s images. If the image is + * already the last image, nothing happens. + * + * @param image + * The image to move down + * @return The image that the given image swapped the place with, or + * null if the image did not change its place + */ + public Image moveImageDown(Image image) { + checkNotNull(image, "image must not be null"); + checkNotNull(image.getSone(), "image must have an owner"); + checkArgument(image.getSone().equals(sone), "image must belong to the same Sone as this album"); + checkArgument(image.getAlbum().equals(this), "image must belong to this album"); + int oldIndex = imageIds.indexOf(image.getId()); + if ((oldIndex == -1) || (oldIndex >= (imageIds.size() - 1))) { + return null; + } + imageIds.remove(image.getId()); + imageIds.add(oldIndex + 1, image.getId()); + return images.get(imageIds.get(oldIndex)); } /** @@ -187,10 +372,22 @@ public class Album implements Fingerprintable { * @return The image to show when this album is listed */ public Image getAlbumImage() { - if (albumImage == -1) { + if (albumImage == null) { return null; } - return images.get(albumImage); + return Optional.fromNullable(images.get(albumImage)).or(images.values().iterator().next()); + } + + /** + * Sets the ID of the album image. + * + * @param id + * The ID of the album image + * @return This album + */ + public Album setAlbumImage(String id) { + this.albumImage = id; + return this; } /** @@ -220,8 +417,7 @@ public class Album implements Fingerprintable { * @return This album */ protected Album setParent(Album parent) { - Validation.begin().isNotNull("Album Parent", parent).check(); - this.parent = parent; + this.parent = checkNotNull(parent, "parent must not be null"); return this; } @@ -252,8 +448,7 @@ public class Album implements Fingerprintable { * @return This album */ public Album setTitle(String title) { - Validation.begin().isNotNull("Album Title", title).check(); - this.title = title; + this.title = checkNotNull(title, "title must not be null"); return this; } @@ -274,8 +469,7 @@ public class Album implements Fingerprintable { * @return This album */ public Album setDescription(String description) { - Validation.begin().isNotNull("Album Description", description).check(); - this.description = description; + this.description = checkNotNull(description, "description must not be null"); return this; } @@ -288,30 +482,33 @@ public class Album implements Fingerprintable { */ @Override public String getFingerprint() { - StringBuilder fingerprint = new StringBuilder(); - fingerprint.append("Album("); - fingerprint.append("ID(").append(id).append(')'); - fingerprint.append("Title(").append(title).append(')'); - fingerprint.append("Description(").append(description).append(')'); + Hasher hash = Hashing.sha256().newHasher(); + hash.putString("Album("); + hash.putString("ID(").putString(id).putString(")"); + hash.putString("Title(").putString(title).putString(")"); + hash.putString("Description(").putString(description).putString(")"); + if (albumImage != null) { + hash.putString("AlbumImage(").putString(albumImage).putString(")"); + } /* add nested albums. */ - fingerprint.append("Albums("); + hash.putString("Albums("); for (Album album : albums) { - fingerprint.append(album.getFingerprint()); + hash.putString(album.getFingerprint()); } - fingerprint.append(')'); + hash.putString(")"); /* add images. */ - fingerprint.append("Images("); - for (Image image : images) { + hash.putString("Images("); + for (Image image : getImages()) { if (image.isInserted()) { - fingerprint.append(image.getFingerprint()); + hash.putString(image.getFingerprint()); } } - fingerprint.append(')'); + hash.putString(")"); - fingerprint.append(')'); - return fingerprint.toString(); + hash.putString(")"); + return hash.hash().toString(); } //