001/*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements.  See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License.  You may obtain a copy of the License at
008 *
009 *      https://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017package org.apache.commons.io.filefilter;
018
019import java.io.File;
020import java.io.FileFilter;
021import java.io.Serializable;
022import java.nio.file.FileVisitResult;
023import java.nio.file.Path;
024import java.nio.file.attribute.BasicFileAttributes;
025import java.util.ArrayList;
026import java.util.Collections;
027import java.util.List;
028import java.util.Objects;
029import java.util.stream.Stream;
030
031/**
032 * A {@link FileFilter} providing conditional AND logic across a list of
033 * file filters. This filter returns {@code true} if all filters in the
034 * list return {@code true}. Otherwise, it returns {@code false}.
035 * Checking of the file filter list stops when the first filter returns
036 * {@code false}.
037 * <h2>Deprecating Serialization</h2>
038 * <p>
039 * <em>Serialization is deprecated and will be removed in 3.0.</em>
040 * </p>
041 *
042 * @since 1.0
043 * @see FileFilterUtils#and(IOFileFilter...)
044 */
045public class AndFileFilter extends AbstractFileFilter implements ConditionalFileFilter, Serializable {
046
047    private static final long serialVersionUID = 7215974688563965257L;
048
049    /** The list of file filters. */
050    private final List<IOFileFilter> fileFilters;
051
052    /**
053     * Constructs a new empty instance.
054     *
055     * @since 1.1
056     */
057    public AndFileFilter() {
058        this(0);
059    }
060
061    /**
062     * Constructs a new instance with the given initial list.
063     *
064     * @param initialList the initial list.
065     */
066    private AndFileFilter(final ArrayList<IOFileFilter> initialList) {
067        this.fileFilters = Objects.requireNonNull(initialList, "initialList");
068    }
069
070    /**
071     * Constructs a new instance with the given initial capacity.
072     *
073     * @param initialCapacity the initial capacity.
074     */
075    private AndFileFilter(final int initialCapacity) {
076        this(new ArrayList<>(initialCapacity));
077    }
078
079    /**
080     * Constructs a new instance for the give filters.
081     *
082     * @param fileFilters filters to OR.
083     * @since 2.9.0
084     */
085    public AndFileFilter(final IOFileFilter... fileFilters) {
086        this(Objects.requireNonNull(fileFilters, "fileFilters").length);
087        addFileFilter(fileFilters);
088    }
089
090    /**
091     * Constructs a new file filter that ANDs the result of other filters.
092     *
093     * @param filter1  the first filter, must second be null
094     * @param filter2  the first filter, must not be null
095     * @throws IllegalArgumentException if either filter is null
096     */
097    public AndFileFilter(final IOFileFilter filter1, final IOFileFilter filter2) {
098        this(2);
099        addFileFilter(filter1);
100        addFileFilter(filter2);
101    }
102
103    /**
104     * Constructs a new instance of {@link AndFileFilter}
105     * with the specified list of filters.
106     *
107     * @param fileFilters  a List of IOFileFilter instances, copied.
108     * @since 1.1
109     */
110    public AndFileFilter(final List<IOFileFilter> fileFilters) {
111        this(new ArrayList<>(Objects.requireNonNull(fileFilters, "fileFilters")));
112    }
113
114    /**
115     * {@inheritDoc}
116     */
117    @Override
118    public boolean accept(final File file) {
119        return !isEmpty() && fileFilters.stream().allMatch(fileFilter -> fileFilter.accept(file));
120    }
121
122    /**
123     * {@inheritDoc}
124     */
125    @Override
126    public boolean accept(final File file, final String name) {
127        return !isEmpty() && fileFilters.stream().allMatch(fileFilter -> fileFilter.accept(file, name));
128    }
129
130    /**
131     * {@inheritDoc}
132     * @since 2.9.0
133     */
134    @Override
135    public FileVisitResult accept(final Path file, final BasicFileAttributes attributes) {
136        return isEmpty() ? FileVisitResult.TERMINATE
137                : toDefaultFileVisitResult(fileFilters.stream().allMatch(fileFilter -> fileFilter.accept(file, attributes) == FileVisitResult.CONTINUE));
138    }
139
140    /**
141     * {@inheritDoc}
142     */
143    @Override
144    public void addFileFilter(final IOFileFilter fileFilter) {
145        fileFilters.add(Objects.requireNonNull(fileFilter, "fileFilter"));
146    }
147
148    /**
149     * Adds the given file filters.
150     *
151     * @param fileFilters the filters to add.
152     * @since 2.9.0
153     */
154    public void addFileFilter(final IOFileFilter... fileFilters) {
155        Stream.of(Objects.requireNonNull(fileFilters, "fileFilters")).forEach(this::addFileFilter);
156    }
157
158    /**
159     * {@inheritDoc}
160     */
161    @Override
162    public List<IOFileFilter> getFileFilters() {
163        return Collections.unmodifiableList(fileFilters);
164    }
165
166    private boolean isEmpty() {
167        return fileFilters.isEmpty();
168    }
169
170    /**
171     * {@inheritDoc}
172     */
173    @Override
174    public boolean removeFileFilter(final IOFileFilter ioFileFilter) {
175        return fileFilters.remove(ioFileFilter);
176    }
177
178    /**
179     * {@inheritDoc}
180     */
181    @Override
182    public void setFileFilters(final List<IOFileFilter> fileFilters) {
183        this.fileFilters.clear();
184        this.fileFilters.addAll(fileFilters);
185    }
186
187    /**
188     * Builds a String representation of this file filter.
189     *
190     * @return a String representation
191     */
192    @Override
193    public String toString() {
194        final StringBuilder buffer = new StringBuilder();
195        buffer.append(super.toString());
196        buffer.append("(");
197        append(fileFilters, buffer);
198        buffer.append(")");
199        return buffer.toString();
200    }
201
202}