public boolean contains(Object o) { return containsKey(o); }
public boolean contains(Object o) { return containsValue(o); }
public boolean remove(Object o) { int oldnodeCount = nodeCount; DoubleOrderedMap.this.remove(o); return nodeCount != oldnodeCount; }
/** * Returns true if this map maps one or more keys to the * specified value. * * @param value value whose presence in this map is to be tested. * * @return true if this map maps one or more keys to the specified * value. */ public boolean containsValue(final Object value) { checkValue(value); return lookup((Comparable) value, VALUE) != null; }
/** * check a key and a value for validity (non-null and implements * Comparable) * * @param key the key to be checked * @param value the value to be checked * * @throws NullPointerException if key or value is null * @throws ClassCastException if key or value is not Comparable */ private static void checkKeyAndValue(final Object key, final Object value) { checkKey(key); checkValue(value); }
/** * common get logic, used to get by key or get by value * * @param o the key or value that we're looking for * @param index KEY or VALUE * * @return the key (if the value was mapped) or the value (if the * key was mapped); null if we couldn't find the specified * object */ private Object doGet(final Comparable o, final int index) { checkNonNullComparable(o, index); Node node = lookup(o, index); return ((node == null) ? null : node.getData(oppositeIndex(index))); }
IllegalArgumentException { checkKeyAndValue(key, value); rootNode[VALUE] = root; grow(); } else { while (true) { int cmp = compare((Comparable) key, node.getData(KEY)); (Comparable) value); insertValue(newNode); node.setLeft(newNode, KEY); newNode.setParent(node, KEY); doRedBlackInsert(newNode, KEY); grow(); (Comparable) value); insertValue(newNode); node.setRight(newNode, KEY); newNode.setParent(node, KEY); doRedBlackInsert(newNode, KEY); grow();
m.put(nodes[k].getKey(), nodes[k]); m.put(nodes[k].getKey(), nodes[k]); int count = m.size(); for (Iterator iter = m.valuesByValue().iterator(); iter.hasNext(); ) assertEquals(count, m.size()); assertTrue(m.isEmpty()); m.put(nodes[k].getKey(), nodes[k]); count = m.size(); Collection s = m.valuesByValue(); assertTrue(!m.containsKey(nodes[k].getKey())); assertTrue(!m.containsValue(nodes[k])); assertTrue(m.isEmpty()); m.put(nodes[k].getKey(), nodes[k]); c1.add(nodes[k]); c2.add(nodes[k]); assertTrue(m.valuesByValue().containsAll(c1)); assertTrue(!m.valuesByValue().containsAll(c2));
m.put(nodes[k].getKey(), nodes[k]); m.put(nodes[k].getKey(), nodes[k]); int count = m.size(); for (Iterator iter = m.keySetByValue().iterator(); iter.hasNext(); ) assertEquals(count, m.size()); assertTrue(m.isEmpty()); m.put(nodes[k].getKey(), nodes[k]); Set s = m.keySetByValue(); assertTrue(!m.containsKey(key)); assertTrue(!m.containsValue(nodes[k])); assertTrue(m.isEmpty()); m.put(nodes[k].getKey(), nodes[k]); c1.add(nodes[k].getKey()); c2.add(nodes[k].getKey()); assertTrue(m.keySetByValue().containsAll(c1)); assertTrue(!m.keySetByValue().containsAll(c2)); m.keySetByValue().addAll(c1);
/** * Returns true if this map contains a mapping for the specified * key. * * @param key key whose presence in this map is to be tested. * * @return true if this map contains a mapping for the specified * key. * * @throws ClassCastException if the key is of an inappropriate * type for this map. * @throws NullPointerException if the key is null */ public boolean containsKey(final Object key) throws ClassCastException, NullPointerException { checkKey(key); return lookup((Comparable) key, KEY) != null; }
m.put(nodes[k].getKey(), nodes[k]); m.removeValue(null); fail("should have caught NullPointerException"); } catch (NullPointerException ignored) {} m.removeValue(new Object()); fail("should have caught ClassCastException"); } catch (ClassCastException ignored) {} assertNull(m.remove(new Integer(-1))); m.removeValue("foo"); fail("should have caught ClassCastException"); } catch (ClassCastException ignored) {} assertNotNull(m.getKeyForValue(nodes[k])); assertSame(nodes[k].getKey(), m.removeValue(nodes[k])); assertNull(m.removeValue(nodes[k])); assertNull(m.getKeyForValue(nodes[k])); assertNotNull(m.getKeyForValue(nodes[k])); assertSame(nodes[k].getKey(), m.removeValue(nodes[k])); assertNull(m.removeValue(nodes[k])); assertNull(m.getKeyForValue(nodes[k])); assertTrue(m.isEmpty());
public int size() { return DoubleOrderedMap.this.size(); }
public boolean remove(Object o) { int oldNodeCount = nodeCount; removeValue(o); return nodeCount != oldNodeCount; }
Collection s = m.valuesByValue(); assertEquals(m.size(), s.size()); assertEquals(m.isEmpty(), s.isEmpty()); m.put(node.getKey(), node); assertEquals(m.size(), s.size()); assertEquals(m.isEmpty(), s.isEmpty()); m.remove(node.getKey()); assertEquals(m.size(), s.size()); assertEquals(m.isEmpty(), s.isEmpty()); assertTrue(!s.contains(node)); for (int k = 0; k < m.size(); k++) { assertTrue(s.contains(new LocalTestNode(k))); m.put(node.getKey(), node); assertTrue(s.contains(node)); m.remove(node.getKey()); assertTrue(!s.contains(node)); m.put(node4.getKey(), node4); m.put(node.getKey(), node); m.remove(node.getKey()); m.put(node.getKey(), node);
Set s = m.entrySetByValue(); assertEquals(m.size(), s.size()); assertEquals(m.isEmpty(), s.isEmpty()); m.put(node.getKey(), node); assertEquals(m.size(), s.size()); assertEquals(m.isEmpty(), s.isEmpty()); m.remove(node.getKey()); assertEquals(m.size(), s.size()); assertEquals(m.isEmpty(), s.isEmpty()); if (m.size() == 0) { m.put(node2.getKey(), node2); m.put(node.getKey(), node); m.remove(node2.getKey()); m.remove(node.getKey()); m.put(node.getKey(), node); assertEquals(m.size(), count); m.put(node3.getKey(), node3); int when = m.size() / 2; int timer = 0;
Set s = m.keySetByValue(); assertEquals(m.size(), s.size()); assertEquals(m.isEmpty(), s.isEmpty()); m.put(node.getKey(), node); assertTrue(s.contains(node.getKey())); assertEquals(m.size(), s.size()); assertEquals(m.isEmpty(), s.isEmpty()); m.remove(node.getKey()); assertTrue(!s.contains(node.getKey())); assertEquals(m.size(), s.size()); assertEquals(m.isEmpty(), s.isEmpty()); for (int k = 0; k < m.size(); k++) { assertTrue(s.contains(new Integer(k))); m.put(node.getKey(), node); Iterator iter = m.keySetByValue().iterator(); LocalTestNode node2 = new LocalTestNode(-2); m.put(node2.getKey(), node2); m.remove(node2.getKey()); m.remove(node.getKey()); m.put(node.getKey(), node);
public void clear() { DoubleOrderedMap.this.clear(); } };
/** * check a key for validity (non-null and implements Comparable) * * @param key the key to be checked * * @throws NullPointerException if key is null * @throws ClassCastException if key is not Comparable */ private static void checkKey(final Object key) { checkNonNullComparable(key, KEY); }
m.put(nodes[k].getKey(), nodes[k]); m.remove(null); fail("should have caught NullPointerException"); } catch (NullPointerException ignored) {} m.remove(new Object()); fail("should have caught ClassCastException"); } catch (ClassCastException ignored) {} assertNull(m.remove(new Integer(-1))); m.remove("foo"); fail("should have caught ClassCastException"); } catch (ClassCastException ignored) {} assertNotNull(m.get(key)); assertSame(nodes[k], m.remove(key)); assertNull(m.remove(key)); assertNull(m.get(key)); assertNotNull(m.get(key)); assertSame(nodes[k], m.remove(key)); assertNull(m.remove(key)); assertNull(m.get(key)); assertTrue(m.isEmpty());
/** * test getKeyForValue() method */ public void testGetKeyForValue() { DoubleOrderedMap m = (DoubleOrderedMap) makeMap(); try { m.getKeyForValue(new Object()); fail("should have caught ClassCastException"); } catch (ClassCastException ignored) {} try { m.getKeyForValue(null); fail("should have caught NullPointerException"); } catch (NullPointerException ignored) {} assertNull(m.getKeyForValue("foo")); LocalTestNode nodes[] = makeLocalNodes(); for (int k = 0; k < nodes.length; k++) { m.put(nodes[k].getKey(), nodes[k]); assertSame(m.getKeyForValue(nodes[k]), nodes[k].getKey()); } assertNull(m.getKeyForValue(new LocalTestNode(-1))); try { m.getKeyForValue("foo"); fail("Should have caught ClassCastException"); } catch (ClassCastException ignored) {} for (int k = 0; k < nodes.length; k++) { assertNotNull(m.getKeyForValue(nodes[k])); m.remove(nodes[k].getKey()); assertNull(m.getKeyForValue(nodes[k])); } }