How to use

AbstractLong2DoubleMap$BasicEntry

in

it.unimi.dsi.fastutil.longs

  /** {@inheritDoc} */
  @Override
  public void fastForEach(final Consumer<? super Long2DoubleMap.Entry> consumer) {
    final AbstractLong2DoubleMap.BasicEntry entry = new AbstractLong2DoubleMap.BasicEntry();
    if (containsNullKey) {
      entry.key = key[n];
      entry.value = value[n];
      consumer.accept(entry);
    }
    for (int pos = n; pos-- != 0;)
      if (!((key[pos]) == (0))) {
        entry.key = key[pos];
        entry.value = value[pos];
        consumer.accept(entry);
      }
  }
}

@Override
public ObjectIterator<Long2DoubleMap.Entry> fastIterator() {
  return new ObjectIterator<Long2DoubleMap.Entry>() {
    int next = 0, curr = -1;
    final BasicEntry entry = new BasicEntry();
    @Override
    public boolean hasNext() {
      return next < size;
    }
    @Override
    public Entry next() {
      if (!hasNext())
        throw new NoSuchElementException();
      entry.key = key[curr = next];
      entry.value = value[next++];
      return entry;
    }
    @Override
    public void remove() {
      if (curr == -1)
        throw new IllegalStateException();
      curr = -1;
      final int tail = size-- - next--;
      System.arraycopy(key, next + 1, key, next, tail);
      System.arraycopy(value, next + 1, value, next, tail);
    }
  };
}
@Override

private Entry entry(int idx) {
  return new BasicEntry(keys.getKey(idx), values[idx]);
}

  /** {@inheritDoc} */
  @Override
  public void fastForEach(final Consumer<? super Long2DoubleMap.Entry> consumer) {
    final AbstractLong2DoubleMap.BasicEntry entry = new AbstractLong2DoubleMap.BasicEntry();
    if (containsNullKey) {
      entry.key = key[n];
      entry.value = value[n];
      consumer.accept(entry);
    }
    for (int pos = n; pos-- != 0;)
      if (!((key[pos]) == (0))) {
        entry.key = key[pos];
        entry.value = value[pos];
        consumer.accept(entry);
      }
  }
}

  /** {@inheritDoc} */
  @Override
  public void fastForEach(final Consumer<? super Long2DoubleMap.Entry> consumer) {
    final AbstractLong2DoubleMap.BasicEntry entry = new AbstractLong2DoubleMap.BasicEntry();
    for (int i = size, curr, next = first; i-- != 0;) {
      curr = next;
      next = (int) link[curr];
      entry.key = key[curr];
      entry.value = value[curr];
      consumer.accept(entry);
    }
  }
}

  @Override
  public Long2DoubleMap.Entry next() {
    Result r = results.next();
    return new AbstractLong2DoubleMap.BasicEntry(r.getId(), r.getScore());
  }
}

@Override
public Long2DoubleMap.Entry previous() {
  Result r = results.previous();
  return new AbstractLong2DoubleMap.BasicEntry(r.getId(), r.getScore());
}

  @Override
  public Entry next() {
    VectorEntry e = delegate.next();
    return new BasicEntry(e.getKey(), e.getValue());
  }
}

@Override
public Long2DoubleMap.Entry first() {
  if (delegate.isEmpty()) {
    throw new NoSuchElementException();
  } else {
    long k = delegate.firstLongKey();
    return new AbstractLong2DoubleMap.BasicEntry(k, getScore(k));
  }
}

/** {@inheritDoc} */
@Override
public void forEach(final Consumer<? super Long2DoubleMap.Entry> consumer) {
  for (int i = size, curr, next = first; i-- != 0;) {
    curr = next;
    next = (int) link[curr];
    consumer.accept(new AbstractLong2DoubleMap.BasicEntry(key[curr], value[curr]));
  }
}
/** {@inheritDoc} */

@Override
public LongBidirectionalIterator iterator(final long from) {
  return new KeySetIterator(long2DoubleEntrySet().iterator(new BasicEntry(from, (0))));
}
@Override

@Override
public Entry next() {
  if (!hasNext())
    throw new NoSuchElementException();
  return new AbstractLong2DoubleMap.BasicEntry(key[curr = next], value[next++]);
}
@Override

  @Override
  public Long2DoubleMap.Entry last() {
    if (delegate.isEmpty()) {
      throw new NoSuchElementException();
    } else {
      long k = delegate.lastLongKey();
      return new AbstractLong2DoubleMap.BasicEntry(k, getScore(k));
    }
  }
}

@Override
public ObjectSortedSet<Long2DoubleMap.Entry> long2DoubleEntrySet() {
  if (entries == null)
    entries = ObjectSortedSets.singleton(new AbstractLong2DoubleMap.BasicEntry(key, value),
        entryComparator(comparator));
  return (ObjectSortedSet<Long2DoubleMap.Entry>) entries;
}
/**

/** {@inheritDoc} */
@Override
public void forEach(final Consumer<? super Long2DoubleMap.Entry> consumer) {
  if (containsNullKey)
    consumer.accept(new AbstractLong2DoubleMap.BasicEntry(key[n], value[n]));
  for (int pos = n; pos-- != 0;)
    if (!((key[pos]) == (0)))
      consumer.accept(new AbstractLong2DoubleMap.BasicEntry(key[pos], value[pos]));
}
/** {@inheritDoc} */

@Override
public ObjectSet<Long2DoubleMap.Entry> long2DoubleEntrySet() {
  if (entries == null)
    entries = ObjectSets.singleton(new AbstractLong2DoubleMap.BasicEntry(key, value));
  return entries;
}
/**

/** {@inheritDoc} */
@Override
public void forEach(final Consumer<? super Long2DoubleMap.Entry> consumer) {
  if (containsNullKey)
    consumer.accept(new AbstractLong2DoubleMap.BasicEntry(key[n], value[n]));
  for (int pos = n; pos-- != 0;)
    if (!((key[pos]) == (0)))
      consumer.accept(new AbstractLong2DoubleMap.BasicEntry(key[pos], value[pos]));
}
/** {@inheritDoc} */

@Test
public void testFastIterStartFrom() {
  double[] values = { 1.5, 2.4, -3.2, 4.3, -5.7 };
  Long2DoubleSortedArrayMap map = new Long2DoubleSortedArrayMap(SortedKeyIndex.create(1, 2, 3, 4, 5),
                                 values);
  AbstractLong2DoubleMap.BasicEntry key = new AbstractLong2DoubleMap.BasicEntry(2, 2.0);
  ObjectBidirectionalIterator<Long2DoubleMap.Entry> iter = map.long2DoubleEntrySet().fastIterator(key);
  assertThat(iter.next().getLongKey(), equalTo(3L));
  assertThat(iter.previous().getLongKey(), equalTo(3L));
  assertThat(iter.previous().getLongKey(), equalTo(2L));
}

  @Override
  public Long2DoubleMap.Entry next() {
    Result r = results.next();
    return new AbstractLong2DoubleMap.BasicEntry(r.getId(), r.getScore());
  }
}

@Override
public Long2DoubleMap.Entry first() {
  if (delegate.isEmpty()) {
    throw new NoSuchElementException();
  } else {
    long k = delegate.firstLongKey();
    return new AbstractLong2DoubleMap.BasicEntry(k, getScore(k));
  }
}