net.sf.javagimmicks.collections.event.AbstractEventNavigableMap Maven / Gradle / Ivy

Go to download
package net.sf.javagimmicks.collections.event;

import java.util.NavigableMap;
import java.util.NavigableSet;

import net.sf.javagimmicks.collections.decorators.AbstractEntryDecorator;

/**
 * A base {@link NavigableMap} wrapper that reports changes to internal callback
 * methods - these must be overwritten by concrete implementations in order to
 * react in any way to the changes.
 * 
 * Methods that must be overwritten:
 * 

 * {@link #fireEntryAdded(Object, Object)}
 * {@link #fireEntryUpdated(Object, Object, Object)}
 * {@link #fireEntryRemoved(Object, Object)}
 * 
 */
public abstract class AbstractEventNavigableMap extends AbstractEventSortedMap implements
      NavigableMap
{
   private static final long serialVersionUID = 7570207692375842675L;

   /**
    * Wraps a new instance around a given {@link NavigableMap}
    * 
    * @param decorated
    *           the {@link NavigableMap} to wrap
    */
   public AbstractEventNavigableMap(final NavigableMap decorated)
   {
      super(decorated);
   }

   @Override
   public NavigableMap getDecorated()
   {
      return (NavigableMap) super.getDecorated();
   }

   @Override
   public Entry ceilingEntry(final K key)
   {
      return new EventEntry(this, getDecorated().ceilingEntry(key));
   }

   @Override
   public K ceilingKey(final K key)
   {
      return getDecorated().ceilingKey(key);
   }

   @Override
   public Entry firstEntry()
   {
      return new EventEntry(this, getDecorated().firstEntry());
   }

   @Override
   public Entry floorEntry(final K key)
   {
      return new EventEntry(this, getDecorated().floorEntry(key));
   }

   @Override
   public K floorKey(final K key)
   {
      return getDecorated().floorKey(key);
   }

   @Override
   public Entry higherEntry(final K key)
   {
      return new EventEntry(this, getDecorated().higherEntry(key));
   }

   @Override
   public K higherKey(final K key)
   {
      return getDecorated().higherKey(key);
   }

   @Override
   public Entry lastEntry()
   {
      return new EventEntry(this, getDecorated().lastEntry());
   }

   @Override
   public Entry lowerEntry(final K key)
   {
      return new EventEntry(this, getDecorated().lowerEntry(key));
   }

   @Override
   public K lowerKey(final K key)
   {
      return getDecorated().lowerKey(key);
   }

   @Override
   public Entry pollFirstEntry()
   {
      final Entry firstEntry = getDecorated().pollFirstEntry();

      if (firstEntry != null)
      {
         fireEntryRemoved(firstEntry.getKey(), firstEntry.getValue());
      }

      return firstEntry;
   }

   @Override
   public Entry pollLastEntry()
   {
      final Entry lastEntry = getDecorated().pollLastEntry();

      if (lastEntry != null)
      {
         fireEntryRemoved(lastEntry.getKey(), lastEntry.getValue());
      }

      return lastEntry;
   }

   @Override
   public NavigableSet descendingKeySet()
   {
      return descendingMap().navigableKeySet();
   }

   @Override
   public NavigableSet navigableKeySet()
   {
      return new NavigableMapKeySetDecorator(this);
   }

   @Override
   public NavigableMap descendingMap()
   {
      return new EventSubNavigableMap(this, getDecorated().descendingMap());
   }

   @Override
   public NavigableMap headMap(final K toKey, final boolean inclusive)
   {
      return new EventSubNavigableMap(this, getDecorated().headMap(toKey, inclusive));
   }

   @Override
   public NavigableMap subMap(final K fromKey, final boolean fromInclusive, final K toKey,
         final boolean toInclusive)
   {
      return new EventSubNavigableMap(this, getDecorated().subMap(fromKey, fromInclusive, toKey, toInclusive));
   }

   @Override
   public NavigableMap tailMap(final K fromKey, final boolean inclusive)
   {
      return new EventSubNavigableMap(this, getDecorated().tailMap(fromKey, inclusive));
   }

   protected static class EventSubNavigableMap extends AbstractEventNavigableMap
   {
      private static final long serialVersionUID = 8445308257944385932L;

      protected final AbstractEventNavigableMap _parent;

      protected EventSubNavigableMap(final AbstractEventNavigableMap parent, final NavigableMap decorated)
      {
         super(decorated);
         _parent = parent;
      }

      @Override
      protected void fireEntryAdded(final K key, final V value)
      {
         _parent.fireEntryAdded(key, value);
      }

      @Override
      protected void fireEntryRemoved(final K key, final V value)
      {
         _parent.fireEntryRemoved(key, value);
      }

      @Override
      protected void fireEntryUpdated(final K key, final V oldValue, final V newValue)
      {
         _parent.fireEntryUpdated(key, oldValue, newValue);
      }
   }

   protected static class EventEntry extends AbstractEntryDecorator
   {
      private static final long serialVersionUID = 5721131374089977796L;

      protected final AbstractEventNavigableMap _parent;

      public EventEntry(final AbstractEventNavigableMap parent, final Entry decorated)
      {
         super(decorated);
         _parent = parent;
      }

      @Override
      public V setValue(final V value)
      {
         final V oldValue = super.setValue(value);

         _parent.fireEntryUpdated(getKey(), oldValue, value);

         return oldValue;
      }
   }
}