X-Git-Url: https://git.pterodactylus.net/?a=blobdiff_plain;f=src%2Fmain%2Fjava%2Fnet%2Fpterodactylus%2Fsone%2Fdatabase%2Fmemory%2FMemoryDatabase.java;h=538d97fa8efbd7d99103a063a498f0f0c2ceb2fe;hb=d37132932d423abaca088fdf3496b9b0f38e3ae3;hp=35d3c379276af50e349069b88859b2668120c84f;hpb=a43efdbac39a7462d5b9392ac064ea0e1042abb4;p=Sone.git diff --git a/src/main/java/net/pterodactylus/sone/database/memory/MemoryDatabase.java b/src/main/java/net/pterodactylus/sone/database/memory/MemoryDatabase.java index 35d3c37..538d97f 100644 --- a/src/main/java/net/pterodactylus/sone/database/memory/MemoryDatabase.java +++ b/src/main/java/net/pterodactylus/sone/database/memory/MemoryDatabase.java @@ -17,11 +17,17 @@ package net.pterodactylus.sone.database.memory; +import static com.google.common.base.Optional.fromNullable; import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.base.Predicates.not; +import static com.google.common.collect.FluentIterable.from; +import static java.util.Collections.emptyList; +import static net.pterodactylus.sone.data.Sone.LOCAL_SONE_FILTER; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; +import java.util.Comparator; import java.util.HashMap; import java.util.HashSet; import java.util.List; @@ -29,26 +35,30 @@ import java.util.Map; import java.util.Set; import java.util.SortedSet; import java.util.TreeSet; -import java.util.UUID; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; +import net.pterodactylus.sone.data.Album; +import net.pterodactylus.sone.data.Image; import net.pterodactylus.sone.data.Post; import net.pterodactylus.sone.data.PostReply; import net.pterodactylus.sone.data.Reply; import net.pterodactylus.sone.data.Sone; -import net.pterodactylus.sone.data.impl.AbstractPostBuilder; -import net.pterodactylus.sone.data.impl.AbstractPostReplyBuilder; import net.pterodactylus.sone.database.Database; import net.pterodactylus.sone.database.DatabaseException; import net.pterodactylus.sone.database.PostBuilder; import net.pterodactylus.sone.database.PostDatabase; import net.pterodactylus.sone.database.PostReplyBuilder; -import net.pterodactylus.sone.database.SoneProvider; +import net.pterodactylus.sone.database.SoneBuilder; import net.pterodactylus.util.config.Configuration; import net.pterodactylus.util.config.ConfigurationException; +import com.google.common.base.Function; import com.google.common.base.Optional; +import com.google.common.collect.ArrayListMultimap; +import com.google.common.collect.ListMultimap; +import com.google.common.collect.SortedSetMultimap; +import com.google.common.collect.TreeMultimap; import com.google.common.util.concurrent.AbstractService; import com.google.inject.Inject; @@ -62,12 +72,11 @@ public class MemoryDatabase extends AbstractService implements Database { /** The lock. */ private final ReadWriteLock lock = new ReentrantReadWriteLock(); - /** The Sone provider. */ - private final SoneProvider soneProvider; - /** The configuration. */ private final Configuration configuration; + private final Map sones = new HashMap(); + /** All posts by their ID. */ private final Map allPosts = new HashMap(); @@ -83,23 +92,35 @@ public class MemoryDatabase extends AbstractService implements Database { /** All post replies by their ID. */ private final Map allPostReplies = new HashMap(); + /** Replies sorted by Sone. */ + private final SortedSetMultimap sonePostReplies = TreeMultimap.create(new Comparator() { + + @Override + public int compare(String leftString, String rightString) { + return leftString.compareTo(rightString); + } + }, PostReply.TIME_COMPARATOR); + /** Replies by post. */ private final Map> postReplies = new HashMap>(); /** Whether post replies are known. */ private final Set knownPostReplies = new HashSet(); + private final Map allAlbums = new HashMap(); + private final ListMultimap albumChildren = ArrayListMultimap.create(); + private final ListMultimap albumImages = ArrayListMultimap.create(); + + private final Map allImages = new HashMap(); + /** * Creates a new memory database. * - * @param soneProvider - * The Sone provider * @param configuration - * The configuration for loading and saving elements + * The configuration for loading and saving elements */ @Inject - public MemoryDatabase(SoneProvider soneProvider, Configuration configuration) { - this.soneProvider = soneProvider; + public MemoryDatabase(Configuration configuration) { this.configuration = configuration; } @@ -111,7 +132,7 @@ public class MemoryDatabase extends AbstractService implements Database { * Saves the database. * * @throws DatabaseException - * if an error occurs while saving + * if an error occurs while saving */ @Override public void save() throws DatabaseException { @@ -123,9 +144,7 @@ public class MemoryDatabase extends AbstractService implements Database { // SERVICE METHODS // - /** - * {@inheritDocs} - */ + /** {@inheritDocs} */ @Override protected void doStart() { loadKnownPosts(); @@ -133,9 +152,7 @@ public class MemoryDatabase extends AbstractService implements Database { notifyStarted(); } - /** - * {@inheritDocs} - */ + /** {@inheritDocs} */ @Override protected void doStop() { try { @@ -146,40 +163,79 @@ public class MemoryDatabase extends AbstractService implements Database { } } + @Override + public Optional getSone(String soneId) { + lock.readLock().lock(); + try { + return fromNullable(sones.get(soneId)); + } finally { + lock.readLock().unlock(); + } + } + + @Override + public Collection getSones() { + lock.readLock().lock(); + try { + return Collections.unmodifiableCollection(sones.values()); + } finally { + lock.readLock().unlock(); + } + } + + @Override + public Collection getLocalSones() { + lock.readLock().lock(); + try { + return from(getSones()).filter(LOCAL_SONE_FILTER).toSet(); + } finally { + lock.readLock().unlock(); + } + } + + @Override + public Collection getRemoteSones() { + lock.readLock().lock(); + try { + return from(getSones()).filter(not(LOCAL_SONE_FILTER)).toSet(); + } finally { + lock.readLock().unlock(); + } + } + + @Override + public SoneBuilder newSoneBuilder() { + return null; + } + // // POSTPROVIDER METHODS // - /** - * {@inheritDocs} - */ + /** {@inheritDocs} */ @Override public Optional getPost(String postId) { lock.readLock().lock(); try { - return Optional.fromNullable(allPosts.get(postId)); + return fromNullable(allPosts.get(postId)); } finally { lock.readLock().unlock(); } } - /** - * {@inheritDocs} - */ + /** {@inheritDocs} */ @Override public Collection getPosts(String soneId) { return new HashSet(getPostsFrom(soneId)); } - /** - * {@inheritDocs} - */ + /** {@inheritDocs} */ @Override public Collection getDirectedPosts(String recipientId) { lock.readLock().lock(); try { Collection posts = recipientPosts.get(recipientId); - return (posts == null) ? Collections. emptySet() : new HashSet(posts); + return (posts == null) ? Collections.emptySet() : new HashSet(posts); } finally { lock.readLock().unlock(); } @@ -189,21 +245,17 @@ public class MemoryDatabase extends AbstractService implements Database { // POSTBUILDERFACTORY METHODS // - /** - * {@inheritDocs} - */ + /** {@inheritDocs} */ @Override public PostBuilder newPostBuilder() { - return new MemoryPostBuilder(soneProvider); + return new MemoryPostBuilder(this); } // // POSTSTORE METHODS // - /** - * {@inheritDocs} - */ + /** {@inheritDocs} */ @Override public void storePost(Post post) { checkNotNull(post, "post must not be null"); @@ -219,9 +271,7 @@ public class MemoryDatabase extends AbstractService implements Database { } } - /** - * {@inheritDocs} - */ + /** {@inheritDocs} */ @Override public void removePost(Post post) { checkNotNull(post, "post must not be null"); @@ -238,9 +288,7 @@ public class MemoryDatabase extends AbstractService implements Database { } } - /** - * {@inheritDocs} - */ + /** {@inheritDocs} */ @Override public void storePosts(Sone sone, Collection posts) throws IllegalArgumentException { checkNotNull(sone, "sone must not be null"); @@ -275,9 +323,7 @@ public class MemoryDatabase extends AbstractService implements Database { } } - /** - * {@inheritDocs} - */ + /** {@inheritDocs} */ @Override public void removePosts(Sone sone) { checkNotNull(sone, "sone must not be null"); @@ -300,28 +346,24 @@ public class MemoryDatabase extends AbstractService implements Database { // POSTREPLYPROVIDER METHODS // - /** - * {@inheritDocs} - */ + /** {@inheritDocs} */ @Override public Optional getPostReply(String id) { lock.readLock().lock(); try { - return Optional.fromNullable(allPostReplies.get(id)); + return fromNullable(allPostReplies.get(id)); } finally { lock.readLock().unlock(); } } - /** - * {@inheritDocs} - */ + /** {@inheritDocs} */ @Override public List getReplies(String postId) { lock.readLock().lock(); try { if (!postReplies.containsKey(postId)) { - return Collections.emptyList(); + return emptyList(); } return new ArrayList(postReplies.get(postId)); } finally { @@ -333,21 +375,17 @@ public class MemoryDatabase extends AbstractService implements Database { // POSTREPLYBUILDERFACTORY METHODS // - /** - * {@inheritDocs} - */ + /** {@inheritDocs} */ @Override public PostReplyBuilder newPostReplyBuilder() { - return new MemoryPostReplyBuilder(); + return new MemoryPostReplyBuilder(this, this); } // // POSTREPLYSTORE METHODS // - /** - * {@inheritDocs} - */ + /** {@inheritDocs} */ @Override public void storePostReply(PostReply postReply) { lock.writeLock().lock(); @@ -365,9 +403,7 @@ public class MemoryDatabase extends AbstractService implements Database { } } - /** - * {@inheritDocs} - */ + /** {@inheritDocs} */ @Override public void storePostReplies(Sone sone, Collection postReplies) { checkNotNull(sone, "sone must not be null"); @@ -380,8 +416,13 @@ public class MemoryDatabase extends AbstractService implements Database { lock.writeLock().lock(); try { + /* remove all post replies of the Sone. */ + for (PostReply postReply : getRepliesFrom(sone.getId())) { + removePostReply(postReply); + } for (PostReply postReply : postReplies) { allPostReplies.put(postReply.getId(), postReply); + sonePostReplies.put(postReply.getSone().getId(), postReply); if (this.postReplies.containsKey(postReply.getPostId())) { this.postReplies.get(postReply.getPostId()).add(postReply); } else { @@ -395,9 +436,7 @@ public class MemoryDatabase extends AbstractService implements Database { } } - /** - * {@inheritDocs} - */ + /** {@inheritDocs} */ @Override public void removePostReply(PostReply postReply) { lock.writeLock().lock(); @@ -414,9 +453,7 @@ public class MemoryDatabase extends AbstractService implements Database { } } - /** - * {@inheritDocs} - */ + /** {@inheritDocs} */ @Override public void removePostReplies(Sone sone) { checkNotNull(sone, "sone must not be null"); @@ -432,6 +469,106 @@ public class MemoryDatabase extends AbstractService implements Database { } // + // ALBUMPROVDER METHODS + // + + @Override + public Optional getAlbum(String albumId) { + lock.readLock().lock(); + try { + return fromNullable(allAlbums.get(albumId)); + } finally { + lock.readLock().unlock(); + } + } + + @Override + public List getAlbums(Album parent) { + lock.readLock().lock(); + try { + return from(albumChildren.get(parent.getId())).transformAndConcat(getAlbum()).toList(); + } finally { + lock.readLock().unlock(); + } + } + + // + // ALBUMSTORE METHODS + // + + @Override + public void storeAlbum(Album album) { + lock.writeLock().lock(); + try { + allAlbums.put(album.getId(), album); + albumChildren.put(album.getParent().getId(), album.getId()); + } finally { + lock.writeLock().unlock(); + } + } + + @Override + public void removeAlbum(Album album) { + lock.writeLock().lock(); + try { + allAlbums.remove(album.getId()); + albumChildren.remove(album.getParent().getId(), album.getId()); + } finally { + lock.writeLock().unlock(); + } + } + + // + // IMAGEPROVIDER METHODS + // + + @Override + public Optional getImage(String imageId) { + lock.readLock().lock(); + try { + return fromNullable(allImages.get(imageId)); + } finally { + lock.readLock().unlock(); + } + } + + @Override + public List getImages(Album parent) { + lock.readLock().lock(); + try { + return from(albumImages.get(parent.getId())).transformAndConcat(getImage()).toList(); + } finally { + lock.readLock().unlock(); + } + } + + // + // IMAGESTORE METHODS + // + + @Override + public void storeImage(Image image) { + lock.writeLock().lock(); + try { + allImages.put(image.getId(), image); + albumImages.put(image.getAlbum().getId(), image.getId()); + } finally { + lock.writeLock().unlock(); + } + } + + @Override + public void removeImage(Image image) { + lock.writeLock().lock(); + try { + allImages.remove(image.getId()); + albumImages.remove(image.getAlbum().getId(), image.getId()); + } finally { + lock.writeLock().unlock(); + } + } + + // // PACKAGE-PRIVATE METHODS // @@ -439,7 +576,7 @@ public class MemoryDatabase extends AbstractService implements Database { * Returns whether the given post is known. * * @param post - * The post + * The post * @return {@code true} if the post is known, {@code false} otherwise */ boolean isPostKnown(Post post) { @@ -455,9 +592,9 @@ public class MemoryDatabase extends AbstractService implements Database { * Sets whether the given post is known. * * @param post - * The post + * The post * @param known - * {@code true} if the post is known, {@code false} otherwise + * {@code true} if the post is known, {@code false} otherwise */ void setPostKnown(Post post, boolean known) { lock.writeLock().lock(); @@ -476,7 +613,7 @@ public class MemoryDatabase extends AbstractService implements Database { * Returns whether the given post reply is known. * * @param postReply - * The post reply + * The post reply * @return {@code true} if the given post reply is known, {@code false} * otherwise */ @@ -493,10 +630,9 @@ public class MemoryDatabase extends AbstractService implements Database { * Sets whether the given post reply is known. * * @param postReply - * The post reply + * The post reply * @param known - * {@code true} if the post reply is known, {@code false} - * otherwise + * {@code true} if the post reply is known, {@code false} otherwise */ void setPostReplyKnown(PostReply postReply, boolean known) { lock.writeLock().lock(); @@ -511,6 +647,66 @@ public class MemoryDatabase extends AbstractService implements Database { } } + void moveUp(Album album) { + lock.writeLock().lock(); + try { + List albums = albumChildren.get(album.getParent().getId()); + int currentIndex = albums.indexOf(album.getId()); + if (currentIndex == 0) { + return; + } + albums.remove(album.getId()); + albums.add(currentIndex - 1, album.getId()); + } finally { + lock.writeLock().unlock(); + } + } + + void moveDown(Album album) { + lock.writeLock().lock(); + try { + List albums = albumChildren.get(album.getParent().getId()); + int currentIndex = albums.indexOf(album.getId()); + if (currentIndex == (albums.size() - 1)) { + return; + } + albums.remove(album.getId()); + albums.add(currentIndex + 1, album.getId()); + } finally { + lock.writeLock().unlock(); + } + } + + void moveUp(Image image) { + lock.writeLock().lock(); + try { + List images = albumImages.get(image.getAlbum().getId()); + int currentIndex = images.indexOf(image.getId()); + if (currentIndex == 0) { + return; + } + images.remove(image.getId()); + images.add(currentIndex - 1, image.getId()); + } finally { + lock.writeLock().unlock(); + } + } + + void moveDown(Image image) { + lock.writeLock().lock(); + try { + List images = albumChildren.get(image.getAlbum().getId()); + int currentIndex = images.indexOf(image.getId()); + if (currentIndex == (images.size() - 1)) { + return; + } + images.remove(image.getId()); + images.add(currentIndex + 1, image.getId()); + } finally { + lock.writeLock().unlock(); + } + } + // // PRIVATE METHODS // @@ -520,7 +716,7 @@ public class MemoryDatabase extends AbstractService implements Database { * none yet. * * @param soneId - * The ID of the Sone to get the posts for + * The ID of the Sone to get the posts for * @return All posts */ private Collection getPostsFrom(String soneId) { @@ -547,11 +743,11 @@ public class MemoryDatabase extends AbstractService implements Database { } /** - * Gets all posts that are directed the given Sone, creating a new - * collection if there is none yet. + * Gets all posts that are directed the given Sone, creating a new collection + * if there is none yet. * * @param recipientId - * The ID of the Sone to get the posts for + * The ID of the Sone to get the posts for * @return All posts */ private Collection getPostsTo(String recipientId) { @@ -577,9 +773,7 @@ public class MemoryDatabase extends AbstractService implements Database { return posts; } - /** - * Loads the known posts. - */ + /** Loads the known posts. */ private void loadKnownPosts() { lock.writeLock().lock(); try { @@ -600,7 +794,7 @@ public class MemoryDatabase extends AbstractService implements Database { * Saves the known posts to the configuration. * * @throws DatabaseException - * if a configuration error occurs + * if a configuration error occurs */ private void saveKnownPosts() throws DatabaseException { lock.readLock().lock(); @@ -618,8 +812,25 @@ public class MemoryDatabase extends AbstractService implements Database { } /** - * Loads the known post replies. + * Returns all replies by the given Sone. + * + * @param id + * The ID of the Sone + * @return The post replies of the Sone, sorted by time (newest first) */ + private Collection getRepliesFrom(String id) { + lock.readLock().lock(); + try { + if (sonePostReplies.containsKey(id)) { + return Collections.unmodifiableCollection(sonePostReplies.get(id)); + } + return Collections.emptySet(); + } finally { + lock.readLock().unlock(); + } + } + + /** Loads the known post replies. */ private void loadKnownPostReplies() { lock.writeLock().lock(); try { @@ -640,7 +851,7 @@ public class MemoryDatabase extends AbstractService implements Database { * Saves the known post replies to the configuration. * * @throws DatabaseException - * if a configuration error occurs + * if a configuration error occurs */ private void saveKnownPostReplies() throws DatabaseException { lock.readLock().lock(); @@ -657,56 +868,22 @@ public class MemoryDatabase extends AbstractService implements Database { } } - /** - * {@link PostBuilder} implementation that creates a {@link MemoryPost}. - * - * @author David ‘Bombe’ Roden - */ - private class MemoryPostBuilder extends AbstractPostBuilder { - - /** - * Creates a new memory post builder. - * - * @param soneProvider - * The Sone provider - */ - public MemoryPostBuilder(SoneProvider soneProvider) { - super(soneProvider); - } - - /** - * {@inheritDocs} - */ - @Override - public Post build() throws IllegalStateException { - validate(); - Post post = new MemoryPost(MemoryDatabase.this, soneProvider, randomId ? UUID.randomUUID().toString() : id, senderId, recipientId, currentTime ? System.currentTimeMillis() : time, text); - post.setKnown(isPostKnown(post)); - return post; - } - + private Function> getAlbum() { + return new Function>() { + @Override + public Iterable apply(String input) { + return (input == null) ? Collections.emptyList() : getAlbum(input).asSet(); + } + }; } - /** - * {@link PostReplyBuilder} implementation that creates - * {@link MemoryPostReply} objects. - * - * @author David ‘Bombe’ Roden - */ - private class MemoryPostReplyBuilder extends AbstractPostReplyBuilder { - - /** - * {@inheritDocs} - */ - @Override - public PostReply build() throws IllegalStateException { - validate(); - - PostReply postReply = new MemoryPostReply(MemoryDatabase.this, soneProvider, randomId ? UUID.randomUUID().toString() : id, senderId, currentTime ? System.currentTimeMillis() : time, text, postId); - postReply.setKnown(isPostReplyKnown(postReply)); - return postReply; - } - + private Function> getImage() { + return new Function>() { + @Override + public Iterable apply(String input) { + return (input == null) ? Collections.emptyList() : getImage(input).asSet(); + } + }; } }