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 * http://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.Serializable; 021import java.nio.file.FileVisitResult; 022import java.nio.file.Path; 023import java.nio.file.attribute.BasicFileAttributes; 024import java.util.ArrayList; 025import java.util.Collections; 026import java.util.List; 027import java.util.Objects; 028import java.util.stream.Stream; 029 030/** 031 * A {@link java.io.FileFilter} providing conditional OR logic across a list of file filters. This filter returns 032 * {@code true} if any filters in the list return {@code true}. Otherwise, it returns {@code false}. Checking of the 033 * file filter list stops when the first filter returns {@code true}. 034 * <h2>Deprecating Serialization</h2> 035 * <p> 036 * <em>Serialization is deprecated and will be removed in 3.0.</em> 037 * </p> 038 * 039 * @since 1.0 040 * @see FileFilterUtils#or(IOFileFilter...) 041 */ 042public class OrFileFilter extends AbstractFileFilter implements ConditionalFileFilter, Serializable { 043 044 private static final long serialVersionUID = 5767770777065432721L; 045 046 /** The list of file filters. */ 047 private final List<IOFileFilter> fileFilters; 048 049 /** 050 * Constructs a new instance of {@link OrFileFilter}. 051 * 052 * @since 1.1 053 */ 054 public OrFileFilter() { 055 this(0); 056 } 057 058 /** 059 * Constructs a new instance with the given initial list. 060 * 061 * @param initialList the initial list. 062 */ 063 private OrFileFilter(final ArrayList<IOFileFilter> initialList) { 064 this.fileFilters = Objects.requireNonNull(initialList, "initialList"); 065 } 066 067 /** 068 * Constructs a new instance with the given initial capacity. 069 * 070 * @param initialCapacity the initial capacity. 071 */ 072 private OrFileFilter(final int initialCapacity) { 073 this(new ArrayList<>(initialCapacity)); 074 } 075 076 /** 077 * Constructs a new instance for the give filters. 078 * @param fileFilters filters to OR. 079 * 080 * @since 2.9.0 081 */ 082 public OrFileFilter(final IOFileFilter... fileFilters) { 083 this(Objects.requireNonNull(fileFilters, "fileFilters").length); 084 addFileFilter(fileFilters); 085 } 086 087 /** 088 * Constructs a new file filter that ORs the result of other filters. 089 * 090 * @param filter1 the first filter, must not be null 091 * @param filter2 the second filter, must not be null 092 * @throws IllegalArgumentException if either filter is null 093 */ 094 public OrFileFilter(final IOFileFilter filter1, final IOFileFilter filter2) { 095 this(2); 096 addFileFilter(filter1); 097 addFileFilter(filter2); 098 } 099 100 /** 101 * Constructs a new instance of {@link OrFileFilter} with the specified filters. 102 * 103 * @param fileFilters the file filters for this filter, copied. 104 * @since 1.1 105 */ 106 public OrFileFilter(final List<IOFileFilter> fileFilters) { 107 this(new ArrayList<>(Objects.requireNonNull(fileFilters, "fileFilters"))); 108 } 109 110 /** 111 * {@inheritDoc} 112 */ 113 @Override 114 public boolean accept(final File file) { 115 return fileFilters.stream().anyMatch(fileFilter -> fileFilter.accept(file)); 116 } 117 118 /** 119 * {@inheritDoc} 120 */ 121 @Override 122 public boolean accept(final File file, final String name) { 123 return fileFilters.stream().anyMatch(fileFilter -> fileFilter.accept(file, name)); 124 } 125 126 /** 127 * {@inheritDoc} 128 */ 129 @Override 130 public FileVisitResult accept(final Path file, final BasicFileAttributes attributes) { 131 return toDefaultFileVisitResult(fileFilters.stream().anyMatch(fileFilter -> fileFilter.accept(file, attributes) == FileVisitResult.CONTINUE)); 132 } 133 134 /** 135 * {@inheritDoc} 136 */ 137 @Override 138 public void addFileFilter(final IOFileFilter fileFilter) { 139 this.fileFilters.add(Objects.requireNonNull(fileFilter, "fileFilter")); 140 } 141 142 /** 143 * Adds the given file filters. 144 * 145 * @param fileFilters the filters to add. 146 * @since 2.9.0 147 */ 148 public void addFileFilter(final IOFileFilter... fileFilters) { 149 Stream.of(Objects.requireNonNull(fileFilters, "fileFilters")).forEach(this::addFileFilter); 150 } 151 152 /** 153 * {@inheritDoc} 154 */ 155 @Override 156 public List<IOFileFilter> getFileFilters() { 157 return Collections.unmodifiableList(this.fileFilters); 158 } 159 160 /** 161 * {@inheritDoc} 162 */ 163 @Override 164 public boolean removeFileFilter(final IOFileFilter fileFilter) { 165 return this.fileFilters.remove(fileFilter); 166 } 167 168 /** 169 * {@inheritDoc} 170 */ 171 @Override 172 public void setFileFilters(final List<IOFileFilter> fileFilters) { 173 this.fileFilters.clear(); 174 this.fileFilters.addAll(Objects.requireNonNull(fileFilters, "fileFilters")); 175 } 176 177 /** 178 * Provide a String representation of this file filter. 179 * 180 * @return a String representation 181 */ 182 @Override 183 public String toString() { 184 final StringBuilder buffer = new StringBuilder(); 185 buffer.append(super.toString()); 186 buffer.append("("); 187 append(fileFilters, buffer); 188 buffer.append(")"); 189 return buffer.toString(); 190 } 191 192}