Added watcher support for agents/atoms/refs/vars

Watchers must be agents
(add-watcher reference :send/:send-off an-agent an-action)

Author: richhickey

src/clj/clojure/core.clj

@@ -1100,24 +1100,22 @@
   occurring, does nothing. Returns the number of actions dispatched."  
   [] (clojure.lang.Agent/releasePendingSends))
 
-(defn add-watch
+(defn add-watcher
   "Experimental.
-  Adds a watcher to an agent. Whenever the agent runs an action, any
-  registered watchers will have their callback function called.  The
-  callback fn will be passed 3 args, the watcher, the agent and a boolean
-  which will be true if the agent's state was (potentially) changed by
-  the action. The callback fn is run synchronously with the action,
-  and thus derefs of the agent in the callback will see the value set
-  during that action. Because it is run on the action thread, the
-  callback should not block, but can send messages."
-  [#^clojure.lang.Agent a watcher callback]
-  (.addWatch a watcher callback))
-
-(defn remove-watch
+  Adds a watcher to an agent/atom/var/ref reference. The watcher must
+  be an Agent, and the action a function of the agent's state and one
+  additional arg, the reference. Whenever the reference's state
+  changes, any registered watchers will have their actions
+  sent. send-type must be one of :send or :send-off. The actions will
+  be sent afer the reference's state is changed."
+  [#^clojure.lang.IRef reference send-type watcher-agent action-fn]
+  (.addWatch reference watcher-agent action-fn (= send-type :send-off)))
+
+(defn remove-watcher
   "Experimental.
-  Removes a watcher (set by add-watch) from an agent"
-  [#^clojure.lang.Agent a watcher]
-  (.removeWatch a watcher))
+  Removes a watcher (set by add-watcher) from a reference"
+  [#^clojure.lang.IRef reference watcher-agent]
+  (.removeWatch reference watcher-agent))
 
 (defn agent-errors
   "Returns a sequence of the exceptions thrown during asynchronous

src/jvm/clojure/lang/ARef.java

@@ -12,8 +12,12 @@
 
 package clojure.lang;
 
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.Map;
+
 public abstract class ARef extends AReference implements IRef {
-    private volatile IFn validator = null;
+    protected volatile IFn validator = null;
+    private AtomicReference<IPersistentMap> watchers = new AtomicReference(PersistentHashMap.EMPTY);
 
     public ARef() {
         super();
@@ -57,4 +61,61 @@ public void setValidator(IFn vf){
     public IFn getValidator(){
         return validator;
     }
+
+    public IPersistentMap getWatches(){
+        return watchers.get();
+    }
+    
+    public IRef addWatch(Agent watcher, IFn action, boolean sendOff){
+        boolean added = false;
+        IPersistentMap prior = null;
+        while(!added)
+            {
+            prior = watchers.get();
+            added = watchers.compareAndSet(prior, prior.assoc(watcher,new Object[]{action,sendOff}));
+            }
+
+        return this;
+    }
+
+    public IRef removeWatch(Agent watcher){
+        boolean removed = false;
+        IPersistentMap prior = null;
+        while(!removed)
+            {
+            prior = watchers.get();
+            try
+                {
+                removed = watchers.compareAndSet(prior, prior.without(watcher));
+                }
+            catch (Exception e)
+                {
+                throw new RuntimeException(e);
+                }
+            }
+
+        return this;
+    }
+
+    public void notifyWatches() {
+        IPersistentMap ws = watchers.get();
+        if (ws != null)
+            {
+            ISeq args = new Cons(this, null);
+            for (ISeq s = RT.seq(ws); s != null; s = s.rest())
+                {
+                Map.Entry e = (Map.Entry) s.first();
+                Object[] a = (Object[]) e.getValue();
+                Agent agent = (Agent) e.getKey();
+                try
+                    {
+                    agent.dispatch((IFn) a[0], args, (Boolean)a[1]);
+                    }
+                catch (Exception e1)
+                    {
+                    //eat dispatching exceptions and continue
+                    }
+                }
+            }
+    }
 }

src/jvm/clojure/lang/Agent.java

@@ -19,9 +19,8 @@
 public class Agent extends ARef {
 volatile Object state;
     AtomicReference<IPersistentStack> q = new AtomicReference(PersistentQueue.EMPTY);
-AtomicReference<IPersistentMap> watchers = new AtomicReference(PersistentHashMap.EMPTY);
 
-volatile ISeq errors = null;
+    volatile ISeq errors = null;
 
 final public static ExecutorService pooledExecutor =
 		Executors.newFixedThreadPool(2 + Runtime.getRuntime().availableProcessors());
@@ -68,11 +67,8 @@ static void doRun(Action action){
 			try
 				{
 				changed = action.agent.setState(action.fn.applyTo(RT.cons(action.agent.state, action.args)));
-				for(Object o : action.agent.watchers.get())
-					{
-					Map.Entry e = (Map.Entry) o;
-					((IFn) e.getValue()).invoke(e.getKey(), action.agent, RT.box(changed));
-					}
+                if(changed)
+                    action.agent.notifyWatches();
 				}
 			catch(Exception e)
 				{
@@ -143,10 +139,10 @@ public void clearErrors(){
 	errors = null;
 }
 
-public Object dispatch(IFn fn, ISeq args, boolean solo) throws Exception{
+public Object dispatch(IFn fn, ISeq args, boolean solo) {
 	if(errors != null)
 		{
-		throw new Exception("Agent has errors", (Exception) RT.first(errors));
+		throw new RuntimeException("Agent has errors", (Exception) RT.first(errors));
 		}
 	Action action = new Action(this, fn, args, solo);
 	dispatchAction(action);
@@ -183,31 +179,7 @@ public int getQueueCount(){
 	return q.get().count();
 }
 
-public Agent addWatch(Object watcher, IFn callback){
-	boolean added = false;
-	IPersistentMap prior = null;
-	while(!added)
-		{
-		prior = watchers.get();
-		added = watchers.compareAndSet(prior, prior.assoc(watcher,callback));
-		}
-
-	return this;
-}
-
-public Agent removeWatch(Object watcher) throws Exception{
-	boolean removed = false;
-	IPersistentMap prior = null;
-	while(!removed)
-		{
-		prior = watchers.get();
-		removed = watchers.compareAndSet(prior, prior.without(watcher));
-		}
-	
-	return this;
-}
-
-static public int releasePendingSends(){
+    static public int releasePendingSends(){
 	IPersistentVector sends = nested.get();
 	if(sends == null)
 		return 0;

src/jvm/clojure/lang/Atom.java

@@ -37,18 +37,26 @@ public Object swap(IFn f, ISeq args) throws Exception {
             Object newv = f.applyTo(new Cons(v, args));
             validate(newv);
             if(state.compareAndSet(v,newv))
+                {
+                if(v != newv)
+                    notifyWatches();
                 return newv;
+                }
             }
     }
 
     public boolean compareAndSet(Object oldv, Object newv){
         validate(newv);
-        return state.compareAndSet(oldv, newv);
+        boolean ret = state.compareAndSet(oldv, newv);
+        if (ret && oldv != newv)
+            notifyWatches();
+        return ret;
     }
 
     public Object reset(Object newval){
         validate(newval);
         state.set(newval);
+        notifyWatches();
         return newval;
     }
 }

src/jvm/clojure/lang/IRef.java

@@ -14,9 +14,17 @@
 
 public interface IRef{
 
-Object get() throws Exception;
+    Object get() throws Exception;
 
-void setValidator(IFn vf);
+    void setValidator(IFn vf);
 
-IFn getValidator();
+    IFn getValidator();
+
+    IPersistentMap getWatches();
+
+    IRef addWatch(Agent watcher, IFn action, boolean sendOff);
+
+    IRef removeWatch(Agent watcher);
+
+    void notifyWatches();
 }

src/jvm/clojure/lang/LockingTransaction.java

@@ -252,11 +252,12 @@ Object run(Callable fn) throws Exception{
 						}
 					}
 
-				//validate
+				//validate and enqueue notifications
 				for(Map.Entry<Ref, Object> e : vals.entrySet())
 					{
 					Ref ref = e.getKey();
 					ref.validate(ref.getValidator(), e.getValue());
+                    ref.notifyWatches();
 					}
 
 				//at this point, all values calced, all refs to be written locked

src/jvm/clojure/lang/Ref.java

@@ -17,7 +17,7 @@
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.UUID;
 
-public class Ref extends AReference implements IFn, Comparable<Ref>, IRef{
+public class Ref extends ARef implements IFn, Comparable<Ref>, IRef{
     public int compareTo(Ref ref) {
         if(this.id == ref.id)
             return 0;
@@ -58,7 +58,7 @@ public static class TVal{
 final AtomicInteger faults;
 final ReentrantReadWriteLock lock;
 LockingTransaction.Info tinfo;
-IFn validator;
+//IFn validator;
 final long id;
 
 static final AtomicLong ids = new AtomicLong();
@@ -101,45 +101,45 @@ public Object get(){
 	return t.doGet(this);
 }
 
-void validate(IFn vf, Object val){
-	try{
-		if(vf != null && !RT.booleanCast(vf.invoke(val)))
-            throw new IllegalStateException("Invalid ref state");
-		}
-    catch(RuntimeException re)
-        {
-        throw re;
-        }
-	catch(Exception e)
-		{
-		throw new IllegalStateException("Invalid ref state", e);
-		}
-}
-
-public void setValidator(IFn vf){
-	try
-		{
-		lock.writeLock().lock();
-		validate(vf,currentVal());
-		validator = vf;
-		}
-	finally
-		{
-		lock.writeLock().unlock();
-		}
-}
-
-public IFn getValidator(){
-	try
-		{
-		lock.readLock().lock();
-		return validator;
-		}
-	finally
-		{
-		lock.readLock().unlock();
-		}
-}
+//void validate(IFn vf, Object val){
+//	try{
+//		if(vf != null && !RT.booleanCast(vf.invoke(val)))
+//            throw new IllegalStateException("Invalid ref state");
+//		}
+//    catch(RuntimeException re)
+//        {
+//        throw re;
+//        }
+//	catch(Exception e)
+//		{
+//		throw new IllegalStateException("Invalid ref state", e);
+//		}
+//}
+//
+//public void setValidator(IFn vf){
+//	try
+//		{
+//		lock.writeLock().lock();
+//		validate(vf,currentVal());
+//		validator = vf;
+//		}
+//	finally
+//		{
+//		lock.writeLock().unlock();
+//		}
+//}
+//
+//public IFn getValidator(){
+//	try
+//		{
+//		lock.readLock().lock();
+//		return validator;
+//		}
+//	finally
+//		{
+//		lock.readLock().unlock();
+//		}
+//}
 
 public Object set(Object val){
 	return LockingTransaction.getEx().doSet(this, val);