/*
- * FreenetSone - Sone.java - Copyright © 2010 David Roden
+ * Sone - Sone.java - Copyright © 2010 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
import java.util.logging.Level;
import java.util.logging.Logger;
+import net.pterodactylus.sone.core.Core;
import net.pterodactylus.sone.core.Options;
import net.pterodactylus.sone.freenet.wot.Identity;
+import net.pterodactylus.sone.freenet.wot.OwnIdentity;
import net.pterodactylus.sone.template.SoneAccessor;
import net.pterodactylus.util.filter.Filter;
import net.pterodactylus.util.logging.Logging;
};
+ /**
+ * Comparator that sorts Sones by last activity (least recent active first).
+ */
+ public static final Comparator<Sone> LAST_ACTIVITY_COMPARATOR = new Comparator<Sone>() {
+
+ @Override
+ public int compare(Sone firstSone, Sone secondSone) {
+ return (int) Math.min(Integer.MAX_VALUE, Math.max(Integer.MIN_VALUE, secondSone.getTime() - firstSone.getTime()));
+ }
+ };
+
+ /** Comparator that sorts Sones by numbers of posts (descending). */
+ public static final Comparator<Sone> POST_COUNT_COMPARATOR = new Comparator<Sone>() {
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public int compare(Sone leftSone, Sone rightSone) {
+ return (leftSone.getPosts().size() != rightSone.getPosts().size()) ? (rightSone.getPosts().size() - leftSone.getPosts().size()) : (rightSone.getReplies().size() - leftSone.getReplies().size());
+ }
+ };
+
+ /** Comparator that sorts Sones by number of images (descending). */
+ public static final Comparator<Sone> IMAGE_COUNT_COMPARATOR = new Comparator<Sone>() {
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public int compare(Sone leftSone, Sone rightSone) {
+ return rightSone.getAllImages().size() - leftSone.getAllImages().size();
+ }
+ };
+
/** Filter to remove Sones that have not been downloaded. */
public static final Filter<Sone> EMPTY_SONE_FILTER = new Filter<Sone>() {
}
};
+ /** Filter that matches all {@link Core#isLocalSone(Sone) local Sones}. */
+ public static final Filter<Sone> LOCAL_SONE_FILTER = new Filter<Sone>() {
+
+ @Override
+ public boolean filterObject(Sone sone) {
+ return sone.getIdentity() instanceof OwnIdentity;
+ }
+
+ };
+
+ /** Filter that matches Sones that have at least one album. */
+ public static final Filter<Sone> HAS_ALBUM_FILTER = new Filter<Sone>() {
+
+ @Override
+ public boolean filterObject(Sone sone) {
+ return !sone.getAlbums().isEmpty();
+ }
+ };
+
/** The logger. */
private static final Logger logger = Logging.getLogger(Sone.class);
private final Set<Post> posts = Collections.synchronizedSet(new HashSet<Post>());
/** All replies. */
- private final Set<Reply> replies = Collections.synchronizedSet(new HashSet<Reply>());
+ private final Set<PostReply> replies = Collections.synchronizedSet(new HashSet<PostReply>());
/** The IDs of all liked posts. */
private final Set<String> likedPostIds = Collections.synchronizedSet(new HashSet<String>());
}
/**
- * Sets all friends of this Sone at once.
- *
- * @param friends
- * The new (and only) friends of this Sone
- * @return This Sone (for method chaining)
- */
- public Sone setFriends(Collection<String> friends) {
- friendSones.clear();
- friendSones.addAll(friends);
- return this;
- }
-
- /**
* Returns whether this Sone has the given Sone as a friend Sone.
*
* @param friendSoneId
*
* @return All replies this Sone made
*/
- public synchronized Set<Reply> getReplies() {
+ public synchronized Set<PostReply> getReplies() {
return Collections.unmodifiableSet(replies);
}
* The new (and only) replies of this Sone
* @return This Sone (for method chaining)
*/
- public synchronized Sone setReplies(Collection<Reply> replies) {
+ public synchronized Sone setReplies(Collection<PostReply> replies) {
this.replies.clear();
this.replies.addAll(replies);
return this;
* @param reply
* The reply to add
*/
- public synchronized void addReply(Reply reply) {
+ public synchronized void addReply(PostReply reply) {
if (reply.getSone().equals(this)) {
replies.add(reply);
}
* @param reply
* The reply to remove
*/
- public synchronized void removeReply(Reply reply) {
+ public synchronized void removeReply(PostReply reply) {
if (reply.getSone().equals(this)) {
replies.remove(reply);
}
}
/**
+ * Returns a flattened list of all albums of this Sone. The resulting list
+ * contains parent albums before child albums so that the resulting list can
+ * be parsed in a single pass.
+ *
+ * @return The flattened albums
+ */
+ public List<Album> getAllAlbums() {
+ List<Album> flatAlbums = new ArrayList<Album>();
+ flatAlbums.addAll(albums);
+ int lastAlbumIndex = 0;
+ while (lastAlbumIndex < flatAlbums.size()) {
+ int previousAlbumCount = flatAlbums.size();
+ for (Album album : new ArrayList<Album>(flatAlbums.subList(lastAlbumIndex, flatAlbums.size()))) {
+ flatAlbums.addAll(album.getAlbums());
+ }
+ lastAlbumIndex = previousAlbumCount;
+ }
+ return flatAlbums;
+ }
+
+ /**
+ * Returns all images of a Sone. Images of a album are inserted into this
+ * list before images of all child albums.
+ *
+ * @return The list of all images
+ */
+ public List<Image> getAllImages() {
+ List<Image> allImages = new ArrayList<Image>();
+ for (Album album : getAllAlbums()) {
+ allImages.addAll(album.getImages());
+ }
+ return allImages;
+ }
+
+ /**
* Adds an album to this Sone.
*
* @param 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
+ * <code>null</code> if the album did not change its place
+ */
+ public Album moveAlbumUp(Album album) {
+ Validation.begin().isNotNull("Album", album).check().isEqual("Album Owner", album.getSone(), this).isNull("Album Parent", album.getParent()).check();
+ 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
+ * <code>null</code> if the album did not change its place
+ */
+ public Album moveAlbumDown(Album album) {
+ Validation.begin().isNotNull("Album", album).check().isEqual("Album Owner", album.getSone(), this).isNull("Album Parent", album.getParent()).check();
+ 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 Sone-specific options.
*
* @return The options of this Sone
}
fingerprint.append(")");
- List<Reply> replies = new ArrayList<Reply>(getReplies());
+ List<PostReply> replies = new ArrayList<PostReply>(getReplies());
Collections.sort(replies, Reply.TIME_COMPARATOR);
fingerprint.append("Replies(");
- for (Reply reply : replies) {
+ for (PostReply reply : replies) {
fingerprint.append("Reply(").append(reply.getId()).append(')');
}
fingerprint.append(')');
}
//
- // STATIC METHODS
- //
-
- /**
- * Flattens the given top-level albums so that the resulting list contains
- * parent albums before child albums and the resulting list can be parsed in
- * a single pass.
- *
- * @param albums
- * The albums to flatten
- * @return The flattened albums
- */
- public static List<Album> flattenAlbums(Collection<? extends Album> albums) {
- List<Album> flatAlbums = new ArrayList<Album>();
- flatAlbums.addAll(albums);
- int lastAlbumIndex = 0;
- while (lastAlbumIndex < flatAlbums.size()) {
- int previousAlbumCount = flatAlbums.size();
- for (Album album : new ArrayList<Album>(flatAlbums.subList(lastAlbumIndex, flatAlbums.size()))) {
- flatAlbums.addAll(album.getAlbums());
- }
- lastAlbumIndex = previousAlbumCount;
- }
- return flatAlbums;
- }
-
- //
// INTERFACE Comparable<Sone>
//