Adds all key value mappings.

@param values the mappings of key to value of type <V>
@return a reference to this object
349216
public QueryBuilder<V> withBindVariableValues(Map<String, V> values) {
    valueMap.putAll(values);
    return this;
  }
476855
public VarDefBuilder values( VarValueDef... values)
    {
    for( VarValueDef value : values)
      {
      varDef_.addValue( value);
      }
    return this;
    }
1001576
public Graph links(Link... values) {
        if (values == null || values.length == 0) {
            return this;
        }
        this.links().addAll(Arrays.asList(values));
        return this;
    }
402791
@Override
	public Collection<Object> values() {
		lock.readLock().lock();
		try {
			final List<Object> result = new LinkedList<Object>();
			final boolean useLocalPrefixes = !mixDefaultAndLocalPrefixes && hasLocalPrefixConfigurations();
			for (final Object key : getKeyMap(false).values()) {
				result.add(get(key, useLocalPrefixes));
			}
			return result;
		} finally {
			lock.readLock().unlock();
		}
	}
5757
public Binder append(Class<?>[] types, Object... values) {
        return new Binder(this, new Insert(type().parameterCount(), types, values));
    }
229965
private void addItems(Map<String, String> values) {
        for (String itemName : values.keySet()) {
            setItem(itemName, values.get(itemName));
        }
    }
186666
@Override
    public Map<String, String> values() {
        Map<String, String> values = new LinkedHashMap<>();
        for (Row each : delegates) {
            for (Entry<String, String> entry : each.values().entrySet()) {
                String name = entry.getKey();
                if (!values.containsKey(name)) {
                    values.put(name, entry.getValue());
                }
            }
        }
        return values;
    }
936327
public void add(byte[] values) {
        ensureCapacity(size + values.length);
        for (byte element : values) {
            this.add(element);
        }
    }
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);
    }
1369689
public ListOrdersRequest withPaymentMethod(String... values) {
        List<String> list = getPaymentMethod();
        for (String value : values) {
            list.add(value);
        }
        return this;
    }
1069743
private void update(final Map<String, Object> values) {

		for (final Entry<String, Object> entry : values.entrySet()) {

			update(entry.getKey(), entry.getValue());
		}
	}
498236
@Override
    public void putAll(final T[] values) {
        if (values == null || values.length == 0) {
            return;
        }
        for (final T value : values) {
            put(value);
        }
    }
671841
function add(values, value) {
  var self = this

  if (value) {
    self.map[values] = value
  } else {
    addAll(self.map, values)
  }

  return self
}
106155
public static <K, V> List<Tuple<K, V>> object(final List<K> keys, final List<V> values) {
        return map(keys, new Function<K, Tuple<K, V>>() {
            private int index;

            @Override
            public Tuple<K, V> apply(K key) {
                return Tuple.create(key, values.get(index++));
            }
        });
    }
1207854
public List<V> values() {
		List<V> list = new ArrayList<V>();
		for (List<V> value : map.values()) {
			list.addAll(value);
		}
		return Collections.unmodifiableList(list);
	}
389078
public static <K, V> ImmutableSet<K> allKeys(final Iterable<? extends Map<K, V>> maps) {
    final ImmutableSet.Builder<K> builder = ImmutableSet.builder();

    for (final Map<K, V> map : maps) {
      builder.addAll(map.keySet());
    }

    return builder.build();
  }
1234749
public void put(String name, String... values) {
    getMap().put(name, Arrays.asList(values));
  }