Iterate over all filesets and return all the filenames.

@return array an array of filenames
506858
private function getFilenames()
    {
        $files = [];

        foreach ($this->filesets as $fileset) {
            $ds = $fileset->getDirectoryScanner($this->project);
            $ds->scan();

            $includedFiles = $ds->getIncludedFiles();

            foreach ($includedFiles as $file) {
                $fs = new PhingFile(basename($ds->getBaseDir()), $file);

                $files[] = $fs->getAbsolutePath();
            }
        }

        return $files;
    }
194399
public function find_all() {
        $this->ensure_path_exists();
        $files = glob($this->glob_keys_pattern(), GLOB_MARK | GLOB_NOSORT);
        $return = array();
        if ($files === false) {
            return $return;
        }
        foreach ($files as $file) {
            $return[] = substr(basename($file), 0, -6);
        }
        return $return;
    }
71706
public function getAvailableSetFiles()
    {
        $arrSets = array();
        foreach ($GLOBALS['TL_CONFIG']['advancedClassesSets'] as $key => $value)
        {
            if(!strpos($value,"system/")!==false)
            {
                $arrSets[$value] = basename( $value ) . ' (custom)';
                continue;
            }
            $arrSets[$value] = basename( $value );

        }
        return $arrSets;
    }
168724
public function getAllNames()
    {
        /** @var \RecursiveDirectoryIterator $files */
        $files = new \DirectoryIterator($this->getTemplatePath());

        $template_names = [];
        while ($files->valid()) {
            $name = $files->getBasename();

            // skip abstract files
            if (!$files->isDir() || in_array($name, ['.', '..'], true)) {
                $files->next();
                continue;
            }

            $template_names[] = $name;
            $files->next();
        }

        return $template_names;
    }
634001
def files(self):
    """"""
    all_files = set()
    for label in self.filesets:
      all_files.update(self.filesets[label])
    return all_files
613204
def _all_filenames(self):
        """"""
        try:
            return [os.path.join(self.cache_dir, filename) for filename in
                    os.listdir(self.cache_dir)]
        except (FileNotFoundError, OSError):
            return []
1067393
public function getFiles()
    {
        $files = get_included_files();

        if (class_exists('\O2System\Framework', false)) {
            foreach ($files as $key => $file) {

                if (strpos($file, 'autoload.php') !== false) {
                    unset($files[ $key ]);
                    continue;
                }

                $files[ $key ] = str_replace(PATH_ROOT, DIRECTORY_SEPARATOR, $file);
            }
        }

        return $files;
    }
133453
public function keys()
    {
        $keyPath = $this->getKeyPath();

        // find all the cached filenames among partitioned dirs within this group key
        // (e.g. '[GROUP PARTITION]/[GROUP]/[PARTITION]/[KEY]/cache')
        $iterator  = new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($keyPath));

        $regIterator = new \RegexIterator($iterator, '/\/[\d]+\/[\w\d]+\/' . self::FILENAME_CACHE .'$/i');
        $keys = array();

        foreach ($regIterator as $path) {
            // extract key from file path
            preg_match('/\/(?<key>[\w\d]+)\/' . self::FILENAME_CACHE . '/', $path->__toString(), $match);
            if (!array_key_exists('key', $match) || empty($match['key'])) {
                continue;
            }
            // decode the key
            $entry = base64_decode($match['key']);
            $keys[] = $entry;
        }
        asort($keys);

        return $keys;
    }
1370092
public function toArray()
    {
        return [
            'fileId' => $this->file->getId(),
            'fileVersion' => $this->file->getVersion(),
            'usageType' => $this->usageType,
            'usageId' => $this->usageId,
            'status' => $this->status,
        ];
    }
260823
public function getAllDirectories(): array
    {
        $directories = [];

        foreach ($this->filesystem->listContents('/'.$this->path) as $info) {
            $id = $info['filename'];

            if ($this->hasDirectory($id)) {
                $directories[$id] = $this->getDirectory($id);
            }
        }

        return $directories;
    }
848020
private function getAllConfigFiles()
        {
            $finded = Finder::create()->files()->name('*.php')->in($this->getConfigPath());
            $files = [];
            foreach ($finded as $find) {
                if ($find instanceof SplFileInfo) {
                    $files[explode('.', $find->getFilename())[0]] = $find->getRealPath();
                }
            }

            return $files;
        }
1097475
public function getAll()
    {
        if (filesize($this->filename) <= static::MAX_FILE_SIZE_FOR_CACHE) {
            $return = $this->query(new Query());
        } else {
            $return = $this->getIterator();
        }

        return $return;
    }
162957
private function dumpFiles()
    {
        $files = [];

        foreach(File::allFiles(Config::dumpPath()) as $dumpFile) {
            $files[] = $dumpFile->getRealpath();
        }

        sort($files);

        return $files;
    }
61592
protected function getAllBaseNames()
    {
        $pluggables = [];

        $path = $this->getPath();

        if (!is_dir($path)) {
            return $pluggables;
        }

        $folders = $this->files->directories($path);

        foreach ($folders as $plug) {
            $pluggables[] = basename($plug);
        }

        return $pluggables;
    }
1288525
public function getFiles() : array
    {
        if(!$this->_isLoaded) {
            $this->load();
        }

        return array_map(function($file) {
            return new File($this->getPath(). DIRECTORY_SEPARATOR .$file);
        }, $this->_files);
    }
964936
public function getAll()
    {
        $all = array();

        foreach ($this->getNames() as $name) {
            $all[$name] = $this->get($name);
        }

        return $all;
    }
1147502
public function getFiles()
    {
        if (!$this->fileSetFiles) {
            $this->populateFiles();
        }
        $files = array();
        foreach ($this->fileSetFiles as $file) {
            $files[] = ConcreteFile::getByID($file->fID);
        }

        return $files;
    }