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