/** * Should only be called by ColumnFamilyStore.apply via Keyspace.apply, which supplies the * appropriate OpOrdering. * * <p>replayPosition should only be null if this is a secondary index, in which case it is * *expected* to be null */ long put(PartitionUpdate update, UpdateTransaction indexer, OpOrder.Group opGroup) { AtomicBTreePartition previous = partitions.get(update.partitionKey()); long initialSize = 0; if (previous == null) { final DecoratedKey cloneKey = allocator.clone(update.partitionKey(), opGroup); AtomicBTreePartition empty = new AtomicBTreePartition(cfs.metadata, cloneKey, allocator); // We'll add the columns later. This avoids wasting works if we get beaten in the putIfAbsent previous = partitions.putIfAbsent(cloneKey, empty); if (previous == null) { previous = empty; // allocate the row overhead after the fact; this saves over allocating and having to free // after, but // means we can overshoot our declared limit. int overhead = (int) (cloneKey.getToken().getHeapSize() + ROW_OVERHEAD_HEAP_SIZE); allocator.onHeap().allocate(overhead, opGroup); initialSize = 8; } else { allocator.reclaimer().reclaimImmediately(cloneKey); } } long[] pair = previous.addAllWithSizeDelta(update, opGroup, indexer); minTimestamp = Math.min(minTimestamp, previous.stats().minTimestamp); liveDataSize.addAndGet(initialSize + pair[0]); columnsCollector.update(update.columns()); statsCollector.update(update.stats()); currentOperations.addAndGet(update.operationCount()); return pair[1]; }
/** {@inheritDoc} */ @Override @Validate public V get(@NotNull final T key, @NotNull final K subkey) { final ConcurrentNavigableMap<K, V> m = map.get(key); if (m != null) return m.get(subkey); return null; }
/** get(null) of nonempty map throws NPE */ public void testGet_NullPointerException() { try { ConcurrentNavigableMap c = map5(); c.get(null); shouldThrow(); } catch (NullPointerException success) { } }
/** {@inheritDoc} */ @Override @Validate public Iterable<V> getValuesBySubkey(@NotNull final K subkey) { for (ConcurrentNavigableMap<K, V> m : map.values()) { V value = m.get(subkey); if (value != null) yield(value); } }
public void deleteTestCase(long id) { String jsonTestCase = testCaseMap.get(id); if (jsonTestCase != null) { TestCase testCase = new Gson().fromJson(jsonTestCase, TestCase.class); testCaseIndex.remove(testCase.title); testCaseMap.remove(id); db.commit(); } }
public Binding getBinding(ResourceAddress address) { String nextProtocol = address.getOption(NEXT_PROTOCOL); if (nextProtocol == null) { return nullNextProtocol.get(); } return nextProtocols.get(nextProtocol); }
public void putTestCase(TestCase testCase) { Long id = testCaseIndex.get(testCase.title); if (id != null && !id.equals(testCase.id)) throw new IllegalArgumentException("Duplicate title"); String jsonTestCase = new Gson().toJson(testCase); testCaseMap.put(testCase.id, jsonTestCase); testCaseIndex.put(testCase.title, testCase.id); db.commit(); }
/** {@inheritDoc} */ @Override @Validate public V removeSubKey(@NotNull final K subkey) { for (ConcurrentNavigableMap<K, V> m : map.values()) { V value = m.get(subkey); if (value != null) return m.remove(subkey); } return null; }
/** remove(key,value) removes only if pair present */ public void testRemove2() { ConcurrentNavigableMap map = map5(); assertTrue(map.containsKey(five)); assertEquals("E", map.get(five)); map.remove(five, "E"); assertEquals(4, map.size()); assertFalse(map.containsKey(five)); map.remove(four, "A"); assertEquals(4, map.size()); assertTrue(map.containsKey(four)); }
/** remove(key,value) removes only if pair present */ public void testDescendingRemove2() { ConcurrentNavigableMap map = dmap5(); assertTrue(map.containsKey(m5)); assertEquals("E", map.get(m5)); map.remove(m5, "E"); assertEquals(4, map.size()); assertFalse(map.containsKey(m5)); map.remove(m4, "A"); assertEquals(4, map.size()); assertTrue(map.containsKey(m4)); }
private void registerRemoval(String id, long lifeTime, TimeUnit unit) { ITaskManagerHook hook = taskManagerHooks.get(id); if (hook != null) { long removalTime = unit.toMillis(lifeTime) + System.currentTimeMillis(); // Remove current scheduled removal Long currentRemovalTime = taskManagerRemovalBackRegister.get(hook); if (currentRemovalTime != null) { taskManagerRemovalRegister.remove(currentRemovalTime); } // Find an empty spot in the sorted map's key register removalTime--; do { removalTime++; taskManagerRemovalRegister.putIfAbsent(removalTime, hook); } while (taskManagerRemovalRegister.get(removalTime) != hook); // Back reference the removal taskManagerRemovalBackRegister.put(hook, removalTime); } }
public boolean removeBinding(ResourceAddress address, Binding binding) { ResourceAddress bindAddress = binding.bindAddress(); String nextProtocol = bindAddress.getOption(NEXT_PROTOCOL); if (nextProtocol == null) { Binding oldBinding = nullNextProtocol.get(); if (equivalent(oldBinding, binding)) { binding = oldBinding; } if (binding.decrementReferenceCount() == 0) { return nullNextProtocol.compareAndSet(binding, null); } return false; } Binding oldBinding = nextProtocols.get(nextProtocol); if (equivalent(oldBinding, binding)) { binding = oldBinding; } if (binding.decrementReferenceCount() == 0) { return nextProtocols.remove(nextProtocol, binding); } return false; }
/** replace value succeeds when the given key mapped to expected value */ public void testDescendingReplaceValue2() { ConcurrentNavigableMap map = dmap5(); assertEquals("A", map.get(m1)); assertTrue(map.replace(m1, "A", "Z")); assertEquals("Z", map.get(m1)); }
public TestCase getTestCase(String title) { Long id = testCaseIndex.get(title); if (id == null) return null; String jsonTestCase = testCaseMap.get(id); return (jsonTestCase == null) ? null : new Gson().fromJson(jsonTestCase, TestCase.class); }
public TestCase getTestCase(long id) { String jsonTestCase = testCaseMap.get(id); return (jsonTestCase == null) ? null : new Gson().fromJson(jsonTestCase, TestCase.class); }
public ColumnFamily getColumnFamily(DecoratedKey key) { return columnFamilies.get(key); }
public String get(String key) { return treeMap.get(key); }
/** get returns the correct element at the given key, or null if not present */ public void testGet() { ConcurrentNavigableMap map = map5(); assertEquals("A", (String) map.get(one)); ConcurrentNavigableMap empty = map0(); assertNull(empty.get(one)); }
/** get returns the correct element at the given key, or null if not present */ public void testDescendingGet() { ConcurrentNavigableMap map = dmap5(); assertEquals("A", (String) map.get(m1)); ConcurrentNavigableMap empty = dmap0(); assertNull(empty.get(m1)); }
public Partition getPartition(DecoratedKey key) { return partitions.get(key); }
/** replace value succeeds when the given key mapped to expected value */ public void testReplaceValue2() { ConcurrentNavigableMap map = map5(); assertEquals("A", map.get(one)); assertTrue(map.replace(one, "A", "Z")); assertEquals("Z", map.get(one)); }
/** replace succeeds if the key is already present */ public void testReplace2() { ConcurrentNavigableMap map = map5(); assertNotNull(map.replace(one, "Z")); assertEquals("Z", map.get(one)); }