Make the mapping <em>key -&gt; val</em>.  Caching.
972306
static public Value put( Key key, Value val, Futures fs ) {
    return put(key,val,fs,false);
  }
1007548
public void cache(Object key, T val) {
        cache.put(key, new SoftReference<T>(val));
    }
187431
public V replace(K key, V val) {
       // synchronized( this ) {
            if( !containsKey(key) ) {
                return null;
            }
            return put(key, val);
        //}
    }
897343
public void cache(Integer key, Object value) {
        synchronized (this) {
            Integer curkey = keys.get(value);
            // Already cached?
            if (curkey != null) return;
            cache.put(key, value);
            keys.put(value, key);
        }
    }
951117
function setKey(key, val, ex, px, flag, req) {
  var saved = HashMap.prototype.setKey.apply(this, arguments);
  if(req && req.def) {
    this.modified(req);
  }
  return saved;
}
551779
def set(self, key, value):
        
        return uwsgi.cache_set(key, value, self.timeout, self.name)
500084
public V put(K key, V value){
		writeLock.lock();
		try {
			cache.put(key, value);
		} finally {
			writeLock.unlock();
		}
		return value;
	}
499800
def _mappingGetValueSet(mapping, keys):
    
    setUnion = set()
    for k in keys:
        setUnion = setUnion.union(mapping[k])
    return setUnion
879800
public ValueMap putValue(String key, Object value) {
    delegate.put(key, value);
    return this;
  }
531753
def setCache(self, val = 1):
        
        # first clear the old cached values
        self.cacheConnections = []
        self.cacheLayers = []
        if val:
            for layer in self.layers:
                if layer.active and not layer.frozen:
                    self.cacheLayers.append( layer )
            for connection in self.connections:
                if connection.active and not connection.frozen:
                    self.cacheConnections.append( connection )
901120
public synchronized ValT put(KeyT key, ValT value) {
        if (isDiskCacheEnabled) {
            cacheToDisk(key, value);
        }

        return cache.put(key, value);
    }
1052314
def map_val(dest, src, key, default=None, src_key=None):
    """"""
    if not src_key:
        src_key = key

    if src_key in src:
        dest[key] = src[src_key]
    else:
        if default is not None:
            dest[key] = default
732773
def set(self, key, val):
        
        data = self.get_data(True)
        if data is not None:
            data[key] = val
        else:
            raise RuntimeError("No task is currently running")
1076563
private void cacheFieldRefKey(String fieldCacheKey,String idCacheKey,long expired){
		if(nullValueCache){
			getCacheProvider().set(fieldCacheKey, idCacheKey, expired);
		}else{
			getCacheProvider().setStr(fieldCacheKey, idCacheKey, expired);
		}
	}
974533
public V put(K key, V value) {
    return _cacheImpl.put(key, value);
  }
157936
def set(self, val, lifetime=None):
        
        cache.set(self.key,
                  (json.dumps(val) if self.serialize else val),
                  lifetime or settings.DEFAULT_CACHE_EXPIRE_TIME)
        return val
824955
public ValueMap withNumberSet(String key, Set<BigDecimal> val) {
        super.put(key, val);
        return this;
    }