// you can arrange the entries in a self-chosen order
// so it's like a very compact LinkedHashMap
// Only good for very small maps
sclass SmallArrayBasedMap<A, B> extends CompactAbstractMap<A, B> {
  O[] entries; // key, value, ... (any order of entries)
  
  *() {}
  *(Map<A, B> map) {
    int n = l(map);
    if (n == 0) ret;
    entries = new O[n*2];
    int i = 0;
    fOr (A key, B value : map) {
      entries[i++] = key;
      entries[i++] = value;
    }
  }
  
  public int size() { ret l(entries)/2; }
  public Set<Map.Entry<A, B>> entrySet() {
    ret new AbstractSet<Map.Entry<A, B>>() {
      public int size() { ret SmallArrayBasedMap.this.size(); }
      
      public Iterator<Map.Entry<A, B>> iterator() {
        ret new Iterator<Map.Entry<A, B>>() {
          int idx;
          
          public bool hasNext() {
            ret idx < l(entries);
          }
          
          public Map.Entry<A, B> next() {
            SimpleEntry<A, B> e = new SimpleEntry<A, B>((A) entries[idx], (B) entries[idx+1]);
            idx += 2;
            ret e;
          }
        };
      }
    };
  }
  
  // returns actual index in entries array
  int find(O key) {
    int n = l(entries);
    //if (n == 0) ret -1;
    //int hash = _hashCode(key);
    for (int i = 0; i < n; i += 2)
      //if (_hashCode(entries[i]) == hash
      if (eq(key, entries[i]))
        ret i;
    ret -1;
  }
    
  public bool containsKey(O o) {
    ret find(o) >= 0;
  }
  
  @Override
  public B get(O o) {
    int i = find(o);
    ret i >= 0 ? (B) entries[i+1] : null;
  }
}