KezvhLib/src-lib/net/kezvh/collections/Map2/AbstractMap2.java

   1 package net.kezvh.collections.Map2;
   2
   3 import java.util.AbstractMap;
   4 import java.util.Collection;
   5 import java.util.Iterator;
   6 import java.util.Map;
   7 import java.util.Set;
   8
   9 import net.kezvh.collections.Pair;
  10 import net.kezvh.collections.views.ConditionalSetView;
  11 import net.kezvh.collections.views.SetView;
  12 import net.kezvh.functional.lambda.L1;
  13 import net.kezvh.functional.lambda.Predicate1;
  14
  15 /**
  16  * @author mjacob
  17  * @param <K1> key 1 type
  18  * @param <K2> key 2 type
  19  * @param <V> value type
  20  */
  21 public abstract class AbstractMap2<K1, K2, V> extends AbstractMap<Pair<K1, K2>, V> implements Map2<K1, K2, V> {
  22         private static final class AbstractCouple<K1, K2> implements Pair<K1, K2> {
  23                 private final K1 key1;
  24                 private final K2 key2;
  25
  26                 public AbstractCouple(final K1 key1, final K2 key2) {
  27                         super();
  28                         this.key1 = key1;
  29                         this.key2 = key2;
  30                 }
  31
  32                 @Override
  33                 public K1 get1() {
  34                         return this.key1;
  35                 }
  36
  37                 @Override
  38                 public K2 get2() {
  39                         return this.key2;
  40                 }
  41         }
  42
  43         @Override
  44         public boolean containsKey(final K1 key1, final K2 key2) {
  45                 return this.containsKey(new AbstractCouple<K1, K2>(key1, key2));
  46         }
  47
  48         private final class K1Filter implements Predicate1<Map.Entry<Pair<K1, K2>, V>> {
  49                 private final K1 key1;
  50
  51                 public K1Filter(final K1 key1) {
  52                         this.key1 = key1;
  53                 }
  54
  55                 public Boolean op(final Map.Entry<Pair<K1, K2>, V> entry) {
  56                         return this.key1.equals(entry.getKey().get1());
  57                 }
  58         }
  59
  60         private final class K2Filter implements Predicate1<Map.Entry<Pair<K1, K2>, V>> {
  61                 private final K2 key2;
  62
  63                 public K2Filter(final K2 key2) {
  64                         this.key2 = key2;
  65                 }
  66
  67                 public Boolean op(final Map.Entry<Pair<K1, K2>, V> entry) {
  68                         return this.key2.equals(entry.getKey().get2());
  69                 }
  70         }
  71
  72         private final L1<Map2.Entry<K1, K2, V>, Map.Entry<Pair<K1, K2>, V>> ENTRY_CONVERTER = new L1<Map2.Entry<K1, K2, V>, Map.Entry<Pair<K1, K2>, V>>() {
  73                 @Override
  74                 public Map2.Entry<K1, K2, V> op(final Map.Entry<Pair<K1, K2>, V> param) {
  75                         return new Map2.Entry<K1, K2, V>() {
  76                                 @Override
  77                                 public Pair<K1, K2> getKey() {
  78                                         return param.getKey();
  79                                 }
  80
  81                                 @Override
  82                                 public K1 getKey1() {
  83                                         return param.getKey().get1();
  84                                 }
  85
  86                                 @Override
  87                                 public K2 getKey2() {
  88                                         return param.getKey().get2();
  89                                 }
  90
  91                                 @Override
  92                                 public V getValue() {
  93                                         return param.getValue();
  94                                 }
  95
  96                                 public V setValue(final V value) {
  97                                         return param.setValue(value);
  98                                 }
  99
 100                                 @Override
 101                                 public int hashCode() {
 102                                         return param.hashCode();
 103                                 }
 104
 105                                 @Override
 106                                 public boolean equals(final Object obj) {
 107                                         if (obj == null)
 108                                                 return false;
 109                                         if (obj == this)
 110                                                 return true;
 111                                         if (this.getClass() != obj.getClass())
 112                                                 return false;
 113
 114                                         final Map2.Entry<?, ?, ?> other = (Map2.Entry<?, ?, ?>) obj;
 115                                         return this.getKey1().equals(other.getKey1()) && this.getKey2().equals(other.getKey2());
 116                                 }
 117                         };
 118                 }
 119         };
 120
 121         @Override
 122         public Set<Map2.Entry<K1, K2, V>> entrySetOnKey1(final K1 key1) {
 123                 final Set<Map.Entry<Pair<K1, K2>, V>> filtered = new ConditionalSetView<Map.Entry<Pair<K1, K2>, V>>(new K1Filter(key1), this.entrySet());
 124                 return new SetView<Map.Entry<Pair<K1, K2>, V>, Map2.Entry<K1, K2, V>>(filtered, this.ENTRY_CONVERTER);
 125         }
 126
 127         @Override
 128         public Set<Map2.Entry<K1, K2, V>> entrySetOnKey2(final K2 key2) {
 129                 final Set<Map.Entry<Pair<K1, K2>, V>> filtered = new ConditionalSetView<Map.Entry<Pair<K1, K2>, V>>(new K2Filter(key2), this.entrySet());
 130                 return new SetView<Map.Entry<Pair<K1, K2>, V>, Map2.Entry<K1, K2, V>>(filtered, this.ENTRY_CONVERTER);
 131         }
 132
 133         @Override
 134         public V get(final K1 key1, final K2 key2) {
 135                 for (final Map.Entry<Pair<K1, K2>, V> entry : this.entrySet())
 136                         if (key1.equals(entry.getKey().get1()) && key2.equals(entry.getKey().get2()))
 137                                 return entry.getValue();
 138                 return null;
 139         }
 140
 141         private final L1<K2, Map2.Entry<K1, K2, V>> K2VIEW = new L1<K2, Map2.Entry<K1, K2, V>>() {
 142                 @Override
 143                 public K2 op(final net.kezvh.collections.Map2.Map2.Entry<K1, K2, V> param) {
 144                         return param.getKey2();
 145                 }
 146         };
 147
 148         private final L1<K1, Map2.Entry<K1, K2, V>> K1VIEW = new L1<K1, Map2.Entry<K1, K2, V>>() {
 149                 @Override
 150                 public K1 op(final net.kezvh.collections.Map2.Map2.Entry<K1, K2, V> param) {
 151                         return param.getKey1();
 152                 }
 153         };
 154
 155         private final L1<V, Map2.Entry<K1, K2, V>> VVIEW = new L1<V, Map2.Entry<K1, K2, V>>() {
 156                 @Override
 157                 public V op(final net.kezvh.collections.Map2.Map2.Entry<K1, K2, V> param) {
 158                         return param.getValue();
 159                 }
 160         };
 161
 162         @Override
 163         public Set<K2> keySetOnKey1(final K1 key1) {
 164                 return new SetView<Map2.Entry<K1, K2, V>, K2>(this.entrySetOnKey1(key1), this.K2VIEW);
 165         }
 166
 167         @Override
 168         public Set<K1> keySetOnKey2(final K2 key2) {
 169                 return new SetView<Map2.Entry<K1, K2, V>, K1>(this.entrySetOnKey2(key2), this.K1VIEW);
 170         }
 171
 172         @Override
 173         public V put(final K1 key1, final K2 key2, final V value) {
 174                 throw new UnsupportedOperationException();
 175         }
 176
 177         /*
 178          * (non-Javadoc)
 179          * @see java.util.AbstractMap#put(java.lang.Object, java.lang.Object)
 180          */
 181         @Override
 182         public V put(final net.kezvh.collections.Pair<K1, K2> key, final V value) {
 183                 return this.put(key.get1(), key.get2(), value);
 184         }
 185
 186         @Override
 187         public void putAll(final Map2<? extends K1, ? extends K2, ? extends V> m) {
 188                 for (final Map.Entry<Pair<K1, K2>, V> entry : this.entrySet())
 189                         this.put(entry.getKey(), entry.getValue());
 190         }
 191
 192         @Override
 193         public V remove(final K1 key1, final K2 key2) {
 194                 for (final Iterator<Map.Entry<Pair<K1, K2>, V>> i = this.entrySet().iterator(); i.hasNext();) {
 195                         final Map.Entry<Pair<K1, K2>, V> entry = i.next();
 196                         if (key1.equals(entry.getKey().get1()) && key2.equals(entry.getKey().get2())) {
 197                                 i.remove();
 198                                 return entry.getValue();
 199                         }
 200                 }
 201                 return null;
 202         }
 203
 204         @Override
 205         public Collection<V> valuesOnKey1(final K1 key1) {
 206                 return new SetView<Map2.Entry<K1, K2, V>, V>(this.entrySetOnKey1(key1), this.VVIEW);
 207         }
 208
 209         @Override
 210         public Collection<V> valuesOnKey2(final K2 key2) {
 211                 return new SetView<Map2.Entry<K1, K2, V>, V>(this.entrySetOnKey2(key2), this.VVIEW);
 212         }
 213 }