Implement IgniteMultimap data structures

// Gets value at a certain index for a key.
V get(K, index);

// Gets all values for a collection of keys at a certain index.
Map<K, V> getAll(Collection<K>, index);

// Gets values for specified indexes for a key.
List<V> get(K, Iterable<Integer> indexes);

// Gets all values for a collection of keys at specified indexes.
Map<K, Collection<V>> getAll(Collection<K>, Iterable<Integer> indexes);

// Gets values for specified range of indexes, between min and max.
List<V> get(K, int min, int max);

// Gets all values for a collection of keys for a specified index range, between min and max.
Map<K, Collection<V>> getAll(Collection<K>, int min, int max);

// Gets all values for a specific key.
List<V> get(K);

// Gets all values for a collection of keys.
Map<K, List<V>> getAll(Collection<K>);

// Iterate through all elements with a certain index.
Iterator<Map.Entry<K, V>> iterate(int idx);

// Do we need this?
Collection<IgniteTuple<Integer V>> get(K, IgniteBiPredicate<Integer, V>)

class MultiKey<K> {
    @CacheAffinityMapped
    private K key;

    int index;
}

MultiKey key;
V v = null;
int index = 0;

List<V> res = new LinkedList<>();

do {
    v = cache.get(MultiKey(K, index));

    if (v != null)
        res.add(v);

    index++;
}
while (v != null);

return res;

int index = 0;

List<V> res = new LinkedList<>();

while (true) {
    List<Key> batch = new ArrayList<>(batchSize);

    // Populate batch.
    for (; index < batchSize; index++)
        batch.add(new MultiKey(K, index % batchSize);

    Map<Key, V> batchRes = cache.getAll(batch);

    // Potentially need to properly sort values, based on the key order,
    // if the returning map does not do it automatically.
    res.addAll(batchRes.values());

    if (res.size() < batch.size())
        break;
}

return res;