{@inheritdoc}

@return StringList
559452
public function keys()
    {

        $keys = new StringList();
        $url = $this->urlOrFail();

        if (!$this->filesystem->isDirectory($url)) {
            return $keys;
        }

        $fileExtension = $this->fileExtension();

        foreach ($this->filesystem->listDirectory($url) as $fileName) {

            if ($this->filesystem->extension($fileName) != $fileExtension) {
                continue;
            }

            if ($this->filesystem->isDirectory($fileName)) {
                continue;
            }

            $keys->append($this->keyOfFile($fileName));

        }

        return $keys;
    }
466448
public java.util.List<String> getStringListValues() {
        if (stringListValues == null) {
            stringListValues = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return stringListValues;
    }
898751
def get_string_list(self, key):
        """"""
        strings = []
        size = self.beginReadArray(key)
        for i in range(size):
            self.setArrayIndex(i)
            entry = str(self._value("entry"))
            strings.append(entry)
        self.endArray()
        return strings
979206
public static function getList()
    {
        $calledClass = get_called_class();
        if (!isset(static::$list[$calledClass])) {
            $refClass = new \ReflectionClass($calledClass);
            $labels   = static::getLabels();
            foreach ($refClass->getConstants() as $constName => $constValue) {
                if (isset($labels[$constValue])) {
                    $label = $labels[$constValue];
                } else {
                    $label = lcfirst(strtolower($constName));
                }
                static::$list[$calledClass][$constValue] = $label;
            }
        }
        return static::$list[$calledClass];
    }
71618
public static function fieldListToValuesString($fields)
    {
        $formattedFields = [];
        foreach ($fields as $field) {
            $fieldWithColonPrefix = ':' . $field;
            $formattedFields[] = $fieldWithColonPrefix;
        }

        return ' value (' . implode(', ', $formattedFields) . ')';
    }
213092
public function setCharList($charList)
    {
        if (! strlen($charList)) {
            $charList = null;
        }

        $this->options['charlist'] = $charList;

        return $this;
    }
197325
def p_string_list(self, t):
        """"""

        if len(t) == 4:
            t[0] = t[1]
            t[0].append(t[3])
        elif t[1]:
            t[0] = [t[1]]
        else:
            t[0] = []
292280
protected function get_string_filters($context) {
        if (!isset($this->stringfilters[$context->id])) {
            $this->load_filters($context);
        }
        return $this->stringfilters[$context->id];
    }
647908
public static List<String> collectionToStringList(Collection c) {
        List<String> l = new ArrayList<String>(c.size());
        for (Object o : c) {
            l.add(o.toString());
        }
        return l;
    }
836848
public function parse(string $value)
    {
        $parsedValue = $this->parser->parse($value);
        if (false === $parsedValue instanceof ListValue) {
            return $parsedValue;
        }

        $mergedValues = array_reduce(
            $parsedValue->getValue(),
            [$this, 'mergeStrings'],
            $initial = []
        );

        return (1 === count($mergedValues))
            ? $mergedValues[0]
            : new ListValue($mergedValues)
        ;
    }
1125878
public function asString()
    {
        $query = '';

        if (!empty($this->list)) {
            foreach ($this->list as $clause) {
                $query .= $clause->asString();
            }
        }

        return $query;
    }
792828
def _get_stringlist_from_commastring(self, field):
        # type: (str) -> List[str]
        
        strings = self.data.get(field)
        if strings:
            return strings.split(',')
        else:
            return list()
218062
@Override
    public List<String> getStringList( final String             key,
                                       final List<String>       defaultValue )
    {
        return getStringList( key, DEFAULT_LIST_DELIMITER, defaultValue );
    }
1259260
public function UsageListAsString()
    {
        $pages = implode(', ', $this->Pages()->column('URLSegment'));
        $sets = implode(', ', $this->BlockSets()->column('Title'));
        $_t_pages = _t('Block.PagesAsString', 'Pages: {pages}', '', ['pages' => $pages]);
        $_t_sets = _t('Block.BlockSetsAsString', 'Block Sets: {sets}', '', ['sets' => $sets]);
        if ($pages && $sets) {
            return "$_t_pages<br />$_t_sets";
        }
        if ($pages) {
            return $_t_pages;
        }
        if ($sets) {
            return $_t_sets;
        }
    }
801784
public static Object[] stringListToArray(List<String> list) {
		Object[] params = null;
		if (list != null) {
			params = list.toArray(new String[list.size()]);
		}
		return params;
	}
898078
private function getOptionsSearchStrings() {
        if (empty($this->searchStringsCache)) {
            $this->searchStringsCache = array(
                0 => '',
                1 => array(),
            );
            foreach ($this->parameters as $Option) {
                $postfix = self::getPostfix($Option);
                /** @var $Option Option */
                $this->searchStringsCache[0] .= $Option->getShort() . $postfix;
                $this->searchStringsCache[1][] = $Option->getLong() . $postfix;
            }
        }
        return $this->searchStringsCache;
    }
799966
protected function generateStringSchema(string $stringValue): array
    {
        $schema = ['type' => 'string'];
        $schemaValidator = new SchemaValidator();
        $detectedFormat = null;

        $detectableFormats = ['uri','email','ip-address','class-name','interface-name'];
        foreach ($detectableFormats as $testFormat) {
            $testSchema = ['type' => 'string', 'format' => $testFormat];
            $result = $schemaValidator->validate($stringValue, $testSchema);
            if ($result->hasErrors() === false) {
                $detectedFormat = $testFormat;
            }
        }
        if ($detectedFormat !== null) {
            $schema['format'] = $detectedFormat;
        }
        return $schema;
    }