Java 类it.unimi.dsi.fastutil.ints.Int2IntMap.Entry 实例源码

private void sparseToDense() {
  initDenseRep();
  ObjectIterator<Entry> iter = sparseRep.int2IntEntrySet().fastIterator();
  nnz = 0;
  while (iter.hasNext()) {
    Entry itemEntry = iter.next();
    denseRep.put(itemEntry.getIntKey(), itemEntry.getIntValue());
    if(itemEntry.getIntValue() != 0) {
      nnz++;
    }
  }
  sparseRep = null;

  // int[] keys = sparseRep.getKeys();
  // int[] values = sparseRep.getValues();
  // boolean[] used = sparseRep.getUsed();
  // nnz = 0;
  // for (int i = 0; i < keys.length; i++)
  // if (used[i]) {
  // denseRep.put(keys[i], values[i]);
  // nnz++;
  // }
  // sparseRep = null;
}

private void sparsePlusDense(byte[] buf) {
  initDenseRep(buf);

  ObjectIterator<Entry> iter = sparseRep.int2IntEntrySet().fastIterator();
  while (iter.hasNext()) {
    Entry itemEntry = iter.next();
    denseRep.put(itemEntry.getIntKey(), itemEntry.getIntValue());
  }
  sparseRep = null;

  // int[] keys = sparseRep.getKeys();
  // int[] values = sparseRep.getValues();
  // boolean[] used = sparseRep.getUsed();
  // for (int i = 0; i < keys.length; i++)
  // if (used[i]) {
  // denseRep.put(keys[i], values[i]);
  // }
  // sparseRep = null;
}

@Override
public void write(final PacketDataSerializer data)
{
    int[] mapping = (this.ref == null) ? null : this.ref.get();
    if (mapping == null)
    {
        synchronized (this.pattern)
        {
            mapping = new int[this.pattern.size()];
            for (final Entry entry : this.pattern.int2IntEntrySet())
            {
                mapping[entry.getIntKey()] = entry.getIntValue();
            }
            this.ref = new SoftReference<>(mapping);
        }
    }
    data.writeVarInt(mapping.length);
    for (final int i : mapping)
    {
        data.writeVarInt(i);
    }
}

private byte[] serializeSparse() {
  int length = 8 * nnz;
  byte[] bytes = new byte[length];

  IntBuffer keysBuf = wrapIntBuffer(bytes, 0, nnz * 4);
  IntBuffer valuesBuf = wrapIntBuffer(bytes, nnz * 4, nnz * 4);

  ObjectIterator<Entry> iter = sparseRep.int2IntEntrySet().fastIterator();
  int idx = 0;
  while (iter.hasNext()) {
    Entry itemEntry = iter.next();
    keysBuf.put(idx, itemEntry.getIntKey());
    valuesBuf.put(idx, itemEntry.getIntValue());
    idx++;
  }

  // int[] keys = sparseRep.getKeys();
  // int[] values = sparseRep.getValues();
  // boolean[] used = sparseRep.getUsed();

  // int idx = 0;
  // for (int i = 0; i < keys.length; i++)
  // if (used[i]) {
  // keysBuf.put(idx, keys[i]);
  // valuesBuf.put(idx, values[i]);
  // idx++;
  // }

  return bytes;
}

private void sparsePlusDense(ByteBuf buf, int size) {
  initDenseRep(buf, size);

  int ov, k, v;
  ObjectIterator<Entry> iter = sparseRep.int2IntEntrySet().fastIterator();
  while (iter.hasNext()) {
    Entry itemEntry = iter.next();
    k = itemEntry.getIntKey();
    ov = denseRep.get(k);
    v = ov + itemEntry.getIntValue();
    denseRep.put(k, v);
    if (ov != 0 && v == 0) {
      nnz--;
    }
  }

  // int[] keys = sparseRep.getKeys();
  // int[] values = sparseRep.getValues();
  // boolean[] used = sparseRep.getUsed();
  // int ov, k, v;
  // for (int i = 0; i < keys.length; i++) {
  // if (used[i]) {
  // k = keys[i];
  // ov = denseRep.get(k);
  // v = ov + values[i];
  // denseRep.put(k, v);
  // if (ov != 0 && v == 0)
  // nnz--;
  // }
  // }
  sparseRep = null;
}

/**
 * write the task state to a output stream
 * @param output the output stream
 */
public void serialize(DataOutputStream output) throws IOException {
  try {
    readLock.lock();
    output.writeUTF(state.toString());
    output.writeInt(iteration);
    output.writeInt(matrixIdToClockMap.size());
    for (Entry clockEntry : matrixIdToClockMap.int2IntEntrySet()) {
      output.writeInt(clockEntry.getIntKey());
      output.writeInt(clockEntry.getIntValue());
    }
  } finally {
    readLock.unlock();
  }
}

@Test
public void testAddTo() {
    Int2IntLinkedOpenHashMap m = new Int2IntLinkedOpenHashMap( Hash.DEFAULT_INITIAL_SIZE );
    assertEquals( 0, m.addTo( 0, 2 ) );
    assertEquals( 2, m.get( 0 ) );
    assertEquals( 2, m.addTo( 0, 3 ) );
    assertEquals( 5, m.get( 0 ) );
    ObjectIterator<Int2IntMap.Entry> fastIterator = m.int2IntEntrySet().fastIterator();
    Int2IntMap.Entry next = fastIterator.next();
    assertEquals( 0, next.getIntKey() );
    assertEquals( 5, next.getIntValue() );
    assertFalse( fastIterator.hasNext() );

    m.defaultReturnValue( -1 );
    assertEquals( -1, m.addTo( 1, 1 ) );
    assertEquals( 0, m.get( 1 ) );
    assertEquals( 0, m.addTo( 1, 1 ) );
    assertEquals( 1, m.get( 1 ) );
    assertEquals( 1, m.addTo( 1, -2 ) );
    assertEquals( -1, m.get( 1 ) );
    fastIterator = m.int2IntEntrySet().fastIterator();
    next = fastIterator.next();
    assertEquals( 0, next.getIntKey() );
    assertEquals( 5, next.getIntValue() );
    next = fastIterator.next();
    assertEquals( 1, next.getIntKey() );
    assertEquals( -1, next.getIntValue() );
    assertFalse( fastIterator.hasNext() );

    for( int i = 0; i < 100; i++ ) m.addTo( i, 1 );
    assertEquals( 0, m.firstIntKey() );
    assertEquals( 99, m.lastIntKey() );
}

@Test
public void testFastIterator() {
    Int2IntLinkedOpenHashMap s = new Int2IntLinkedOpenHashMap( Hash.DEFAULT_INITIAL_SIZE );
    s.defaultReturnValue( -1 );
    for( int i = 0; i < 100; i++ ) assertEquals( -1, s.put( i, i ) );
    ObjectIterator<Entry> fastIterator = s.int2IntEntrySet().fastIterator();
    Entry entry = fastIterator.next();
    int key = entry.getIntKey();
    entry.setValue( -1000 );
    assertEquals( s.get( key ), -1000 );
    fastIterator.remove();
    assertEquals( s.get( key ), -1 );
}

@Test
public void testFastIterator() {
    Int2IntOpenHashMap s = new Int2IntOpenHashMap( Hash.DEFAULT_INITIAL_SIZE );
    s.defaultReturnValue( -1 );
    for( int i = 0; i < 100; i++ ) assertEquals( -1, s.put( i, i ) );
    ObjectIterator<Entry> fastIterator = s.int2IntEntrySet().fastIterator();
    Entry entry = fastIterator.next();
    int key = entry.getIntKey();
    entry.setValue( -1000 );
    assertEquals( s.get( key ), -1000 );
    fastIterator.remove();
    assertEquals( s.get( key ), -1 );
}