+ finish bound hash operations + hash operations

+ finish hash ops implementations in RedisTemplate
+ finish redis map implementation

spring-data-redis/src/main/java/org/springframework/data/keyvalue/redis/core/BoundHashOperations.java

@@ -15,10 +15,32 @@
  */
 package org.springframework.data.keyvalue.redis.core;
 
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+
 /**
  * @author Costin Leau
  */
-public interface BoundHashOperations<K, HF, HV> extends KeyBound<K> {
+public interface BoundHashOperations<H, HK, HV> extends KeyBound<H> {
 
+	RedisOperations<H, ?> getOperations();
 
+	boolean hasKey(Object key);
+
+	Integer increment(HK key, int delta);
+
+	HV get(Object key);
+
+	void set(HK key, HV value);
+
+	void multiSet(Map<? extends HK, ? extends HV> m);
+
+	Set<HK> keys();
+
+	Collection<HV> values();
+
+	Integer length();
+
+	void delete(Object key);
 }

spring-data-redis/src/main/java/org/springframework/data/keyvalue/redis/core/DefaultBoundHashOperations.java

@@ -15,19 +15,78 @@
  */
 package org.springframework.data.keyvalue.redis.core;
 
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+
 /**
  * Default implementation for {@link HashOperations}.
  * 
  * @author Costin Leau
  */
-class DefaultBoundHashOperations<K, HF, HV> extends DefaultKeyBound<K> implements BoundHashOperations<K, HF, HV> {
+class DefaultBoundHashOperations<H, HK, HV> extends DefaultKeyBound<H> implements BoundHashOperations<H, HK, HV> {
+
+	private final HashOperations<H, HK, HV> ops;
+	private RedisOperations<H, ?> template;
 
 	/**
 	 * Constructs a new <code>DefaultBoundHashOperations</code> instance.
 	 *
 	 * @param key
+	 * @param template
 	 */
-	public DefaultBoundHashOperations(K key) {
+	public DefaultBoundHashOperations(H key, RedisTemplate<H, ?> template) {
 		super(key);
+		this.ops = template.hashOps();
 	}
-}
+
+	@Override
+	public void delete(Object key) {
+		ops.delete(getKey(), key);
+	}
+
+	@Override
+	public HV get(Object key) {
+		return ops.get(getKey(), key);
+	}
+
+	@Override
+	public RedisOperations<H, ?> getOperations() {
+		return template;
+	}
+
+	@Override
+	public boolean hasKey(Object key) {
+		return ops.hasKey(getKey(), key);
+	}
+
+	@Override
+	public Integer increment(HK key, int delta) {
+		return ops.increment(getKey(), key, delta);
+	}
+
+	@Override
+	public Set<HK> keys() {
+		return ops.keys(getKey());
+	}
+
+	@Override
+	public Integer length() {
+		return ops.length(getKey());
+	}
+
+	@Override
+	public void multiSet(Map<? extends HK, ? extends HV> m) {
+		ops.multiSet(getKey(), m);
+	}
+
+	@Override
+	public void set(HK key, HV value) {
+		ops.set(getKey(), key, value);
+	}
+
+	@Override
+	public Collection<HV> values() {
+		return ops.values(getKey());
+	}
+}

spring-data-redis/src/main/java/org/springframework/data/keyvalue/redis/core/HashOperations.java

@@ -15,12 +15,32 @@
  */
 package org.springframework.data.keyvalue.redis.core;
 
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+
 /**
  * Redis map specific operations working on a hash.
  * 
  * @author Costin Leau
  */
-public interface HashOperations<HF, HV> {
+public interface HashOperations<H, HK, HV> {
 
+	void delete(H key, Object hashKey);
 
+	Boolean hasKey(H key, Object hashKey);
+
+	HV get(H key, Object hashKey);
+
+	Integer increment(H key, HK hashKey, int delta);
+
+	Set<HK> keys(H key);
+
+	Integer length(H key);
+
+	void multiSet(H key, Map<? extends HK, ? extends HV> m);
+
+	void set(H key, HK hashKey, HV value);
+
+	Collection<HV> values(H key);
 }

spring-data-redis/src/main/java/org/springframework/data/keyvalue/redis/core/RedisOperations.java

@@ -51,7 +51,7 @@ public interface RedisOperations<K, V> {
 
 	BoundZSetOperations<K, V> forZSet(K key);
 	
-	<HF, HV> HashOperations<HF, HV> hashOps();
+	<HK, HV> HashOperations<K, HK, HV> hashOps();
 
-	<HF, HV> BoundHashOperations<K, HF, HV> forHash(K key);
+	<HK, HV> BoundHashOperations<K, HK, HV> forHash(K key);
 }

spring-data-redis/src/main/java/org/springframework/data/keyvalue/redis/core/RedisTemplate.java

@@ -21,8 +21,10 @@ import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 import org.springframework.data.keyvalue.redis.connection.RedisConnection;
@@ -211,6 +213,17 @@ public class RedisTemplate<K, V> extends RedisAccessor implements RedisOperation
 		return (T) values;
 	}
 
+	@SuppressWarnings("unchecked")
+	private <H> Collection<H> arbitraryValues(Collection<byte[]> rawValues, Class<? extends Collection> type) {
+		Collection<H> values = (List.class.isAssignableFrom(type) ? new ArrayList<H>(rawValues.size())
+				: new LinkedHashSet<H>(rawValues.size()));
+		for (byte[] bs : rawValues) {
+			values.add((H) valueSerializer.deserialize(bs));
+		}
+
+		return values;
+	}
+
 	// utility methods for the template internal methods
 	private abstract class ValueDeserializingRedisCallback implements RedisCallback<V> {
 		private K key;
@@ -857,16 +870,145 @@ public class RedisTemplate<K, V> extends RedisAccessor implements RedisOperation
 	//
 
 	@Override
-	public <HF, HV> BoundHashOperations<K, HF, HV> forHash(K key) {
-		return new DefaultBoundHashOperations<K, HF, HV>(key);
+	public <HK, HV> BoundHashOperations<K, HK, HV> forHash(K key) {
+		return new DefaultBoundHashOperations<K, HK, HV>(key, this);
 	}
 
 	@Override
-	public <HF, HV> HashOperations<HF, HV> hashOps() {
-		return new DefaultHashOperations<HF, HV>();
+	public <HK, HV> HashOperations<K, HK, HV> hashOps() {
+		return new DefaultHashOperations<HK, HV>();
 	}
 
-	private class DefaultHashOperations<HF, HV> implements HashOperations<HF, HV> {
+	private class DefaultHashOperations<HK, HV> implements HashOperations<K, HK, HV> {
 
+		@Override
+		public HV get(K key, Object hashKey) {
+			final byte[] rawKey = rawKey(key);
+			final byte[] rawHashKey = rawValue(hashKey);
+
+			byte[] rawHashValue = execute(new RedisCallback<byte[]>() {
+				@Override
+				public byte[] doInRedis(RedisConnection connection) {
+					return connection.hGet(rawKey, rawHashKey);
+				}
+			}, true);
+
+			return (HV) valueSerializer.deserialize(rawHashValue);
+		}
+
+		@Override
+		public Boolean hasKey(K key, Object hashKey) {
+			final byte[] rawKey = rawKey(key);
+			final byte[] rawHashKey = rawValue(hashKey);
+
+			return execute(new RedisCallback<Boolean>() {
+				@Override
+				public Boolean doInRedis(RedisConnection connection) {
+					return connection.hExists(rawKey, rawHashKey);
+				}
+			}, true);
+		}
+
+		@Override
+		public Integer increment(K key, HK hashKey, final int delta) {
+			final byte[] rawKey = rawKey(key);
+			final byte[] rawHashKey = rawValue(hashKey);
+
+			return execute(new RedisCallback<Integer>() {
+				@Override
+				public Integer doInRedis(RedisConnection connection) {
+					return connection.hIncrBy(rawKey, rawHashKey, delta);
+				}
+			}, true);
+
+		}
+
+		@Override
+		public Set<HK> keys(K key) {
+			final byte[] rawKey = rawKey(key);
+
+			Set<byte[]> rawValues = execute(new RedisCallback<Set<byte[]>>() {
+				@Override
+				public Set<byte[]> doInRedis(RedisConnection connection) {
+					return connection.hKeys(rawKey);
+				}
+			}, true);
+
+			return (Set<HK>) arbitraryValues(rawValues, Set.class);
+		}
+
+		@Override
+		public Integer length(K key) {
+			final byte[] rawKey = rawKey(key);
+
+			return execute(new RedisCallback<Integer>() {
+				@Override
+				public Integer doInRedis(RedisConnection connection) {
+					return connection.hLen(rawKey);
+				}
+			}, true);
+		}
+
+		@Override
+		public void multiSet(K key, Map<? extends HK, ? extends HV> m) {
+			final byte[] rawKey = rawKey(key);
+
+			final Map<byte[], byte[]> hashes = new LinkedHashMap<byte[], byte[]>(m.size());
+
+			for (Map.Entry<byte[], byte[]> entry : hashes.entrySet()) {
+				hashes.put(rawValue(entry.getKey()), rawValue(entry.getValue()));
+			}
+
+			execute(new RedisCallback<Object>() {
+				@Override
+				public Object doInRedis(RedisConnection connection) {
+					connection.hMSet(rawKey, hashes);
+					return null;
+				}
+			}, true);
+		}
+
+		@Override
+		public void set(K key, HK hashKey, HV value) {
+			final byte[] rawKey = rawKey(key);
+			final byte[] rawHashKey = rawValue(hashKey);
+			final byte[] rawHashValue = rawValue(value);
+
+			execute(new RedisCallback<Object>() {
+				@Override
+				public Object doInRedis(RedisConnection connection) {
+					connection.hSet(rawKey, rawHashKey, rawHashValue);
+					return null;
+				}
+			}, true);
+		}
+
+		@Override
+		public List<HV> values(K key) {
+			final byte[] rawKey = rawKey(key);
+
+			List<byte[]> rawValues = execute(new RedisCallback<List<byte[]>>() {
+				@Override
+				public List<byte[]> doInRedis(RedisConnection connection) {
+					return connection.hVals(rawKey);
+				}
+			}, true);
+
+			return (List<HV>) arbitraryValues(rawValues, List.class);
+		}
+
+		@Override
+		public void delete(K key, Object hashKey) {
+			final byte[] rawKey = rawKey(key);
+			final byte[] rawHashKey = rawValue(hashKey);
+
+			execute(new RedisCallback<Object>() {
+				@Override
+				public Object doInRedis(RedisConnection connection) {
+					connection.hDel(rawKey, rawHashKey);
+					return null;
+				}
+			}, true);
+		}
 	}
 }

spring-data-redis/src/main/java/org/springframework/data/keyvalue/redis/util/DefaultRedisMap.java

@@ -41,32 +41,36 @@ public class DefaultRedisMap<K, V> implements RedisMap<K, V> {
 
 	@Override
 	public Integer increment(K key, int delta) {
-		throw new UnsupportedOperationException();
+		return hashOps.increment(key, delta);
 	}
 
 	@Override
 	public boolean putIfAbsent(K key, V value) {
-		throw new UnsupportedOperationException();
+		if (!hashOps.hasKey(key)) {
+			put(key, value);
+			return true;
+		}
+		return false;
 	}
 
 	@Override
 	public String getKey() {
-		throw new UnsupportedOperationException();
+		return hashOps.getKey();
 	}
 
 	@Override
 	public RedisOperations<String, ?> getOperations() {
-		throw new UnsupportedOperationException();
+		return hashOps.getOperations();
 	}
 
 	@Override
 	public void clear() {
-		throw new UnsupportedOperationException();
+		getOperations().delete(getKey());
 	}
 
 	@Override
 	public boolean containsKey(Object key) {
-		throw new UnsupportedOperationException();
+		return hashOps.hasKey(key);
 	}
 
 	@Override
@@ -81,41 +85,45 @@ public class DefaultRedisMap<K, V> implements RedisMap<K, V> {
 
 	@Override
 	public V get(Object key) {
-		throw new UnsupportedOperationException();
+		return hashOps.get(key);
 	}
 
 	@Override
 	public boolean isEmpty() {
-		throw new UnsupportedOperationException();
+		return size() == 0;
 	}
 
 	@Override
 	public Set<K> keySet() {
-		throw new UnsupportedOperationException();
+		return hashOps.keys();
 	}
 
 	@Override
 	public V put(K key, V value) {
-		throw new UnsupportedOperationException();
+		V oldV = get(key);
+		hashOps.set(key, value);
+		return oldV;
 	}
 
 	@Override
 	public void putAll(Map<? extends K, ? extends V> m) {
-		throw new UnsupportedOperationException();
+		hashOps.multiSet(m);
 	}
 
 	@Override
 	public V remove(Object key) {
-		throw new UnsupportedOperationException();
+		V v = get(key);
+		hashOps.delete(key);
+		return v;
 	}
 
 	@Override
 	public int size() {
-		throw new UnsupportedOperationException();
+		return hashOps.length();
 	}
 
 	@Override
 	public Collection<V> values() {
-		throw new UnsupportedOperationException();
+		return hashOps.values();
 	}
 }