src/main/java/net/pterodactylus/sone/database/memory/MemoryBookmarkDatabase.java

   1 package net.pterodactylus.sone.database.memory;
   2
   3 import static com.google.common.collect.FluentIterable.from;
   4
   5 import java.util.HashSet;
   6 import java.util.Set;
   7 import java.util.concurrent.locks.ReadWriteLock;
   8 import java.util.concurrent.locks.ReentrantReadWriteLock;
   9
  10 import net.pterodactylus.sone.data.Post;
  11 import net.pterodactylus.sone.database.BookmarkDatabase;
  12
  13 import com.google.common.base.Function;
  14
  15 /**
  16  * Memory-based {@link BookmarkDatabase} implementation.
  17  *
  18  * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
  19  */
  20 public class MemoryBookmarkDatabase implements BookmarkDatabase {
  21
  22         private final ReadWriteLock lock = new ReentrantReadWriteLock();
  23         private final MemoryDatabase memoryDatabase;
  24         private final ConfigurationLoader configurationLoader;
  25         private final Set<String> bookmarkedPosts = new HashSet<String>();
  26
  27         public MemoryBookmarkDatabase(MemoryDatabase memoryDatabase,
  28                         ConfigurationLoader configurationLoader) {
  29                 this.memoryDatabase = memoryDatabase;
  30                 this.configurationLoader = configurationLoader;
  31         }
  32
  33         public void start() {
  34                 loadBookmarkedPosts();
  35         }
  36
  37         private void loadBookmarkedPosts() {
  38                 Set<String> bookmarkedPosts = configurationLoader.loadBookmarkedPosts();
  39                 lock.writeLock().lock();
  40                 try {
  41                         this.bookmarkedPosts.clear();
  42                         this.bookmarkedPosts.addAll(bookmarkedPosts);
  43                 } finally {
  44                         lock.writeLock().unlock();
  45                 }
  46         }
  47
  48         @Override
  49         public void bookmarkPost(String postId) {
  50                 lock.writeLock().lock();
  51                 try {
  52                         bookmarkedPosts.add(postId);
  53                 } finally {
  54                         lock.writeLock().unlock();
  55                 }
  56         }
  57
  58         @Override
  59         public void bookmarkPost(Post post) {
  60                 lock.writeLock().lock();
  61                 try {
  62                         bookmarkedPosts.add(post.getId());
  63                 } finally {
  64                         lock.writeLock().unlock();
  65                 }
  66         }
  67
  68         @Override
  69         public void unbookmarkPost(Post post) {
  70                 lock.writeLock().lock();
  71                 try {
  72                         bookmarkedPosts.remove(post.getId());
  73                 } finally {
  74                         lock.writeLock().unlock();
  75                 }
  76         }
  77
  78         @Override
  79         public boolean isPostBookmarked(Post post) {
  80                 lock.readLock().lock();
  81                 try {
  82                         return bookmarkedPosts.contains(post.getId());
  83                 } finally {
  84                         lock.readLock().unlock();
  85                 }
  86         }
  87
  88         @Override
  89         public Set<Post> getBookmarkedPosts() {
  90                 lock.readLock().lock();
  91                 try {
  92                         return from(bookmarkedPosts).transformAndConcat(
  93                                         new Function<String, Iterable<Post>>() {
  94                                                 @Override
  95                                                 public Iterable<Post> apply(String postId) {
  96                                                         return memoryDatabase.getPost(postId).asSet();
  97                                                 }
  98                                         }).toSet();
  99                 } finally {
 100                         lock.readLock().unlock();
 101                 }
 102         }
 103
 104 }