X-Git-Url: https://git.pterodactylus.net/?p=Sone.git;a=blobdiff_plain;f=src%2Fmain%2Fjava%2Fnet%2Fpterodactylus%2Fsone%2Fcore%2FCore.java;h=4b7e199a54465ab9a418c5f955b1f78c3ba8a1d1;hp=27e8db86f41900d2b0cc3100ff79e8f9ab97d5b9;hb=f83db349c7bafcd1ad3b8a2c4e2e7e4d7ef66c09;hpb=f4ea1e1b3526175e255831c975d6eea813589f25

diff --git a/src/main/java/net/pterodactylus/sone/core/Core.java b/src/main/java/net/pterodactylus/sone/core/Core.java
index 27e8db8..4b7e199 100644
--- a/src/main/java/net/pterodactylus/sone/core/Core.java
+++ b/src/main/java/net/pterodactylus/sone/core/Core.java
@@ -85,6 +85,9 @@ public class Core implements IdentityListener, UpdateListener {
 	/** The options. */
 	private final Options options = new Options();
 
+	/** The preferences. */
+	private final Preferences preferences = new Preferences(options);
+
 	/** The core listener manager. */
 	private final CoreListenerManager coreListenerManager = new CoreListenerManager(this);
 
@@ -155,6 +158,10 @@ public class Core implements IdentityListener, UpdateListener {
 	/** All known replies. */
 	private Set<String> knownReplies = new HashSet<String>();
 
+	/** All bookmarked posts. */
+	/* synchronize access on itself. */
+	private Set<String> bookmarkedPosts = new HashSet<String>();
+
 	/** Trusted identities, sorted by own identities. */
 	private Map<OwnIdentity, Set<Identity>> trustedIdentities = Collections.synchronizedMap(new HashMap<OwnIdentity, Set<Identity>>());
 
@@ -221,18 +228,8 @@ public class Core implements IdentityListener, UpdateListener {
 	 *
 	 * @return The options of the core
 	 */
-	public Options getOptions() {
-		return options;
-	}
-
-	/**
-	 * Returns whether the “Sone rescue mode” is currently activated.
-	 *
-	 * @return {@code true} if the “Sone rescue mode” is currently activated,
-	 *         {@code false} if it is not
-	 */
-	public boolean isSoneRescueMode() {
-		return options.getBooleanOption("SoneRescueMode").get();
+	public Preferences getPreferences() {
+		return preferences;
 	}
 
 	/**
@@ -415,6 +412,7 @@ public class Core implements IdentityListener, UpdateListener {
 			if ((sone == null) && create) {
 				sone = new Sone(id);
 				localSones.put(id, sone);
+				setSoneStatus(sone, SoneStatus.unknown);
 			}
 			return sone;
 		}
@@ -458,6 +456,7 @@ public class Core implements IdentityListener, UpdateListener {
 			if ((sone == null) && create) {
 				sone = new Sone(id);
 				remoteSones.put(id, sone);
+				setSoneStatus(sone, SoneStatus.unknown);
 			}
 			return sone;
 		}
@@ -492,22 +491,15 @@ public class Core implements IdentityListener, UpdateListener {
 	}
 
 	/**
-	 * Returns whether the given Sone is a new Sone. After this check, the Sone
-	 * is marked as known, i.e. a second call with the same parameters will
-	 * always yield {@code false}.
+	 * Returns whether the Sone with the given ID is a new Sone.
 	 *
-	 * @param sone
-	 *            The sone to check for
+	 * @param soneId
+	 *            The ID of the sone to check for
 	 * @return {@code true} if the given Sone is new, false otherwise
 	 */
-	public boolean isNewSone(Sone sone) {
+	public boolean isNewSone(String soneId) {
 		synchronized (newSones) {
-			boolean isNew = !knownSones.contains(sone.getId()) && newSones.remove(sone.getId());
-			knownSones.add(sone.getId());
-			if (isNew) {
-				coreListenerManager.fireMarkSoneKnown(sone);
-			}
-			return isNew;
+			return !knownSones.contains(soneId) && newSones.contains(soneId);
 		}
 	}
 
@@ -533,7 +525,8 @@ public class Core implements IdentityListener, UpdateListener {
 	 * @return {@code true} if the target Sone is trusted by the origin Sone
 	 */
 	public boolean isSoneTrusted(Sone origin, Sone target) {
-		return trustedIdentities.containsKey(origin) && trustedIdentities.get(origin.getIdentity()).contains(target);
+		Validation.begin().isNotNull("Origin", origin).isNotNull("Target", target).check().isInstanceOf("Origin’s OwnIdentity", origin.getIdentity(), OwnIdentity.class).check();
+		return trustedIdentities.containsKey(origin.getIdentity()) && trustedIdentities.get(origin.getIdentity()).contains(target.getIdentity());
 	}
 
 	/**
@@ -541,7 +534,7 @@ public class Core implements IdentityListener, UpdateListener {
 	 *
 	 * @param postId
 	 *            The ID of the post to get
-	 * @return The post, or {@code null} if there is no such post
+	 * @return The post with the given ID, or a new post with the given ID
 	 */
 	public Post getPost(String postId) {
 		return getPost(postId, true);
@@ -569,8 +562,7 @@ public class Core implements IdentityListener, UpdateListener {
 	}
 
 	/**
-	 * Returns whether the given post ID is new. After this method returns it is
-	 * marked a known post ID.
+	 * Returns whether the given post ID is new.
 	 *
 	 * @param postId
 	 *            The post ID
@@ -578,33 +570,30 @@ public class Core implements IdentityListener, UpdateListener {
 	 *         otherwise
 	 */
 	public boolean isNewPost(String postId) {
-		return isNewPost(postId, true);
+		synchronized (newPosts) {
+			return !knownPosts.contains(postId) && newPosts.contains(postId);
+		}
 	}
 
 	/**
-	 * Returns whether the given post ID is new. If {@code markAsKnown} is
-	 * {@code true} then after this method returns the post ID is marked a known
-	 * post ID.
+	 * Returns all posts that have the given Sone as recipient.
 	 *
-	 * @param postId
-	 *            The post ID
-	 * @param markAsKnown
-	 *            {@code true} to mark the post ID as known, {@code false} to
-	 *            not to mark it as known
-	 * @return {@code true} if the post is considered to be new, {@code false}
-	 *         otherwise
+	 * @see Post#getRecipient()
+	 * @param recipient
+	 *            The recipient of the posts
+	 * @return All posts that have the given Sone as recipient
 	 */
-	public boolean isNewPost(String postId, boolean markAsKnown) {
-		synchronized (newPosts) {
-			boolean isNew = !knownPosts.contains(postId) && newPosts.contains(postId);
-			if (markAsKnown) {
-				Post post = getPost(postId, false);
-				if (post != null) {
-					markPostKnown(post);
+	public Set<Post> getDirectedPosts(Sone recipient) {
+		Validation.begin().isNotNull("Recipient", recipient).check();
+		Set<Post> directedPosts = new HashSet<Post>();
+		synchronized (posts) {
+			for (Post post : posts.values()) {
+				if (recipient.equals(post.getRecipient())) {
+					directedPosts.add(post);
 				}
 			}
-			return isNew;
 		}
+		return directedPosts;
 	}
 
 	/**
@@ -672,30 +661,8 @@ public class Core implements IdentityListener, UpdateListener {
 	 *         otherwise
 	 */
 	public boolean isNewReply(String replyId) {
-		return isNewReply(replyId, true);
-	}
-
-	/**
-	 * Returns whether the reply with the given ID is new.
-	 *
-	 * @param replyId
-	 *            The ID of the reply to check
-	 * @param markAsKnown
-	 *            {@code true} to mark the reply as known, {@code false} to not
-	 *            to mark it as known
-	 * @return {@code true} if the reply is considered to be new, {@code false}
-	 *         otherwise
-	 */
-	public boolean isNewReply(String replyId, boolean markAsKnown) {
 		synchronized (newReplies) {
-			boolean isNew = !knownReplies.contains(replyId) && newReplies.contains(replyId);
-			if (markAsKnown) {
-				Reply reply = getReply(replyId, false);
-				if (reply != null) {
-					markReplyKnown(reply);
-				}
-			}
-			return isNew;
+			return !knownReplies.contains(replyId) && newReplies.contains(replyId);
 		}
 	}
 
@@ -733,6 +700,50 @@ public class Core implements IdentityListener, UpdateListener {
 		return sones;
 	}
 
+	/**
+	 * Returns whether the given post is bookmarked.
+	 *
+	 * @param post
+	 *            The post to check
+	 * @return {@code true} if the given post is bookmarked, {@code false}
+	 *         otherwise
+	 */
+	public boolean isBookmarked(Post post) {
+		return isPostBookmarked(post.getId());
+	}
+
+	/**
+	 * Returns whether the post with the given ID is bookmarked.
+	 *
+	 * @param id
+	 *            The ID of the post to check
+	 * @return {@code true} if the post with the given ID is bookmarked,
+	 *         {@code false} otherwise
+	 */
+	public boolean isPostBookmarked(String id) {
+		synchronized (bookmarkedPosts) {
+			return bookmarkedPosts.contains(id);
+		}
+	}
+
+	/**
+	 * Returns all currently known bookmarked posts.
+	 *
+	 * @return All bookmarked posts
+	 */
+	public Set<Post> getBookmarkedPosts() {
+		Set<Post> posts = new HashSet<Post>();
+		synchronized (bookmarkedPosts) {
+			for (String bookmarkedPostId : bookmarkedPosts) {
+				Post post = getPost(bookmarkedPostId, false);
+				if (post != null) {
+					posts.add(post);
+				}
+			}
+		}
+		return posts;
+	}
+
 	//
 	// ACTIONS
 	//
@@ -819,7 +830,7 @@ public class Core implements IdentityListener, UpdateListener {
 			soneInserters.put(sone, soneInserter);
 			setSoneStatus(sone, SoneStatus.idle);
 			loadSone(sone);
-			if (!isSoneRescueMode()) {
+			if (!preferences.isSoneRescueMode()) {
 				soneInserter.start();
 			}
 			new Thread(new Runnable() {
@@ -827,15 +838,14 @@ public class Core implements IdentityListener, UpdateListener {
 				@Override
 				@SuppressWarnings("synthetic-access")
 				public void run() {
-					if (!isSoneRescueMode()) {
-						soneDownloader.fetchSone(sone);
+					if (!preferences.isSoneRescueMode()) {
 						return;
 					}
 					logger.log(Level.INFO, "Trying to restore Sone from Freenet…");
 					coreListenerManager.fireRescuingSone(sone);
 					lockSone(sone);
 					long edition = sone.getLatestEdition();
-					while (!stopped && (edition >= 0) && isSoneRescueMode()) {
+					while (!stopped && (edition >= 0) && preferences.isSoneRescueMode()) {
 						logger.log(Level.FINE, "Downloading edition " + edition + "…");
 						soneDownloader.fetchSone(sone, sone.getRequestUri().setKeyType("SSK").setDocName("Sone-" + edition));
 						--edition;
@@ -866,6 +876,9 @@ public class Core implements IdentityListener, UpdateListener {
 			return null;
 		}
 		Sone sone = addLocalSone(ownIdentity);
+		sone.getOptions().addBooleanOption("AutoFollow", new DefaultOption<Boolean>(false));
+		sone.addFriend("nwa8lHa271k2QvJ8aa0Ov7IHAV-DFOCFgmDt3X6BpCI");
+		saveSone(sone);
 		return sone;
 	}
 
@@ -895,6 +908,11 @@ public class Core implements IdentityListener, UpdateListener {
 				}
 				if (newSone) {
 					coreListenerManager.fireNewSoneFound(sone);
+					for (Sone localSone : getLocalSones()) {
+						if (localSone.getOptions().getBooleanOption("AutoFollow").get()) {
+							localSone.addFriend(sone.getId());
+						}
+					}
 				}
 			}
 			remoteSones.put(identity.getId(), sone);
@@ -905,7 +923,7 @@ public class Core implements IdentityListener, UpdateListener {
 				@Override
 				@SuppressWarnings("synthetic-access")
 				public void run() {
-					soneDownloader.fetchSone(sone);
+					soneDownloader.fetchSone(sone, sone.getRequestUri());
 				}
 
 			}, "Sone Downloader").start();
@@ -945,7 +963,7 @@ public class Core implements IdentityListener, UpdateListener {
 	public void setTrust(Sone origin, Sone target, int trustValue) {
 		Validation.begin().isNotNull("Trust Origin", origin).check().isInstanceOf("Trust Origin", origin.getIdentity(), OwnIdentity.class).isNotNull("Trust Target", target).isLessOrEqual("Trust Value", trustValue, 100).isGreaterOrEqual("Trust Value", trustValue, -100).check();
 		try {
-			((OwnIdentity) origin.getIdentity()).setTrust(target.getIdentity(), trustValue, options.getStringOption("TrustComment").get());
+			((OwnIdentity) origin.getIdentity()).setTrust(target.getIdentity(), trustValue, preferences.getTrustComment());
 		} catch (WebOfTrustException wote1) {
 			logger.log(Level.WARNING, "Could not set trust for Sone: " + target, wote1);
 		}
@@ -977,7 +995,7 @@ public class Core implements IdentityListener, UpdateListener {
 	 *            The trust target
 	 */
 	public void trustSone(Sone origin, Sone target) {
-		setTrust(origin, target, options.getIntegerOption("PositiveTrust").get());
+		setTrust(origin, target, preferences.getPositiveTrust());
 	}
 
 	/**
@@ -989,7 +1007,7 @@ public class Core implements IdentityListener, UpdateListener {
 	 *            The trust target
 	 */
 	public void distrustSone(Sone origin, Sone target) {
-		setTrust(origin, target, options.getIntegerOption("NegativeTrust").get());
+		setTrust(origin, target, preferences.getNegativeTrust());
 	}
 
 	/**
@@ -1012,7 +1030,7 @@ public class Core implements IdentityListener, UpdateListener {
 	 */
 	public void updateSone(Sone sone) {
 		if (hasSone(sone.getId())) {
-			boolean soneRescueMode = isLocalSone(sone) && isSoneRescueMode();
+			boolean soneRescueMode = isLocalSone(sone) && preferences.isSoneRescueMode();
 			Sone storedSone = getSone(sone.getId());
 			if (!soneRescueMode && !(sone.getTime() > storedSone.getTime())) {
 				logger.log(Level.FINE, "Downloaded Sone %s is not newer than stored Sone %s.", new Object[] { sone, storedSone });
@@ -1027,10 +1045,11 @@ public class Core implements IdentityListener, UpdateListener {
 						}
 					}
 				}
+				List<Post> storedPosts = storedSone.getPosts();
 				synchronized (newPosts) {
 					for (Post post : sone.getPosts()) {
-						post.setSone(getSone(post.getSone().getId()));
-						if (!storedSone.getPosts().contains(post) && !knownPosts.contains(post.getId())) {
+						post.setSone(storedSone);
+						if (!storedPosts.contains(post) && !knownPosts.contains(post.getId())) {
 							newPosts.add(post.getId());
 							coreListenerManager.fireNewPostFound(post);
 						}
@@ -1047,10 +1066,11 @@ public class Core implements IdentityListener, UpdateListener {
 						}
 					}
 				}
+				Set<Reply> storedReplies = storedSone.getReplies();
 				synchronized (newReplies) {
 					for (Reply reply : sone.getReplies()) {
-						reply.setSone(getSone(reply.getSone().getId()));
-						if (!storedSone.getReplies().contains(reply) && !knownReplies.contains(reply.getId())) {
+						reply.setSone(storedSone);
+						if (!storedReplies.contains(reply) && !knownReplies.contains(reply.getId())) {
 							newReplies.add(reply.getId());
 							coreListenerManager.fireNewReplyFound(reply);
 						}
@@ -1123,6 +1143,23 @@ public class Core implements IdentityListener, UpdateListener {
 	}
 
 	/**
+	 * Marks the given Sone as known. If the Sone was {@link #isNewPost(String)
+	 * new} before, a {@link CoreListener#markSoneKnown(Sone)} event is fired.
+	 *
+	 * @param sone
+	 *            The Sone to mark as known
+	 */
+	public void markSoneKnown(Sone sone) {
+		synchronized (newSones) {
+			if (newSones.remove(sone.getId())) {
+				knownSones.add(sone.getId());
+				coreListenerManager.fireMarkSoneKnown(sone);
+				saveConfiguration();
+			}
+		}
+	}
+
+	/**
 	 * Loads and updates the given Sone from the configuration. If any error is
 	 * encountered, loading is aborted and the given Sone is not changed.
 	 *
@@ -1234,6 +1271,10 @@ public class Core implements IdentityListener, UpdateListener {
 			friends.add(friendId);
 		}
 
+		/* load options. */
+		sone.getOptions().addBooleanOption("AutoFollow", new DefaultOption<Boolean>(false));
+		sone.getOptions().getBooleanOption("AutoFollow").set(configuration.getBooleanValue(sonePrefix + "/Options/AutoFollow").getValue(null));
+
 		/* if we’re still here, Sone was loaded successfully. */
 		synchronized (sone) {
 			sone.setTime(soneTime);
@@ -1349,6 +1390,9 @@ public class Core implements IdentityListener, UpdateListener {
 			}
 			configuration.getStringValue(sonePrefix + "/Friends/" + friendCounter + "/ID").setValue(null);
 
+			/* save options. */
+			configuration.getBooleanValue(sonePrefix + "/Options/AutoFollow").setValue(sone.getOptions().getBooleanOption("AutoFollow").getReal());
+
 			configuration.save();
 			logger.log(Level.INFO, "Sone %s saved.", sone);
 		} catch (ConfigurationException ce1) {
@@ -1429,7 +1473,8 @@ public class Core implements IdentityListener, UpdateListener {
 			posts.put(post.getId(), post);
 		}
 		synchronized (newPosts) {
-			knownPosts.add(post.getId());
+			newPosts.add(post.getId());
+			coreListenerManager.fireNewPostFound(post);
 		}
 		sone.addPost(post);
 		saveSone(sone);
@@ -1451,6 +1496,11 @@ public class Core implements IdentityListener, UpdateListener {
 		synchronized (posts) {
 			posts.remove(post.getId());
 		}
+		coreListenerManager.firePostRemoved(post);
+		synchronized (newPosts) {
+			markPostKnown(post);
+			knownPosts.remove(post.getId());
+		}
 		saveSone(post.getSone());
 	}
 
@@ -1472,6 +1522,50 @@ public class Core implements IdentityListener, UpdateListener {
 	}
 
 	/**
+	 * Bookmarks the given post.
+	 *
+	 * @param post
+	 *            The post to bookmark
+	 */
+	public void bookmark(Post post) {
+		bookmarkPost(post.getId());
+	}
+
+	/**
+	 * Bookmarks the post with the given ID.
+	 *
+	 * @param id
+	 *            The ID of the post to bookmark
+	 */
+	public void bookmarkPost(String id) {
+		synchronized (bookmarkedPosts) {
+			bookmarkedPosts.add(id);
+		}
+	}
+
+	/**
+	 * Removes the given post from the bookmarks.
+	 *
+	 * @param post
+	 *            The post to unbookmark
+	 */
+	public void unbookmark(Post post) {
+		unbookmarkPost(post.getId());
+	}
+
+	/**
+	 * Removes the post with the given ID from the bookmarks.
+	 *
+	 * @param id
+	 *            The ID of the post to unbookmark
+	 */
+	public void unbookmarkPost(String id) {
+		synchronized (bookmarkedPosts) {
+			bookmarkedPosts.remove(id);
+		}
+	}
+
+	/**
 	 * Creates a new reply.
 	 *
 	 * @param sone
@@ -1509,7 +1603,8 @@ public class Core implements IdentityListener, UpdateListener {
 			replies.put(reply.getId(), reply);
 		}
 		synchronized (newReplies) {
-			knownReplies.add(reply.getId());
+			newReplies.add(reply.getId());
+			coreListenerManager.fireNewReplyFound(reply);
 		}
 		sone.addReply(reply);
 		saveSone(sone);
@@ -1531,6 +1626,10 @@ public class Core implements IdentityListener, UpdateListener {
 		synchronized (replies) {
 			replies.remove(reply.getId());
 		}
+		synchronized (newReplies) {
+			markReplyKnown(reply);
+			knownReplies.remove(reply.getId());
+		}
 		sone.removeReply(reply);
 		saveSone(sone);
 	}
@@ -1593,6 +1692,7 @@ public class Core implements IdentityListener, UpdateListener {
 		try {
 			configuration.getIntValue("Option/ConfigurationVersion").setValue(0);
 			configuration.getIntValue("Option/InsertionDelay").setValue(options.getIntegerOption("InsertionDelay").getReal());
+			configuration.getIntValue("Option/PostsPerPage").setValue(options.getIntegerOption("PostsPerPage").getReal());
 			configuration.getIntValue("Option/PositiveTrust").setValue(options.getIntegerOption("PositiveTrust").getReal());
 			configuration.getIntValue("Option/NegativeTrust").setValue(options.getIntegerOption("NegativeTrust").getReal());
 			configuration.getStringValue("Option/TrustComment").setValue(options.getStringOption("TrustComment").getReal());
@@ -1627,6 +1727,15 @@ public class Core implements IdentityListener, UpdateListener {
 				configuration.getStringValue("KnownReplies/" + replyCounter + "/ID").setValue(null);
 			}
 
+			/* save bookmarked posts. */
+			int bookmarkedPostCounter = 0;
+			synchronized (bookmarkedPosts) {
+				for (String bookmarkedPostId : bookmarkedPosts) {
+					configuration.getStringValue("Bookmarks/Post/" + bookmarkedPostCounter++ + "/ID").setValue(bookmarkedPostId);
+				}
+			}
+			configuration.getStringValue("Bookmarks/Post/" + bookmarkedPostCounter++ + "/ID").setValue(null);
+
 			/* now save it. */
 			configuration.save();
 
@@ -1657,8 +1766,9 @@ public class Core implements IdentityListener, UpdateListener {
 			}
 
 		}));
+		options.addIntegerOption("PostsPerPage", new DefaultOption<Integer>(10));
 		options.addIntegerOption("PositiveTrust", new DefaultOption<Integer>(75));
-		options.addIntegerOption("NegativeTrust", new DefaultOption<Integer>(-100));
+		options.addIntegerOption("NegativeTrust", new DefaultOption<Integer>(-25));
 		options.addStringOption("TrustComment", new DefaultOption<String>("Set from Sone Web Interface"));
 		options.addBooleanOption("SoneRescueMode", new DefaultOption<Boolean>(false));
 		options.addBooleanOption("ClearOnNextRestart", new DefaultOption<Boolean>(false));
@@ -1676,6 +1786,7 @@ public class Core implements IdentityListener, UpdateListener {
 		}
 
 		options.getIntegerOption("InsertionDelay").set(configuration.getIntValue("Option/InsertionDelay").getValue(null));
+		options.getIntegerOption("PostsPerPage").set(configuration.getIntValue("Option/PostsPerPage").getValue(null));
 		options.getIntegerOption("PositiveTrust").set(configuration.getIntValue("Option/PositiveTrust").getValue(null));
 		options.getIntegerOption("NegativeTrust").set(configuration.getIntValue("Option/NegativeTrust").getValue(null));
 		options.getStringOption("TrustComment").set(configuration.getStringValue("Option/TrustComment").getValue(null));
@@ -1717,6 +1828,18 @@ public class Core implements IdentityListener, UpdateListener {
 			}
 		}
 
+		/* load bookmarked posts. */
+		int bookmarkedPostCounter = 0;
+		while (true) {
+			String bookmarkedPostId = configuration.getStringValue("Bookmarks/Post/" + bookmarkedPostCounter++ + "/ID").getValue(null);
+			if (bookmarkedPostId == null) {
+				break;
+			}
+			synchronized (bookmarkedPosts) {
+				bookmarkedPosts.add(bookmarkedPostId);
+			}
+		}
+
 	}
 
 	/**
@@ -1783,6 +1906,8 @@ public class Core implements IdentityListener, UpdateListener {
 			public void run() {
 				Sone sone = getRemoteSone(identity.getId());
 				sone.setIdentity(identity);
+				sone.setLatestEdition(Numbers.safeParseLong(identity.getProperty("Sone.LatestEdition"), sone.getLatestEdition()));
+				soneDownloader.addSone(sone);
 				soneDownloader.fetchSone(sone);
 			}
 		}).start();
@@ -1804,8 +1929,216 @@ public class Core implements IdentityListener, UpdateListener {
 	 * {@inheritDoc}
 	 */
 	@Override
-	public void updateFound(Version version, long releaseTime) {
-		coreListenerManager.fireUpdateFound(version, releaseTime);
+	public void updateFound(Version version, long releaseTime, long latestEdition) {
+		coreListenerManager.fireUpdateFound(version, releaseTime, latestEdition);
+	}
+
+	/**
+	 * Convenience interface for external classes that want to access the core’s
+	 * configuration.
+	 *
+	 * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
+	 */
+	public static class Preferences {
+
+		/** The wrapped options. */
+		private final Options options;
+
+		/**
+		 * Creates a new preferences object wrapped around the given options.
+		 *
+		 * @param options
+		 *            The options to wrap
+		 */
+		public Preferences(Options options) {
+			this.options = options;
+		}
+
+		/**
+		 * Returns the insertion delay.
+		 *
+		 * @return The insertion delay
+		 */
+		public int getInsertionDelay() {
+			return options.getIntegerOption("InsertionDelay").get();
+		}
+
+		/**
+		 * Sets the insertion delay
+		 *
+		 * @param insertionDelay
+		 *            The new insertion delay, or {@code null} to restore it to
+		 *            the default value
+		 * @return This preferences
+		 */
+		public Preferences setInsertionDelay(Integer insertionDelay) {
+			options.getIntegerOption("InsertionDelay").set(insertionDelay);
+			return this;
+		}
+
+		/**
+		 * Returns the number of posts to show per page.
+		 *
+		 * @return The number of posts to show per page
+		 */
+		public int getPostsPerPage() {
+			return options.getIntegerOption("PostsPerPage").get();
+		}
+
+		/**
+		 * Sets the number of posts to show per page.
+		 *
+		 * @param postsPerPage
+		 *            The number of posts to show per page
+		 * @return This preferences object
+		 */
+		public Preferences setPostsPerPage(Integer postsPerPage) {
+			options.getIntegerOption("PostsPerPage").set(postsPerPage);
+			return this;
+		}
+
+		/**
+		 * Returns the positive trust.
+		 *
+		 * @return The positive trust
+		 */
+		public int getPositiveTrust() {
+			return options.getIntegerOption("PositiveTrust").get();
+		}
+
+		/**
+		 * Sets the positive trust.
+		 *
+		 * @param positiveTrust
+		 *            The new positive trust, or {@code null} to restore it to
+		 *            the default vlaue
+		 * @return This preferences
+		 */
+		public Preferences setPositiveTrust(Integer positiveTrust) {
+			options.getIntegerOption("PositiveTrust").set(positiveTrust);
+			return this;
+		}
+
+		/**
+		 * Returns the negative trust.
+		 *
+		 * @return The negative trust
+		 */
+		public int getNegativeTrust() {
+			return options.getIntegerOption("NegativeTrust").get();
+		}
+
+		/**
+		 * Sets the negative trust.
+		 *
+		 * @param negativeTrust
+		 *            The negative trust, or {@code null} to restore it to the
+		 *            default value
+		 * @return The preferences
+		 */
+		public Preferences setNegativeTrust(Integer negativeTrust) {
+			options.getIntegerOption("NegativeTrust").set(negativeTrust);
+			return this;
+		}
+
+		/**
+		 * Returns the trust comment. This is the comment that is set in the web
+		 * of trust when a trust value is assigned to an identity.
+		 *
+		 * @return The trust comment
+		 */
+		public String getTrustComment() {
+			return options.getStringOption("TrustComment").get();
+		}
+
+		/**
+		 * Sets the trust comment.
+		 *
+		 * @param trustComment
+		 *            The trust comment, or {@code null} to restore it to the
+		 *            default value
+		 * @return This preferences
+		 */
+		public Preferences setTrustComment(String trustComment) {
+			options.getStringOption("TrustComment").set(trustComment);
+			return this;
+		}
+
+		/**
+		 * Returns whether the rescue mode is active.
+		 *
+		 * @return {@code true} if the rescue mode is active, {@code false}
+		 *         otherwise
+		 */
+		public boolean isSoneRescueMode() {
+			return options.getBooleanOption("SoneRescueMode").get();
+		}
+
+		/**
+		 * Sets whether the rescue mode is active.
+		 *
+		 * @param soneRescueMode
+		 *            {@code true} if the rescue mode is active, {@code false}
+		 *            otherwise
+		 * @return This preferences
+		 */
+		public Preferences setSoneRescueMode(Boolean soneRescueMode) {
+			options.getBooleanOption("SoneRescueMode").set(soneRescueMode);
+			return this;
+		}
+
+		/**
+		 * Returns whether Sone should clear its settings on the next restart.
+		 * In order to be effective, {@link #isReallyClearOnNextRestart()} needs
+		 * to return {@code true} as well!
+		 *
+		 * @return {@code true} if Sone should clear its settings on the next
+		 *         restart, {@code false} otherwise
+		 */
+		public boolean isClearOnNextRestart() {
+			return options.getBooleanOption("ClearOnNextRestart").get();
+		}
+
+		/**
+		 * Sets whether Sone will clear its settings on the next restart.
+		 *
+		 * @param clearOnNextRestart
+		 *            {@code true} if Sone should clear its settings on the next
+		 *            restart, {@code false} otherwise
+		 * @return This preferences
+		 */
+		public Preferences setClearOnNextRestart(Boolean clearOnNextRestart) {
+			options.getBooleanOption("ClearOnNextRestart").set(clearOnNextRestart);
+			return this;
+		}
+
+		/**
+		 * Returns whether Sone should really clear its settings on next
+		 * restart. This is a confirmation option that needs to be set in
+		 * addition to {@link #isClearOnNextRestart()} in order to clear Sone’s
+		 * settings on the next restart.
+		 *
+		 * @return {@code true} if Sone should really clear its settings on the
+		 *         next restart, {@code false} otherwise
+		 */
+		public boolean isReallyClearOnNextRestart() {
+			return options.getBooleanOption("ReallyClearOnNextRestart").get();
+		}
+
+		/**
+		 * Sets whether Sone should really clear its settings on the next
+		 * restart.
+		 *
+		 * @param reallyClearOnNextRestart
+		 *            {@code true} if Sone should really clear its settings on
+		 *            the next restart, {@code false} otherwise
+		 * @return This preferences
+		 */
+		public Preferences setReallyClearOnNextRestart(Boolean reallyClearOnNextRestart) {
+			options.getBooleanOption("ReallyClearOnNextRestart").set(reallyClearOnNextRestart);
+			return this;
+		}
+
 	}
 
 }