Better handling of null values, and yielding callbacks

Author: jedediah

src/main/java/me/anxuiz/settings/SettingCallbackManager.java

@@ -3,6 +3,7 @@
 import java.util.List;
 
 import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
 
 public interface SettingCallbackManager {
     @Nonnull List<SettingCallback> getCallbacks(@Nonnull Setting setting);
@@ -29,7 +30,5 @@ public interface SettingCallbackManager {
 
     boolean removeGlobalCallback(@Nonnull SettingCallback callback);
 
-    int notifyChange(@Nonnull SettingManager manager, @Nonnull Setting setting, @Nonnull Object oldValue, @Nonnull Object newValue);
-
-    int notifyChange(@Nonnull SettingManager manager, @Nonnull Setting setting, @Nonnull Object oldValue, @Nonnull Object newValue, boolean includeGlobal);
+    void notifyChange(@Nonnull SettingManager manager, @Nonnull Setting setting, @Nullable Object oldValue, @Nullable Object newValue, @Nullable Object rawValue, boolean includeGlobal, Runnable changeCallback);
 }

src/main/java/me/anxuiz/settings/base/AbstractSettingCallbackManager.java

@@ -7,7 +7,6 @@
 import me.anxuiz.settings.Setting;
 import me.anxuiz.settings.SettingCallback;
 import me.anxuiz.settings.SettingCallbackManager;
-import me.anxuiz.settings.SettingManager;
 
 public abstract class AbstractSettingCallbackManager implements SettingCallbackManager {
     public List<SettingCallback> getCallbacks(@Nonnull Setting setting) {
@@ -21,8 +20,4 @@ public int getNumCallbacks(@Nonnull Setting setting) {
     public boolean hasCallbacks(@Nonnull Setting setting) {
         return this.hasCallbacks(setting, false);
     }
-
-    public int notifyChange(@Nonnull SettingManager manager, @Nonnull Setting setting, @Nonnull Object oldValue, @Nonnull Object newValue) {
-        return this.notifyChange(manager, setting, oldValue, newValue, true);
-    }
 }

src/main/java/me/anxuiz/settings/base/AbstractSettingManager.java

@@ -3,6 +3,7 @@
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
+import com.google.common.base.Objects;
 import me.anxuiz.settings.Setting;
 import me.anxuiz.settings.SettingManager;
 import me.anxuiz.settings.util.TypeUtil;
@@ -12,6 +13,8 @@
 public abstract class AbstractSettingManager implements SettingManager {
     public @Nullable abstract Object getRawValue(@Nonnull Setting setting);
 
+    protected abstract void setRawValue(Setting setting, @Nullable Object value);
+
     public boolean hasValue(Setting setting) {
         Preconditions.checkNotNull(setting);
 
@@ -70,7 +73,25 @@ public <T> T getValue(Setting setting, Class<T> typeClass, T defaultValue) throw
         }
     }
 
+    public void setValue(final Setting setting, final Object rawValue, boolean notifyGlobal) {
+        Preconditions.checkNotNull(setting, "setting");
+        Preconditions.checkArgument(rawValue == null || setting.getType().isInstance(rawValue), "value is not the correct type");
+
+        Object oldValue = this.getValue(setting);
+        Object newValue = rawValue != null ? rawValue : setting.getDefaultValue();
+
+        getCallbackManager().notifyChange(this, setting, oldValue, newValue, rawValue, notifyGlobal, new Runnable() {
+            public void run() {
+                setRawValue(setting, rawValue);
+            }
+        });
+    }
+
     public void setValue(Setting setting, Object value) {
         this.setValue(setting, value, true);
     }
+
+    public void deleteValue(Setting setting) {
+        setValue(setting, null);
+    }
 }

src/main/java/me/anxuiz/settings/base/SimpleSettingCallbackManager.java

@@ -1,9 +1,13 @@
 package me.anxuiz.settings.base;
 
+import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.CopyOnWriteArraySet;
 
+import com.google.common.base.Objects;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterators;
 import me.anxuiz.settings.Setting;
 import me.anxuiz.settings.SettingCallback;
 import me.anxuiz.settings.SettingManager;
@@ -83,28 +87,61 @@ public boolean removeGlobalCallback(SettingCallback callback) {
         return this.globalCallbacks.remove(callback);
     }
 
-    public int notifyChange(SettingManager manager, Setting setting, Object oldValue, Object newValue, boolean includeGlobal) {
+    public void notifyChange(SettingManager manager, Setting setting, Object oldValue, Object newValue, Object rawValue, boolean includeGlobal, final Runnable changeCallback) {
         Preconditions.checkNotNull(manager, "setting manager may not be null");
         Preconditions.checkNotNull(setting, "setting may not be null");
         Preconditions.checkNotNull(oldValue, "old value may not be null");
         Preconditions.checkNotNull(newValue, "new value may not be null");
 
-        // don't notify if the values are the same
-        if(oldValue.equals(newValue)) {
-            return 0;
+        // Global callbacks get the raw value
+        if(includeGlobal && !Objects.equal(oldValue, rawValue)) {
+            for(SettingCallback callback : ImmutableSet.copyOf(globalCallbacks)) {
+                callback.notifyChange(manager, setting, oldValue, rawValue);
+            }
+        }
+
+        // Per-setting callbacks get the cooked value i.e. null replaced with default
+        if(!Objects.equal(oldValue, newValue)) {
+            dispatch(
+                manager, setting, oldValue, newValue,
+                Iterators.concat(
+                    ImmutableSet.copyOf(callbacks.get(setting)).iterator(),
+                    Iterators.singletonIterator(new SettingCallback() {
+                        public void notifyChange(SettingManager manager, Setting setting, Object oldValue, Object newValue) {
+                            changeCallback.run();
+                        }
+                    })
+                )
+            );
         }
+    }
+
+    private void dispatch(final SettingManager manager, final Setting setting, final Object oldValue, final Object newValue, final Iterator<SettingCallback> callbacks) {
+        if(!callbacks.hasNext()) return;
 
-        List<SettingCallback> callbacks = this.getCallbacks(setting, includeGlobal); // get a copy of the callbacks
-        int notified = 0;
-        for(SettingCallback callback : callbacks) {
-            try {
-                callback.notifyChange(manager, setting, oldValue, newValue);
-                notified++;
-            } catch (Throwable t) {
-                t.printStackTrace();
+        final Runnable old = YIELDER.get();
+
+        YIELDER.set(new Runnable() {
+            boolean yielded;
+            public void run() {
+                if(yielded) return;
+                yielded = true;
+                dispatch(manager, setting, oldValue, newValue, callbacks);
             }
+        });
+
+        try {
+            callbacks.next().notifyChange(manager, setting, oldValue, newValue);
+            YIELDER.get().run(); // If callback didn't yield, do it ourselves
+        } finally {
+            YIELDER.set(old);
         }
+    }
 
-        return notified;
+    public static void yield() {
+        Preconditions.checkState(YIELDER.get() != null, "cannot call yield() outside of a change notification");
+        YIELDER.get().run();
     }
+
+    private static final ThreadLocal<Runnable> YIELDER = new ThreadLocal<Runnable>();
 }