Adds the given input map to the start of the node's list of input maps, so that an event will be pattern-matched
against the given input map before being pattern-matched against any other input maps currently
"installed" in the node.
348480
public static void addInputMap(Node node, InputMap<?> im) {
        // getInputMap calls init, so can use unsafe setter
        setInputMapUnsafe(node, InputMap.sequence(im, getInputMap(node)));
    }
713709
private static void mapAdd(Map<String, List<String>> map, String key, String val) {
    List<String> list = map.get(key);
    if (list == null) {
      list = new ArrayList<>();
      map.put(key, list);
    }
    list.add(val);
  }
1322717
public void putDefaults(Map map) {
        Iterator it = map.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry entry = (Map.Entry)it.next();
            Object key = entry.getKey();
            if (!containsKey(key)) {
                put(key, entry.getValue());
            }
        }
    }
1051087
@Override
    public void addMapping(IMapping mapping) {
        if (mappingCount + 1 >= map.length) growMappingArray();
        map[mappingCount] = mapping;
        mappingCount++;
        notifyChanged();
    }
123520
public CacheKeyBuilder appendStringsIgnoringOrder(Collection<String> input)
  {
    appendItem(STRING_LIST_KEY, stringCollectionToByteArray(input, false));
    return this;
  }
211339
public static Map<String, Object> putAllIfNew(Map<String, Object> dest, Map<String, Object> source)
    {
    	if (dest == null)
    		return source;
    	if (source == null)
    	    return dest;
    	for (String key : source.keySet())
    	{
    		if (dest.get(key) == null)
    			dest.put(key, source.get(key));
    	}
    	return dest;
    }
378347
function addNodeToSlot (slot, node, insertBefore) {
  const isInDefaultMode = slot.assignedNodes().length === 0;
  registerNode(slot, node, insertBefore, eachNode => {
    if (isInDefaultMode) {
      slot.__insertBefore(eachNode, insertBefore !== undefined ? insertBefore : null);
    }
  });
}
1126846
public void addAll(Map<K, V> m) {
    if (m instanceof CollectionValuedMap<?, ?>) {
      throw new UnsupportedOperationException();
    }
    for (Map.Entry<K, V> e : m.entrySet()) {
      add(e.getKey(), e.getValue());
    }
  }
228477
@Deprecated
	@SuppressWarnings("unchecked")
	public void addInput(List<Operator<IN>> inputs) {
		this.input = Operator.createUnionCascade(this.input, inputs.toArray(new Operator[inputs.size()]));
	}
1294791
def add_event(self, event, prepend=False):
        
        if prepend:
            self._events.insert(0, event)
        else:
            self._events.append(event)
762572
public NextInputs add(Input input, Scheme... schemes) {
        if (schemes == null || schemes.length == 0) {
            throw new IllegalArgumentException("Test schemes is required !");
        }
        Arrays.sort(schemes, ORDERING);
        mInputSpecs.add(new InputSpec(input, schemes));
        return this;
    }
1352480
@Deprecated
	public void addInput(Operator<IN>... input) {
		this.input = Operator.createUnionCascade(this.input, input);
	}
818256
private void merge(Map<String, NodeT> source, Map<String, NodeT> target) {
        for (Map.Entry<String, NodeT> entry : source.entrySet()) {
            String key = entry.getKey();
            if (!target.containsKey(key)) {
                target.put(key, entry.getValue());
            }
        }
    }
47098
function addMultipleNodeOrPathListeners(eventId, listenerMap) {

    for( var pattern in listenerMap ) {
      addSingleNodeOrPathListener(eventId, pattern, listenerMap[pattern]);
    }
  }
857344
public static void addDeclaredMethodsFromInterfaces(ClassNode cNode, Map<String, MethodNode> methodsMap) {
        // add in unimplemented abstract methods from the interfaces
        for (ClassNode iface : cNode.getInterfaces()) {
            Map<String, MethodNode> ifaceMethodsMap = iface.getDeclaredMethodsMap();
            for (Map.Entry<String, MethodNode> entry : ifaceMethodsMap.entrySet()) {
                String methSig = entry.getKey();
                if (!methodsMap.containsKey(methSig)) {
                    methodsMap.put(methSig, entry.getValue());
                }
            }
        }
    }
669843
private Function<Expression, Statement> addNodeToPlaceholderMap(
      String mapKey, StandaloneNode node) {
    return putToMapFunction(
        mapKey,
        placeholderCompiler.compileToSoyValueProvider(
            mapKey,
            node,
            /* prefix= */ ExtraCodeCompiler.NO_OP,
            /* suffix= */ ExtraCodeCompiler.NO_OP));
  }
1192536
private void addNewElement(final EAdd paramAdd, final StartElement paramStartElement) throws TTException {
        assert paramStartElement != null;
        final QName name = paramStartElement.getName();
        long key;

        if (mFirstChildAppend == EShredderInsert.ADDASRIGHTSIBLING) {
            key = mWtx.insertElementAsRightSibling(name);
        } else {
            if (paramAdd == EAdd.ASFIRSTCHILD) {
                key = mWtx.insertElementAsFirstChild(name);
            } else {
                key = mWtx.insertElementAsRightSibling(name);
            }
        }

        // Parse namespaces.
        for (final Iterator<?> it = paramStartElement.getNamespaces(); it.hasNext();) {
            final Namespace namespace = (Namespace)it.next();
            mWtx.insertNamespace(new QName(namespace.getNamespaceURI(), "", namespace.getPrefix()));
            mWtx.moveTo(key);
        }

        // Parse attributes.
        for (final Iterator<?> it = paramStartElement.getAttributes(); it.hasNext();) {
            final Attribute attribute = (Attribute)it.next();
            mWtx.insertAttribute(attribute.getName(), attribute.getValue());
            mWtx.moveTo(key);
        }
    }