net.sf.javagimmicks.collections.transformer.ValueTransformingMap Maven / Gradle / Ivy

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

import java.util.AbstractMap;
import java.util.Collection;
import java.util.Map;
import java.util.Set;

class ValueTransformingMap
   extends AbstractMap
   implements Transforming
{
   protected final Map _internalMap;
   private final Transformer _transformer;
   
   /**
    * @deprecated Use TranformerUtils.decorateValueBased() instead
    */
   @Deprecated
   public ValueTransformingMap(Map map, Transformer valueTransformer)
   {
      _internalMap = map;
      _transformer = valueTransformer;
   }
   
   public Transformer getTransformer()
   {
      return _transformer;
   }

   public void clear()
   {
      _internalMap.clear();
   }

   public boolean containsKey(Object key)
   {
      return _internalMap.containsKey(key);
   }

   public Set> entrySet()
   {
      return TransformerUtils.decorate(
         _internalMap.entrySet(),
         new ValueTransformingEntryTransformer(getTransformer()));
   }
   
   public VT get(Object key)
   {
      VF result = _internalMap.get(key);
      
      if(result == null && !containsKey(key))
      {
         return null;
      }
      
      return transform(result);
   }

   public boolean isEmpty()
   {
      return _internalMap.isEmpty();
   }

   public Set keySet()
   {
      return _internalMap.keySet();
   }

   public VT remove(Object key)
   {
      if(!containsKey(key))
      {
         return null;
      }
      
      VF result = _internalMap.remove(key);
      return transform(result);
   }

   public int size()
   {
      return _internalMap.size();
   }

   public Collection values()
   {
      return TransformerUtils.decorate(
         _internalMap.values(),
         getTransformer());
   }
   
   protected VT transform(VF element)
   {
      return getTransformer().transform(element);
   }
   
   protected static class ValueTransformingEntry
      implements Entry, Transforming
   {
      protected final Transformer _transformer;
      protected final Entry _internalEntry;
      
      public ValueTransformingEntry(Entry entry, Transformer transformer)
      {
         _transformer = transformer;
         _internalEntry = entry;
      }
      
      public Transformer getTransformer()
      {
         return _transformer;
      }

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

      public VT getValue()
      {
         return getTransformer().transform(_internalEntry.getValue());
      }

      public VT setValue(VT value)
      {
         throw new UnsupportedOperationException();
      }
   }
   
   protected static class ValueTransformingEntryTransformer
      implements Transformer, Entry>
   {
      protected final Transformer _transformer;
      
      public ValueTransformingEntryTransformer(Transformer transformer)
      {
         _transformer = transformer;
      }

      public Entry transform(Entry source)
      {
         return new ValueTransformingEntry(source, _transformer);
      }
   }
}