// 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;

  }

}