Go through all the values of an object and adds the corresponding value inside its entries using the provided
keyName
@param {Object} container
@param {String} keyName
1735
function (container, keyName) {
            for (var element in container) {
                if (container.hasOwnProperty(element)) {
                    container[element][keyName] = element;
                }
            }
        }
1007108
def set(cls, obj, keys, value, fill_list_value=None):
        
        current = obj
        keys_list = keys.split(".")

        for idx, key in enumerate(keys_list, 1):
            if type(current) == list:
                # Validate this key works with a list.
                try:
                    key = int(key)
                except ValueError:
                    raise cls.Missing(key)

            try:
                # This is the last key, so set the value.
                if idx == len(keys_list):
                    if type(current) == list:
                        safe_list_set(
                            current,
                            key,
                            lambda: copy.copy(fill_list_value),
                            value
                        )
                    else:
                        current[key] = value

                    # done.
                    return

                # More keys left, ensure we have a container for this key.
                if type(key) == int:
                    try:
                        current[key]
                    except IndexError:
                        # Create a list for this key.
                        cnext = container_for_key(keys_list[idx])
                        if type(cnext) == list:
                            def fill_with():
                                return []
                        else:
                            def fill_with():
                                return {}

                        safe_list_set(
                            current,
                            key,
                            fill_with,
                            [] if type(cnext) == list else {}
                        )
                else:
                    if key not in current:
                        # Create a list for this key.
                        current[key] = container_for_key(keys_list[idx])

                # Move on to the next key.
                current = current[key]
            except (IndexError, KeyError, TypeError):
                raise cls.Missing(key)
97256
function() {
            this.containerOptions = {};
            this.formOptions = {};
            
            if(!$.fn[this.containerName]) {
                throw new Error(this.containerName + ' not found. Have you included corresponding js file?');   
            }
            
            var cDef = $.fn[this.containerName].defaults;
            //keys defined in container defaults go to container, others go to form
            for(var k in this.options) {
              if(k in cDef) {
                 this.containerOptions[k] = this.options[k];
              } else {
                 this.formOptions[k] = this.options[k];
              } 
            }
        }
418908
public void putValue(K key, V value) {
		Collection<V> collection = this.get(key);
		if (null == collection) {
			collection = createCollction();
			this.put(key, collection);
		}
		collection.add(value);
	}
1293442
function getKeys(container) {
  function arrayIndex(value, i) {
    return i;
  }
  if (typeof container === 'object') {
    return Array.isArray(container) ? container.map(arrayIndex) : Object.keys(container);
  } else {
    return [];
  }
}
673582
function(key, value) {
            //set option(s) by object
            if(key && typeof key === 'object') {
               $.each(key, $.proxy(function(k, v){
                  this.option($.trim(k), v); 
               }, this)); 
               return;
            }

            //set option by string             
            this.options[key] = value;                          
            
            //disabled
            if(key === 'disabled') {
               return value ? this.disable() : this.enable();
            } 
            
            //value
            if(key === 'value') {
                this.setValue(value);
            }
            
            //transfer new option to container! 
            if(this.container) {
                this.container.option(key, value);  
            }
             
            //pass option to input directly (as it points to the same in form)
            if(this.input.option) {
                this.input.option(key, value);
            }
            
        }
244078
public boolean add(final K key, final S subcontainer, final V value) {
		final S curSubcontainer = this.subcontainerByKey.get(key);
		if (curSubcontainer == null) { // key does not exist
			if (this.mode == Mode.UPDATE)
				return false;

		} else { // key exists
			if (this.mode == Mode.CREATE)
				return false;

			if (subcontainer != curSubcontainer) {
				if (this.closed)
					throw new IllegalStateException(
							"MultiContainer put(" + key + ", " + value + ") in " + subcontainer);
				this.valueByKeyBySubcontainer.get(curSubcontainer).remove(key);
			}
		}


		if (subcontainer != curSubcontainer)
			this.subcontainerByKey.put(key, subcontainer);

		final Map<K, V> valueByKey = this.valueByKeyBySubcontainer.get(subcontainer);
		if (this.closed && !valueByKey.containsKey(key))
			throw new IllegalStateException(
					"MultiContainer put(" + key + ", " + value + ") in " + subcontainer);
		else if (this.debug && !valueByKey.containsKey(key))
			Logger.getLogger("debug").severe(
					"MultiContainer put(" + key + ", " + value + ") in " + subcontainer);

		valueByKey.put(key, value);
		return true;
	}
785688
function(indexName, key) {
        if (this.indexes === undefined) {
            this.indexes = {};
        }
        if (!this.indexes.hasOwnProperty(indexName)) {
            this.indexes[indexName] = [];
        }
        for (var i = 1; i < arguments.length; i++) {
            this.indexes[indexName].push(arguments[i]);
        }
        return this;
    }
648867
function(result, name, value) {
		var operand_name = this._container_resources_operands_map[name];
		if (operand_name in result) {
			result[operand_name] = result[operand_name].concat(value);
		} else {
			result[operand_name] = value;
		}
	}
146227
public void setKeyValues(String keyName, Object obj)
    {
        if (this.keyValues == null)
        {
            this.keyValues = new HashMap<String, Object>();
        }
        this.keyValues.put(keyName, obj);
    }
382116
function append(name, value) {
    validateArgumentsLength(arguments.length, 2);
    var state = getInternalParamsState(this);
    state.entries.push({ key: name + '', value: value + '' });
    if (state.updateURL) state.updateURL();
  }
335038
def _add_to_dict(t, container, name, value):
    

    if name in container:
        raise Exception("%s '%s' already exists" % (t, name))
    else:
        container[name] = value
1284560
function(key, value){
    if (this.currentItem || this.currentKey || this.currentParents.length>0){
      this.currentParents.push({key: this.currentKey, value: this.currentItem})
    }
    this.currentItem = value
    this.currentKey = key
  }
226839
function (key, value) {
        var index = this.indexOfKey(key);

        if (index >= 0) {
            this.slot.values[index] = value;
            return;
        }

        this.insert(~index, key, value);
    }
1337950
def add(self, key, val):
        
        key_lower = key.lower()
        new_vals = [key, val]
        # Keep the common case aka no item present as fast as possible
        vals = self._container.setdefault(key_lower, new_vals)
        if new_vals is not vals:
            vals.append(val)
511873
public void setValue(String key, String value) {
        KeyValue kv = getKV(key);
        if (kv != null) {
            kv.setValue(value);
        } else if (key != null) {
            map.add(new KeyValue(key,value));
        }
    }
154860
function forEachValue (obj, iteratee) {
  Object.keys(obj).forEach((key) => iteratee(obj[key], key, obj))
}