public int remove( int key ) { synchronized( mutex ) { return m.remove( key ); } } public void putAll( Map<? extends Integer, ? extends Integer> map ) {
/** * Deletes a key/value pair from the map. * * @param key an <code>Object</code> value * @return the removed value, or null if it was not found in the map */ public Integer remove( Object key ) { int k; if ( key != null ) { if ( key instanceof Integer ) { k = unwrapKey( key ); } else { return null; } } else { k = _map.getNoEntryKey(); } int v = _map.remove( k ); // There may be a false positive since primitive maps // cannot return null, so we have to do an extra // check here. if ( v == _map.getNoEntryValue() ) { return null; } else { return wrapValue( v ); } }
private synchronized void decrementReadCount(int clientIndex) { if (readLockHolders == null) { throw LockServerLock.throwIllegalMonitorStateException( clients.fromIndex(clientIndex) + " does not hold the read lock"); } int readCount = readLockHolders.remove(clientIndex); if (readCount > 1) { readLockHolders.put(clientIndex, readCount - 1); } else if (readCount == 0) { throw LockServerLock.throwIllegalMonitorStateException( clients.fromIndex(clientIndex) + " does not hold the read lock"); } }
public int remove( int key ) { synchronized( mutex ) { return m.remove( key ); } } public void putAll( Map<? extends Integer, ? extends Integer> map ) {
@Override public int remove( int key ) { synchronized( mutex ) { return m.remove( key ); } } @Override
public int remove( int key ) { synchronized( mutex ) { return m.remove( key ); } } public void putAll( Map<? extends Integer, ? extends Integer> map ) {
public int remove( int key ) { synchronized( mutex ) { return m.remove( key ); } } public void putAll( Map<? extends Integer, ? extends Integer> map ) {
@Override public void delete(DBIDRef id) { map.remove(DBIDUtil.asInteger(id)); }
@Override public void delete(DBIDRef id) { map.remove(DBIDUtil.asInteger(id)); }
/** * {@inheritDoc} */ public void set(int index, int value) { int cur = map.get(index); if (value == 0) { if (cur != 0) map.remove(index); } else map.put(index, value); }
/** * {@inheritDoc} */ public int add(int index, int delta) { int val = map.get(index); int newVal = val + delta; if (newVal == 0) map.remove(index); else map.put(index, newVal); magnitude = -1; return newVal; }
/** * {@inheritDoc} */ public void set(int index, int value) { int cur = map.get(index); if (value == 0) { if (cur != 0) map.remove(index); } else map.put(index, value); magnitude = -1; }
@Override public final int setInt(int index, int value) { this.checkBounds(index, length); final int oldValue = getInt(index); if (value == defaultValue) { this.values.remove(index); return oldValue; } else { this.values.put(index, value); return oldValue; } }
@Override public final Integer setValue(int index, Integer value) { this.checkBounds(index, length); final Integer oldValue = getValue(index); if (value == null) { this.values.remove(index); return oldValue; } else { this.values.put(index, value); return oldValue; } }
/** * Deletes a key/value pair from the map. * * @param key an <code>Object</code> value * @return the removed value, or null if it was not found in the map */ @Override public Integer remove( Object key ) { if (! (key instanceof Integer ) ) { return null; } int k = unwrapKey( key ); if ( _map.containsKey( k ) ) { int v = _map.remove( k ); return wrapValue( v ); } return null; }
@Override public final T setValue(int index, T value) { this.checkBounds(index, length); final T oldValue = getValue(index); final int code = coding.getCode(value); if (code == defaultCode) { this.codes.remove(index); return oldValue; } else { this.codes.put(index, code); return oldValue; } }
@Override public int test() { final TIntIntMap m_map = new TIntIntHashMap( m_keys.length / 2 + 1, m_fillFactor ); int add = 0, remove = 0; while ( add < m_keys.length ) { m_map.put( m_keys[ add ], m_keys[ add ] ); ++add; m_map.put( m_keys[ add ], m_keys[ add ] ); ++add; m_map.remove( m_keys[ remove++ ] ); } return m_map.size(); } }
@Override public final int replace(T existing, T replacement) { final int existingCode = coding.getCode(existing); final int index = indexMap.remove(existingCode); if (index == -1) { throw new IndexException("No match key for " + existing); } else { final int replacementCode = coding.getCode(existing); if (indexMap.containsKey(replacementCode)) { throw new IndexException("The replacement key already exists in index " + replacement); } else { final int ordinal = getOrdinalForIndex(index); this.indexMap.put(replacementCode, index); this.keyArray().setValue(ordinal, replacement); return index; } } }