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=225e3e6181b30d772ff1811bc1bf6e26da617ec7;hb=f83db349c7bafcd1ad3b8a2c4e2e7e4d7ef66c09;hpb=cbeea5bd399143abd649bd295729137a886de3b6

diff --git a/src/main/java/net/pterodactylus/sone/core/Core.java b/src/main/java/net/pterodactylus/sone/core/Core.java
index 225e3e6..4b7e199 100644
--- a/src/main/java/net/pterodactylus/sone/core/Core.java
+++ b/src/main/java/net/pterodactylus/sone/core/Core.java
@@ -34,17 +34,22 @@ import net.pterodactylus.sone.core.Options.OptionWatcher;
 import net.pterodactylus.sone.data.Client;
 import net.pterodactylus.sone.data.Post;
 import net.pterodactylus.sone.data.Profile;
+import net.pterodactylus.sone.data.Profile.Field;
 import net.pterodactylus.sone.data.Reply;
 import net.pterodactylus.sone.data.Sone;
 import net.pterodactylus.sone.freenet.wot.Identity;
 import net.pterodactylus.sone.freenet.wot.IdentityListener;
 import net.pterodactylus.sone.freenet.wot.IdentityManager;
 import net.pterodactylus.sone.freenet.wot.OwnIdentity;
+import net.pterodactylus.sone.freenet.wot.Trust;
+import net.pterodactylus.sone.freenet.wot.WebOfTrustException;
 import net.pterodactylus.sone.main.SonePlugin;
 import net.pterodactylus.util.config.Configuration;
 import net.pterodactylus.util.config.ConfigurationException;
 import net.pterodactylus.util.logging.Logging;
 import net.pterodactylus.util.number.Numbers;
+import net.pterodactylus.util.validation.Validation;
+import net.pterodactylus.util.version.Version;
 import freenet.keys.FreenetURI;
 
 /**
@@ -52,7 +57,7 @@ import freenet.keys.FreenetURI;
  *
  * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
  */
-public class Core implements IdentityListener {
+public class Core implements IdentityListener, UpdateListener {
 
 	/**
 	 * Enumeration for the possible states of a {@link Sone}.
@@ -80,11 +85,17 @@ public class Core implements IdentityListener {
 	/** 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);
 
 	/** The configuration. */
-	private final Configuration configuration;
+	private Configuration configuration;
+
+	/** Whether we’re currently saving the configuration. */
+	private boolean storingConfiguration = false;
 
 	/** The identity manager. */
 	private final IdentityManager identityManager;
@@ -95,6 +106,9 @@ public class Core implements IdentityListener {
 	/** The Sone downloader. */
 	private final SoneDownloader soneDownloader;
 
+	/** The update checker. */
+	private final UpdateChecker updateChecker;
+
 	/** Whether the core has been stopped. */
 	private volatile boolean stopped;
 
@@ -144,6 +158,13 @@ public class Core implements IdentityListener {
 	/** 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>>());
+
 	/**
 	 * Creates a new core.
 	 *
@@ -159,6 +180,7 @@ public class Core implements IdentityListener {
 		this.freenetInterface = freenetInterface;
 		this.identityManager = identityManager;
 		this.soneDownloader = new SoneDownloader(this, freenetInterface);
+		this.updateChecker = new UpdateChecker(freenetInterface);
 	}
 
 	//
@@ -190,22 +212,24 @@ public class Core implements IdentityListener {
 	//
 
 	/**
-	 * Returns the options used by the core.
+	 * Sets the configuration to use. This will automatically save the current
+	 * configuration to the given configuration.
 	 *
-	 * @return The options of the core
+	 * @param configuration
+	 *            The new configuration to use
 	 */
-	public Options getOptions() {
-		return options;
+	public void setConfiguration(Configuration configuration) {
+		this.configuration = configuration;
+		saveConfiguration();
 	}
 
 	/**
-	 * Returns whether the “Sone rescue mode” is currently activated.
+	 * Returns the options used by the core.
 	 *
-	 * @return {@code true} if the “Sone rescue mode” is currently activated,
-	 *         {@code false} if it is not
+	 * @return The options of the core
 	 */
-	public boolean isSoneRescueMode() {
-		return options.getBooleanOption("SoneRescueMode").get();
+	public Preferences getPreferences() {
+		return preferences;
 	}
 
 	/**
@@ -218,6 +242,15 @@ public class Core implements IdentityListener {
 	}
 
 	/**
+	 * Returns the update checker.
+	 *
+	 * @return The update checker
+	 */
+	public UpdateChecker getUpdateChecker() {
+		return updateChecker;
+	}
+
+	/**
 	 * Returns the status of the given Sone.
 	 *
 	 * @param sone
@@ -379,6 +412,7 @@ public class Core implements IdentityListener {
 			if ((sone == null) && create) {
 				sone = new Sone(id);
 				localSones.put(id, sone);
+				setSoneStatus(sone, SoneStatus.unknown);
 			}
 			return sone;
 		}
@@ -422,6 +456,7 @@ public class Core implements IdentityListener {
 			if ((sone == null) && create) {
 				sone = new Sone(id);
 				remoteSones.put(id, sone);
+				setSoneStatus(sone, SoneStatus.unknown);
 			}
 			return sone;
 		}
@@ -456,22 +491,15 @@ public class Core implements IdentityListener {
 	}
 
 	/**
-	 * 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);
 		}
 	}
 
@@ -488,11 +516,25 @@ public class Core implements IdentityListener {
 	}
 
 	/**
+	 * Returns whether the target Sone is trusted by the origin Sone.
+	 *
+	 * @param origin
+	 *            The origin Sone
+	 * @param target
+	 *            The target Sone
+	 * @return {@code true} if the target Sone is trusted by the origin Sone
+	 */
+	public boolean isSoneTrusted(Sone origin, Sone 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());
+	}
+
+	/**
 	 * Returns the post with the given ID.
 	 *
 	 * @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);
@@ -520,8 +562,7 @@ public class Core implements IdentityListener {
 	}
 
 	/**
-	 * 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
@@ -530,26 +571,59 @@ public class Core implements IdentityListener {
 	 */
 	public boolean isNewPost(String postId) {
 		synchronized (newPosts) {
-			boolean isNew = !knownPosts.contains(postId) && newPosts.remove(postId);
-			knownPosts.add(postId);
-			if (isNew) {
-				coreListenerManager.fireMarkPostKnown(getPost(postId));
+			return !knownPosts.contains(postId) && newPosts.contains(postId);
+		}
+	}
+
+	/**
+	 * Returns all posts that have the given Sone as recipient.
+	 *
+	 * @see Post#getRecipient()
+	 * @param recipient
+	 *            The recipient of the posts
+	 * @return All posts that have the given Sone as recipient
+	 */
+	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;
 	}
 
 	/**
-	 * Returns the reply with the given ID.
+	 * Returns the reply with the given ID. If there is no reply with the given
+	 * ID yet, a new one is created.
 	 *
 	 * @param replyId
 	 *            The ID of the reply to get
-	 * @return The reply, or {@code null} if there is no such reply
+	 * @return The reply
 	 */
 	public Reply getReply(String replyId) {
+		return getReply(replyId, true);
+	}
+
+	/**
+	 * Returns the reply with the given ID. If there is no reply with the given
+	 * ID yet, a new one is created, unless {@code create} is false in which
+	 * case {@code null} is returned.
+	 *
+	 * @param replyId
+	 *            The ID of the reply to get
+	 * @param create
+	 *            {@code true} to always return a {@link Reply}, {@code false}
+	 *            to return {@code null} if no reply can be found
+	 * @return The reply, or {@code null} if there is no such reply
+	 */
+	public Reply getReply(String replyId, boolean create) {
 		synchronized (replies) {
 			Reply reply = replies.get(replyId);
-			if (reply == null) {
+			if (create && (reply == null)) {
 				reply = new Reply(replyId);
 				replies.put(replyId, reply);
 			}
@@ -588,12 +662,7 @@ public class Core implements IdentityListener {
 	 */
 	public boolean isNewReply(String replyId) {
 		synchronized (newReplies) {
-			boolean isNew = !knownReplies.contains(replyId) && newReplies.remove(replyId);
-			knownReplies.add(replyId);
-			if (isNew) {
-				coreListenerManager.fireMarkReplyKnown(getReply(replyId));
-			}
-			return isNew;
+			return !knownReplies.contains(replyId) && newReplies.contains(replyId);
 		}
 	}
 
@@ -631,6 +700,50 @@ public class Core implements IdentityListener {
 		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
 	//
@@ -645,7 +758,9 @@ public class Core implements IdentityListener {
 	 */
 	public void lockSone(Sone sone) {
 		synchronized (lockedSones) {
-			lockedSones.add(sone);
+			if (lockedSones.add(sone)) {
+				coreListenerManager.fireSoneLocked(sone);
+			}
 		}
 	}
 
@@ -658,7 +773,9 @@ public class Core implements IdentityListener {
 	 */
 	public void unlockSone(Sone sone) {
 		synchronized (lockedSones) {
-			lockedSones.remove(sone);
+			if (lockedSones.remove(sone)) {
+				coreListenerManager.fireSoneUnlocked(sone);
+			}
 		}
 	}
 
@@ -713,7 +830,7 @@ public class Core implements IdentityListener {
 			soneInserters.put(sone, soneInserter);
 			setSoneStatus(sone, SoneStatus.idle);
 			loadSone(sone);
-			if (!isSoneRescueMode()) {
+			if (!preferences.isSoneRescueMode()) {
 				soneInserter.start();
 			}
 			new Thread(new Runnable() {
@@ -721,15 +838,14 @@ public class Core implements IdentityListener {
 				@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;
@@ -753,8 +869,16 @@ public class Core implements IdentityListener {
 	 * @return The created Sone
 	 */
 	public Sone createSone(OwnIdentity ownIdentity) {
-		identityManager.addContext(ownIdentity, "Sone");
+		try {
+			ownIdentity.addContext("Sone");
+		} catch (WebOfTrustException wote1) {
+			logger.log(Level.SEVERE, "Could not add “Sone” context to own identity: " + ownIdentity, wote1);
+			return null;
+		}
 		Sone sone = addLocalSone(ownIdentity);
+		sone.getOptions().addBooleanOption("AutoFollow", new DefaultOption<Boolean>(false));
+		sone.addFriend("nwa8lHa271k2QvJ8aa0Ov7IHAV-DFOCFgmDt3X6BpCI");
+		saveSone(sone);
 		return sone;
 	}
 
@@ -784,6 +908,11 @@ public class Core implements IdentityListener {
 				}
 				if (newSone) {
 					coreListenerManager.fireNewSoneFound(sone);
+					for (Sone localSone : getLocalSones()) {
+						if (localSone.getOptions().getBooleanOption("AutoFollow").get()) {
+							localSone.addFriend(sone.getId());
+						}
+					}
 				}
 			}
 			remoteSones.put(identity.getId(), sone);
@@ -794,7 +923,7 @@ public class Core implements IdentityListener {
 				@Override
 				@SuppressWarnings("synthetic-access")
 				public void run() {
-					soneDownloader.fetchSone(sone);
+					soneDownloader.fetchSone(sone, sone.getRequestUri());
 				}
 
 			}, "Sone Downloader").start();
@@ -803,6 +932,97 @@ public class Core implements IdentityListener {
 	}
 
 	/**
+	 * Retrieves the trust relationship from the origin to the target. If the
+	 * trust relationship can not be retrieved, {@code null} is returned.
+	 *
+	 * @see Identity#getTrust(OwnIdentity)
+	 * @param origin
+	 *            The origin of the trust tree
+	 * @param target
+	 *            The target of the trust
+	 * @return The trust relationship
+	 */
+	public Trust getTrust(Sone origin, Sone target) {
+		if (!isLocalSone(origin)) {
+			logger.log(Level.WARNING, "Tried to get trust from remote Sone: %s", origin);
+			return null;
+		}
+		return target.getIdentity().getTrust((OwnIdentity) origin.getIdentity());
+	}
+
+	/**
+	 * Sets the trust value of the given origin Sone for the target Sone.
+	 *
+	 * @param origin
+	 *            The origin Sone
+	 * @param target
+	 *            The target Sone
+	 * @param trustValue
+	 *            The trust value (from {@code -100} to {@code 100})
+	 */
+	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, preferences.getTrustComment());
+		} catch (WebOfTrustException wote1) {
+			logger.log(Level.WARNING, "Could not set trust for Sone: " + target, wote1);
+		}
+	}
+
+	/**
+	 * Removes any trust assignment for the given target Sone.
+	 *
+	 * @param origin
+	 *            The trust origin
+	 * @param target
+	 *            The trust target
+	 */
+	public void removeTrust(Sone origin, Sone target) {
+		Validation.begin().isNotNull("Trust Origin", origin).isNotNull("Trust Target", target).check().isInstanceOf("Trust Origin Identity", origin.getIdentity(), OwnIdentity.class).check();
+		try {
+			((OwnIdentity) origin.getIdentity()).removeTrust(target.getIdentity());
+		} catch (WebOfTrustException wote1) {
+			logger.log(Level.WARNING, "Could not remove trust for Sone: " + target, wote1);
+		}
+	}
+
+	/**
+	 * Assigns the configured positive trust value for the given target.
+	 *
+	 * @param origin
+	 *            The trust origin
+	 * @param target
+	 *            The trust target
+	 */
+	public void trustSone(Sone origin, Sone target) {
+		setTrust(origin, target, preferences.getPositiveTrust());
+	}
+
+	/**
+	 * Assigns the configured negative trust value for the given target.
+	 *
+	 * @param origin
+	 *            The trust origin
+	 * @param target
+	 *            The trust target
+	 */
+	public void distrustSone(Sone origin, Sone target) {
+		setTrust(origin, target, preferences.getNegativeTrust());
+	}
+
+	/**
+	 * Removes the trust assignment for the given target.
+	 *
+	 * @param origin
+	 *            The trust origin
+	 * @param target
+	 *            The trust target
+	 */
+	public void untrustSone(Sone origin, Sone target) {
+		removeTrust(origin, target);
+	}
+
+	/**
 	 * Updates the stores Sone with the given Sone.
 	 *
 	 * @param sone
@@ -810,7 +1030,7 @@ public class Core implements IdentityListener {
 	 */
 	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 });
@@ -820,12 +1040,16 @@ public class Core implements IdentityListener {
 				if (!soneRescueMode) {
 					for (Post post : storedSone.getPosts()) {
 						posts.remove(post.getId());
+						if (!sone.getPosts().contains(post)) {
+							coreListenerManager.firePostRemoved(post);
+						}
 					}
 				}
+				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);
 						}
@@ -837,12 +1061,16 @@ public class Core implements IdentityListener {
 				if (!soneRescueMode) {
 					for (Reply reply : storedSone.getReplies()) {
 						replies.remove(reply.getId());
+						if (!sone.getReplies().contains(reply)) {
+							coreListenerManager.fireReplyRemoved(reply);
+						}
 					}
 				}
+				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);
 						}
@@ -901,8 +1129,12 @@ public class Core implements IdentityListener {
 			localSones.remove(sone.getId());
 			soneInserters.remove(sone).stop();
 		}
-		identityManager.removeContext((OwnIdentity) sone.getIdentity(), "Sone");
-		identityManager.removeProperty((OwnIdentity) sone.getIdentity(), "Sone.LatestEdition");
+		try {
+			((OwnIdentity) sone.getIdentity()).removeContext("Sone");
+			((OwnIdentity) sone.getIdentity()).removeProperty("Sone.LatestEdition");
+		} catch (WebOfTrustException wote1) {
+			logger.log(Level.WARNING, "Could not remove context and properties from Sone: " + sone, wote1);
+		}
 		try {
 			configuration.getLongValue("Sone/" + sone.getId() + "/Time").setValue(null);
 		} catch (ConfigurationException ce1) {
@@ -911,6 +1143,23 @@ public class Core implements IdentityListener {
 	}
 
 	/**
+	 * 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.
 	 *
@@ -941,6 +1190,17 @@ public class Core implements IdentityListener {
 		profile.setBirthMonth(configuration.getIntValue(sonePrefix + "/Profile/BirthMonth").getValue(null));
 		profile.setBirthYear(configuration.getIntValue(sonePrefix + "/Profile/BirthYear").getValue(null));
 
+		/* load profile fields. */
+		while (true) {
+			String fieldPrefix = sonePrefix + "/Profile/Fields/" + profile.getFields().size();
+			String fieldName = configuration.getStringValue(fieldPrefix + "/Name").getValue(null);
+			if (fieldName == null) {
+				break;
+			}
+			String fieldValue = configuration.getStringValue(fieldPrefix + "/Value").getValue("");
+			profile.addField(fieldName).setValue(fieldValue);
+		}
+
 		/* load posts. */
 		Set<Post> posts = new HashSet<Post>();
 		while (true) {
@@ -949,13 +1209,18 @@ public class Core implements IdentityListener {
 			if (postId == null) {
 				break;
 			}
+			String postRecipientId = configuration.getStringValue(postPrefix + "/Recipient").getValue(null);
 			long postTime = configuration.getLongValue(postPrefix + "/Time").getValue((long) 0);
 			String postText = configuration.getStringValue(postPrefix + "/Text").getValue(null);
 			if ((postTime == 0) || (postText == null)) {
 				logger.log(Level.WARNING, "Invalid post found, aborting load!");
 				return;
 			}
-			posts.add(getPost(postId).setSone(sone).setTime(postTime).setText(postText));
+			Post post = getPost(postId).setSone(sone).setTime(postTime).setText(postText);
+			if ((postRecipientId != null) && (postRecipientId.length() == 43)) {
+				post.setRecipient(getSone(postRecipientId));
+			}
+			posts.add(post);
 		}
 
 		/* load replies. */
@@ -1006,6 +1271,10 @@ public class Core implements IdentityListener {
 			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);
@@ -1041,7 +1310,7 @@ public class Core implements IdentityListener {
 	 * @param sone
 	 *            The Sone to save
 	 */
-	public void saveSone(Sone sone) {
+	public synchronized void saveSone(Sone sone) {
 		if (!isLocalSone(sone)) {
 			logger.log(Level.FINE, "Tried to save non-local Sone: %s", sone);
 			return;
@@ -1052,8 +1321,9 @@ public class Core implements IdentityListener {
 		}
 
 		logger.log(Level.INFO, "Saving Sone: %s", sone);
-		identityManager.setProperty((OwnIdentity) sone.getIdentity(), "Sone.LatestEdition", String.valueOf(sone.getLatestEdition()));
 		try {
+			((OwnIdentity) sone.getIdentity()).setProperty("Sone.LatestEdition", String.valueOf(sone.getLatestEdition()));
+
 			/* save Sone into configuration. */
 			String sonePrefix = "Sone/" + sone.getId();
 			configuration.getLongValue(sonePrefix + "/Time").setValue(sone.getTime());
@@ -1068,11 +1338,21 @@ public class Core implements IdentityListener {
 			configuration.getIntValue(sonePrefix + "/Profile/BirthMonth").setValue(profile.getBirthMonth());
 			configuration.getIntValue(sonePrefix + "/Profile/BirthYear").setValue(profile.getBirthYear());
 
+			/* save profile fields. */
+			int fieldCounter = 0;
+			for (Field profileField : profile.getFields()) {
+				String fieldPrefix = sonePrefix + "/Profile/Fields/" + fieldCounter++;
+				configuration.getStringValue(fieldPrefix + "/Name").setValue(profileField.getName());
+				configuration.getStringValue(fieldPrefix + "/Value").setValue(profileField.getValue());
+			}
+			configuration.getStringValue(sonePrefix + "/Profile/Fields/" + fieldCounter + "/Name").setValue(null);
+
 			/* save posts. */
 			int postCounter = 0;
 			for (Post post : sone.getPosts()) {
 				String postPrefix = sonePrefix + "/Posts/" + postCounter++;
 				configuration.getStringValue(postPrefix + "/ID").setValue(post.getId());
+				configuration.getStringValue(postPrefix + "/Recipient").setValue((post.getRecipient() != null) ? post.getRecipient().getId() : null);
 				configuration.getLongValue(postPrefix + "/Time").setValue(post.getTime());
 				configuration.getStringValue(postPrefix + "/Text").setValue(post.getText());
 			}
@@ -1110,9 +1390,15 @@ public class Core implements IdentityListener {
 			}
 			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) {
 			logger.log(Level.WARNING, "Could not save Sone: " + sone, ce1);
+		} catch (WebOfTrustException wote1) {
+			logger.log(Level.WARNING, "Could not set WoT property for Sone: " + sone, wote1);
 		}
 	}
 
@@ -1123,9 +1409,41 @@ public class Core implements IdentityListener {
 	 *            The Sone that creates the post
 	 * @param text
 	 *            The text of the post
+	 * @return The created post
+	 */
+	public Post createPost(Sone sone, String text) {
+		return createPost(sone, System.currentTimeMillis(), text);
+	}
+
+	/**
+	 * Creates a new post.
+	 *
+	 * @param sone
+	 *            The Sone that creates the post
+	 * @param time
+	 *            The time of the post
+	 * @param text
+	 *            The text of the post
+	 * @return The created post
+	 */
+	public Post createPost(Sone sone, long time, String text) {
+		return createPost(sone, null, time, text);
+	}
+
+	/**
+	 * Creates a new post.
+	 *
+	 * @param sone
+	 *            The Sone that creates the post
+	 * @param recipient
+	 *            The recipient Sone, or {@code null} if this post does not have
+	 *            a recipient
+	 * @param text
+	 *            The text of the post
+	 * @return The created post
 	 */
-	public void createPost(Sone sone, String text) {
-		createPost(sone, System.currentTimeMillis(), text);
+	public Post createPost(Sone sone, Sone recipient, String text) {
+		return createPost(sone, recipient, System.currentTimeMillis(), text);
 	}
 
 	/**
@@ -1133,25 +1451,34 @@ public class Core implements IdentityListener {
 	 *
 	 * @param sone
 	 *            The Sone that creates the post
+	 * @param recipient
+	 *            The recipient Sone, or {@code null} if this post does not have
+	 *            a recipient
 	 * @param time
 	 *            The time of the post
 	 * @param text
 	 *            The text of the post
+	 * @return The created post
 	 */
-	public void createPost(Sone sone, long time, String text) {
+	public Post createPost(Sone sone, Sone recipient, long time, String text) {
 		if (!isLocalSone(sone)) {
 			logger.log(Level.FINE, "Tried to create post for non-local Sone: %s", sone);
-			return;
+			return null;
 		}
 		Post post = new Post(sone, time, text);
+		if (recipient != null) {
+			post.setRecipient(recipient);
+		}
 		synchronized (posts) {
 			posts.put(post.getId(), post);
 		}
 		synchronized (newPosts) {
-			knownPosts.add(post.getId());
+			newPosts.add(post.getId());
+			coreListenerManager.fireNewPostFound(post);
 		}
 		sone.addPost(post);
 		saveSone(sone);
+		return post;
 	}
 
 	/**
@@ -1169,10 +1496,76 @@ public class Core implements IdentityListener {
 		synchronized (posts) {
 			posts.remove(post.getId());
 		}
+		coreListenerManager.firePostRemoved(post);
+		synchronized (newPosts) {
+			markPostKnown(post);
+			knownPosts.remove(post.getId());
+		}
 		saveSone(post.getSone());
 	}
 
 	/**
+	 * Marks the given post as known, if it is currently a new post (according
+	 * to {@link #isNewPost(String)}).
+	 *
+	 * @param post
+	 *            The post to mark as known
+	 */
+	public void markPostKnown(Post post) {
+		synchronized (newPosts) {
+			if (newPosts.remove(post.getId())) {
+				knownPosts.add(post.getId());
+				coreListenerManager.fireMarkPostKnown(post);
+				saveConfiguration();
+			}
+		}
+	}
+
+	/**
+	 * 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
@@ -1210,7 +1603,8 @@ public class Core implements IdentityListener {
 			replies.put(reply.getId(), reply);
 		}
 		synchronized (newReplies) {
-			knownReplies.add(reply.getId());
+			newReplies.add(reply.getId());
+			coreListenerManager.fireNewReplyFound(reply);
 		}
 		sone.addReply(reply);
 		saveSone(sone);
@@ -1232,15 +1626,38 @@ public class Core implements IdentityListener {
 		synchronized (replies) {
 			replies.remove(reply.getId());
 		}
+		synchronized (newReplies) {
+			markReplyKnown(reply);
+			knownReplies.remove(reply.getId());
+		}
 		sone.removeReply(reply);
 		saveSone(sone);
 	}
 
 	/**
+	 * Marks the given reply as known, if it is currently a new reply (according
+	 * to {@link #isNewReply(String)}).
+	 *
+	 * @param reply
+	 *            The reply to mark as known
+	 */
+	public void markReplyKnown(Reply reply) {
+		synchronized (newReplies) {
+			if (newReplies.remove(reply.getId())) {
+				knownReplies.add(reply.getId());
+				coreListenerManager.fireMarkReplyKnown(reply);
+				saveConfiguration();
+			}
+		}
+	}
+
+	/**
 	 * Starts the core.
 	 */
 	public void start() {
 		loadConfiguration();
+		updateChecker.addUpdateListener(this);
+		updateChecker.start();
 	}
 
 	/**
@@ -1252,10 +1669,85 @@ public class Core implements IdentityListener {
 				soneInserter.stop();
 			}
 		}
+		updateChecker.stop();
+		updateChecker.removeUpdateListener(this);
+		soneDownloader.stop();
 		saveConfiguration();
 		stopped = true;
 	}
 
+	/**
+	 * Saves the current options.
+	 */
+	public void saveConfiguration() {
+		synchronized (configuration) {
+			if (storingConfiguration) {
+				logger.log(Level.FINE, "Already storing configuration…");
+				return;
+			}
+			storingConfiguration = true;
+		}
+
+		/* store the options first. */
+		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());
+			configuration.getBooleanValue("Option/SoneRescueMode").setValue(options.getBooleanOption("SoneRescueMode").getReal());
+			configuration.getBooleanValue("Option/ClearOnNextRestart").setValue(options.getBooleanOption("ClearOnNextRestart").getReal());
+			configuration.getBooleanValue("Option/ReallyClearOnNextRestart").setValue(options.getBooleanOption("ReallyClearOnNextRestart").getReal());
+
+			/* save known Sones. */
+			int soneCounter = 0;
+			synchronized (newSones) {
+				for (String knownSoneId : knownSones) {
+					configuration.getStringValue("KnownSone/" + soneCounter++ + "/ID").setValue(knownSoneId);
+				}
+				configuration.getStringValue("KnownSone/" + soneCounter + "/ID").setValue(null);
+			}
+
+			/* save known posts. */
+			int postCounter = 0;
+			synchronized (newPosts) {
+				for (String knownPostId : knownPosts) {
+					configuration.getStringValue("KnownPosts/" + postCounter++ + "/ID").setValue(knownPostId);
+				}
+				configuration.getStringValue("KnownPosts/" + postCounter + "/ID").setValue(null);
+			}
+
+			/* save known replies. */
+			int replyCounter = 0;
+			synchronized (newReplies) {
+				for (String knownReplyId : knownReplies) {
+					configuration.getStringValue("KnownReplies/" + replyCounter++ + "/ID").setValue(knownReplyId);
+				}
+				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();
+
+		} catch (ConfigurationException ce1) {
+			logger.log(Level.SEVERE, "Could not store configuration!", ce1);
+		} finally {
+			synchronized (configuration) {
+				storingConfiguration = false;
+			}
+		}
+	}
+
 	//
 	// PRIVATE METHODS
 	//
@@ -1274,6 +1766,10 @@ public class Core implements IdentityListener {
 			}
 
 		}));
+		options.addIntegerOption("PostsPerPage", new DefaultOption<Integer>(10));
+		options.addIntegerOption("PositiveTrust", new DefaultOption<Integer>(75));
+		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));
 		options.addBooleanOption("ReallyClearOnNextRestart", new DefaultOption<Boolean>(false));
@@ -1290,6 +1786,10 @@ public class Core implements IdentityListener {
 		}
 
 		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));
 		options.getBooleanOption("SoneRescueMode").set(configuration.getBooleanValue("Option/SoneRescueMode").getValue(null));
 
 		/* load known Sones. */
@@ -1328,49 +1828,18 @@ public class Core implements IdentityListener {
 			}
 		}
 
-	}
-
-	/**
-	 * Saves the current options.
-	 */
-	private void saveConfiguration() {
-		/* store the options first. */
-		try {
-			configuration.getIntValue("Option/InsertionDelay").setValue(options.getIntegerOption("InsertionDelay").getReal());
-			configuration.getBooleanValue("Option/SoneRescueMode").setValue(options.getBooleanOption("SoneRescueMode").getReal());
-			configuration.getBooleanValue("Option/ClearOnNextRestart").setValue(options.getBooleanOption("ClearOnNextRestart").getReal());
-			configuration.getBooleanValue("Option/ReallyClearOnNextRestart").setValue(options.getBooleanOption("ReallyClearOnNextRestart").getReal());
-
-			/* save known Sones. */
-			int soneCounter = 0;
-			synchronized (newSones) {
-				for (String knownSoneId : knownSones) {
-					configuration.getStringValue("KnownSone/" + soneCounter++ + "/ID").setValue(knownSoneId);
-				}
-				configuration.getStringValue("KnownSone/" + soneCounter + "/ID").setValue(null);
-			}
-
-			/* save known posts. */
-			int postCounter = 0;
-			synchronized (newPosts) {
-				for (String knownPostId : knownPosts) {
-					configuration.getStringValue("KnownPosts/" + postCounter++ + "/ID").setValue(knownPostId);
-				}
-				configuration.getStringValue("KnownPosts/" + postCounter + "/ID").setValue(null);
+		/* load bookmarked posts. */
+		int bookmarkedPostCounter = 0;
+		while (true) {
+			String bookmarkedPostId = configuration.getStringValue("Bookmarks/Post/" + bookmarkedPostCounter++ + "/ID").getValue(null);
+			if (bookmarkedPostId == null) {
+				break;
 			}
-
-			/* save known replies. */
-			int replyCounter = 0;
-			synchronized (newReplies) {
-				for (String knownReplyId : knownReplies) {
-					configuration.getStringValue("KnownReplies/" + replyCounter++ + "/ID").setValue(knownReplyId);
-				}
-				configuration.getStringValue("KnownReplies/" + replyCounter + "/ID").setValue(null);
+			synchronized (bookmarkedPosts) {
+				bookmarkedPosts.add(bookmarkedPostId);
 			}
-
-		} catch (ConfigurationException ce1) {
-			logger.log(Level.SEVERE, "Could not store configuration!", ce1);
 		}
+
 	}
 
 	/**
@@ -1401,6 +1870,7 @@ public class Core implements IdentityListener {
 	public void ownIdentityAdded(OwnIdentity ownIdentity) {
 		logger.log(Level.FINEST, "Adding OwnIdentity: " + ownIdentity);
 		if (ownIdentity.hasContext("Sone")) {
+			trustedIdentities.put(ownIdentity, Collections.synchronizedSet(new HashSet<Identity>()));
 			addLocalSone(ownIdentity);
 		}
 	}
@@ -1411,14 +1881,16 @@ public class Core implements IdentityListener {
 	@Override
 	public void ownIdentityRemoved(OwnIdentity ownIdentity) {
 		logger.log(Level.FINEST, "Removing OwnIdentity: " + ownIdentity);
+		trustedIdentities.remove(ownIdentity);
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
-	public void identityAdded(Identity identity) {
+	public void identityAdded(OwnIdentity ownIdentity, Identity identity) {
 		logger.log(Level.FINEST, "Adding Identity: " + identity);
+		trustedIdentities.get(ownIdentity).add(identity);
 		addRemoteSone(identity);
 	}
 
@@ -1426,13 +1898,16 @@ public class Core implements IdentityListener {
 	 * {@inheritDoc}
 	 */
 	@Override
-	public void identityUpdated(final Identity identity) {
+	public void identityUpdated(OwnIdentity ownIdentity, final Identity identity) {
 		new Thread(new Runnable() {
 
 			@Override
 			@SuppressWarnings("synthetic-access")
 			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();
@@ -1442,8 +1917,228 @@ public class Core implements IdentityListener {
 	 * {@inheritDoc}
 	 */
 	@Override
-	public void identityRemoved(Identity identity) {
-		/* TODO */
+	public void identityRemoved(OwnIdentity ownIdentity, Identity identity) {
+		trustedIdentities.get(ownIdentity).remove(identity);
+	}
+
+	//
+	// INTERFACE UpdateListener
+	//
+
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override
+	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;
+		}
+
 	}
 
 }