--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/tango/tango/net/cluster/CacheInvalidator.d	Fri Jan 11 17:57:40 2008 +0100
@@ -0,0 +1,134 @@
+/*******************************************************************************
+
+        copyright:      Copyright (c) 2004 Kris Bell. All rights reserved
+
+        license:        BSD style: $(LICENSE)
+        
+        version:        July 2004: Initial release      
+        
+        author:         Kris
+
+*******************************************************************************/
+
+module tango.net.cluster.CacheInvalidator;
+
+package import  tango.net.cluster.NetworkClient;
+
+private import  tango.net.cluster.NetworkMessage;
+
+/*******************************************************************************
+
+        Utility class to invalidate specific cache entries across a 
+        network. Any active CacheInvalidatee objects listening upon
+        the channel specified for this class will "wake up" whenever
+        the invalidate() method is invoked.
+
+*******************************************************************************/
+
+class CacheInvalidator : NetworkClient
+{
+        private InvalidatorPayload filter;
+
+        /***********************************************************************
+
+                Construct an invalidator on the specified channel. Only
+                those CacheInvalidatee instances configured for the same
+                channel will be listening to this invalidator.
+
+        ***********************************************************************/
+        
+        this (ICluster cluster, char[] channel)
+        {
+                assert (channel.length);
+                super (cluster, channel);
+
+                // this is what we'll send as an invalidation notification ...
+                this.filter = new InvalidatorPayload;
+        }
+
+        /***********************************************************************
+
+                Invalidate all network cache instances on this channel
+                using the specified key. When 'timeLimit' is specified, 
+                only those cache entries with a time lesser or equal to
+                that specified will be removed. This is often useful if 
+                you wish to avoid invalidating a cache (local or remote)
+                that has just been updated; simply pass the time value
+                of the 'old' IMessage as the argument.
+
+                Note that this is asynchronous! An invalidation is just
+                a request to remove the item within a short time period.
+                If you need the entry removed synchronously, you should
+                use the NetworkCache extract() method instead.
+
+        ***********************************************************************/
+        
+        void invalidate (char[] key, Time timeLimit = Time.max)
+        {
+                assert (key.length);
+                filter.key  (key);
+                filter.time (timeLimit);
+
+                // broadcast a message across the cluster
+                channel.broadcast (filter);
+        }
+}
+
+
+/*******************************************************************************
+
+*******************************************************************************/
+
+private class InvalidatorPayload : NetworkMessage
+{
+        private char[] key_;
+
+        /***********************************************************************
+
+        ***********************************************************************/
+
+        char[] key ()
+        {
+                return key_;
+        }
+
+        /***********************************************************************
+
+        ***********************************************************************/
+
+        void key (char[] key)
+        {
+                assert (key.length);
+                key_ = key;
+        }
+
+        /***********************************************************************
+
+                Read our attributes, after telling our superclass to do
+                likewise. The order of this is important with respect to
+                inheritance, such that a subclass and superclass may be 
+                populated in isolation where appropriate.
+
+                Note that we slice our text attribute, rather than copying
+                it. Since this class is temporal we can forego allocation
+                of memory, and just map it directly from the input buffer. 
+
+        ***********************************************************************/
+
+        override void read (IReader input)
+        {
+                super.read (input);
+                input (key_); 
+        }
+
+        /***********************************************************************
+
+        ***********************************************************************/
+
+        override void write (IWriter output)
+        {
+                super.write (output);
+                output (key_);
+        }
+}
+