[putMeta description]
@param {String} key [description]
@param {Object} value [description]
@return {Promise} [description]
348889
function putMeta(key, value) {
  const { schema, table } = findSchemaAndTable(key),
    map = columnToValueMap('id', key);

  // add meta column to map
  columnToValueMap('meta', parseOrNot(value), map);

  return onConflictPut(map, schema, table).then(() => map.meta);
}
634996
function setUpdateStateInJSON(key, value) {
         var result = $.Deferred();

        updateJsonHandler.set(key, value)
            .done(function () {
                result.resolve();
            })
            .fail(function () {
                resetStateInFailure("AutoUpdate : Could not modify updatehelper.json");
                result.reject();
            });
        return result.promise();
    }
151193
@Override
    public V put(K key, V value) {
        final V old = this.get(key);
        this.cache.put(new Element(key, value));
        return old;
    }
243234
function put(key, value) {
	var sections = key.split("/");
	if (!sections.length) return this;
	var tree = this.tree;
	putValue(sections, tree, value, 0);
	return new Result(sections, value);
}
1216238
function put(key, value) {
  const entry = { key, value };
  // Note: No protection agains replacing, and thus orphan entries. By design.
  this._keymap[key] = entry;
  if (this.tail) {
    // link previous tail to the new tail (entry)
    this.tail.newer = entry;
    entry.older = this.tail;
  } else {
    // we're first in -- yay
    this.head = entry;
  }
  // add new entry to the end of the linked list -- it's now the freshest entry.
  this.tail = entry;
  if (this.size === this.limit) {
    // we hit the limit -- remove the head
    return this.shift();
  }
  // increase the size counter
  this.size += 1;
  return undefined;
}
1290642
function(key, value) {
        var hashCode = hash(key);
        if (!(hashCode in this.data)) {
            this.keys.push(key);
            this.values.push(value);
        }
        this.data[hashCode] = value;
    }
1364769
function (key) {
        var a = this.all()
        a.push(key)
        storage.setItem(this.key, JSON.stringify(a))
      }
1080274
function makeMemcacheSetProto(key, value) {
  var memcacheSetRequest = new apphosting.MemcacheSetRequest();
  var item = new apphosting.MemcacheSetRequest.Item();
  item.setKey(key);
  item.setValue(value);
  item.setSetPolicy(apphosting.MemcacheSetRequest.SetPolicy.SET);
  memcacheSetRequest.addItem(item);
  return memcacheSetRequest;
}
298486
public void put(String key, Object value) {
        // acquire write lock
        writeLock.lock();
        try {
            if(METADATA_KEYS.contains(key)) {
                VectorClock version = (VectorClock) get(key, null).get(0).getVersion();
                put(key,
                    new Versioned<Object>(value, version.incremented(getNodeId(),
                                                                     System.currentTimeMillis())));
            } else {
                throw new VoldemortException("Unhandled Key:" + key + " for MetadataStore put()");
            }
        } finally {
            writeLock.unlock();
        }
    }
791254
static public void put( Key key, Value val, Futures fs ) {
    assert !val.isLockable();
    Value res = DKV.put(key,val,fs);
    assert res == null || !res.isLockable();
  }
779250
@Override
    public Object put(String key, Object value) {
        return update(String.valueOf(key), value);
    }
710158
static public Value put( Key key, Iced v, Futures fs,boolean dontCache ) {
    return put(key,new Value(key,v),fs,dontCache);
  }
272615
public Object put(String key, Object value) {
		if (size == keys.length) {
			throw new ArrayIndexOutOfBoundsException(size);
		}
		keys[size] = key;
		values[size] = value;
		size++;
		return value;
	}
1065392
public synchronized Object put(final String key, final Object value) {
		try {
			if (maxCacheSize == 0) {
				return null;
			}

			// if the key isn't in the cache and the cache is full...
			if (!super.containsKey(key) && !list.isEmpty()
					&& list.size() + 1 > maxCacheSize) {
				final Object deadKey = list.removeLast();
				super.remove(deadKey);
			}

			updateKey(key);
		} catch (Exception e) {
			log.log(Level.SEVERE, "put", e);
		}
		return super.put(key, value);
	}
198294
public void put(Key key, Value val) {
		if (val == null) st.remove(key);
		else             st.put(key, val);
	}
1309776
public V _put(K key, V value) {
        V retval=map.put(key, value);
        for(Notification notif:notifs)
            notif.entrySet(key, value);
        return retval;
    }
1284538
public Eval<UploadResult> putAsync(String key, Object value) {
        return Eval.later(() -> put(key, value))
                   .map(t -> t.orElse(null))
                   .map(FluentFunctions.ofChecked(up -> up.waitForUploadResult()));

    }