Source code: jtemporal/PublishedSortedMap.java

   /*
      Copyright (C) 2002 Thomas A Beck (http://thomas.beck.name)
   
      This library is free software; you can redistribute it and/or
      modify it under the terms of the GNU Lesser General Public
      License as published by the Free Software Foundation; either
      version 2.1 of the License, or (at your option) any later version.
   
      This library 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
     Lesser General Public License for more details.
  
     You should have received a copy of the GNU Lesser General Public
     License along with this library; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA    */
  
  package jtemporal;
  
  import java.util.SortedMap;
  import java.util.Comparator;
  import java.util.Map;
  import java.util.Set;
  import java.util.Collection;
  import java.util.AbstractSet;
  import java.util.Iterator;
  import java.util.NoSuchElementException;
  import java.util.AbstractMap;
  
  /**
   * Decorates a SortedMap allowing a single third object to subscribe to updates.
   * That's more efficient in terms of performance than using events and listeners.
   * If you need events and multiple listener, you need to create an intermediate
   * map subscriber class, which creates and dispatches the events.  <BR>
   * This class is optimized for the jtemporal use, that's
   * why the class is not public (also some methods not used by JTemporal are not
   * implemented). However with minimal changes, this class can become generic.
   * @author Thomas Beck
   * @version $Id$
   */
  
  class PublishedSortedMap implements SortedMap {
  
    private final SortedMap map;
    private final MapSubscriber subscriber;
  
    // compulsory constructor
    public PublishedSortedMap(SortedMap decoratedMap, MapSubscriber sub) {
        this.map = decoratedMap;
        this.subscriber = sub;
    }
  
    //accessors
    public SortedMap getDecoratedMap() {
      return this.map;
    }
    public MapSubscriber getSubscriber() {
      return this.subscriber;
    }
  
    // notifications
    private void firePut(Object key, Object value) {
      this.subscriber.put(this, key, value);
    }
  
    private void fireRemoved(Object key) {
      this.subscriber.removed(this, key);
    }
  
  
    // read-only methods
  
    public Comparator comparator() {
      return this.map.comparator();
    }
    public Object firstKey() {
      return this.map.firstKey();
    }
    public Object lastKey() {
      return this.map.lastKey();
    }
    public int size() {
      return this.map.size();
    }
    public boolean isEmpty() {
      return this.map.isEmpty();
    }
    public boolean containsKey(Object key) {
      return this.map.containsKey(key);
    }
    public boolean containsValue(Object value) {
      return this.map.containsValue(value);
    }
    public Object get(Object key) {
      return this.map.get(key);
    }
    public boolean equals(Object o) {
      return this.map.equals(o);
    }
   public int hashCode() {
     return this.map.hashCode();
   }
 
 
   // submaps
 
   public SortedMap subMap(Object fromKey, Object toKey) {
     SortedMap subMap = this.map.subMap(fromKey, toKey);
     return new PublishedSortedMap(subMap, this.subscriber);
   }
   public SortedMap headMap(Object toKey) {
     SortedMap subMap = this.map.headMap(toKey);
     return new PublishedSortedMap(subMap, this.subscriber);
   }
   public SortedMap tailMap(Object fromKey) {
     SortedMap subMap = this.map.tailMap(fromKey);
     return new PublishedSortedMap(subMap, this.subscriber);
   }
 
 
   // changes
 
   public Object put(Object key, Object value) {
     Object replaced = this.map.put(key, value);
     this.firePut(key, value);
     return replaced;
   }
   public Object remove(Object key) {
     Object removed = this.map.remove(key);
     this.fireRemoved(key);
     return removed;
   }
 
   /**
    * Internaly, instead caling clear(); this method iterates and removes all the
    * elements one by one.  That allows a subscriber to receive the detail of the
    * deletions.
    */
   public void clear() {
     Iterator i = this.keySet().iterator();
     while (i.hasNext()) {
       i.next();
       i.remove();
     }
     //consistency check
     if (this.map.size() != 0) {
       // should never happen
       throw new IllegalStateException("The published SortedMap is inconsistent");
     }
   }
   public void putAll(Map t) {
     Iterator i = t.entrySet().iterator();
     while (i.hasNext()) {
       Map.Entry e = (Map.Entry) i.next();
       put(e.getKey(), e.getValue());
     }
   }
   public Set keySet() {
     Set decSet = this.map.keySet();
     return new PublishedSortedMap.KeySet(decSet);
   }
   public Collection values() {
     // not used by JTemporal
     // must be implemented if used outside JTemporal
     throw new UnsupportedOperationException();
     //return this.map.values();
   }
   public Set entrySet() {
     // not used by JTemporal
     // must be implemented if used outside JTemporal
     throw new UnsupportedOperationException();
     //return this.map.entrySet();
   }
 
 
   private class KeySet extends AbstractSet
   {
     final Set decSet;
 
     public KeySet(Set decoratedSet) {
       this.decSet = decoratedSet;
     }
 
     public int size() {
       return this.decSet.size();
     }
     public boolean isEmpty() {
       return this.decSet.isEmpty();
     }
     public boolean contains(Object o) {
       return this.decSet.contains(o);
     }
 
     public boolean remove(Object o) {
       boolean b = this.decSet.remove(o);
       PublishedSortedMap.this.fireRemoved(o);
       return b;
     }
 
     public Iterator iterator() {
       Iterator decIterator = this.decSet.iterator();
       return new SetIterator(decIterator);
     } // iterator()
 
     private class SetIterator implements Iterator
     {
       private final Iterator decIterator;
       private Object lastRead = null;
 
       SetIterator(Iterator decoratedIterator) {
   this.decIterator = decoratedIterator;
       }
 
       public boolean hasNext() {
   return decIterator.hasNext();
       }
 
       public Object next() {
   return lastRead = decIterator.next();
       }
 
       public void remove() {
   decIterator.remove();
   PublishedSortedMap.this.fireRemoved(lastRead);
       }
 
     } // SetIterator
 
 
   } // class KeySet */
 
 } // class PublishedSortedMap