remove a (key, value)-entry by its value
@param value the value object
320978
public void removeByValue(Object value)
    {
        Object key = valueTable.remove(value);
        if (key != null)
        {
            keyTable.remove(key);
        }
    }
172136
public void remove(V value) {
		int index = values.indexOf(value);
		values.remove(value);
		
		if (value instanceof JsonEntity) {
			((JsonEntity)value).removePropertyChangeListener(propListener);
		}
		
		firePropertyChange("#" + index, value, null);
	}
344558
def remove_entry(self, **field_value):
        
        field, value = next(iter(field_value.items()))
        self.data['entries'][:] = [entry
            for entry in self.data.get('entries')
            if entry.get('{}_entry'.format(self.typeof))
            .get(field) != str(value)]
503647
private static void removeLiveReference(Object value) {
    synchronized (sLiveObjects) {
      Integer count = sLiveObjects.get(value);
      if (count == null) {
        // Uh oh.
        FLog.wtf(
            "SharedReference",
            "No entry in sLiveObjects for value of type %s",
            value.getClass());
      } else if (count == 1) {
        sLiveObjects.remove(value);
      } else {
        sLiveObjects.put(value, count - 1);
      }
    }
  }
820498
public boolean remove(K key, V value) {
        Set<V> set = storage.get(key);
        if (set != null) {
            final boolean removed = set.remove(value);
            if (removed && set.isEmpty()) {
                storage.remove(key);
            }
            return removed;
        }
        return false;
    }
753981
public void remove(List<Value> values) {
		Key[] keys = makeSubKeys(values);
		List<byte[]> digestList = getDigestList();

		//		int startIndex = digestList.IndexOf (subKey.digest);
		//		int count = values.Count;
		//		foreach (Key key in keys){
		//
		//			client.Delete (this.policy, key);
		//		}
		//		client.Operate(this.policy, this.key, ListOperation.Remove(this.binNameString, startIndex, count));

		for (Key key : keys) {
			client.delete(this.policy, key);
			digestList.remove(key.digest);
		}

		client.put(this.policy, this.key, new Bin(this.binNameString, digestList));
	}
91517
public synchronized void insert(Object key, Object value) {
        // evict until size < maxSize
        while (isEvictionRequired() && entryLimit > 0 && entryLimit < Integer.MAX_VALUE) {
            evictStaleEntries();
        }

        Entry curEntry = new Entry(value);
        Entry oldEntry = (Entry) primaryTable.put(key, curEntry);

        if (oldEntry != null && oldEntry.value != null) {
            ArrayList<Object> evictedValues = new ArrayList<Object>();
            evictedValues.add(oldEntry.value);
            for (CacheEvictionListener evictionCallback : cacheEvictionListenerSet) {
                evictionCallback.evicted(evictedValues);
            }
        }
    }
635377
public int delete(String column, Object value) {
        return delete(Operators.match(column, value));
    }
1209647
public static <T> void removeValue(Map<?,T> map, T value) {
		ArrayList<Object> keys = new ArrayList<>();
		for (Map.Entry<?,T> e : map.entrySet())
			if (e.getValue().equals(value))
				keys.add(e.getKey());
		for (Object key : keys)
			map.remove(key);
	}
330488
protected void removeEntry(T entry) {
        T prev = entry.getPrev();
        T next = entry.getNext();
        if (prev != null) {
            prev.setNext(next);
        } else {
            head = next;
        }
        if (next != null) {
            next.setPrev(prev);
        } else {
            last = prev;
        }
        size--;
    }
426850
public final boolean remove(E entry) {
        TreeEntry<E> e = getEntry(entry);

        if (e == null) {
            return false;
        } else {
            deleteEntry(e);
        }

        return true;
    }
974174
function removeKeyFromList(list, key, value) {
    for (var i = list.length - 1; i >= 0; i--) {
        if (list[i][key] == value) {
            return list.splice(i, 1); // remove from array
        }
    }
    return false;
}
1273999
public void replaceValues(String key, Object value) {
//    fields.replaceValues(key, Collections.singletonList(value)); // unnecessarily slow
    List<Object> list = fields.get(key);
    list.clear(); 
    list.add(value);
  }
1067841
public synchronized void remove(Entry entry)
  {
    if (tc.isEntryEnabled())
      SibTr.entry(tc, "remove", new Object[] { entry });

    super.remove(entry);
    DestinationHandler dh = (DestinationHandler) entry.data;
    HashMap<String, Entry> busMap = getBusMap(dh.getBus());
    DestinationEntry destEntry = (DestinationEntry) busMap.get(dh.getName());
    if(destEntry == entry)
    {
      busMap.remove(dh.getName());
    }    
    
    if (tc.isEntryEnabled())
      SibTr.exit(tc, "remove");
  }
1096133
private void setParameter(String key, Object value){
        if (value == null){
            parameters.remove(key);
        }     
        else{
            parameters.put(key, value);
        }
    }
855652
protected void cancelTtl(MapEntryValue value) {
    if (value != null && value.timer != null) {
      value.timer.cancel();
    }
  }
704085
public void removeValue(V value) {
        if (value == null) {
            throw new IllegalArgumentException("Method argument value must not be null.");
        }
        for (Collection<V> values : values()) {
            values.remove(value);
        }
    }