Adds the given input map to the end of the node's list of input maps, so that an event will be pattern-matched
against all other input maps currently "installed" in the node before being pattern-matched against the given
input map.
185567
public static void addFallbackInputMap(Node node, InputMap<?> im) {
        // getInputMap calls init, so can use unsafe setter
        setInputMapUnsafe(node, InputMap.sequence(getInputMap(node), im));
    }
464263
public static <S, N extends Node, E extends Event> void installFallback(InputMapTemplate<S, E> imt, S target, Function<? super S, ? extends N> getNode) {
        Nodes.addFallbackInputMap(getNode.apply(target), imt.instantiate(target));
    }
1024800
public static <S, N extends Node, E extends Event> void installOverride(InputMapTemplate<S, E> imt, S target, Function<? super S, ? extends N> getNode) {
        Nodes.addInputMap(getNode.apply(target), imt.instantiate(target));
    }
1277297
private boolean appendMap(StringBuilder builder, Object value)
    {
        boolean isPresent = false;
        if (value instanceof Map)
        {
            Map map = ((Map) value);
            isPresent = true;
            builder.append(Constants.OPEN_CURLY_BRACKET);
            for (Object mapKey : map.keySet())
            {
                Object mapValue = map.get(mapKey);
                // Allowing null keys.
                appendValue(builder, mapKey != null ? mapKey.getClass() : null, mapKey, false);
                builder.append(Constants.COLON);
                // Allowing null values.
                appendValue(builder, mapValue != null ? mapValue.getClass() : null, mapValue, false);
                builder.append(Constants.COMMA);
            }
            if (!map.isEmpty())
            {
                builder.deleteCharAt(builder.length() - 1);
            }

            builder.append(Constants.CLOSE_CURLY_BRACKET);
        }
        else
        {
            appendValue(builder, value.getClass(), value, false);
        }
        return isPresent;
    }
1113591
public void add(T value) {
        if (value == null)
            return;

        if (map.containsKey(value)) {
            map.put(value, map.get(value) + 1);
        } else {
            map.put(value, 1l);
        }
    }
6984
public void add(String input) {
        TrieNode currentNode = root;

        for(char c: input.toCharArray()) {
            Map<Character, TrieNode> children = currentNode.getChildren();
            TrieNode matchingNode = children.get(c);
            if(matchingNode != null) {
                currentNode = matchingNode;
            } else {
                TrieNode newNode = new TrieNode();
                children.put(c, newNode);
                currentNode = newNode;
            }
        }
        currentNode.end=true; // this is the end of an input that was added, there may be more children
    }
493050
@Deprecated
	public void addInput(Operator<IN>... inputs) {
		Preconditions.checkNotNull(inputs, "The input may not be null.");
		this.input = Operator.createUnionCascade(this.input, inputs);
	}
271313
function(map) {
        OpenLayers.Control.prototype.setMap.apply(this, arguments);
        var i, layers = this.layers || map.layers;
        for (i=layers.length-1; i>=0; --i) {
            this.addLayer({layer: layers[i]});
        }
        if (!this.layers) {
            map.events.on({
                addlayer: this.addLayer,
                removeLayer: this.removeLayer,
                scope: this
            });
        }
    }
1110021
private void add(TreeMap<String, Object> map, String key, Object value) {
		// ZAP: Added the type argument.
	    Vector<Object> v = getList(map, key);
	    if (v == null) {
	    	// ZAP: Added the type argument.
	        v = new Vector<>();
	        synchronized (map) {
	            map.put(key, v);
	        }
	    }
	    if (!v.contains(value)) {
	        v.add(value);
	    }

	}
1108297
public boolean addEvent(Hook k, Event n) {
        Set<Event> l = events.get(k);
        if (l == null) {
            l = new HashSet<>();
            events.put(k, l);
        }
        return l.add(n);
    }
1283058
private void addTypeElement(TypeElement typeElement, Map<PackageElement, SortedSet<TypeElement>> map) {

        PackageElement pkg = utils.containingPackage(typeElement);
        if (utils.isSpecified(pkg) || configuration.nodeprecated && utils.isDeprecated(pkg)) {
            // No need to catalog this class if it's package is
            // specified on the command line or if -nodeprecated option is set
            return;
        }

        SortedSet<TypeElement> s = map.get(pkg);
        if (s == null) {
            packageSet.add(pkg);
            s = new TreeSet<>(comparator);
        }
        s.add(typeElement);
        map.put(pkg, s);

    }
1319335
public void append(long start, long end) {
        assert(start <= end && (m_map.isEmpty() || start > end(m_map.span())));
        addRange(start, end);
    }
926669
public void append(final Event... events) {
        if (events != null && events.length > 0) {
            this.events.addAll(EscSpiUtils.asList(events));
        }
    }
532323
public static <S, T extends Event> InputMapTemplate<S, T> when(
            Predicate<? super S> condition, InputMapTemplate<S, T> imt) {

        return new InputMapTemplate<S, T>() {
            @Override
            protected InputHandlerTemplateMap<S, T> getInputHandlerTemplateMap() {
                return imt.getInputHandlerTemplateMap().map(
                        h -> (s, evt) -> condition.test(s) ? h.process(s, evt) : Result.PROCEED);
            }
        };
    }
265182
public static void addMapping(GraphRewrite event, String pattern, Class<? extends WindupVertexFrame> type)
    {
        getMappings(event, pattern).add(type);
    }
674688
private void insert(ArrayList<String> list, String input) {
		if (!list.contains(input)) {
			if (input.equals("a") || input.equals("rdf:type")) {
				list.add(0, input);
			} else {
				list.add(input);
			}
		}
	}
509503
public boolean add(final K key, final V value) {
        if (!this.map.containsKey(key)) {
            this.map.put(key, new ArrayList<V>());
        }
        return this.map.get(key).add(value);
    }