This is a useful primitive collection type like IntList.
Change-Id: I04b9b2ba25247df056eb3a1725602f1be6d3b440
+++ /dev/null
-/*
- * Copyright (C) 2009, Google Inc.
- * and other copyright owners as documented in the project's IP log.
- *
- * This program and the accompanying materials are made available
- * under the terms of the Eclipse Distribution License v1.0 which
- * accompanies this distribution, is reproduced below, and is
- * available at http://www.eclipse.org/org/documents/edl-v10.php
- *
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or
- * without modification, are permitted provided that the following
- * conditions are met:
- *
- * - Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *
- * - Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- *
- * - Neither the name of the Eclipse Foundation, Inc. nor the
- * names of its contributors may be used to endorse or promote
- * products derived from this software without specific prior
- * written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package org.eclipse.jgit.transport;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
-
-import org.junit.Before;
-import org.junit.Test;
-
-public class LongMapTest {
- private LongMap<Long> map;
-
- @Before
- public void setUp() throws Exception {
- map = new LongMap<>();
- }
-
- @Test
- public void testEmptyMap() {
- assertFalse(map.containsKey(0));
- assertFalse(map.containsKey(1));
-
- assertNull(map.get(0));
- assertNull(map.get(1));
-
- assertNull(map.remove(0));
- assertNull(map.remove(1));
- }
-
- @Test
- public void testInsertMinValue() {
- final Long min = Long.valueOf(Long.MIN_VALUE);
- assertNull(map.put(Long.MIN_VALUE, min));
- assertTrue(map.containsKey(Long.MIN_VALUE));
- assertSame(min, map.get(Long.MIN_VALUE));
- assertFalse(map.containsKey(Integer.MIN_VALUE));
- }
-
- @Test
- public void testReplaceMaxValue() {
- final Long min = Long.valueOf(Long.MAX_VALUE);
- final Long one = Long.valueOf(1);
- assertNull(map.put(Long.MAX_VALUE, min));
- assertSame(min, map.get(Long.MAX_VALUE));
- assertSame(min, map.put(Long.MAX_VALUE, one));
- assertSame(one, map.get(Long.MAX_VALUE));
- }
-
- @Test
- public void testRemoveOne() {
- final long start = 1;
- assertNull(map.put(start, Long.valueOf(start)));
- assertEquals(Long.valueOf(start), map.remove(start));
- assertFalse(map.containsKey(start));
- }
-
- @Test
- public void testRemoveCollision1() {
- // This test relies upon the fact that we always >>> 1 the value
- // to derive an unsigned hash code. Thus, 0 and 1 fall into the
- // same hash bucket. Further it relies on the fact that we add
- // the 2nd put at the top of the chain, so removing the 1st will
- // cause a different code path.
- //
- assertNull(map.put(0, Long.valueOf(0)));
- assertNull(map.put(1, Long.valueOf(1)));
- assertEquals(Long.valueOf(0), map.remove(0));
-
- assertFalse(map.containsKey(0));
- assertTrue(map.containsKey(1));
- }
-
- @Test
- public void testRemoveCollision2() {
- // This test relies upon the fact that we always >>> 1 the value
- // to derive an unsigned hash code. Thus, 0 and 1 fall into the
- // same hash bucket. Further it relies on the fact that we add
- // the 2nd put at the top of the chain, so removing the 2nd will
- // cause a different code path.
- //
- assertNull(map.put(0, Long.valueOf(0)));
- assertNull(map.put(1, Long.valueOf(1)));
- assertEquals(Long.valueOf(1), map.remove(1));
-
- assertTrue(map.containsKey(0));
- assertFalse(map.containsKey(1));
- }
-
- @Test
- public void testSmallMap() {
- final long start = 12;
- final long n = 8;
- for (long i = start; i < start + n; i++)
- assertNull(map.put(i, Long.valueOf(i)));
- for (long i = start; i < start + n; i++)
- assertEquals(Long.valueOf(i), map.get(i));
- }
-
- @Test
- public void testLargeMap() {
- final long start = Integer.MAX_VALUE;
- final long n = 100000;
- for (long i = start; i < start + n; i++)
- assertNull(map.put(i, Long.valueOf(i)));
- for (long i = start; i < start + n; i++)
- assertEquals(Long.valueOf(i), map.get(i));
- }
-}
--- /dev/null
+/*
+ * Copyright (C) 2009, Google Inc.
+ * and other copyright owners as documented in the project's IP log.
+ *
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Distribution License v1.0 which
+ * accompanies this distribution, is reproduced below, and is
+ * available at http://www.eclipse.org/org/documents/edl-v10.php
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ *
+ * - Neither the name of the Eclipse Foundation, Inc. nor the
+ * names of its contributors may be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.eclipse.jgit.util;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class LongMapTest {
+ private LongMap<Long> map;
+
+ @Before
+ public void setUp() throws Exception {
+ map = new LongMap<>();
+ }
+
+ @Test
+ public void testEmptyMap() {
+ assertFalse(map.containsKey(0));
+ assertFalse(map.containsKey(1));
+
+ assertNull(map.get(0));
+ assertNull(map.get(1));
+
+ assertNull(map.remove(0));
+ assertNull(map.remove(1));
+ }
+
+ @Test
+ public void testInsertMinValue() {
+ final Long min = Long.valueOf(Long.MIN_VALUE);
+ assertNull(map.put(Long.MIN_VALUE, min));
+ assertTrue(map.containsKey(Long.MIN_VALUE));
+ assertSame(min, map.get(Long.MIN_VALUE));
+ assertFalse(map.containsKey(Integer.MIN_VALUE));
+ }
+
+ @Test
+ public void testReplaceMaxValue() {
+ final Long min = Long.valueOf(Long.MAX_VALUE);
+ final Long one = Long.valueOf(1);
+ assertNull(map.put(Long.MAX_VALUE, min));
+ assertSame(min, map.get(Long.MAX_VALUE));
+ assertSame(min, map.put(Long.MAX_VALUE, one));
+ assertSame(one, map.get(Long.MAX_VALUE));
+ }
+
+ @Test
+ public void testRemoveOne() {
+ final long start = 1;
+ assertNull(map.put(start, Long.valueOf(start)));
+ assertEquals(Long.valueOf(start), map.remove(start));
+ assertFalse(map.containsKey(start));
+ }
+
+ @Test
+ public void testRemoveCollision1() {
+ // This test relies upon the fact that we always >>> 1 the value
+ // to derive an unsigned hash code. Thus, 0 and 1 fall into the
+ // same hash bucket. Further it relies on the fact that we add
+ // the 2nd put at the top of the chain, so removing the 1st will
+ // cause a different code path.
+ //
+ assertNull(map.put(0, Long.valueOf(0)));
+ assertNull(map.put(1, Long.valueOf(1)));
+ assertEquals(Long.valueOf(0), map.remove(0));
+
+ assertFalse(map.containsKey(0));
+ assertTrue(map.containsKey(1));
+ }
+
+ @Test
+ public void testRemoveCollision2() {
+ // This test relies upon the fact that we always >>> 1 the value
+ // to derive an unsigned hash code. Thus, 0 and 1 fall into the
+ // same hash bucket. Further it relies on the fact that we add
+ // the 2nd put at the top of the chain, so removing the 2nd will
+ // cause a different code path.
+ //
+ assertNull(map.put(0, Long.valueOf(0)));
+ assertNull(map.put(1, Long.valueOf(1)));
+ assertEquals(Long.valueOf(1), map.remove(1));
+
+ assertTrue(map.containsKey(0));
+ assertFalse(map.containsKey(1));
+ }
+
+ @Test
+ public void testSmallMap() {
+ final long start = 12;
+ final long n = 8;
+ for (long i = start; i < start + n; i++)
+ assertNull(map.put(i, Long.valueOf(i)));
+ for (long i = start; i < start + n; i++)
+ assertEquals(Long.valueOf(i), map.get(i));
+ }
+
+ @Test
+ public void testLargeMap() {
+ final long start = Integer.MAX_VALUE;
+ final long n = 100000;
+ for (long i = start; i < start + n; i++)
+ assertNull(map.put(i, Long.valueOf(i)));
+ for (long i = start; i < start + n; i++)
+ assertEquals(Long.valueOf(i), map.get(i));
+ }
+}
+++ /dev/null
-/*
- * Copyright (C) 2009, Google Inc.
- * and other copyright owners as documented in the project's IP log.
- *
- * This program and the accompanying materials are made available
- * under the terms of the Eclipse Distribution License v1.0 which
- * accompanies this distribution, is reproduced below, and is
- * available at http://www.eclipse.org/org/documents/edl-v10.php
- *
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or
- * without modification, are permitted provided that the following
- * conditions are met:
- *
- * - Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *
- * - Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- *
- * - Neither the name of the Eclipse Foundation, Inc. nor the
- * names of its contributors may be used to endorse or promote
- * products derived from this software without specific prior
- * written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package org.eclipse.jgit.transport;
-
-/**
- * Simple Map<long,Object> helper for {@link PackParser}.
- *
- * @param <V>
- * type of the value instance.
- */
-final class LongMap<V> {
- private static final float LOAD_FACTOR = 0.75f;
-
- private Node<V>[] table;
-
- /** Number of entries currently in the map. */
- private int size;
-
- /** Next {@link #size} to trigger a {@link #grow()}. */
- private int growAt;
-
- LongMap() {
- table = createArray(64);
- growAt = (int) (table.length * LOAD_FACTOR);
- }
-
- boolean containsKey(final long key) {
- return get(key) != null;
- }
-
- V get(final long key) {
- for (Node<V> n = table[index(key)]; n != null; n = n.next) {
- if (n.key == key)
- return n.value;
- }
- return null;
- }
-
- V remove(final long key) {
- Node<V> n = table[index(key)];
- Node<V> prior = null;
- while (n != null) {
- if (n.key == key) {
- if (prior == null)
- table[index(key)] = n.next;
- else
- prior.next = n.next;
- size--;
- return n.value;
- }
- prior = n;
- n = n.next;
- }
- return null;
- }
-
- V put(final long key, final V value) {
- for (Node<V> n = table[index(key)]; n != null; n = n.next) {
- if (n.key == key) {
- final V o = n.value;
- n.value = value;
- return o;
- }
- }
-
- if (++size == growAt)
- grow();
- insert(new Node<>(key, value));
- return null;
- }
-
- private void insert(final Node<V> n) {
- final int idx = index(n.key);
- n.next = table[idx];
- table[idx] = n;
- }
-
- private void grow() {
- final Node<V>[] oldTable = table;
- final int oldSize = table.length;
-
- table = createArray(oldSize << 1);
- growAt = (int) (table.length * LOAD_FACTOR);
- for (int i = 0; i < oldSize; i++) {
- Node<V> e = oldTable[i];
- while (e != null) {
- final Node<V> n = e.next;
- insert(e);
- e = n;
- }
- }
- }
-
- private final int index(final long key) {
- int h = ((int) key) >>> 1;
- h ^= (h >>> 20) ^ (h >>> 12);
- return h & (table.length - 1);
- }
-
- @SuppressWarnings("unchecked")
- private static final <V> Node<V>[] createArray(final int sz) {
- return new Node[sz];
- }
-
- private static class Node<V> {
- final long key;
-
- V value;
-
- Node<V> next;
-
- Node(final long k, final V v) {
- key = k;
- value = v;
- }
- }
-}
import org.eclipse.jgit.lib.ProgressMonitor;
import org.eclipse.jgit.util.BlockList;
import org.eclipse.jgit.util.IO;
+import org.eclipse.jgit.util.LongMap;
import org.eclipse.jgit.util.NB;
import org.eclipse.jgit.util.sha1.SHA1;
--- /dev/null
+/*
+ * Copyright (C) 2009, Google Inc.
+ * and other copyright owners as documented in the project's IP log.
+ *
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Distribution License v1.0 which
+ * accompanies this distribution, is reproduced below, and is
+ * available at http://www.eclipse.org/org/documents/edl-v10.php
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ *
+ * - Neither the name of the Eclipse Foundation, Inc. nor the
+ * names of its contributors may be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.eclipse.jgit.util;
+
+/**
+ * Simple Map<long,Object>.
+ *
+ * @param <V>
+ * type of the value instance.
+ * @since 4.9
+ */
+public class LongMap<V> {
+ private static final float LOAD_FACTOR = 0.75f;
+
+ private Node<V>[] table;
+
+ /** Number of entries currently in the map. */
+ private int size;
+
+ /** Next {@link #size} to trigger a {@link #grow()}. */
+ private int growAt;
+
+ /** Initialize an empty LongMap. */
+ public LongMap() {
+ table = createArray(64);
+ growAt = (int) (table.length * LOAD_FACTOR);
+ }
+
+ /**
+ * @param key
+ * the key to find.
+ * @return {@code true} if {@code key} is present in the map.
+ */
+ public boolean containsKey(long key) {
+ return get(key) != null;
+ }
+
+ /**
+ * @param key
+ * the key to find.
+ * @return stored value of the key, or {@code null}.
+ */
+ public V get(long key) {
+ for (Node<V> n = table[index(key)]; n != null; n = n.next) {
+ if (n.key == key)
+ return n.value;
+ }
+ return null;
+ }
+
+ /**
+ * @param key
+ * key to remove from the map.
+ * @return old value of the key, or {@code null}.
+ */
+ public V remove(long key) {
+ Node<V> n = table[index(key)];
+ Node<V> prior = null;
+ while (n != null) {
+ if (n.key == key) {
+ if (prior == null)
+ table[index(key)] = n.next;
+ else
+ prior.next = n.next;
+ size--;
+ return n.value;
+ }
+ prior = n;
+ n = n.next;
+ }
+ return null;
+ }
+
+ /**
+ * @param key
+ * key to store {@code value} under.
+ * @param value
+ * new value.
+ * @return prior value, or null.
+ */
+ public V put(long key, V value) {
+ for (Node<V> n = table[index(key)]; n != null; n = n.next) {
+ if (n.key == key) {
+ final V o = n.value;
+ n.value = value;
+ return o;
+ }
+ }
+
+ if (++size == growAt)
+ grow();
+ insert(new Node<>(key, value));
+ return null;
+ }
+
+ private void insert(final Node<V> n) {
+ final int idx = index(n.key);
+ n.next = table[idx];
+ table[idx] = n;
+ }
+
+ private void grow() {
+ final Node<V>[] oldTable = table;
+ final int oldSize = table.length;
+
+ table = createArray(oldSize << 1);
+ growAt = (int) (table.length * LOAD_FACTOR);
+ for (int i = 0; i < oldSize; i++) {
+ Node<V> e = oldTable[i];
+ while (e != null) {
+ final Node<V> n = e.next;
+ insert(e);
+ e = n;
+ }
+ }
+ }
+
+ private final int index(final long key) {
+ int h = ((int) key) >>> 1;
+ h ^= (h >>> 20) ^ (h >>> 12);
+ return h & (table.length - 1);
+ }
+
+ @SuppressWarnings("unchecked")
+ private static final <V> Node<V>[] createArray(final int sz) {
+ return new Node[sz];
+ }
+
+ private static class Node<V> {
+ final long key;
+ V value;
+ Node<V> next;
+
+ Node(final long k, final V v) {
+ key = k;
+ value = v;
+ }
+ }
+}
projects / jgit.git / commitdiff