package com.trendmicro.grid.acl.ds.cache.commands;
   
   import java.util.*;
   import java.util.concurrent.Callable;
   
   import static net.sf.tinyjee.util.Assert.assertEquals;
   
   /**
    * Defines the base for cache commands.
   *
   * @author juergen_kellerer, 2011-03-24
   * @version 1.0
   */
  public abstract class AbstractCommand<K, V> implements Callable<Map<K, V>> {
  
  	protected Collection<K> keys;
  
  	protected AbstractCommand(Collection<K> keys) {
  		this.keys = keys;
  	}
  
  	/**
  	 * Converts the keys to a map that may be returned with {@link #call()}.
  	 *
  	 * @return a map containing the command's key mapped against 'null'.
  	 */
  	protected Map<K, V> keysToCallResult() {
  		return new MapAdapter<K, V>(keys, Collections.nCopies(keys.size(), (V) null));
  	}
  
  	/**
  	 * Adapts a key and corresponding values collection to a map.
  	 * <p/>
  	 * The implementation does not copy any of the collections.
  	 *
  	 * @param <K> the keys of the map.
  	 * @param <V> the values of the map.
  	 */
  	protected static final class MapAdapter<K, V> extends AbstractMap<K, V> {
  
  		private final Collection<K> keys;
  		private final Collection<V> values;
  		private final Set<Entry<K, V>> entries;
  
  		public MapAdapter(Collection<K> keys, Collection<V> values) {
  			assertEquals("keys#size() != values#size()", keys.size(), values.size());
  			this.keys = keys;
  			this.values = values;
  
  			entries = new AbstractSet<Entry<K, V>>() {
  				@Override
  				public Iterator<Entry<K, V>> iterator() {
  					return new Iterator<Entry<K, V>>() {
  
  						final Iterator<K> kI = MapAdapter.this.keys.iterator();
  						final Iterator<V> vI = MapAdapter.this.values.iterator();
  
  						@Override
  						public boolean hasNext() {
  							return kI.hasNext();
  						}
  
  						@Override
  						public Entry<K, V> next() {
  							return new SimpleImmutableEntry<K, V>(kI.next(), vI.next());
  						}
  
  						@Override
  						public void remove() {
  							kI.remove();
  							vI.remove();
  						}
  					};
  				}
  
  				@Override
  				public int size() {
  					return MapAdapter.this.keys.size();
  				}
  
  				@Override
  				public boolean isEmpty() {
  					return MapAdapter.this.keys.isEmpty();
  				}
  			};
  		}
  
  		@Override
  		public Set<K> keySet() {
  			return keys instanceof Set ? (Set<K>) keys :
  					new AbstractSet<K>() {
  						@Override
  						public Iterator<K> iterator() {
  							return keys.iterator();
  						}
  
  						@Override
  						public int size() {
  							return keys.size();
 						}
 					};
 		}
 
 		@Override
 		public Collection<V> values() {
 			return values;
 		}
 
 		@Override
 		public Set<Entry<K, V>> entrySet() {
 			return entries;
 		}
 	}
 
 	/**
 	 * Is a map implementation that has the same performance characteristics as ArrayList or
 	 * LinkedList (depending on the constructor) for puts and iterations, at the cost that it does not
 	 * guarantee uniqueness of key and values pairs and does not offer indexed key access.
 	 * <p/>
 	 * Do not use it as general purpose map as it violates uniqueness and is efficient only in
 	 * iterating and building the map entries.
 	 */
 	protected static final class NonUniqueMap<K, V> extends AbstractMap<K, V> {
 
 		protected static class ArraySet<E> extends ArrayList<E> implements Set<E> {
 			private static final long serialVersionUID = -5172793228894213934L;
 
 			private ArraySet(int initialCapacity) {
 				super(initialCapacity);
 			}
 		}
 
 		protected static class LinkedSet<E> extends LinkedList<E> implements Set<E> {
 			private static final long serialVersionUID = -5172793228894213934L;
 		}
 
 		private final Set<Entry<K, V>> entries;
 		private boolean readonly;
 
 		protected NonUniqueMap() {
 			entries = new LinkedSet<Entry<K, V>>();
 		}
 
 		protected NonUniqueMap(int capacity) {
 			entries = new ArraySet<Entry<K, V>>(capacity);
 		}
 
 		/**
 		 * Makes the map readonly.
 		 */
 		protected void makeReadonly() {
 			this.readonly = true;
 		}
 
 		@Override
 		public V put(K key, V value) {
 			if (readonly)
 				throw new UnsupportedOperationException();
 			entries.add(new SimpleEntry<K, V>(key, value));
 			return null;
 		}
 
 		@Override
 		public Set<Entry<K, V>> entrySet() {
 			return entries;
 		}
 	}
 }