net.sf.javagimmicks.collections.bidimap.DualBidiMap Maven / Gradle / Ivy

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

import java.util.AbstractMap;
import java.util.AbstractSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class DualBidiMap extends AbstractMap implements BidiMap
{
   protected final Map _forwardMap;
   protected final Map _reverseMap;
   
   DualBidiMap(Map forwardMap, Map reverseMap)
   {
      _forwardMap = forwardMap;
      _reverseMap = reverseMap;
   }

   @Override
   public Set> entrySet()
   {
      return new DualBidiEntrySet(getForwardMap().entrySet());
   }
   
   @Override
   public V put(K key, V value)
   {
      checkValue(value);

      V oldValue = getForwardMap().put(key, value);
      K oldKey = getReverseMap().put(value, key);
      
      getForwardMap().remove(oldKey);
      getReverseMap().remove(oldValue);
      
      return oldValue;
   }

   @Override
   public V remove(Object key)
   {
      V value = getForwardMap().remove(key);
      getReverseMap().remove(value);
      
      return value;
   }

   public BidiMap inverseBidiMap()
   {
      return new InverseDualBidiMap(getReverseMap(), getForwardMap());
   }
   
   @Override
   public V get(Object key)
   {
      return getForwardMap().get(key);
   }
   
   public K getKey(V value)
   {
      return getReverseMap().get(value);
   }

   protected Map getForwardMap()
   {
      return _forwardMap;
   }
   
   protected Map getReverseMap()
   {
      return _reverseMap;
   }
   
   protected static  void checkValue(V value)
   {
      if(value == null)
      {
         throw new IllegalArgumentException("Null values not allowed in BidiMaps!");
      }
   }

   protected class DualBidiEntry implements Entry
   {
      protected final Entry internalEntry;

      protected DualBidiEntry(Entry internalEntry)
      {
         this.internalEntry = internalEntry;
      }

      public K getKey()
      {
         return internalEntry.getKey();
      }

      public V getValue()
      {
         return internalEntry.getValue();
      }

      public V setValue(V value)
      {
         return put(getKey(), value);
      }
   }

   protected class DualBidiEntryIterator implements Iterator>
   {
      protected final Iterator> internalIterator;
      protected Entry _lastEntry;

      protected DualBidiEntryIterator(Iterator> internalIterator)
      {
         this.internalIterator = internalIterator;
      }

      public boolean hasNext()
      {
         return internalIterator.hasNext();
      }

      public Entry next()
      {
         _lastEntry = internalIterator.next();
         return new DualBidiEntry(_lastEntry);
      }

      public void remove()
      {
         internalIterator.remove();
         _reverseMap.remove(_lastEntry.getValue());
      }
   }

   protected class DualBidiEntrySet extends AbstractSet>
   {
      private final Set> internalEntrySet;

      protected DualBidiEntrySet(Set> internalEntrySet)
      {
         this.internalEntrySet = internalEntrySet;
      }

      @Override
      public Iterator> iterator()
      {
         return new DualBidiEntryIterator(internalEntrySet.iterator());
      }

      @Override
      public int size()
      {
         return internalEntrySet.size();
      }
   }

   protected class InverseDualBidiMap extends DualBidiMap
   {
      protected InverseDualBidiMap(Map reverseMap, Map forwardMap)
      {
         super(reverseMap, forwardMap);
      }

      @Override
      public BidiMap inverseBidiMap()
      {
         return DualBidiMap.this;
      }
   }
}