Select all options that have a value matching any arguments.

@param values
the values to select
488333
public void selectByValue(String[] values) {
        for (int i = 0; i < values.length; i++) {
            selectByValue(values[i]);
        }
    }
1044201
public T value(Object... values) {
        if (values == null || values.length == 0) {
            return (T) this;
        }
        if (this.value == null) {
            this.value = new ArrayList<Object>(values.length);
        }
        if (this.value instanceof List) {
            ((List) this.value).addAll(Arrays.asList(values));
        }
        return (T) this;
    }
751835
public void setValueSelected(T value, boolean selected) {
        int idx = getIndex(value);
        if (idx >= 0) {
            setItemSelectedInternal(idx, selected);
        }
    }
505204
protected void view(Map values){
        for(Object key:values.keySet() ){
            assign(key.toString(), values.get(key));
        }
    }
280865
public void setValues(List<T> values, boolean fireEvents) {
        String[] stringValues = new String[values.size()];
        for (int i = 0; i < values.size(); i++) {
            stringValues[i] = keyFactory.generateKey(values.get(i));
        }
        suppressChangeEvent = !fireEvents;
        $(listbox.getElement()).val(stringValues).trigger("change", selectedIndex);
        suppressChangeEvent = false;
    }
991729
private List<?> getNewOptions(final String[] paramValues) {
		// Take a copy of the old options
		List<?> copyOldOptions = new ArrayList(getOptions());

		// Create a new list to hold the shuffled options
		List<Object> newOptions = new ArrayList<>(paramValues.length);

		// Process the option parameters
		for (String param : paramValues) {
			for (Object oldOption : copyOldOptions) {
				// Match the string value of the option
				String stringOldOption = String.valueOf(oldOption);
				if (Util.equals(stringOldOption, param)) {
					newOptions.add(oldOption);
					copyOldOptions.remove(oldOption);
					break;
				}
			}
		}

		return newOptions;
	}
645355
public MethodParamsType<T> methodParam(String ... values)
   {
      if (values != null)
      {
         for(String name: values)
         {
            childNode.createChild("method-param").text(name);
         }
      }
      return this;
   }
704085
public void removeValue(V value) {
        if (value == null) {
            throw new IllegalArgumentException("Method argument value must not be null.");
        }
        for (Collection<V> values : values()) {
            values.remove(value);
        }
    }
863685
public void setValueOptions(java.util.Collection<String> valueOptions) {
        if (valueOptions == null) {
            this.valueOptions = null;
            return;
        }

        this.valueOptions = new com.amazonaws.internal.SdkInternalList<String>(valueOptions);
    }
157645
def select_values(statement, build_arg = nil)
    select(statement, build_arg).collect { |row| row.values }
  end
17669
public void deselectByValue(String value) {
        getDispatcher().beforeDeselect(this, value);
        
        new Select(getElement()).deselectByValue(value);
        if (Config.getBoolConfigProperty(ConfigProperty.ENABLE_GUI_LOGGING)) {
            logUIActions(UIActions.CLEARED, value);
        }
        
        getDispatcher().afterDeselect(this, value);
    }
1059740
public static <T> T pick(T[] values) {
		if (values == null || values.length == 0)
			return null;

		return values[RandomInteger.nextInteger(values.length)];
	}
49795
public static Value<Boolean> or (final Iterable<Value<Boolean>> values)
    {
        MultiMappedValue<Boolean, Boolean> mapped =
            new MultiMappedValue<Boolean, Boolean>(computeOr(values)) {
            @Override protected Boolean recompute (Boolean ignored) {
                return computeOr(values);
            }
        };
        for (Value<Boolean> value : values) {
            value.addListener(mapped);
        }
        return mapped;
    }
237297
public String[] buildValueWhereArgs(Collection<ColumnValue> values) {
		List<String> selectionArgs = new ArrayList<String>();
		for (ColumnValue value : values) {
			if (value != null && value.getValue() != null) {
				if (value.getTolerance() != null) {
					String[] toleranceArgs = getValueToleranceRange(value);
					selectionArgs.add(toleranceArgs[0]);
					selectionArgs.add(toleranceArgs[1]);
				} else {
					selectionArgs.add(value.getValue().toString());
				}
			}
		}
		return selectionArgs.isEmpty() ? null : selectionArgs
				.toArray(new String[] {});
	}
533062
public String[] buildWhereArgs(Collection<Object> values) {
		List<String> selectionArgs = new ArrayList<String>();
		for (Object value : values) {
			if (value != null) {
				selectionArgs.add(value.toString());
			}
		}
		return selectionArgs.isEmpty() ? null : selectionArgs
				.toArray(new String[] {});
	}
737372
public void setParameterValues(java.util.Collection<ParameterValue> parameterValues) {
        if (parameterValues == null) {
            this.parameterValues = null;
            return;
        }

        this.parameterValues = new com.amazonaws.internal.SdkInternalList<ParameterValue>(parameterValues);
    }
882007
public static <T> T pickRandom (List<T> values)
    {
        int size = values.size();
        if (size == 0) {
            throw new IllegalArgumentException(
                "Must have at least one element [size=" + size + "]");
        }
        return values.get(getInt(size));
    }