Store identities in database.

[Sone.git] / src / main / java / net / pterodactylus / sone / database / memory / MemoryDatabase.java

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 9edab57..df39511 100644 (file)
--- a/src/main/java/net/pterodactylus/sone/database/memory/MemoryDatabase.java
+++ b/src/main/java/net/pterodactylus/sone/database/memory/MemoryDatabase.java
@@ -33,8 +33,6 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.SortedSet;
-import java.util.TreeSet;
 import java.util.concurrent.locks.ReadWriteLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 
@@ -42,8 +40,8 @@ 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.DefaultSoneBuilder;
 import net.pterodactylus.sone.database.Database;
 import net.pterodactylus.sone.database.DatabaseException;
 import net.pterodactylus.sone.database.PostDatabase;
@@ -59,6 +57,7 @@ import com.google.common.collect.HashMultimap;
 import com.google.common.collect.ListMultimap;
 import com.google.common.collect.Maps;
 import com.google.common.collect.Multimap;
+import com.google.common.collect.SetMultimap;
 import com.google.common.collect.SortedSetMultimap;
 import com.google.common.collect.TreeMultimap;
 import com.google.common.util.concurrent.AbstractService;
@@ -85,6 +84,8 @@ public class MemoryDatabase extends AbstractService implements Database {
 
        /** All posts by their Sones. */
        private final Multimap<String, Post> sonePosts = HashMultimap.create();
+       private final SetMultimap<String, String> likedPostsBySone = HashMultimap.create();
+       private final SetMultimap<String, String> postLikingSones = HashMultimap.create();
 
        /** All posts by their recipient. */
        private final Multimap<String, Post> recipientPosts = HashMultimap.create();
@@ -94,6 +95,8 @@ public class MemoryDatabase extends AbstractService implements Database {
 
        /** All post replies by their ID. */
        private final Map<String, PostReply> allPostReplies = new HashMap<String, PostReply>();
+       private final SetMultimap<String, String> likedPostRepliesBySone = HashMultimap.create();
+       private final SetMultimap<String, String> postReplyLikingSones = HashMultimap.create();
 
        /** Replies sorted by Sone. */
        private final SortedSetMultimap<String, PostReply> sonePostReplies = TreeMultimap.create(new Comparator<String>() {
@@ -175,6 +178,26 @@ public class MemoryDatabase extends AbstractService implements Database {
        }
 
        @Override
+       public void storeIdentity(Identity identitiy) {
+               lock.writeLock().lock();
+               try {
+                       identities.put(identitiy.getId(), identitiy);
+               } finally {
+                       lock.writeLock().unlock();
+               }
+       }
+
+       @Override
+       public Function<String, Optional<Sone>> getSone() {
+               return new Function<String, Optional<Sone>>() {
+                       @Override
+                       public Optional<Sone> apply(String soneId) {
+                               return (soneId == null) ? Optional.<Sone>absent() : getSone(soneId);
+                       }
+               };
+       }
+
+       @Override
        public Optional<Sone> getSone(String soneId) {
                lock.readLock().lock();
                try {
@@ -216,7 +239,19 @@ public class MemoryDatabase extends AbstractService implements Database {
 
        @Override
        public SoneBuilder newSoneBuilder() {
-               return null;
+               return new DefaultSoneBuilder(this) {
+                       @Override
+                       public Sone build(Optional<SoneCreated> soneCreated) throws IllegalStateException {
+                               Sone sone = super.build(soneCreated);
+                               lock.writeLock().lock();
+                               try {
+                                       sones.put(sone.getId(), sone);
+                               } finally {
+                                       lock.writeLock().unlock();
+                               }
+                               return sone;
+                       }
+               };
        }
 
        //
@@ -224,6 +259,16 @@ public class MemoryDatabase extends AbstractService implements Database {
        //
 
        @Override
+       public Function<String, Optional<Post>> getPost() {
+               return new Function<String, Optional<Post>>() {
+                       @Override
+                       public Optional<Post> apply(String postId) {
+                               return (postId == null) ? Optional.<Post>absent() : getPost(postId);
+                       }
+               };
+       }
+
+       @Override
        public Optional<Post> getPost(String postId) {
                lock.readLock().lock();
                try {
@@ -254,6 +299,47 @@ public class MemoryDatabase extends AbstractService implements Database {
                }
        }
 
+       @Override
+       public void likePost(Post post, Sone localSone) {
+               lock.writeLock().lock();
+               try {
+                       likedPostsBySone.put(localSone.getId(), post.getId());
+                       postLikingSones.put(post.getId(), localSone.getId());
+               } finally {
+                       lock.writeLock().unlock();
+               }
+       }
+
+       @Override
+       public void unlikePost(Post post, Sone localSone) {
+               lock.writeLock().lock();
+               try {
+                       likedPostsBySone.remove(localSone.getId(), post.getId());
+                       postLikingSones.remove(post.getId(), localSone.getId());
+               } finally {
+                       lock.writeLock().unlock();
+               }
+       }
+
+       public boolean isLiked(Post post, Sone sone) {
+               lock.readLock().lock();
+               try {
+                       return likedPostsBySone.containsEntry(sone.getId(), post.getId());
+               } finally {
+                       lock.readLock().unlock();
+               }
+       }
+
+       @Override
+       public Set<Sone> getLikes(Post post) {
+               lock.readLock().lock();
+               try {
+                       return from(postLikingSones.get(post.getId())).transform(getSone()).transformAndConcat(this.<Sone>unwrap()).toSet();
+               } finally {
+                       lock.readLock().unlock();
+               }
+       }
+
        //
        // POSTSTORE METHODS
        //
@@ -368,6 +454,48 @@ public class MemoryDatabase extends AbstractService implements Database {
                }
        }
 
+       @Override
+       public void likePostReply(PostReply postReply, Sone localSone) {
+               lock.writeLock().lock();
+               try {
+                       likedPostRepliesBySone.put(localSone.getId(), postReply.getId());
+                       postReplyLikingSones.put(postReply.getId(), localSone.getId());
+               } finally {
+                       lock.writeLock().unlock();
+               }
+       }
+
+       @Override
+       public void unlikePostReply(PostReply postReply, Sone localSone) {
+               lock.writeLock().lock();
+               try {
+                       likedPostRepliesBySone.remove(localSone.getId(), postReply.getId());
+                       postReplyLikingSones.remove(postReply.getId(), localSone.getId());
+               } finally {
+                       lock.writeLock().unlock();
+               }
+       }
+
+       @Override
+       public boolean isLiked(PostReply postReply, Sone sone) {
+               lock.readLock().lock();
+               try {
+                       return postReplyLikingSones.containsEntry(postReply.getId(), sone.getId());
+               } finally {
+                       lock.readLock().unlock();
+               }
+       }
+
+       @Override
+       public Set<Sone> getLikes(PostReply postReply) {
+               lock.readLock().lock();
+               try {
+                       return from(postReplyLikingSones.get(postReply.getId())).transform(getSone()).transformAndConcat(this.<Sone>unwrap()).toSet();
+               } finally {
+                       lock.readLock().unlock();
+               }
+       }
+
        //
        // POSTREPLYSTORE METHODS
        //
@@ -526,7 +654,9 @@ public class MemoryDatabase extends AbstractService implements Database {
                lock.writeLock().lock();
                try {
                        allAlbums.put(album.getId(), album);
-                       albumChildren.put(album.getParent().getId(), album.getId());
+                       if (!album.isRoot()) {
+                               albumChildren.put(album.getParent().getId(), album.getId());
+                       }
                } finally {
                        lock.writeLock().unlock();
                }
@@ -783,4 +913,13 @@ public class MemoryDatabase extends AbstractService implements Database {
                };
        }
 
+       private static <T> Function<Optional<T>, Iterable<T>> unwrap() {
+               return new Function<Optional<T>, Iterable<T>>() {
+                       @Override
+                       public Iterable<T> apply(Optional<T> input) {
+                               return (input == null) ? Collections.<T>emptyList() : input.asSet();
+                       }
+               };
+       }
+
 }