--- a/pom.xml	Tue May 05 15:35:46 2015 +0200
+++ b/pom.xml	Fri May 08 16:36:25 2015 +0200
@@ -11,15 +11,15 @@
 
 	
 	<dependencies>
-	
+		<!-- 
 	    <dependency>
             <groupId>cl.talca</groupId>
             <artifactId>hashMapping</artifactId>
             <version>1.0</version>
-            <scope>system</scope>
+            <scope>compile</scope>
             <systemPath>${basedir}/lib/hash-mapping-1.0.jar</systemPath>
         </dependency>		
-		<!-- 
+		
 		<dependency>
 			<groupId>javax.servlet</groupId>
 			<artifactId>javax.servlet-api</artifactId>

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/cl/maps/duplex/DuplexKey.java	Fri May 08 16:36:25 2015 +0200
@@ -0,0 +1,81 @@
+package cl.maps.duplex;
+
+
+public class DuplexKey<A, B> {
+	
+	private A aKey;
+	private B ownKey;
+	
+	public DuplexKey(A aKey, B ownKey){
+		this.aKey = aKey;
+		this.ownKey = ownKey;
+	}
+	
+	public boolean equalsAKey(A key){
+		if(aKey != null && key != null){
+			return aKey.equals(key);
+		}else if(aKey == null && key == null){
+			return true;
+		}
+		return false;
+	}
+	
+	public boolean equalsOwnKey(B key){
+		if(ownKey != null && key != null){
+			return ownKey.equals(key);
+		}else if(ownKey == null && key == null){
+			return true;
+		}
+		return false;
+	}
+	
+	public A getAKey() {
+		return aKey;
+	}
+
+	public void setAKey(A aKey) {
+		this.aKey = aKey;
+	}
+
+	public B getOwnKey() {
+		return ownKey;
+	}
+
+	public void setOwnKey(B ownKey) {
+		this.ownKey = ownKey;
+	}
+	
+	@Override
+	public boolean equals(Object o){
+		if(o instanceof DuplexKey){
+			try {
+				DuplexKey<A, B> other = (DuplexKey<A, B>)o;
+				
+				if(this.equalsOwnKey(other.getOwnKey()) &&
+						this.equalsAKey(other.getAKey())){
+					return true;
+				}	
+			} catch (Exception e) {}
+			
+		}
+		return false;
+	}
+	
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + ((aKey == null) ? 0 : aKey.hashCode());
+		result = prime * result + ((ownKey == null) ? 0 : ownKey.hashCode());
+		
+		return result;
+	}
+
+	@Override
+	public String toString() {
+		if (aKey == null || ownKey == null) {
+			return super.toString();
+		}
+		return "DuplexKey [" + aKey.toString() + ", " + ownKey.toString() + "]";
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/cl/maps/duplex/DuplexMap.java	Fri May 08 16:36:25 2015 +0200
@@ -0,0 +1,132 @@
+package cl.maps.duplex;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public class DuplexMap<V, A, B> implements IDuplexMap<V, A, B>{
+
+	private Map<DuplexKey<A, B>, V> map;
+	private Map<A, List<DuplexKey<A, B>>> mapAKey;
+	private Map<B, DuplexKey<A, B>> mapOwnKey;
+	
+	public DuplexMap(){
+		this.map  = new HashMap<DuplexKey<A, B>, V>();
+		this.mapAKey = new HashMap<A, List<DuplexKey<A, B>>>();
+		this.mapOwnKey = new HashMap<B, DuplexKey<A, B>>();
+	}
+	
+	public DuplexMap(DuplexMap<? extends V, A, B> m) {
+		this.map  = new HashMap<DuplexKey<A, B>, V>();
+		this.mapAKey = new HashMap<A, List<DuplexKey<A, B>>>();
+		this.mapOwnKey = new HashMap<B, DuplexKey<A, B>>();
+		this.putAllForCreate(m);
+	}
+
+	private void putAllForCreate(DuplexMap<? extends V, A, B> m) {
+		for(Map.Entry<DuplexKey<A, B>, ? extends V> e : m.entrySet()){
+			DuplexKey<A, B> tKey = e.getKey(); 
+			 this.map.put(tKey, e.getValue());
+			 this.mapOwnKey.put(tKey.getOwnKey(), tKey);
+			 
+			 if(!mapAKey.containsKey(tKey.getAKey())){
+				 mapAKey.put(tKey.getAKey(), new LinkedList<DuplexKey<A, B>>());
+			 }
+			 if(!mapAKey.get(tKey.getAKey()).contains(tKey)){
+				 mapAKey.get(tKey.getAKey()).add(tKey);	 
+			 }
+		}
+	}
+	
+	public List<V>getValuesByAKey(A srcKey){
+		List<V> list = new ArrayList<V>();
+		if(mapAKey.containsKey(srcKey)){
+			for(DuplexKey<A, B> tKey : mapAKey.get(srcKey)){
+				list.add(map.get(tKey));
+			}
+		}
+		return list;
+	}
+	
+	public V getValuesByOwnKey(B ownKey){
+		DuplexKey<A, B> tKey = mapOwnKey.get(ownKey);
+		if(tKey != null){
+			return this.map.get(tKey);
+		}
+		return null;
+	}
+	
+	public Set<DuplexKey<A, B>> keySet(){
+		return this.map.keySet();
+	}
+	
+	public Set<Map.Entry<DuplexKey<A, B>, V>> entrySet() {
+		return this.map.entrySet();
+	}	
+	
+	@Override
+	public int size() {
+		return this.map.size();
+	}
+
+	@Override
+	public boolean isEmpty() {
+		return this.map.isEmpty();
+	}
+
+	@Override
+	public boolean containsKey(DuplexKey<A, B> key) {
+		return this.map.containsKey(key);
+	}
+
+	@Override
+	public boolean containsValue(Object value) {
+		return this.map.containsValue(value);
+	}
+
+	@Override
+	public V get(DuplexKey<A, B> key) {
+		return map.get(key);
+	}
+
+	@Override
+	public V put(DuplexKey<A, B> tKey, V value) {
+		if(!mapAKey.containsKey(tKey.getAKey())){
+			List<DuplexKey<A, B>> list = new ArrayList<DuplexKey<A, B>>();
+			mapAKey.put(tKey.getAKey(), list);
+		}
+		if(!mapAKey.get(tKey.getAKey()).contains(tKey)){
+			mapAKey.get(tKey.getAKey()).add(tKey);
+		}
+		
+		this.mapOwnKey.put(tKey.getOwnKey(), tKey);
+		return this.map.put(tKey, value);
+	}
+
+	@Override
+	public V remove(DuplexKey<A, B> key) {
+		if(mapAKey.containsKey(key.getAKey())){
+			mapAKey.get(key.getAKey()).remove(key);
+		}
+		this.mapOwnKey.remove(key.getOwnKey());
+		return this.map.remove(key);
+	}
+
+	@Override
+	public void clear() {
+		this.map.clear();
+		this.mapAKey.clear();
+		this.mapOwnKey.clear();
+	}
+
+	@Override
+	public Collection<V> values() {
+		return this.map.values();
+	}
+
+	
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/cl/maps/duplex/IDuplexMap.java	Fri May 08 16:36:25 2015 +0200
@@ -0,0 +1,51 @@
+package cl.maps.duplex;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+
+
+public interface IDuplexMap<V, A, B> {
+
+	int size();
+	
+	boolean isEmpty();
+
+	boolean containsKey(DuplexKey<A, B> key);
+
+	boolean containsValue(Object value);
+	
+	V get(DuplexKey<A, B> key);
+	
+	V put(DuplexKey<A, B> key, V value);
+
+	V remove(DuplexKey<A, B> key);
+
+	//void putAll(Map<? extends K, ? extends V> m);
+
+	void clear();
+
+	Set<DuplexKey<A, B>> keySet();
+
+	Collection<V> values();
+
+	Set<Map.Entry<DuplexKey<A, B>, V>> entrySet();
+
+	boolean equals(Object o);
+
+	/**
+	  * Returns the hash code value for this map.  The hash code of a map is
+	  * defined to be the sum of the hash codes of each entry in the map's
+	  * <tt>entrySet()</tt> view.  This ensures that <tt>m1.equals(m2)</tt>
+	  * implies that <tt>m1.hashCode()==m2.hashCode()</tt> for any two maps
+	  * <tt>m1</tt> and <tt>m2</tt>, as required by the general contract of
+	  * {@link Object#hashCode}.
+	  *
+	  * @return the hash code value for this map
+	  * @see Map.Entry#hashCode()
+	  * @see Object#equals(Object)
+	  * @see #equals(Object)
+	  */
+	int hashCode();
+	
+}