Returns comma-separated preference value as array of values
@param {String} name
@returns {Array} Returns <code>undefined</code> if preference is
not defined, <code>null</code> if string cannot be converted to array
971003
function(name) {
			var val = this.get(name);
			if (typeof val === 'undefined' || val === null || val === '')  {
				return null;
			}

			val = val.split(',').map(utils.trim);
			if (!val.length) {
				return null;
			}
			
			return val;
		}
556874
function parsePrimitives(info, name, value) {
  var index
  var length
  var result

  if (typeof value !== 'object' || !('length' in value)) {
    return parsePrimitive(info, name, value)
  }

  length = value.length
  index = -1
  result = []

  while (++index < length) {
    result[index] = parsePrimitive(info, name, value[index])
  }

  return result
}
576303
function () {
		var result = [];
		var args = arguments;
		var l = args.length;
		var name, value;
		for (var i = 0; i < l; i++) {
			name = args[i];
			value = this.getValue(name);
			result.push(value);
		}
		return result;
	}
1148692
public List<String> getStrings(String name, String delimiter) {
        String value = getString(name, null);
        if (StringUtils.isNullOrEmpty(value)) {
            return Collections.emptyList();
        }

        value = value.trim();
        // to handles cases where value is specified like [a,b, c]
        if (value.startsWith("[") && value.endsWith("]")) {
            value = value.substring(1, value.length() - 1);
        }
        return StringUtils.getList(value, delimiter);
    }
1097144
function get(name) {
    validateArgumentsLength(arguments.length, 1);
    var entries = getInternalParamsState(this).entries;
    var key = name + '';
    var i = 0;
    for (; i < entries.length; i++) if (entries[i].key === key) return entries[i].value;
    return null;
  }
455898
@Override
    public Object getMember(String name) {
        switch (name) {
            case "wrapRDD": return F_wrapRDD;
            case "persist": return F_persist;
            case "unpersist": return F_unpersist;
            case "distinct": return F_distinct;
            case "filter": return F_filter;
            case "cache": return F_cache;
            case "coalesce": return F_coalesce;
            case "repartition": return F_repartition;
            case "sample": return F_sample;
            case "sampleByKey": return F_sampleByKey;
            case "sampleByKeyExact": return F_sampleByKeyExact;
            case "union": return F_union;
            case "intersection": return F_intersection;
            case "first": return F_first;
            case "combineByKey": return F_combineByKey;
            case "reduceByKey": return F_reduceByKey;
            case "reduceByKeyLocally": return F_reduceByKeyLocally;
            case "countByKey": return F_countByKey;
            case "countByKeyApprox": return F_countByKeyApprox;
            case "aggregateByKey": return F_aggregateByKey;
            case "foldByKey": return F_foldByKey;
            case "groupByKey": return F_groupByKey;
            case "subtract": return F_subtract;
            case "subtractByKey": return F_subtractByKey;
            case "join": return F_join;
            case "leftOuterJoin": return F_leftOuterJoin;
            case "rightOuterJoin": return F_rightOuterJoin;
            case "fullOuterJoin": return F_fullOuterJoin;
            case "collectAsMap": return F_collectAsMap;
            case "mapValues": return F_mapValues;
            case "flatMapValues": return F_flatMapValues;
            case "cogroup": return F_cogroup;
            case "groupWith": return F_groupWith;
            case "lookup": return F_lookup;
            case "sortByKey": return F_sortByKey;
            case "keys": return F_keys;
            case "values": return F_values;
            case "countApproxDistinctByKey": return F_countApproxDistinctByKey;
            case "setName": return F_setName;
            case "rdd": return F_rdd;

        }
        return super.getMember(name);
    }
709172
private List<String> getParameterAsList(String name) {
        String[] values = getParameterValues(name);
        if (values == null) {
            return null;
        }

        List<String> valueList = new ArrayList<>(values.length);
        Collections.addAll(valueList, values);
        return valueList;
    }
1112928
function(value, name) {

		var result = false,
			index = this._data_values.indexOf(value);

		if (index == -1) {
			this.push(value, name);
			result = true;
		}

		return result;

	}
1356621
function (name, items) {
    var List = this.get('List');
    var list = this.lists[name];
    if (typeof list === 'undefined') {
      var opts = lazy.clone(this.options);
      opts.items = items || this.items;
      opts.collection = this;
      this.lists[name] = list = new List(opts);
    }
    return list;
  }
224104
public String[] values(String name) {
        final HttpHeader header = getHeader(name);
        return header == null ? null : header.values();
    }
1331690
@Override
    public String getParameter(String name) {
        String[] vals = getParameterMap().get(name);

        return (vals != null && vals.length > 0) ? vals[0] : null;
    }
383381
@Nullable
    public static String[] getStringArray(@NonNull SharedPreferences prefs,
            @NonNull String key, @NonNull String delimiter) {
        return split(prefs.getString(key, null), delimiter);
    }
265356
public static FeatureSet valueOf(String name) {
    switch (name) {
      case "es3":
        return ES3;
      case "es5":
        return ES5;
      case "es6-impl":
      case "es6":
        return ES6;
      case "typeCheckSupported":
        return TYPE_CHECK_SUPPORTED;
      case "es7":
        return ES7;
      case "es8":
        return ES8;
      case "es2018":
      case "es9":
        return ES2018;
      case "es_2019":
        return ES2019;
      case "es_next":
        return ES_NEXT;
      case "ts":
        return TYPESCRIPT;
      default:
        throw new IllegalArgumentException("No such FeatureSet: " + name);
    }
  }
1162711
function(name) {
			if (typeof name === 'number') {
				return this.list()[name];
			}
			
			if (typeof name === 'string') {
				return utils.find(this.list(), function(prop) {
					return prop.name() === name;
				});
			}
			
			return name;
		}
991865
function(name) {
			if (!Array.isArray(name)) {
				name = [name];
			}
			
			name.forEach(function(key) {
				if (key in preferences) {
					delete preferences[key];
				}
				
				if (key in defaults) {
					delete defaults[key];
				}
			});
		}
59564
@Nullable
    public static String[] getStringArray(@NonNull SharedPreferences prefs, @NonNull String key) {
        return getStringArray(prefs, key, DEFAULT_DELIMITER);
    }
1090296
public static final Nature fromString(String name)
    {
        Integer id = idMap.get(name);
        if (id == null)
            return null;
        return values[id];
    }