--- /dev/null
+/*
+ * Sone - IdentityChangeDetector.java - Copyright © 2013 David Roden
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package net.pterodactylus.freenet.wot;
+
+import static com.google.common.base.Optional.absent;
+import static com.google.common.base.Optional.fromNullable;
+import static com.google.common.base.Predicates.not;
+import static com.google.common.collect.FluentIterable.from;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import com.google.common.base.Optional;
+import com.google.common.base.Predicate;
+import com.google.common.collect.FluentIterable;
+import com.google.common.collect.ImmutableMap;
+
+/**
+ * Detects changes between two lists of {@link Identity}s. The detector can find
+ * added and removed identities, and for identities that exist in both list
+ * their contexts and properties are checked for added, removed, or (in case of
+ * properties) changed values.
+ *
+ * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
+ */
+public class IdentityChangeDetector {
+
+ private final Map<String, Identity> oldIdentities;
+ private Optional<IdentityProcessor> onNewIdentity = absent();
+ private Optional<IdentityProcessor> onRemovedIdentity = absent();
+ private Optional<IdentityProcessor> onChangedIdentity = absent();
+ private Optional<IdentityProcessor> onUnchangedIdentity = absent();
+
+ public IdentityChangeDetector(Collection<? extends Identity> oldIdentities) {
+ this.oldIdentities = convertToMap(oldIdentities);
+ }
+
+ public void onNewIdentity(IdentityProcessor onNewIdentity) {
+ this.onNewIdentity = fromNullable(onNewIdentity);
+ }
+
+ public void onRemovedIdentity(IdentityProcessor onRemovedIdentity) {
+ this.onRemovedIdentity = fromNullable(onRemovedIdentity);
+ }
+
+ public void onChangedIdentity(IdentityProcessor onChangedIdentity) {
+ this.onChangedIdentity = fromNullable(onChangedIdentity);
+ }
+
+ public void onUnchangedIdentity(IdentityProcessor onUnchangedIdentity) {
+ this.onUnchangedIdentity = fromNullable(onUnchangedIdentity);
+ }
+
+ public void detectChanges(Collection<? extends Identity> newIdentities) {
+ notifyForRemovedIdentities(from(oldIdentities.values()).filter(notContainedIn(newIdentities)));
+ notifyForNewIdentities(from(newIdentities).filter(notContainedIn(oldIdentities.values())));
+ notifyForChangedIdentities(from(newIdentities).filter(containedIn(oldIdentities)).filter(hasChanged(oldIdentities)));
+ notifyForUnchangedIdentities(from(newIdentities).filter(containedIn(oldIdentities)).filter(not(hasChanged(oldIdentities))));
+ }
+
+ private void notifyForRemovedIdentities(Iterable<Identity> identities) {
+ notify(onRemovedIdentity, identities);
+ }
+
+ private void notifyForNewIdentities(FluentIterable<? extends Identity> newIdentities) {
+ notify(onNewIdentity, newIdentities);
+ }
+
+ private void notifyForChangedIdentities(FluentIterable<? extends Identity> identities) {
+ notify(onChangedIdentity, identities);
+ }
+
+ private void notifyForUnchangedIdentities(FluentIterable<? extends Identity> identities) {
+ notify(onUnchangedIdentity, identities);
+ }
+
+ private void notify(Optional<IdentityProcessor> identityProcessor, Iterable<? extends Identity> identities) {
+ if (!identityProcessor.isPresent()) {
+ return;
+ }
+ for (Identity identity : identities) {
+ identityProcessor.get().processIdentity(identity);
+ }
+ }
+
+ private static Predicate<Identity> hasChanged(Map<String, Identity> oldIdentities) {
+ return identity -> identityHasChanged(oldIdentities.get(identity.getId()), identity);
+ }
+
+ private static boolean identityHasChanged(Identity oldIdentity, Identity newIdentity) {
+ return identityHasNewContexts(oldIdentity, newIdentity)
+ || identityHasRemovedContexts(oldIdentity, newIdentity)
+ || identityHasNewProperties(oldIdentity, newIdentity)
+ || identityHasRemovedProperties(oldIdentity, newIdentity)
+ || identityHasChangedProperties(oldIdentity, newIdentity);
+ }
+
+ private static boolean identityHasNewContexts(Identity oldIdentity, Identity newIdentity) {
+ return from(newIdentity.getContexts()).anyMatch(notAContextOf(oldIdentity));
+ }
+
+ private static boolean identityHasRemovedContexts(Identity oldIdentity, Identity newIdentity) {
+ return from(oldIdentity.getContexts()).anyMatch(notAContextOf(newIdentity));
+ }
+
+ private static boolean identityHasNewProperties(Identity oldIdentity, Identity newIdentity) {
+ return from(newIdentity.getProperties().entrySet()).anyMatch(notAPropertyOf(oldIdentity));
+ }
+
+ private static boolean identityHasRemovedProperties(Identity oldIdentity, Identity newIdentity) {
+ return from(oldIdentity.getProperties().entrySet()).anyMatch(notAPropertyOf(newIdentity));
+ }
+
+ private static boolean identityHasChangedProperties(Identity oldIdentity, Identity newIdentity) {
+ return from(oldIdentity.getProperties().entrySet()).anyMatch(hasADifferentValueThanIn(newIdentity));
+ }
+
+ private static Predicate<Identity> containedIn(Map<String, Identity> identities) {
+ return identity -> identities.containsKey(identity.getId());
+ }
+
+ private static Predicate<String> notAContextOf(Identity identity) {
+ return context -> (identity != null) && !identity.getContexts().contains(context);
+ }
+
+ private static Predicate<Identity> notContainedIn(Collection<? extends Identity> newIdentities) {
+ return identity -> (identity != null) && !newIdentities.contains(identity);
+ }
+
+ private static Predicate<Entry<String, String>> notAPropertyOf(Identity identity) {
+ return property -> (property != null) && !identity.getProperties().containsKey(property.getKey());
+ }
+
+ private static Predicate<Entry<String, String>> hasADifferentValueThanIn(Identity newIdentity) {
+ return property ->
+ (property != null) && !newIdentity.getProperty(property.getKey()).equals(property.getValue());
+ }
+
+ private static Map<String, Identity> convertToMap(Collection<? extends Identity> identities) {
+ ImmutableMap.Builder<String, Identity> mapBuilder = ImmutableMap.builder();
+ for (Identity identity : identities) {
+ mapBuilder.put(identity.getId(), identity);
+ }
+ return mapBuilder.build();
+ }
+
+ public interface IdentityProcessor {
+
+ void processIdentity(Identity identity);
+
+ }
+
+}
projects / fwot.git / blobdiff