Gets output file names.

@param inputFile
String input file name
@param versionInfo
version info, not used by this compiler.
@return String[] output file names
964290
@Override
  public String[] getOutputFileNames(final String inputFile, final VersionInfo versionInfo) {
    if (inputFile.endsWith(".cpp")) {
      return super.getOutputFileNames(inputFile, versionInfo);
    }
    //
    // if a recognized input file
    //
    final String baseName = getBaseOutputName(inputFile);
    return new String[] {
      "moc_" + baseName + ".cpp"
    };
  }
1037771
protected Collection<ICalVersion> getValueSupportedVersions() {
		return (value == null) ? Collections.<ICalVersion> emptyList() : Arrays.asList(ICalVersion.values());
	}
798124
private File[] getSources(final List<File> sourceList) {
    final File[] sortedSources = new File[sourceList.size()];
    sourceList.toArray(sortedSources);
    Arrays.sort(sortedSources, new Comparator<File>() {
      @Override
      public int compare(final File o1, final File o2) {
        return o1.getName().compareTo(o2.getName());
      }
    });
    return sortedSources;
  }
704893
public function getReferencedFiles(array $fieldIds, $versionNo)
    {
        if (empty($fieldIds)) {
            return array();
        }

        $connection = $this->getConnection();

        $selectQuery = $connection->createSelectQuery();
        $selectQuery->select(
            $connection->quoteColumn('filename'),
            $connection->quoteColumn('mime_type')
        )->from(
            $connection->quoteTable($this->getStorageTable())
        )->where(
            $selectQuery->expr->lAnd(
                $selectQuery->expr->in(
                    $connection->quoteColumn('contentobject_attribute_id'),
                    $fieldIds
                ),
                $selectQuery->expr->eq(
                    $connection->quoteColumn('version'),
                    $selectQuery->bindValue($versionNo, null, \PDO::PARAM_INT)
                )
            )
        );

        $statement = $selectQuery->prepare();
        $statement->execute();

        $gateway = $this;

        return array_map(
            function ($row) use ($gateway) {
                return $gateway->prependMimeToPath($row['filename'], $row['mime_type']);
            },
            $statement->fetchAll(\PDO::FETCH_ASSOC)
        );
    }
1141169
public Iterable<ValidationComponent> getStandardValidationComponents(File inputFile) {
		final ValidationHandler handler = new ValidationHandler();
		getDocumentParser().extractValidationComponents(inputFile, handler);
		return handler.getComponents();
	}
235472
public function getReferencedFiles(array $fieldIds, $versionNo)
    {
        if (empty($fieldIds)) {
            return [];
        }

        $selectQuery = $this->connection->createQueryBuilder();
        $selectQuery
            ->select(
                $this->connection->quoteIdentifier('filename'),
                $this->connection->quoteIdentifier('mime_type')
            )
            ->from($this->connection->quoteIdentifier($this->getStorageTable()))
            ->where(
                $selectQuery->expr()->andX(
                    $selectQuery->expr()->in(
                        $this->connection->quoteIdentifier('contentobject_attribute_id'),
                        ':fieldIds'
                    ),
                    $selectQuery->expr()->eq(
                        $this->connection->quoteIdentifier('version'),
                        ':versionNo'
                    )
                )
            )
            ->setParameter(':fieldIds', $fieldIds, Connection::PARAM_INT_ARRAY)
            ->setParameter(':versionNo', $versionNo, PDO::PARAM_INT)
        ;

        $statement = $selectQuery->execute();

        return array_map(
            function ($row) {
                return $this->prependMimeToPath($row['filename'], $row['mime_type']);
            },
            $statement->fetchAll(PDO::FETCH_ASSOC)
        );
    }
1247028
public String getFileNameWithoutSuffix( File texFile )
    {
        String nameTexFile = texFile.getName();
        String namePrefixTexFile = nameTexFile.substring( 0, nameTexFile.lastIndexOf( "." ) );
        return namePrefixTexFile;
    }
1255798
public function getFileNames()
    {

        $filesArray = $this->getFiles();
        $filenamesArray = array();

        foreach ($filesArray as $file) {
            $sFileName = $file->getName();
            array_push($filenamesArray, $sFileName);
        }
        sort($filenamesArray);
        return $filenamesArray;
    }
9090
def _get_name_and_version(name, version, for_filename=False):
    """"""
    if for_filename:
        # For both name and version any runs of non-alphanumeric or '.'
        # characters are replaced with a single '-'.  Additionally any
        # spaces in the version string become '.'
        name = _FILESAFE.sub('-', name)
        version = _FILESAFE.sub('-', version.replace(' ', '.'))
    return '%s-%s' % (name, version)
1360966
public String getFileName() {

        CmsMacroResolver resolver = new CmsMacroResolver();
        resolver.addMacro("version", OpenCms.getModuleManager().getModule(m_moduleName).getVersionStr());
        return resolver.resolveMacros(m_fileName);
    }
523353
public static File[] listRepositories(File parent) {
        if (parent == null) {
            throw new IllegalArgumentException("Input parameter can't be null.");
        }
        parent = checkKnownType(parent);
        if (!parent.isDirectory()) {
            throw new IllegalArgumentException("Input parameter should be an existing directory: " + parent);
        }
        File[] result = parent.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                return pathname.isDirectory() &&
                       getChild(pathname, LogRepositoryBrowserImpl.DEFAULT_LOCATION).isDirectory() ||
                       getChild(pathname, LogRepositoryBrowserImpl.TRACE_LOCATION).isDirectory();
            }
        });
        return result == null ? new File[] {} : result;
    }
445182
public static function getCompiledFile($inputFile)
    {
        $currentFile = self::fixPathForInput($inputFile);
        $pathInfo = pathinfo($currentFile);
        $parser = \KayStrobach\Dyncss\Configuration\BeRegistry::get()->getFileHandler($pathInfo['extension']);
        if ($parser !== null) {
            $parser->setOverrides(self::getOverrides());
            $outputFile = $parser->compileFile($currentFile);

            return self::fixPathForOutput($outputFile);
        } else {
            return $inputFile;
        }
    }
261553
private String extractNumericVersion(Collection<String> versionStrings) {
        if (versionStrings == null) {
            return "";
        }
        for (String value : versionStrings) {
            String releaseValue = calculateReleaseVersion(value);
            if (!releaseValue.equals(value)) {
                return releaseValue;
            }
        }
        return "";
    }
229081
public List<ClasspathResourceVersion> getResourceVersions() throws URISyntaxException, IOException {
        if (!lazyLoadDone) {
            if (isClassFolder()) {
                logger.debug("\nScanning class folder: " + getUrl());

                URI uri = new URI(getUrl());
                Path start = Paths.get(uri);

                scanClasspathEntry(start);

            } else if (isJar()) {
                logger.debug("\nScanning jar: " + getUrl());

                URI uri = new URI("jar:" + getUrl());

                try (FileSystem jarFS = FileSystems.newFileSystem(uri, new HashMap<String, String>())) {
                    Path zipInJarPath = jarFS.getPath("/");

                    scanClasspathEntry(zipInJarPath);

                } catch (Exception exc) {
                    logger.debug("Could not scan jar: " + getUrl() + " - reason:" + exc.getMessage());
                }
            }
            lazyLoadDone = true;
        }

        return resourceVersions;
    }
724320
public String[] getFilenames(String name) 
    {
        List parts = (List)_partMap.getValues(name);
        if (parts==null)
            return null;
        String[] filenames = new String[parts.size()];
        for (int i=0; i<filenames.length; i++) {
            filenames[i] = ((Part)parts.get(i))._filename;
        }
        return filenames;
    }
1238678
protected Integer[] getVersionParts() {

        String[] sParts = version.split("\\.");
        ArrayList<Integer> iParts = new ArrayList<>();
        int trailingZeros = 0;

        for (String sPart : sParts) {
            Integer iPart = new Integer(sPart);

            if (iPart == 0) {
                ++trailingZeros;
            } else {
                for (int i = 0; i < trailingZeros; ++i) {
                    iParts.add(0);
                }
                trailingZeros = 0;
                iParts.add(iPart);
            }
        }
        return iParts.toArray(new Integer[iParts.size()]);
    }
1085740
private function getResourceFilesInSource(string $sourceFileContent): array
  {
    $resource_files = [];
    foreach ($this->getResourcesInfo() as $file_info)
    {
      if (strpos($sourceFileContent, $file_info['path_name_in_sources_with_hash'])!==false)
      {
        $resource_files[] = $file_info;
      }
    }

    return $resource_files;
  }