/** * Retrieves the base-directory for this instance. * @return <code>File</code>. */ public File getDir() { return getDir(getProject()); }
/** * Returns the directory scanner needed to access the files to process. * @return a <code>DirectoryScanner</code> instance. */ public DirectoryScanner getDirectoryScanner() { return getDirectoryScanner(getProject()); }
/** * Set up the specified directory scanner against this * AbstractFileSet's Project. * @param ds a <code>FileScanner</code> instance. */ public void setupDirectoryScanner(FileScanner ds) { setupDirectoryScanner(ds, getProject()); }
/** * Construct a new <code>AbstractFileSet</code>, shallowly cloned * from the specified <code>AbstractFileSet</code>. * @param fileset the <code>AbstractFileSet</code> to use as a template. */ protected AbstractFileSet(AbstractFileSet fileset) { this.dir = fileset.dir; this.defaultPatterns = fileset.defaultPatterns; this.additionalPatterns = fileset.additionalPatterns; this.selectors = fileset.selectors; this.useDefaultExcludes = fileset.useDefaultExcludes; this.caseSensitive = fileset.caseSensitive; this.followSymlinks = fileset.followSymlinks; this.errorOnMissingDir = fileset.errorOnMissingDir; this.maxLevelsOfSymlinks = fileset.maxLevelsOfSymlinks; setProject(fileset.getProject()); }
/** * Indicates whether there are any patterns here. * * @return whether any patterns are in this container. */ public synchronized boolean hasPatterns() { if (isReference() && getProject() != null) { return getRef(getProject()).hasPatterns(); } dieOnCircularReference(); return defaultPatterns.hasPatterns(getProject()) || additionalPatterns.stream().anyMatch(ps -> ps.hasPatterns(getProject())); }
/** * Returns included files as a list of semicolon-separated filenames. * * @return a <code>String</code> of included filenames. */ @Override public String toString() { if (isReference()) { return getRef(getProject()).toString(); } dieOnCircularReference(); DirectoryScanner ds = getDirectoryScanner(getProject()); return Stream.of(ds.getIncludedFiles()).collect(Collectors.joining(";")); }
/** * Creates a deep clone of this instance, except for the nested * selectors (the list of selectors is a shallow clone of this * instance's list). * @return the cloned object * @since Ant 1.6 */ @Override public synchronized Object clone() { if (isReference()) { return (getRef(getProject())).clone(); } try { AbstractFileSet fs = (AbstractFileSet) super.clone(); fs.defaultPatterns = (PatternSet) defaultPatterns.clone(); fs.additionalPatterns = additionalPatterns.stream().map(PatternSet::clone) .map(PatternSet.class::cast).collect(Collectors.toList()); fs.selectors = new ArrayList<>(selectors); return fs; } catch (CloneNotSupportedException e) { throw new BuildException(e); } }
/** * Returns the set of selectors as an array. * @param p the current project * @return a <code>FileSelector[]</code> of the selectors in this container. */ @Override public synchronized FileSelector[] getSelectors(Project p) { if (isReference()) { return getRef(getProject()).getSelectors(p); } dieOnCircularReference(p); return selectors.toArray(new FileSelector[selectors.size()]); }
/** * Indicates whether there are any selectors here. * * @return whether any selectors are in this container. */ @Override public synchronized boolean hasSelectors() { if (isReference()) { return getRef(getProject()).hasSelectors(); } dieOnCircularReference(); return !selectors.isEmpty(); }
/** * Gives the count of the number of selectors in this container. * * @return the number of selectors in this container as an <code>int</code>. */ @Override public synchronized int selectorCount() { if (isReference()) { return getRef(getProject()).selectorCount(); } dieOnCircularReference(); return selectors.size(); }
/** * Returns an enumerator for accessing the set of selectors. * * @return an <code>Enumeration</code> of selectors. */ @Override public synchronized Enumeration<FileSelector> selectorElements() { if (isReference()) { return getRef(getProject()).selectorElements(); } dieOnCircularReference(); return Collections.enumeration(selectors); }
/** * Whether default exclusions should be used or not. * @return the default exclusions value. * @since Ant 1.6.3 */ public synchronized boolean getDefaultexcludes() { if (isReference()) { return getRef(getProject()).getDefaultexcludes(); } dieOnCircularReference(); return useDefaultExcludes; }
/** * Makes this instance in effect a reference to another instance. * * <p>You must not set another attribute or nest elements inside * this element if you make it a reference.</p> * @param r the <code>Reference</code> to use. * @throws BuildException on error */ @Override public void setRefid(Reference r) throws BuildException { if (dir != null || defaultPatterns.hasPatterns(getProject())) { throw tooManyAttributes(); } if (!additionalPatterns.isEmpty()) { throw noChildrenAllowed(); } if (!selectors.isEmpty()) { throw noChildrenAllowed(); } super.setRefid(r); }
/** * Creates a single file fileset. * @param file the single <code>File</code> included in this * <code>AbstractFileSet</code>. */ public synchronized void setFile(File file) { if (isReference()) { throw tooManyAttributes(); } if (fileAttributeUsed) { if (getDir().equals(file.getParentFile())) { String[] includes = defaultPatterns.getIncludePatterns(getProject()); if (includes.length == 1 && includes[0].equals(file.getName())) { // NOOP, setFile has been invoked twice with the same parameter return; } } throw new BuildException("setFile cannot be called twice with different arguments"); } else if (getDir() != null) { throw dirAndFileAreMutuallyExclusive(); } setDir(file.getParentFile()); fileAttributeUsed = true; createInclude().setName(file.getName()); }
/** * Find out if the fileset wants to follow symbolic links. * * @return <code>boolean</code> indicating whether symbolic links * should be followed. * * @since Ant 1.6 */ public synchronized boolean isFollowSymlinks() { if (isReference()) { return getRef(getProject()).isCaseSensitive(); } dieOnCircularReference(); return followSymlinks; }
final DirectoryScanner ds; synchronized (this) { if (directoryScanner != null && p == getProject()) { ds = directoryScanner; } else { ds.setErrorOnMissingDir(errorOnMissingDir); ds.setMaxLevelsOfSymlinks(maxLevelsOfSymlinks); directoryScanner = (p == getProject()) ? ds : directoryScanner;
/** * Find out if the fileset is case sensitive. * * @return <code>boolean</code> indicating whether the fileset is * case sensitive. * * @since Ant 1.7 */ public synchronized boolean isCaseSensitive() { if (isReference()) { return getRef(getProject()).isCaseSensitive(); } dieOnCircularReference(); return caseSensitive; }