X-Git-Url: https://git.pterodactylus.net/?p=Sone.git;a=blobdiff_plain;f=src%2Fmain%2Fjava%2Fnet%2Fpterodactylus%2Fsone%2Fdata%2FAlbum.java;h=f90a42f3b02a9154afe52b15012436bcc6f50b32;hp=60fb296373a037dc7d8237415ecf00b772199169;hb=f5fc7fdf598e1a10757069e0701c41a86047d266;hpb=e31ead2b972074c1e5ecc5213b2bdc34c453d8b6 diff --git a/src/main/java/net/pterodactylus/sone/data/Album.java b/src/main/java/net/pterodactylus/sone/data/Album.java index 60fb296..f90a42f 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–2016 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,283 +17,259 @@ package net.pterodactylus.sone.data; +import static java.util.Arrays.asList; +import static java.util.Collections.emptyList; + import java.util.ArrayList; +import java.util.Collections; import java.util.List; -import java.util.UUID; +import javax.annotation.Nonnull; -import net.pterodactylus.util.validation.Validation; +import com.google.common.base.Function; +import com.google.common.base.Predicate; +import com.google.common.collect.FluentIterable; +import com.google.common.collect.ImmutableList; /** * Container for images that can also contain nested {@link Album}s. - * - * @author David ‘Bombe’ Roden */ -public class Album implements Fingerprintable { - - /** The ID of this album. */ - private final String id; - - /** The Sone this album belongs to. */ - private Sone sone; - - /** Nested albums. */ - private final List albums = new ArrayList(); - - /** The images in this album. */ - private final List images = new ArrayList(); - - /** The parent album. */ - private Album parent; - - /** The name of this album. */ - private String name; +public interface Album extends Identified, Fingerprintable { + + /** Function that flattens the given album and all albums beneath it. */ + Function> FLATTENER = new Function>() { + + @Override + @Nonnull + public List apply(Album album) { + if (album == null) { + return emptyList(); + } + List albums = new ArrayList(); + albums.add(album); + for (Album subAlbum : album.getAlbums()) { + albums.addAll(FluentIterable.from(ImmutableList.of(subAlbum)).transformAndConcat(FLATTENER).toList()); + } + return albums; + } + }; - /** The description of this album. */ - private String description; + /** Function that transforms an album into the images it contains. */ + Function> IMAGES = new Function>() { - /** - * Creates a new album with a random ID. - */ - public Album() { - this(UUID.randomUUID().toString()); - } + @Override + @Nonnull + public List apply(Album album) { + return (album != null) ? album.getImages() : Collections.emptyList(); + } + }; /** - * Creates a new album with the given ID. - * - * @param id - * The ID of the album + * Filter that removes all albums that do not have any images in any album + * below it. */ - public Album(String id) { - Validation.begin().isNotNull("Album ID", id).check(); - this.id = id; - } - - // - // ACCESSORS - // + Predicate NOT_EMPTY = new Predicate() { + + @Override + public boolean apply(Album album) { + /* so, we flatten all albums below the given one and check whether at least one album… */ + return FluentIterable.from(asList(album)).transformAndConcat(FLATTENER).anyMatch(new Predicate() { + + @Override + public boolean apply(Album album) { + /* …contains any inserted images. */ + return !album.getImages().isEmpty() && FluentIterable.from(album.getImages()).allMatch(new Predicate() { + + @Override + public boolean apply(Image input) { + return input.isInserted(); + } + }); + } + }); + } + }; /** * Returns the ID of this album. * * @return The ID of this album */ - public String getId() { - return id; - } + String getId(); /** * Returns the Sone this album belongs to. * * @return The Sone this album belongs to */ - public Sone getSone() { - return sone; - } - - /** - * Sets the owner of the album. The owner can only be set as long as the - * current owner is {@code null}. - * - * @param sone - * The album owner - * @return This album - */ - public Album setSone(Sone sone) { - Validation.begin().isNull("Current Album Owner", this.sone).isNotNull("New Album Owner", sone).check().isEqual("New Album Owner", sone, this.sone).check(); - this.sone = sone; - return this; - } + Sone getSone(); /** * Returns the nested albums. * * @return The nested albums */ - public List getNestedAlbums() { - return new ArrayList(albums); - } + List getAlbums(); /** * Adds an album to this album. * * @param album - * The album to add + * The album to add */ - public void addAlbum(Album album) { - Validation.begin().isNotNull("Album", album).check().isEqual("Album Owner", album.sone, sone).isNull("Album Parent", album.parent).check(); - albums.add(album); - album.setParent(this); - } + void addAlbum(Album album); /** * Removes an album from this album. * * @param album - * The album to remove + * 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(); - albums.remove(album); - album.removeParent(); - } + void removeAlbum(Album album); + + /** + * 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 + */ + Album moveAlbumUp(Album album); + + /** + * 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 + */ + Album moveAlbumDown(Album album); /** * Returns the images in this album. * * @return The images in this album */ - public List getImages() { - return new ArrayList(images); - } + List getImages(); /** * Adds the given image to this album. * * @param image - * The image to add + * The image to add */ - public void addImage(Image image) { - Validation.begin().isNotNull("Image", image).check().isEqual("Image Owner", image.getSone(), sone).check(); - images.add(image); - } + void addImage(Image image); /** * Removes the given image from this album. * * @param image - * The image to remove + * 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); - } + void removeImage(Image image); + + /** + * 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 + */ + Image moveImageUp(Image image); + + /** + * 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 + */ + Image moveImageDown(Image image); + + /** + * Returns whether this album contains any other albums or images. + * + * @return {@code true} if this album is empty, {@code false} otherwise + */ + boolean isEmpty(); + + /** + * Returns whether this album is an identitiy’s root album. + * + * @return {@code true} if this album is an identity’s root album, {@code + * false} otherwise + */ + boolean isRoot(); /** * Returns the parent album of this album. * - * @return The parent album of this album, or {@code null} if this album - * does not have a parent + * @return The parent album of this album, or {@code null} if this album does + * not have a parent */ - public Album getParent() { - return parent; - } + Album getParent(); /** * Sets the parent album of this album. * * @param parent - * The new parent album of this album + * The new parent album of this album * @return This album */ - protected Album setParent(Album parent) { - Validation.begin().isNotNull("Album Parent", parent).check(); - this.parent = parent; - return this; - } + Album setParent(Album parent); /** * Removes the parent album of this album. * * @return This album */ - protected Album removeParent() { - Validation.begin().isNotNull("Album Parent", parent).check(); - this.parent = null; - return this; - } - - /** - * Returns the name of this album. - * - * @return The name of this album - */ - public String getName() { - return name; - } + Album removeParent(); /** - * Sets the name of this album. + * Returns the title of this album. * - * @param name - * The name of this album - * @return This album + * @return The title of this album */ - public Album setName(String name) { - Validation.begin().isNotNull("Album Name", name).check(); - this.name = name; - return this; - } + String getTitle(); /** * Returns the description of this album. * * @return The description of this album */ - public String getDescription() { - return description; - } + String getDescription(); /** - * Sets the description of this album. + * Returns a modifier for this album. * - * @param description - * The description of this album - * @return This album + * @return A modifier for this album + * @throws IllegalStateException + * if this album can not be modified */ - public Album setDescription(String description) { - Validation.begin().isNotNull("Album Description", description).check(); - this.description = description; - return this; - } - - // - // FINGERPRINTABLE METHODS - // + Modifier modify() throws IllegalStateException; /** - * {@inheritDoc} + * Allows modifying an album. Modifications are only performed once {@link + * #update()} has succesfully returned a new album with the modifications + * made. */ - @Override - public String getFingerprint() { - StringBuilder fingerprint = new StringBuilder(); - fingerprint.append("Album("); - fingerprint.append("ID(").append(id).append(')'); - fingerprint.append("Name(").append(name).append(')'); - fingerprint.append("Description(").append(description).append(')'); - - /* add nested albums. */ - fingerprint.append("Albums("); - for (Album album : albums) { - fingerprint.append(album.getFingerprint()); - } - fingerprint.append(')'); + interface Modifier { - /* add images. */ - fingerprint.append("Images("); - for (Image image : images) { - fingerprint.append(image.getFingerprint()); - } - fingerprint.append(')'); + Modifier setTitle(String title); - fingerprint.append(')'); - return fingerprint.toString(); - } + Modifier setDescription(String description); - // - // OBJECT METHODS - // + Album update() throws IllegalStateException; + + class AlbumTitleMustNotBeEmpty extends IllegalStateException { } - /** - * {@inheritDoc} - */ - @Override - public boolean equals(Object object) { - if (!(object instanceof Album)) { - return false; - } - Album album = (Album) object; - return id.equals(album.id); } }