*
     * @since 3.5
     */
    public Set<ResourceFilter> getResourceFilters() {
        return resourceFilters;
    }

    /**
     * Sets the resource filters of this Eclipse project.
     *
     * @since 3.5
     */
    public void setResourceFilters(Set<ResourceFilter> resourceFilters) {
        this.resourceFilters = resourceFilters;
    }

        project.natures == CUSTOM_NATURES + eclipseProject.natures
        project.linkedResources == eclipseProject.linkedResources + CUSTOM_LINKED_RESOURCES
        project.resourceFilters == eclipseProject.resourceFilters + CUSTOM_RESOURCE_FILTERS
    }

    def loadDefaults() {
        when:
        project.loadDefaults()

        then:
        project.name == ""
        project.comment == ""

                <td>[]</td>
            </tr>
            <tr>
                <td>file</td>
                <td/>
            </tr>
            <tr>
                <td>resourceFilters</td>
                <td>[]</td>
            </tr>
        </table>
    </section>
    <section>
        <title>Methods</title>
        <table>
            <thead>
                <tr>

     */
    public ResourceFilter resourceFilter(@DelegatesTo(value=ResourceFilter.class, strategy = Closure.DELEGATE_FIRST) Closure configureClosure) {
        return resourceFilter(new ClosureBackedAction<ResourceFilter>(configureClosure));
    }

    /**
     * Adds a resource filter to the eclipse project.
     * <p>
     * For examples, see docs for {@link ResourceFilter}
     *

 *       }
 *     }
 *   }
 * }
 * </pre>
 *
 * @since 3.5
 */
public interface ResourceFilter {
    /**
     * Indicates whether this ResourceFilter applies to files, folders, or both.  Default is FILES_AND_FOLDERS
     */
    ResourceFilterAppliesTo getAppliesTo();

    /**
     * Indicates whether this ResourceFilter applies to files, folders, or both.  Default is FILES_AND_FOLDERS
     *

import org.gradle.internal.fingerprint.hashing.ConfigurableNormalizer;
import org.gradle.internal.hash.Hasher;

import java.util.function.Supplier;

public interface ResourceFilter extends ConfigurableNormalizer {
    ResourceFilter FILTER_NOTHING = new ResourceFilter() {
        @Override
        public boolean shouldBeIgnored(Supplier<String[]> relativePathFactory) {
            return false;
        }

        @Override

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs;


/**
 * Filter based on a resource instance
 * 
 * @author mbechler
 *
 */
public interface ResourceFilter {

    /**
     * 
     * @param resource
     * @return whether the given resource should be included
     * @throws CIFSException
     */

public class IgnoringResourceHasher implements ResourceHasher {
    private final ResourceHasher delegate;
    private final ResourceFilter resourceFilter;

    public IgnoringResourceHasher(ResourceHasher delegate, ResourceFilter resourceFilter) {
        this.delegate = delegate;
        this.resourceFilter = resourceFilter;
    }

    @Override
    public void appendConfigurationToHasher(Hasher hasher) {

    private final MetaInfNormalization metaInfNormalization = new RuntimeMetaInfNormalization();
    private final EvaluatableFilter<ResourceFilter> resourceFilter = filter(IgnoringResourceFilter::new, ResourceFilter.FILTER_NOTHING);
    private final EvaluatableFilter<ResourceEntryFilter> manifestAttributeResourceFilter = filter(IgnoringResourceEntryFilter::new, ResourceEntryFilter.FILTER_NOTHING);

            return false;
        }
        DefaultResourceFilter resourceFilter = (DefaultResourceFilter) o;
        return Objects.equal(appliesTo, resourceFilter.appliesTo)
            && Objects.equal(type, resourceFilter.type)
            && Objects.equal(recursive, resourceFilter.recursive)
            && Objects.equal(matcher, resourceFilter.matcher);
    }

    @Override
    public int hashCode() {