@Override public Object putIfAbsent(Object key, Object value) { Object maskedKey = maskNull(key); Object superVal = super.putIfAbsent(maskedKey, maskNull(value)); addRandomKey(maskedKey); return unmaskNull(superVal); }
@Override public Object get(Object key) { return unmaskNull(super.get(maskNull(key))); }
@Override public Object putIfAbsent(Object key, Object value) { if (maxSize != Integer.MAX_VALUE) removeOverflow(true); return super.putIfAbsent(key, value); }
@Override public Object put(Object key, Object value) { if (maxSize != Integer.MAX_VALUE) removeOverflow(true); return super.put(key, value); }
public Entry next() { // hasNext() will initialize this.next if (!nextSet && !hasNext()) return null; // if we get here, then we're about to return a next value nextSet = false; if (containsKey(next.getKey())) return next; // something has changed since the last iteration (presumably // due to multi-threaded access to the underlying data // structure); recurse return next(); }
public Entry removeRandom() { // this doesn't just use randomEntryIterator() because that iterator // has weaker concurrency guarantees than this method. In particular, // this method will continue to attempt to remove random entries even // as other threads remove the same entries, whereas the random // iterator may return values that have been removed. for (Iterator iter = randomKeys.iterator(); iter.hasNext(); ) { // randomKeys contains null-masked data Object key = iter.next(); if (key != null && randomKeys.remove(key)) { Object val = super.remove(key); if (val != null) return new EntryImpl(unmaskNull(key), unmaskNull(val)); } } // if randomKeys is empty, fall back to non-random behavior. for (Iterator iter = super.keySet().iterator(); iter.hasNext(); ) { Object key = iter.next(); if (key == null) continue; Object val = super.remove(key); if (val != null) return new EntryImpl(unmaskNull(key), unmaskNull(val)); } return null; }
pinnedMap = new NullSafeConcurrentHashMap();
@Override public Object remove(Object key) { Object maskedKey = maskNull(key); Object val = unmaskNull(super.remove(maskedKey)); randomKeys.remove(maskedKey); return val; }
@Override public Object putIfAbsent(Object key, Object value) { if (maxSize != Integer.MAX_VALUE) removeOverflow(true); return super.putIfAbsent(key, value); }
@Override public Object put(Object key, Object value) { if (maxSize != Integer.MAX_VALUE) removeOverflow(true); return super.put(key, value); }
public Entry next() { // hasNext() will initialize this.next if (!nextSet && !hasNext()) return null; // if we get here, then we're about to return a next value nextSet = false; if (containsKey(next.getKey())) return next; // something has changed since the last iteration (presumably // due to multi-threaded access to the underlying data // structure); recurse return next(); }
public Entry removeRandom() { // this doesn't just use randomEntryIterator() because that iterator // has weaker concurrency guarantees than this method. In particular, // this method will continue to attempt to remove random entries even // as other threads remove the same entries, whereas the random // iterator may return values that have been removed. for (Iterator iter = randomKeys.iterator(); iter.hasNext(); ) { // randomKeys contains null-masked data Object key = iter.next(); if (key != null && randomKeys.remove(key)) { Object val = super.remove(key); if (val != null) return new EntryImpl(unmaskNull(key), unmaskNull(val)); } } // if randomKeys is empty, fall back to non-random behavior. for (Iterator iter = super.keySet().iterator(); iter.hasNext(); ) { Object key = iter.next(); if (key == null) continue; Object val = super.remove(key); if (val != null) return new EntryImpl(unmaskNull(key), unmaskNull(val)); } return null; }
@Override public Object putIfAbsent(Object key, Object value) { Object maskedKey = maskNull(key); Object superVal = super.putIfAbsent(maskedKey, maskNull(value)); addRandomKey(maskedKey); return unmaskNull(superVal); }
@Override public Object remove(Object key) { Object maskedKey = maskNull(key); Object val = unmaskNull(super.remove(maskedKey)); randomKeys.remove(maskedKey); return val; }
@Override public boolean containsKey(Object key) { return super.containsKey(maskNull(key)); }
@Override public Object put(Object key, Object value) { Object maskedKey = maskNull(key); Object superVal = super.put(maskedKey, maskNull(value)); addRandomKey(maskedKey); return unmaskNull(superVal); }
@Override public Object get(Object key) { return unmaskNull(super.get(maskNull(key))); }