### setFromString() Sets a property from a string.  t.setFromString('scale', '2,4'); // Same as set('scale', '2', '4');
323285
function(prop, val) {
      var args =
        (typeof val === 'string')  ? val.split(',') :
        (val.constructor === Array) ? val :
        [ val ];

      args.unshift(prop);

      Transform.prototype.set.apply(this, args);
    }
693167
@NonNull
    public Parameters setString(@NonNull String name, String value) {
        return setValue(name, value);
    }
490331
public void setValue(int numStrings, String[] newValues) {
        value.clear();
        if (numStrings == newValues.length) {
            for (int i = 0; i < newValues.length; i++) {
                value.add(newValues[i]);
            }
        }
        else {
            Log.e(TAG, "X3D MFString setValue() numStrings not equal total newValues");
        }
    }
1120311
@Override
    public void setString(int parameterIndex, String x) throws SQLException {
        internalStmt.setString(parameterIndex, x);
    }
653083
public final void setString(String s) {
        if (s == null) Kit.codeBug();
        ((Name)this).setIdentifier(s);
    }
934628
public void setString(String key, String value) {
        prefHelper_.prefsEditor_.putString(key, value);
        prefHelper_.prefsEditor_.apply();
    }
123264
func SetValueFromString(f reflect.Value, value string) error {
	ft := f.Type()
	if ft.Kind() == reflect.Ptr {
		ft = ft.Elem()
		f = f.Elem()
	}

	switch ft.Kind() {
	case reflect.String:
		f.SetString(value)
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		{
			v, err := strconv.ParseInt(value, 0, ft.Bits())
			if err != nil {
				return newBadRequestf("%s is not int format", value)
			}
			f.SetInt(v)
		}
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		{
			v, err := strconv.ParseUint(value, 0, ft.Bits())
			if err != nil {
				return newBadRequestf("%s is not uint format", value)
			}
			f.SetUint(v)
		}
	case reflect.Float32, reflect.Float64:
		{
			v, err := strconv.ParseFloat(value, ft.Bits())
			if err != nil {
				return newBadRequestf("%s is not float format", value)
			}
			f.SetFloat(v)
		}
	case reflect.Bool:
		{
			v, err := strconv.ParseBool(value)
			if err != nil {
				return newBadRequestf("%s is not bool format", value)
			}
			f.SetBool(v)
		}
	case reflect.Slice, reflect.Array:
		elem := reflect.New(ft.Elem()).Elem()
		err := SetValueFromString(elem, value)
		if err != nil {
			return err
		}
		result := reflect.New(ft).Elem()
		result = reflect.Append(result, elem)
		f.Set(result)
	default:
		return fmt.Errorf("unsupported format %s", ft.Name())
	}

	return nil
}
928089
public void setStringSetValue(java.util.Collection<String> stringSetValue) {
        if (stringSetValue == null) {
            this.stringSetValue = null;
            return;
        }

        this.stringSetValue = new com.amazonaws.internal.SdkInternalList<String>(stringSetValue);
    }
1024881
@Override
	public final void setStringProperty(String name, String value) throws JMSException
    {
        setProperty(name,value);
    }
49492
public int setString(String strValue, boolean bDisplayOption, int iMoveMode)
    {
        if ((strValue == null) || (strValue.length() == 0))
            return super.setString(strValue, bDisplayOption, iMoveMode);  // Don't trip change or display
        if (TEN_SPACES.equals(strValue))
            return DBConstants.NORMAL_RETURN;
        return super.setString(strValue, bDisplayOption, iMoveMode);
    }
1374707
@Override
	public String setValue(String value) {
		String result = this.value;
		this.value = value;
		calculateCompareKey();
		return result;
	}
1107587
@Override
    public void setString(int parameterIndex, String x) throws SQLException
    {
        checkParameterBounds(parameterIndex);
        this.parameters[parameterIndex-1] = x == null ? VoltType.NULL_STRING_OR_VARBINARY : x;
    }
457812
def do_string_set(self, element, decl, pseudo):
        """"""
        args = serialize(decl.value)
        step = self.state[self.state['current_step']]

        strval = ''
        strname = None
        for term in decl.value:
            if type(term) is ast.WhitespaceToken:
                continue

            elif type(term) is ast.StringToken:
                if strname is not None:
                    strval += term.value
                else:
                    log(WARN, u"Bad string-set: {}".format(
                        args).encode('utf-8'))

            elif type(term) is ast.IdentToken:
                if strname is not None:
                    log(WARN, u"Bad string-set: {}".format(
                        args).encode('utf-8'))
                else:
                    strname = term.value

            elif type(term) is ast.LiteralToken:
                if strname is None:
                    log(WARN, u"Bad string-set: {}".format(
                        args).encode('utf-8'))
                else:
                    step['strings'][strname] = strval
                    strval = ''
                    strname = None

            elif type(term) is ast.FunctionBlock:
                if term.name == 'string':
                    str_args = split(term.arguments, ',')
                    str_name = self.eval_string_value(element,
                                                      str_args[0])[0]
                    val = self.lookup('strings', str_name)
                    if val == '':
                        if len(str_args) > 1:
                            val = self.eval_string_value(element,
                                                         str_args[1])[0]
                        else:
                            log(WARN, u"{} blank string"
                                .format(str_name).encode('utf-8'))

                    if strname is not None:
                        strval += val
                    else:
                        log(WARN, u"Bad string-set: {}".format(
                            args).encode('utf-8'))

                elif term.name == 'counter':
                    counterargs = [serialize(t).strip(" \'")
                                   for t in split(term.arguments, ',')]
                    count = self.lookup('counters', counterargs)
                    strval += str(count)

                elif term.name == u'attr':
                    if strname is not None:
                        att_args = split(term.arguments, ',')
                        att_name = self.eval_string_value(element,
                                                          att_args[0])[0]
                        att_def = ''
                        if len(att_args) > 1:
                            att_def = self.eval_string_value(element,
                                                             att_args[1])[0]
                        if '|' in att_name:
                            ns, att = att_name.split('|')
                            try:
                                ns = self.css_namespaces[ns]
                            except KeyError:
                                log(WARN, u"Undefined namespace prefix {}"
                                    .format(ns).encode('utf-8'))
                                continue
                            att_name = etree.QName(ns, att)
                        strval += element.etree_element.get(att_name, att_def)
                    else:
                        log(WARN, u"Bad string-set: {}".format(
                            args).encode('utf-8'))

                elif term.name == u'content':
                    if strname is not None:
                        strval += etree.tostring(element.etree_element,
                                                 encoding='unicode',
                                                 method='text',
                                                 with_tail=False)
                    else:
                        log(WARN, u"Bad string-set: {}".format(
                            args).encode('utf-8'))

                elif term.name == u'first-letter':
                    tmpstr = self.eval_string_value(element, term.arguments)
                    if tmpstr:
                        if isinstance(tmpstr[0], basestring):
                            strval += tmpstr[0][0]
                        else:
                            log(WARN, u"Bad string value:"
                                u" nested target-* not allowed. "
                                u"{}".format(serialize(
                                    args)).encode('utf-8'))

                elif term.name == u'pending':
                    log(WARN, u"Bad string-set:pending() not allowed. {}"
                        .format(args).encode('utf-8'))

        if strname is not None:
            step['strings'][strname] = strval
247060
protected void setStringValue(String input) {
        this.bValue = null;
        this.sValue = input;
        this.offset = 0;
        this.valueLength = (null == input) ? 0 : input.length();
        if (ELEM_ADDED != this.status) {
            this.status = ELEM_CHANGED;
        }
    }
761005
function baseToString(value) {
  // Exit early for strings to avoid a performance hit in some environments.
  if (typeof value === 'string') {
    return value
  }
  if (isSymbol(value)) {
    return symbolToString ? symbolToString.call(value) : ''
  }
  var result = value + ''
  return result == '0' && 1 / value == -INFINITY ? '-0' : result
}
1060961
public static boolean isStringSet(PrefsProperty property) {
		boolean isStringSet = false;

		TypeName typeName;
		if (property.hasTypeAdapter()) {
			typeName = TypeUtility.typeName(property.typeAdapter.dataType);
		} else {
			typeName = TypeUtility.typeName(property.getElement().asType());
		}

		// it is parameterized type name for sure

		if (typeName instanceof ParameterizedTypeName && TypeUtility.isSet(typeName)) {
			ParameterizedTypeName parameterizedTypeName = (ParameterizedTypeName) typeName;
			if (TypeUtility.isEquals(parameterizedTypeName.typeArguments.get(0), String.class.getCanonicalName())) {
				isStringSet = true;
			}
		}

		return isStringSet;
	}
598180
def set_string(self, string):
        """"""
        self.string = string
        self.length = len(string)
        self.reset_position()