Provide array of String enumeration results ['"MIDDLE" | "BEGIN" | "END" | "FIRST"'] from initializeOnly MFString field named justify.
@array saved in valueDestination
515005
public String[] getJustify() {
        String[] valueDestination = new String[ justify.size() ];
        this.justify.getValue(valueDestination);
        return valueDestination;
    }
649204
public List<String> getValuesAsString() {
        List<CharSequence> valuesAsCharSequence = getValues();
        List<String> res = new ArrayList<>(valuesAsCharSequence.size());
        for (CharSequence value : valuesAsCharSequence) {
            res.add(value.toString());
        }
        return res;
    }
986888
public String sprintf(Object[] o) {
    Enumeration e = vFmt.elements();
    ConversionSpecification cs = null;
    char c = 0;
    int i=0;
    StringBuffer sb=new StringBuffer();
    while (e.hasMoreElements()) {
      cs = (ConversionSpecification)
        e.nextElement();
      c = cs.getConversionCharacter();
      if (c=='\0') sb.append(cs.getLiteral());
      else if (c=='%') sb.append("%");
      else {
        if (cs.isPositionalSpecification()) {
          i=cs.getArgumentPosition()-1;
          if (cs.isPositionalFieldWidth()) {
            int ifw=cs.getArgumentPositionForFieldWidth()-1;
            cs.setFieldWidthWithArg(((Integer)o[ifw]).intValue());
          }
          if (cs.isPositionalPrecision()) {
            int ipr=cs.getArgumentPositionForPrecision()-1;
            cs.setPrecisionWithArg(((Integer)o[ipr]).intValue());
          }
        }
        else {
          if (cs.isVariableFieldWidth()) {
            cs.setFieldWidthWithArg(((Integer)o[i]).intValue());
            i++;
          }
          if (cs.isVariablePrecision()) {
            cs.setPrecisionWithArg(((Integer)o[i]).intValue());
            i++;
          }
        }
        if (o[i] instanceof Byte)
          sb.append(cs.internalsprintf(
          ((Byte)o[i]).byteValue()));
        else if (o[i] instanceof Short)
          sb.append(cs.internalsprintf(
          ((Short)o[i]).shortValue()));
        else if (o[i] instanceof Integer)
          sb.append(cs.internalsprintf(
          ((Integer)o[i]).intValue()));
        else if (o[i] instanceof Long)
          sb.append(cs.internalsprintf(
          ((Long)o[i]).longValue()));
        else if (o[i] instanceof Float)
          sb.append(cs.internalsprintf(
          ((Float)o[i]).floatValue()));
        else if (o[i] instanceof Double)
          sb.append(cs.internalsprintf(
          ((Double)o[i]).doubleValue()));
        else if (o[i] instanceof Character)
          sb.append(cs.internalsprintf(
          ((Character)o[i]).charValue()));
        else if (o[i] instanceof String)
          sb.append(cs.internalsprintf(
          (String)o[i]));
        else
          sb.append(cs.internalsprintf(
          o[i]));
        if (!cs.isPositionalSpecification())
          i++;
      }
    }
    return sb.toString();
  }
537425
function stringStartsWith (str, val, startIndex) {
  var rest = '' + str
  return (arguments.length === 1 ? rest : rest.substring(startIndex)).indexOf(val) === 0
}
1303733
function stringToNumberArray(string, separator = "", setNaN = null) {
  if (isEmptyString(string)) {
    return [];
  }

  let array = string.split(separator);
  for (let i = 0; i < array.length; ++i) {
    array[i] = parseInt(array[i].trim(), 10);
    if (isNaN(array[i]) && setNaN !== null) {
      array[i] = setNaN;
    }
  }
  return array;
}
1125607
public String[] getStrings(String name) {

		Object value = super.get(name);
		if (value instanceof String[]) {
			return (String[]) value;
		}

		throw new IllegalArgumentException("Setting: '" + name + "', can't be converted to string array: '" + value + "'!");
	}
553480
public function interpString($m)
    {
        // this should only be called for doubly quoted strings
        // and triple-double quotes
        //
        // interpolation is betwee ${ ... }
        $patterns = array('interp' => '/(?<!\\$)\\$\\{/');
        $start = $this->pos();
        if (preg_match('/^"""/', $m[0])) {
            $patterns['term'] = '/"""/';
            $this->posShift(3);
        } else {
            assert(preg_match('/^"/', $m[0]));
            $patterns['term'] = '/"/';
            $this->posShift(1);
        }
        while (1) {
            $p = $this->pos();
            list($name, $index, $matches) = $this->getNextNamed($patterns);
            if ($name === null) {
                // no matches, terminate
                $this->record(substr($this->string(), $start), 'STRING');
                $this->terminate();
                break;
            } elseif ($name === 'term') {
                // end of the string
                $range = $index + strlen($matches[0]);
                $this->record(substr($this->string(), $start, $range - $start), 'STRING');
                $this->pos($range);
                break;
            } else {
                // interpolation, handle this with a subscanner
                $this->record(substr($this->string(), $start, $index - $start), 'STRING');
                $this->record($matches[0], 'DELIMITER');
                $subscanner = new GroovyScanner($this->string());
                $subscanner->interpolation = true;
                $subscanner->init();
                $subscanner->pos($index + strlen($matches[0]));
                $subscanner->main();

                $tagged = $subscanner->tagged();
                $this->record($tagged, 'INTERPOLATION', true);
                $this->pos($subscanner->pos());
                if ($this->scan('/\\}/')) {
                    $this->record($this->match(), 'DELIMITER');
                }
                $start = $this->pos();
            }
            assert($p < $this->pos());
        }
    }
1073021
public String[] getStringArray(String key) {
    String effectiveKey = definitions.validKey(key);
    Optional<PropertyDefinition> def = getDefinition(effectiveKey);
    if ((def.isPresent()) && (def.get().multiValues())) {
      String value = getString(key);
      if (value == null) {
        return ArrayUtils.EMPTY_STRING_ARRAY;
      }

      List<String> values = new ArrayList<>();
      for (String v : Splitter.on(",").trimResults().split(value)) {
        values.add(v.replace("%2C", ","));
      }
      return values.toArray(new String[values.size()]);
    }

    return getStringArrayBySeparator(key, ",");
  }
1068580
function(formatString, value) {

                var fieldDelimiterIndex;
                var fieldDelimiter = '{';
                var endPlaceholder = false;
                var formattedStringArray = [];

                while ((fieldDelimiterIndex = formatString.indexOf(fieldDelimiter)) !== -1) {

                    var pieceFormatedString, formatSpec, fieldName;

                    pieceFormatedString = formatString.slice(0, fieldDelimiterIndex);

                    if (endPlaceholder) {
                        formatSpec = pieceFormatedString.split(':');
                        fieldName = formatSpec.shift().split('.');
                        pieceFormatedString = value;

                        for (var i = 0; i < fieldName.length; i++)
                            pieceFormatedString = pieceFormatedString[fieldName[i]];

                        if (formatSpec.length)
                            pieceFormatedString = this.number(formatSpec, pieceFormatedString);
                    }

                    formattedStringArray.push(pieceFormatedString);

                    formatString = formatString.slice(fieldDelimiterIndex + 1);
                    endPlaceholder = !endPlaceholder;
                    fieldDelimiter = (endPlaceholder) ? '}' : '{';
                }
                formattedStringArray.push(formatString);

                return formattedStringArray.join('');
            }
445873
@Override
    public CaseFoldCodeItem[]caseFoldCodesByString(int flag, byte[]bytes, int p, int end) {
        return asciiCaseFoldCodesByString(flag, bytes, p, end);
    }
714345
def justify(texts, max_len, mode='right'):
    
    if mode == 'left':
        return [x.ljust(max_len) for x in texts]
    elif mode == 'center':
        return [x.center(max_len) for x in texts]
    else:
        return [x.rjust(max_len) for x in texts]
631636
function parseArrayInitialiser() {
        var elements = [],
            undef;

        expect('[');

        while (!match(']')) {
            if (match(',')) {
                lex();
                elements.push(undef);
            } else {
                elements.push(parseAssignmentExpression());

                if (!match(']')) {
                    expect(',');
                }
            }
        }

        expect(']');

        return {
            type: Syntax.ArrayExpression,
            elements: elements
        };
    }
1305649
@Override
	public String getValueAsString() {
		String result = null;

		String[] inputs = getValue();

		if (inputs != null && inputs.length > 0) {
			StringBuffer stringValues = new StringBuffer();

			for (int i = 0; i < inputs.length; i++) {
				if (i > 0) {
					stringValues.append(", ");
				}

				stringValues.append(inputs[i]);
			}

			result = stringValues.toString();

		}

		return result;
	}
742205
public String[] getValueNames() {

        Enumeration enumeration = super.getAttributeNames();
        Vector valueNames = new Vector();
        String name = null;
        boolean securityPropFound = false;
        while (enumeration.hasMoreElements()) {
            name = (String) enumeration.nextElement();
            if (!name.equals(SECURITY_PROP_NAME)) {
                valueNames.add(name);
            } else {
                securityPropFound = true;
            }
        }
        _hasSecurityInfo = securityPropFound;
        String[] names = new String[valueNames.size()];
        return (String[]) valueNames.toArray(names);
    }
145851
public String[] toStringArray() {
	String[] result;
	result = new String[size() + 2];

	result[0] = name;
	result[1] = String.valueOf(size());
	System.arraycopy(values, 0, result, 2, size());

	return result;
    }
177563
public static function toString()
    {
        $return = [];

        foreach (static::$globals as $key => $value) {
            $type = gettype($value);

            if (is_callable($value)) {
                $valueString = 'callable';
                $type = 'callable';
            } elseif (is_array($value)) {
                $valueString = implode(', ', $value);
            } else {
                $valueString = (string)$value;
            }

            $return[] = sprintf(
                '"%s": (%s) %s',
                $key,
                $type,
                $valueString
            );
        }

        return implode(PHP_EOL, $return);
    }
800096
public static List<ExtensionConfig> parseEnum(Enumeration<String> valuesEnum) {
        List<ExtensionConfig> configs = new ArrayList<>();

        if (valuesEnum != null) {
            while (valuesEnum.hasMoreElements()) {
                Iterator<String> extTokenIter = QuoteUtil.splitAt(valuesEnum.nextElement(), ",");
                while (extTokenIter.hasNext()) {
                    String extToken = extTokenIter.next();
                    configs.add(ExtensionConfig.parse(extToken));
                }
            }
        }

        return configs;
    }