001/* 002 * Copyright (c) 2009 The openGion Project. 003 * 004 * Licensed under the Apache License, Version 2.0 (the "License"); 005 * you may not use this file except in compliance with the License. 006 * You may obtain a copy of the License at 007 * 008 * http://www.apache.org/licenses/LICENSE-2.0 009 * 010 * Unless required by applicable law or agreed to in writing, software 011 * distributed under the License is distributed on an "AS IS" BASIS, 012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, 013 * either express or implied. See the License for the specific language 014 * governing permissions and limitations under the License. 015 */ 016package org.opengion.fukurou.util; 017 018// import org.opengion.fukurou.system.DateSet ; // 6.8.0.0 (2017/06/02) 019import org.opengion.fukurou.system.OgRuntimeException ; // 6.4.2.0 (2016/01/29) 020import static org.opengion.fukurou.system.HybsConst.CR; // 6.1.0.0 (2014/12/26) refactoring 021import static org.opengion.fukurou.system.HybsConst.BUFFER_MIDDLE; // 6.1.0.0 (2014/12/26) refactoring 022 023import java.io.File; 024import java.io.FileFilter; 025import java.util.List; 026import java.util.ArrayList; 027import java.util.Calendar; 028import java.util.StringTokenizer; 029import java.util.Locale; // 6.3.1.1 (2015/07/10) 030import java.util.Arrays; // 6.8.0.0 (2017/06/02) 031import java.util.function.BiPredicate; // 7.2.6.0 (2020/06/30) 032import java.util.regex.Pattern; 033// import java.util.regex.Matcher; 034 035/** 036 * HybsFileFilter.java は、複数の FileFilter を順次実行する フィルタクラスです。 037 * 038 * FileFilter インターフェースを継承し、File クラスの listFiles(FileFilter) メソッドに 039 * 渡すことができます。 040 * Filterに設定された複数のフィルタすべてを満たす場合の時のみ、accept(File pathname) 041 * メソッドは、true を返します。 042 * 043 * ※ 6.3.1.1 (2015/07/10) 044 * 各フィルター登録時に、自分自身を返す、メソッドチェーンに対応します。 045 * 大文字/小文字の区別なしで判定する、(ignoreCase=true)属性を追加します。 046 * 大文字小文字は、すべての文字判定型フィルターに適用されます。 047 * 048 * ※ 6.4.0.2 (2015/12/11) 049 * prefix,suffix,instr,equals に、("|"で複数指定可) の説明をJavaDocに追加。 050 * useDIR 属性に、onlyパラメータを追加[false:File/true:File+Dir/only:Dir]。 051 * ※ 7.2.6.0 (2020/06/30) 052 * useDIR 属性は廃止。 053 * 054 * この実装は同期化されません。 055 * 056 * @og.rev 6.3.1.1 (2015/07/10) メソッドチェーン化と、大文字/小文字の区別なし(ignoreCase=true)対応 057 * @og.rev 7.2.6.0 (2020/06/30) ディレクトリ処理を統一します。 058 * 059 * @version 7.2 060 * @author Kazuhiko Hasegawa 061 * @since JDK11.0, 062 */ 063public final class HybsFileFilter implements FileFilter { 064 065// private static final boolean IS_DIR = true; 066// private static final boolean IS_FILE = !IS_DIR; 067 068 private final List<FileFilter> listF = new ArrayList<>(); // 7.2.6.0 (2020/06/30) ファイル判定用 069 private final List<FileFilter> listD = new ArrayList<>(); // 7.2.6.0 (2020/06/30) ディレクトリ判定用 070// private final boolean isUseFile ; // 6.4.0.2 (2015/12/11) useDIR 属性に、onlyパラメータを追加[false:File/true:File+Dir/only:Dir]。 071// private final boolean isUseDIR ; // 7.2.6.0 (2020/06/30) useDIR 属性 廃止 072 073 private final boolean ignoreCase ; // 6.3.1.1 (2015/07/10) 大文字/小文字の区別[true:しない/false:する] 074 private final boolean notEquals ; // 6.8.0.0 (2017/06/02) 判定結果を反転させて処理します。 075 076 /** 077 * 指定された抽象パス名がパス名リストに含まれる必要がある場合、スルー(選択)されます。 078 * ここでの判定ロジックでは、ファイルについてのみ処理します。 079 * ディレクトリは、常に、true を返します。 080 * notEquals 属性で、判定結果を反転させることができます。 081 * 082 * ignoreCase の初期値は、大文字/小文字の区別しない(true)です。 083 * 084 * @og.rev 6.3.1.1 (2015/07/10) 大文字/小文字の区別[true:しない/false:する] 085 * @og.rev 6.4.0.2 (2015/12/11) useDIR 属性に、onlyパラメータを追加します[false:File/true:File+Dir/only:Dir]。 086 * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。 087 * @og.rev 7.2.6.0 (2020/06/30) ディレクトリ処理を統一します。 088 */ 089 public HybsFileFilter() { 090// this( "false" , true , false ); // 6.8.0.0 (2017/06/02) 091 this( true , false ); // 7.2.6.0 (2020/06/30) useDIR 属性 廃止 092 } 093 094 /** 095 * 引数に、ディレクトリの判定を行うかどうかを指定するコンストラクタです。 096 * ここで、true を指定すると、ファイル、ディレクトリの両方に対して 097 * 処理を実施します。 098 * ディレクトリの判定の場合、acceptメソッドで、false が返ると 099 * それ以下の処理も実行されません。 100 * 101 * @og.rev 5.1.2.0 (2010/01/01) 引数つきコンストラクタ追加 102 * @og.rev 6.3.1.1 (2015/07/10) 大文字/小文字の区別[true:しない/false:する] 103 * @og.rev 6.4.0.2 (2015/12/11) useDIR 属性に、onlyパラメータを追加します[false:File/true:File+Dir/only:Dir]。 104 * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。 105 * @og.rev 7.2.6.0 (2020/06/30) ディレクトリ処理を統一します。 106 * 107// * @param useDIR 判定対象を指定します[false:File/true:File+Dir/only:Dir]。 108 * @param ignoreCase 大文字/小文字の区別[true:しない/false:する] 109 */ 110// public HybsFileFilter( final String useDIR , final boolean ignoreCase ) { 111// this( useDIR , ignoreCase , false ); // 6.8.0.0 (2017/06/02) 112 public HybsFileFilter( final boolean ignoreCase ) { 113 this( ignoreCase , false ); // 7.2.6.0 (2020/06/30) useDIR 属性 廃止 114 } 115 116 /** 117 * 引数に、ディレクトリの判定を行うかどうかを指定するコンストラクタです。 118 * ここで、true を指定すると、ファイル、ディレクトリの両方に対して 119 * 処理を実施します。 120 * ディレクトリの判定の場合、acceptメソッドで、false が返ると 121 * それ以下の処理も実行されません。 122 * 123 * @og.rev 5.1.2.0 (2010/01/01) 引数つきコンストラクタ追加 124 * @og.rev 6.3.1.1 (2015/07/10) 大文字/小文字の区別[true:しない/false:する] 125 * @og.rev 6.4.0.2 (2015/12/11) useDIR 属性に、onlyパラメータを追加します[false:File/true:File+Dir/only:Dir]。 126 * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。 127 * @og.rev 7.2.6.0 (2020/06/30) ディレクトリ処理を統一します。 128 * 129// * @param useDIR 判定対象を指定します[false:File/true:File+Dir/only:Dir]。 130 * @param ignoreCase 大文字/小文字の区別[true:しない/false:する] 131 * @param notEquals 判定結果を反転させて処理するかどうか[true:反転する/false:通常] 132 */ 133// public HybsFileFilter( final String useDIR , final boolean ignoreCase , final boolean notEquals ) { 134 public HybsFileFilter( final boolean ignoreCase , final boolean notEquals ) { // 7.2.6.0 (2020/06/30) useDIR 属性 廃止 135 super(); 136 137 this.ignoreCase = ignoreCase; // 6.3.1.1 (2015/07/10) 138 this.notEquals = notEquals; // 6.8.0.0 (2017/06/02) 139 140// // 7.2.6.0 (2020/06/30) useDIR 属性 廃止 141// // 6.4.0.2 (2015/12/11) useDIR 属性に、onlyパラメータを追加[false:File/true:File+Dir/only:Dir]。 142// isUseDIR = "true".equalsIgnoreCase( useDIR ) || "only".equalsIgnoreCase( useDIR ) ; 143// // 6.8.0.0 (2017/06/02) only 以外にします。(nullも許容します。) 144// isUseFile = !"only".equalsIgnoreCase( useDIR ); 145 } 146 147 /** 148 * 指定された抽象パス名がパス名リストに含まれる必要がある場合、スルー(選択)されます。 149 * ここでの判定ロジックでは、ファイルについてのみ処理します。 150 * ディレクトリは、常に、true を返します。 151 * 152 * @og.rev 6.4.0.2 (2015/12/11) useDIR 属性に、onlyパラメータを追加します[false:File/true:File+Dir/only:Dir]。 153 * @og.rev 7.2.6.0 (2020/06/30) ディレクトリ処理を統一します。 154 * 155 * @param pathname ファイルオブジェクト 156 * 157 * @return パス名リストに含まれるかどうか 158 * @see java.io.FileFilter#accept(File) 159 */ 160 public boolean accept( final File pathname ) { 161 if( pathname != null ) { 162 // 7.2.6.0 (2020/06/30) ファイルチェックとディレクトリチェックを分ける。 163 final List<FileFilter> list = pathname.isFile() ? listF : listD ; 164 for( final FileFilter filter : list ) { 165 if( !filter.accept( pathname ) ) { 166 return false; 167 } 168 } 169 } 170 return true; 171 172 // 7.2.6.0 (2020/06/30) useDIR 属性 廃止 173// if( pathname != null && (pathname.isFile() && isUseFile || pathname.isDirectory() && isUseDIR) ) { // 6.4.0.2 (2015/12/11) 174// final int size = list.size(); 175// for( int i=0; i<size; i++ ) { 176// final FileFilter filter = list.get(i); 177// if( !filter.accept( pathname ) ) { 178// return false; 179// } 180// } 181// } 182// return true; 183 } 184 185// /** 186// * 外部指定フィルタ: 内部判定条件に、フィルタを追加します。 187// * 引数が null の場合は、追加しません。 188// * 189// * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。 190// * @og.rev 7.2.6.0 (2020/06/30) ディレクトリ処理を統一します。 191// * 192// * @param filter 外部指定フィルタ 193// * @param isDir ディレクトリ判定を[true:行う/false:行わない] 194// * @return 自分自身(this) 195// */ 196// public HybsFileFilter addFileFilter( final FileFilter filter, final boolean isDir ) { 197//// if( filter != null ) { list.add( filter ); } 198// if( filter != null ) { 199// if( isDir ) { listD.add( filter ); } 200// else { listF.add( filter ); } 201// } 202// return this; // 6.3.1.1 (2015/07/10) 203// } 204 205 /** 206 * 指定された接頭辞で始まる場合に選択される FileFilter インターフェースの実装内部クラスです。 207 * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。 208 * 209 * @og.rev 7.2.6.0 (2020/06/30) ディレクトリ処理を統一します。 210 * 211 * @version 7.2 212 * @author Kazuhiko Hasegawa 213 * @since JDK11.0, 214 */ 215 private static final class DefaultFilter implements FileFilter { 216 private final String[] tkens ; 217 private final int cnt ; 218 private final boolean rvse ; 219 private final boolean igCase ; // 6.3.1.1 (2015/07/10) 220 221 private BiPredicate<String,String> biPred = (nm,tkn) -> true; // 初期値 222 223 /** 224 * 接頭辞フィルターオブジェクトを作成します。 225 * 226 * @param tokens 判定のキーワード("|"で複数指定可) 227 * @param reverse true:結果を反転する 228 * @param ignoreCase 大文字/小文字の区別[true:しない/false:する] 229 */ 230 DefaultFilter( final String tokens,final boolean reverse,final boolean ignoreCase ) { 231 rvse = reverse; 232 igCase = ignoreCase; // 6.3.1.1 (2015/07/10) 233 234 final StringTokenizer token = new StringTokenizer( tokens, "|" ); 235 cnt = token.countTokens(); 236 237 tkens = new String[cnt]; 238 for( int i=0; i<cnt; i++ ) { 239 // 6.3.1.1 (2015/07/10) ignoreCase 対応 240 final String tkn = token.nextToken(); 241 tkens[i] = igCase ? tkn.toLowerCase( Locale.JAPAN ) : tkn ; 242 } 243 } 244 245 /** 246 * 関数型インタフェースをセットします。 247 * 248 * ファイル/フォルダ名称と判定のキーワードの2つの引数を持つBiPredicateインターフェースをセットします。 249 * 250 * @param biPred 関数型インタフェース 251 * @see java.util.function.BiPredicate 252 */ 253 public void setPred( final BiPredicate<String,String> biPred ) { 254 this.biPred = biPred; 255 } 256 257 /** 258 * FileFilter インターフェースの accept( File ) メソッド。 259 * 260 * @og.rev 7.2.6.0 (2020/06/30) ディレクトリ処理を統一します。 261 * 262 * @param pathname ファイルオブジェクト 263 * @return true:処理対象 / false:処理非対象 264 * @see java.io.FileFilter#accept( File ) 265 */ 266 public boolean accept( final File pathname ) { 267// if( pathname.isFile() && !isDir || pathname.isDirectory() && isDir ) { 268 if( biPred != null ) { 269 final String org = pathname.getName() ; 270 final String name = igCase ? org.toLowerCase( Locale.JAPAN ) : org ; 271 for( int i=0; i<cnt; i++ ) { 272 if( biPred.test( name,tkens[i] ) ) { 273 return !rvse; // true ^ rvse 274 } 275 } 276 } 277 return rvse; // false ^ rvse 278 } 279 280 /** 281 * このオブジェクトの文字列表現を返します。 282 * 基本的にデバッグ目的に使用します。 283 * 284 * @return このクラスの文字列表現 285 * @og.rtnNotNull 286 */ 287 @Override 288 public String toString() { 289 final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE ) 290 .append( getClass() ).append( ':' ) 291 .append( " tokens=" ).append( Arrays.toString( tkens ) ) 292 .append( " reverse=" ).append( rvse ) 293 .append( " ignoreCase=" ).append( igCase ); 294// .append( " isDirectory=" ).append( isDir ); 295 296 return buf.toString(); 297 } 298 } 299 300 /** 301 * 内部判定フィルタ: 指定された接頭辞で始まる場合、スルー(選択)されます。 302 * 引数が null の場合は、追加しません。 303 * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。 304 * 305 * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。 306 * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。 307 * 308 * @param prefix 接頭辞("|"で複数指定可) 309 * @return 自分自身(this) 310 * @see java.lang.String#startsWith(String) 311 */ 312 public HybsFileFilter startsWith( final String prefix ) { 313 return startsWith( prefix, notEquals ); // notEquals 属性 314 } 315 316 /** 317 * 内部判定フィルタ: 指定された接頭辞で始まる場合、スルー(選択)されます。 318 * 引数が null の場合は、追加しません。 319 * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。 320 * reverse = true に設定すると、結果を反転させます。 321 * 322 * @og.rev 5.1.2.0 (2010/01/01) reverse属性の追加 323 * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。 324 * @og.rev 7.2.6.0 (2020/06/30) ディレクトリ処理を統一します。 325 * 326 * @param prefix 接頭辞("|"で複数指定可) 327 * @param reverse true:結果を反転する 328 * @return 自分自身(this) 329 * @see java.lang.String#startsWith(String) 330 */ 331 public HybsFileFilter startsWith( final String prefix,final boolean reverse ) { 332 if( prefix != null ) { 333// list.add( new StartsWithFilter( prefix,reverse,ignoreCase ) ); 334 final DefaultFilter filter = new DefaultFilter( prefix,reverse,ignoreCase ); 335 filter.setPred( (name,tkn) -> name.startsWith( tkn ) ); 336 listF.add( filter ); 337 } 338 return this; // 6.3.1.1 (2015/07/10) 339 } 340 341// /** 342// * 指定された接頭辞で始まる場合に選択される FileFilter インターフェースの実装内部クラスです。 343// * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。 344// * 345// * @og.rev 5.1.2.0 (2010/01/01) '|' 区切り文字で複数設定処理の追加、reverse属性の追加 346// * @og.rev 6.3.1.1 (2015/07/10) ignoreCase による 大文字小文字の判定方法指定 347// * @og.rev 7.2.6.0 (2020/06/30) ディレクトリ処理を統一します。 348// * 349// * @version 4.0 350// * @author Kazuhiko Hasegawa 351// * @since JDK5.0, 352// */ 353// private static final class StartsWithFilter implements FileFilter { 354// private final String[] pfix ; 355// private final int cnt ; 356// private final boolean rvse ; 357// private final boolean igCase ; // 6.3.1.1 (2015/07/10) 358// private final boolean isDir ; // 7.2.6.0 (2020/06/30) 359// 360// /** 361// * 接頭辞フィルターオブジェクトを作成します。 362// * 363// * @param prefix 接頭辞("|"で複数指定可) 364// * @param reverse true:結果を反転する 365// * @param ignoreCase 大文字/小文字の区別[true:しない/false:する] 366// * @param isDirectory ディレクトリに対して処理する場合は、true 367// */ 368//// StartsWithFilter( final String prefix,final boolean reverse,final boolean ignoreCase ) { 369// StartsWithFilter( final String prefix,final boolean reverse,final boolean ignoreCase,final boolean isDirectory ) { 370// rvse = reverse; 371// igCase = ignoreCase; // 6.3.1.1 (2015/07/10) 372// isDir = isDirectory; // 7.2.6.0 (2020/06/30) 373// 374// final StringTokenizer token = new StringTokenizer( prefix, "|" ); 375// cnt = token.countTokens(); 376// 377// pfix = new String[cnt]; 378// for( int i=0; i<cnt; i++ ) { 379// // 6.3.1.1 (2015/07/10) ignoreCase 対応 380// final String tkn = token.nextToken(); 381// pfix[i] = igCase ? tkn.toLowerCase( Locale.JAPAN ) : tkn ; 382// } 383// } 384// 385// /** 386// * FileFilter インターフェースの accept( File ) メソッド。 387// * 388// * @og.rev 7.2.6.0 (2020/06/30) ディレクトリ処理を統一します。 389// * 390// * @param pathname ファイルオブジェクト 391// * @return true:処理対象 / false:処理非対象 392// * @see java.io.FileFilter#accept( File ) 393// */ 394// public boolean accept( final File pathname ) { 395// return isDir ? check( pathname.getParentFile() ) : check( pathname ) ; 396// } 397// 398// /** 399// * FileFilter インターフェースの accept( File ) メソッド。 400// * 401// * @og.rev 7.2.6.0 (2020/06/30) ディレクトリ処理を統一します。 402// * 403// * @param pathname ファイルオブジェクト 404// * @return true:処理対象 / false:処理非対象 405// * @see java.io.FileFilter#accept( File ) 406// */ 407// private boolean check( final File pathname ) { 408// if( pathname != null ) { // 7.2.6.0 (2020/06/30) 409// // 6.3.1.1 (2015/07/10) ignoreCase 対応 410// final String org = pathname.getName() ; 411// final String name = igCase ? org.toLowerCase( Locale.JAPAN ) : org ; 412// for( int i=0; i<cnt; i++ ) { 413// if( name.startsWith( pfix[i] ) ) { 414// return !rvse; // true ^ rvse 415// } 416// } 417// } 418// return rvse; // false ^ rvse 419// } 420// 421// /** 422// * このオブジェクトの文字列表現を返します。 423// * 基本的にデバッグ目的に使用します。 424// * 425// * @return このクラスの文字列表現 426// * @og.rtnNotNull 427// */ 428// @Override 429// public String toString() { 430// final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE ) 431// .append( getClass() ).append( ':' ) 432// .append( " prefix=" ).append( Arrays.toString( pfix ) ) 433// .append( " reverse=" ).append( rvse ) 434// .append( " ignoreCase=" ).append( igCase ); 435// 436// return buf.toString(); 437// } 438// } 439 440 /** 441 * 内部判定フィルタ: 指定された接頭辞で始まるディレクトリの場合、スルー(選択)されます。 442 * 引数が null の場合は、追加しません。 443 * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。 444 * 445 * @og.rev 6.4.3.2 (2016/02/19) ディレクトリの先頭一致対応 446 * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。 447 * 448 * @param prefix 接頭辞("|"で複数指定可) 449 * @return 自分自身(this) 450 * @see java.lang.String#startsWith(String) 451 */ 452 public HybsFileFilter startsDir( final String prefix ) { 453 return startsDir( prefix, notEquals ); // notEquals 属性 454 } 455 456 /** 457 * 内部判定フィルタ: 指定された接頭辞で始まるディレクトリの場合、スルー(選択)されます。 458 * 引数が null の場合は、追加しません。 459 * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。 460 * reverse = true に設定すると、結果を反転させます。 461 * 462 * @og.rev 6.4.3.2 (2016/02/19) ディレクトリの先頭一致対応 463 * @og.rev 7.2.6.0 (2020/06/30) ディレクトリ処理を統一します。 464 * 465 * @param prefix 接頭辞("|"で複数指定可) 466 * @param reverse true:結果を反転する 467 * @return 自分自身(this) 468 * @see java.lang.String#startsWith(String) 469 */ 470 public HybsFileFilter startsDir( final String prefix,final boolean reverse ) { 471 if( prefix != null ) { 472// list.add( new StartsDirFilter( prefix,reverse,ignoreCase ) ); 473 final DefaultFilter filter = new DefaultFilter( prefix,reverse,ignoreCase ); 474 filter.setPred( (name,tkn) -> name.startsWith( tkn ) ); 475 listD.add( filter ); 476 } 477 return this; // 6.3.1.1 (2015/07/10) 478 } 479 480// /** 481// * 指定された接頭辞で始まるディレクトリが選択される FileFilter インターフェースの実装内部クラスです。 482// * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。 483// * 484// * @og.rev 6.4.3.2 (2016/02/19) ディレクトリの先頭一致対応 485// * @og.rev 7.2.6.0 (2020/06/30) ディレクトリ処理を統一します。 486// * 487// * @version 4.0 488// * @author Kazuhiko Hasegawa 489// * @since JDK5.0, 490// */ 491// private static final class StartsDirFilter implements FileFilter { 492// private final String[] pfix ; 493// private final int cnt ; 494// private final boolean rvse ; 495// private final boolean igCase ; // 6.3.1.1 (2015/07/10) 496// 497// /** 498// * 接頭辞フィルターオブジェクトを作成します。 499// * 500// * @param prefix 接頭辞("|"で複数指定可) 501// * @param reverse true:結果を反転する 502// * @param ignoreCase 大文字/小文字の区別[true:しない/false:する] 503// */ 504// StartsDirFilter( final String prefix,final boolean reverse,final boolean ignoreCase ) { 505// rvse = reverse; 506// igCase = ignoreCase; // 6.3.1.1 (2015/07/10) 507// 508// final StringTokenizer token = new StringTokenizer( prefix, "|" ); 509// cnt = token.countTokens(); 510// 511// pfix = new String[cnt]; 512// for( int i=0; i<cnt; i++ ) { 513// // 6.3.1.1 (2015/07/10) ignoreCase 対応 514// final String tkn = token.nextToken(); 515// pfix[i] = igCase ? tkn.toLowerCase( Locale.JAPAN ) : tkn ; 516// } 517// } 518// 519// /** 520// * FileFilter インターフェースの accept( File ) メソッド。 521// * 522// * @param pathname ファイルオブジェクト 523// * @return true:処理対象 / false:処理非対象 524// * @see java.io.FileFilter#accept( File ) 525// */ 526// public boolean accept( final File pathname ) { 527// final File parent = pathname.getParentFile(); 528// if( parent != null && parent.isDirectory() ) { // まず、ディレクトリのはず 529// final String org = parent.getName(); 530// final String name = igCase ? org.toLowerCase( Locale.JAPAN ) : org ; 531// for( int i=0; i<cnt; i++ ) { 532// if( name.startsWith( pfix[i] ) ) { 533// return !rvse; 534// } 535// } 536// } 537// return rvse; 538// } 539// 540// /** 541// * このオブジェクトの文字列表現を返します。 542// * 基本的にデバッグ目的に使用します。 543// * 544// * @return このクラスの文字列表現 545// * @og.rtnNotNull 546// */ 547// @Override 548// public String toString() { 549// final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE ) 550// .append( getClass() ).append( ':' ) 551// .append( " prefix=" ).append( Arrays.toString( pfix ) ) 552// .append( " reverse=" ).append( rvse ) 553// .append( " ignoreCase=" ).append( igCase ); 554// 555// return buf.toString(); 556// } 557// } 558 559 /** 560 * 内部判定フィルタ: 指定された接頭辞で終わる場合、スルー(選択)されます。 561 * 引数が null の場合は、追加しません。 562 * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。 563 * 564 * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。 565 * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。 566 * 567 * @param suffix 接尾辞("|"で複数指定可) 568 * @return 自分自身(this) 569 * @see java.lang.String#endsWith(String) 570 */ 571 public HybsFileFilter endsWith( final String suffix ) { 572 return endsWith( suffix, notEquals ); // notEquals 属性 573 } 574 575 /** 576 * 内部判定フィルタ: 指定された接頭辞で終わる場合、スルー(選択)されます。 577 * 引数が null の場合は、追加しません。 578 * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。 579 * reverse = true に設定すると、結果を反転させます。 580 * 581 * @og.rev 5.1.2.0 (2010/01/01) reverse属性の追加 582 * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。 583 * @og.rev 7.2.6.0 (2020/06/30) ディレクトリ処理を統一します。 584 * 585 * @param suffix 接尾辞("|"で複数指定可) 586 * @param reverse true:結果を反転する 587 * @return 自分自身(this) 588 * @see java.lang.String#endsWith(String) 589 */ 590 public HybsFileFilter endsWith( final String suffix,final boolean reverse ) { 591 if( suffix != null ) { 592// list.add( new EndsWithFilter( suffix,reverse,ignoreCase ) ); 593 final DefaultFilter filter = new DefaultFilter( suffix,reverse,ignoreCase ); 594 filter.setPred( (name,tkn) -> name.endsWith( tkn ) ); 595 listF.add( filter ); 596 } 597 return this; // 6.3.1.1 (2015/07/10) 598 } 599 600// /** 601// * 指定された接頭辞で終わる場合に選択される FileFilter インターフェースの実装内部クラスです。 602// * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。 603// * 604// * @og.rev 5.1.2.0 (2010/01/01) '|' 区切り文字で複数設定処理の追加、reverse属性の追加 605// * @og.rev 6.3.1.1 (2015/07/10) ignoreCase による 大文字小文字の判定方法指定 606// * @og.rev 7.2.6.0 (2020/06/30) ディレクトリ処理を統一します。 607// * 608// * @version 4.0 609// * @author Kazuhiko Hasegawa 610// * @since JDK5.0, 611// */ 612// private static final class EndsWithFilter implements FileFilter { 613// private final String[] sfix ; 614// private final int cnt ; 615// private final boolean rvse ; 616// private final boolean igCase ; // 6.3.1.1 (2015/07/10) 617// 618// /** 619// * 接頭辞フィルターオブジェクトを作成します。 620// * 621// * @param suffix 接頭辞("|"で複数指定可) 622// * @param reverse true:結果を反転する 623// * @param ignoreCase 大文字/小文字の区別[true:しない/false:する] 624// */ 625// EndsWithFilter( final String suffix,final boolean reverse,final boolean ignoreCase ) { 626// rvse = reverse; 627// igCase = ignoreCase; // 6.3.1.1 (2015/07/10) 628// 629// final StringTokenizer token = new StringTokenizer( suffix, "|" ); 630// cnt = token.countTokens(); 631// 632// sfix = new String[cnt]; 633// for( int i=0; i<cnt; i++ ) { 634// // 6.3.1.1 (2015/07/10) ignoreCase 対応 635// final String tkn = token.nextToken(); 636// sfix[i] = igCase ? tkn.toLowerCase( Locale.JAPAN ) : tkn ; 637// } 638// } 639// 640// /** 641// * FileFilter インターフェースの accept( File ) メソッド。 642// * 643// * @param pathname ファイルオブジェクト 644// * @return true:処理対象 / false:処理非対象 645// * @see java.io.FileFilter#accept( File ) 646// */ 647// public boolean accept( final File pathname ) { 648// // 6.3.1.1 (2015/07/10) ignoreCase 対応 649// final String org = pathname.getName() ; 650// final String name = igCase ? org.toLowerCase( Locale.JAPAN ) : org ; 651// for( int i=0; i<cnt; i++ ) { 652// if( name.endsWith( sfix[i] ) ) { 653// return !rvse; 654// } 655// } 656// return rvse; 657// } 658// 659// /** 660// * このオブジェクトの文字列表現を返します。 661// * 基本的にデバッグ目的に使用します。 662// * 663// * @return このクラスの文字列表現 664// * @og.rtnNotNull 665// */ 666// @Override 667// public String toString() { 668// final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE ) 669// .append( getClass() ).append( ':' ) 670// .append( " suffix=" ).append( Arrays.toString( sfix ) ) 671// .append( " reverse=" ).append( rvse ) 672// .append( " ignoreCase=" ).append( igCase ); 673// 674// return buf.toString(); 675// } 676// } 677 678 /** 679 * 内部判定フィルタ: 指定された文字列がファイル名に含まれる場合、スルー(選択)されます。 680 * 引数が null の場合は、追加しません。 681 * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。 682 * 683 * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。 684 * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。 685 * 686 * @param str 指定の部分文字列("|"で複数指定可) 687 * @return 自分自身(this) 688 */ 689 public HybsFileFilter instr( final String str ) { 690 return instr( str, notEquals ); // notEquals 属性 691 } 692 693 /** 694 * 内部判定フィルタ: 指定された文字列がファイル名に含まれる場合、スルー(選択)されます。 695 * 引数が null の場合は、追加しません。 696 * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。 697 * reverse = true に設定すると、結果を反転させます。 698 * 699 * @og.rev 5.1.2.0 (2010/01/01) reverse属性の追加 700 * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。 701 * @og.rev 7.2.6.0 (2020/06/30) ディレクトリ処理を統一します。 702 * 703 * @param str 指定の部分文字列("|"で複数指定可) 704 * @param reverse 結果を反転させるかどうか(true:反転) 705 * @return 自分自身(this) 706 */ 707 public HybsFileFilter instr( final String str,final boolean reverse ) { 708 if( str != null ) { 709// list.add( new InstrFilter( str,reverse,ignoreCase ) ); 710 final DefaultFilter filter = new DefaultFilter( str,reverse,ignoreCase ); 711 filter.setPred( (name,tkn) -> name.contains( tkn ) ); 712 listF.add( filter ); 713 } 714 return this; // 6.3.1.1 (2015/07/10) 715 } 716 717 /** 718 * 内部判定フィルタ: 指定された文字列がフォルダ名に含まれる場合、スルー(選択)されます。 719 * 引数が null の場合は、追加しません。 720 * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。 721 * 722 * @og.rev 7.2.6.0 (2020/06/30) ディレクトリ処理を統一します。 723 * 724 * @param str 指定の部分文字列("|"で複数指定可) 725 * @return 自分自身(this) 726 */ 727 public HybsFileFilter instrDir( final String str ) { 728 return instrDir( str, notEquals ); // notEquals 属性 729 } 730 731 /** 732 * 内部判定フィルタ: 指定された文字列がフォルダ名に含まれる場合、スルー(選択)されます。 733 * 引数が null の場合は、追加しません。 734 * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。 735 * reverse = true に設定すると、結果を反転させます。 736 * 737 * @og.rev 7.2.6.0 (2020/06/30) ディレクトリ処理を統一します。 738 * 739 * @param str 指定の部分文字列("|"で複数指定可) 740 * @param reverse 結果を反転させるかどうか(true:反転) 741 * @return 自分自身(this) 742 */ 743 public HybsFileFilter instrDir( final String str,final boolean reverse ) { 744 if( str != null ) { 745// list.add( new InstrFilter( str,reverse,ignoreCase ) ); 746 final DefaultFilter filter = new DefaultFilter( str,reverse,ignoreCase ); 747 filter.setPred( (name,tkn) -> name.contains( tkn ) ); 748 listD.add( filter ); 749 } 750 return this; // 6.3.1.1 (2015/07/10) 751 } 752 753// /** 754// * 指定された文字列がファイル名に含まれる場合に選択される FileFilter インターフェースの実装内部クラスです。 755// * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。 756// * 757// * @og.rev 5.1.2.0 (2010/01/01) '|' 区切り文字で複数設定処理の追加、reverse属性の追加 758// * @og.rev 6.3.1.1 (2015/07/10) ignoreCase による 大文字小文字の判定方法指定 759// * @og.rev 7.2.6.0 (2020/06/30) ディレクトリ処理を統一します。 760// * 761// * @version 4.0 762// * @author Kazuhiko Hasegawa 763// * @since JDK5.0, 764// */ 765// private static final class InstrFilter implements FileFilter { 766// private final String[] instr ; 767// private final int cnt ; 768// private final boolean rvse ; 769// private final boolean igCase ; // 6.3.1.1 (2015/07/10) 770// 771// /** 772// * 文字列包含フィルターオブジェクトを作成します。 773// * 774// * @param str 包含を判定する文字列("|"で複数指定可) 775// * @param reverse true:結果を反転する 776// * @param ignoreCase 大文字/小文字の区別[true:しない/false:する] 777// */ 778// InstrFilter( final String str,final boolean reverse,final boolean ignoreCase ) { 779// rvse = reverse; 780// igCase = ignoreCase; // 6.3.1.1 (2015/07/10) 781// 782// final StringTokenizer token = new StringTokenizer( str, "|" ); 783// cnt = token.countTokens(); 784// 785// instr = new String[cnt]; 786// for( int i=0; i<cnt; i++ ) { 787// // 6.3.1.1 (2015/07/10) ignoreCase 対応 788// final String tkn = token.nextToken(); 789// instr[i] = igCase ? tkn.toLowerCase( Locale.JAPAN ) : tkn ; 790// } 791// } 792// 793// /** 794// * FileFilter インターフェースの accept( File ) メソッド。 795// * 796// * @param pathname ファイルオブジェクト 797// * @return true:処理対象 / false:処理非対象 798// * @see java.io.FileFilter#accept( File ) 799// */ 800// public boolean accept( final File pathname ) { 801// // 6.3.1.1 (2015/07/10) ignoreCase 対応 802// final String org = pathname.getName() ; 803// final String name = igCase ? org.toLowerCase( Locale.JAPAN ) : org ; 804// for( int i=0; i<cnt; i++ ) { 805// if( name.indexOf( instr[i] ) >= 0 ) { 806// return !rvse; 807// } 808// } 809// return rvse; 810// } 811// 812// /** 813// * このオブジェクトの文字列表現を返します。 814// * 基本的にデバッグ目的に使用します。 815// * 816// * @return このクラスの文字列表現 817// * @og.rtnNotNull 818// */ 819// @Override 820// public String toString() { 821// final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE ) 822// .append( getClass() ).append( ':' ) 823// .append( " instr=" ).append( Arrays.toString( instr ) ) 824// .append( " reverse=" ).append( rvse ) 825// .append( " ignoreCase=" ).append( igCase ); 826// 827// return buf.toString(); 828// } 829// } 830 831 /** 832 * 内部判定フィルタ: ファイル名が一致する場合、スルー(選択)されます。 833 * 引数が null の場合は、追加しません。 834 * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。 835 * 836 * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。 837 * 838 * @param str ファイル名文字列("|"で複数指定可) 839 * @return 自分自身(this) 840 */ 841 public HybsFileFilter fileEquals( final String str ) { 842 return fileEquals( str, false ); // 反転しない 843 } 844 845 /** 846 * 内部判定フィルタ: ファイル名が一致する場合、スルー(選択)されます。 847 * 引数が null の場合は、追加しません。 848 * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。 849 * reverse = true に設定すると、結果を反転させます。 850 * 851 * @og.rev 5.1.2.0 (2010/01/01) reverse属性の追加 852 * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。 853 * @og.rev 7.2.6.0 (2020/06/30) ディレクトリ処理を統一します。 854 * 855 * @param str ファイル名文字列("|"で複数指定可) 856 * @param reverse true:結果を反転する 857 * @return 自分自身(this) 858 */ 859 public HybsFileFilter fileEquals( final String str,final boolean reverse ) { 860 if( str != null ) { 861// list.add( new EqualsFilter( str,reverse,ignoreCase ) ); 862 final DefaultFilter filter = new DefaultFilter( str,reverse,ignoreCase ); 863 filter.setPred( (name,tkn) -> name.equals( tkn ) ); 864 listF.add( filter ); 865 } 866 return this; // 6.3.1.1 (2015/07/10) 867 } 868 869// /** 870// * ファイル名が一致する場合に選択される FileFilter インターフェースの実装内部クラスです。 871// * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。 872// * 873// * @og.rev 5.1.2.0 (2010/01/01) '|' 区切り文字で複数設定処理の追加、reverse属性の追加 874// * @og.rev 6.3.1.1 (2015/07/10) ignoreCase による 大文字小文字の判定方法指定 875// * @og.rev 7.2.6.0 (2020/06/30) ディレクトリ処理を統一します。 876// * 877// * @version 4.0 878// * @author Kazuhiko Hasegawa 879// * @since JDK5.0, 880// */ 881// private static final class EqualsFilter implements FileFilter { 882// private final String[] eqstr ; 883// private final int cnt ; 884// private final boolean rvse ; 885// private final boolean igCase ; // 6.3.1.1 (2015/07/10) 886// 887// /** 888// * ファイル名一致フィルターオブジェクトを作成します。 889// * 890// * @param str ファイル名一致判定用文字列("|"で複数指定可) 891// * @param reverse true:結果を反転する 892// * @param ignoreCase 大文字/小文字の区別[true:しない/false:する] 893// */ 894// EqualsFilter( final String str,final boolean reverse,final boolean ignoreCase ) { 895// rvse = reverse; 896// igCase = ignoreCase; // 6.3.1.1 (2015/07/10) 897// 898// final StringTokenizer token = new StringTokenizer( str, "|" ); 899// cnt = token.countTokens(); 900// 901// eqstr = new String[cnt]; 902// for( int i=0; i<cnt; i++ ) { 903// eqstr[i] = token.nextToken(); 904// } 905// } 906// 907// /** 908// * FileFilter インターフェースの accept( File ) メソッド。 909// * 910// * @param pathname ファイルオブジェクト 911// * @return true:処理対象 / false:処理非対象 912// * @see java.io.FileFilter#accept( File ) 913// */ 914// public boolean accept( final File pathname ) { 915// // 6.3.1.1 (2015/07/10) ignoreCase 対応 916// final String name = pathname.getName() ; 917// for( int i=0; i<cnt; i++ ) { 918// if( ( igCase ? name.equalsIgnoreCase( eqstr[i] ) : name.equals( eqstr[i] ) ) ) { 919// return !rvse; 920// } 921// } 922// return rvse; 923// } 924// 925// /** 926// * このオブジェクトの文字列表現を返します。 927// * 基本的にデバッグ目的に使用します。 928// * 929// * @return このクラスの文字列表現 930// * @og.rtnNotNull 931// */ 932// @Override 933// public String toString() { 934// final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE ) 935// .append( getClass() ).append( ':' ) 936// .append( " eqstr=" ).append( Arrays.toString( eqstr ) ) 937// .append( " reverse=" ).append( rvse ) 938// .append( " ignoreCase=" ).append( igCase ); 939// 940// return buf.toString(); 941// } 942// } 943 944 /** 945 * 内部判定フィルタ: ファイル名が、指定された 946 * <a href="/java/api14/api/java/util/regex/Pattern.html#sum">正規表現</a> 947 * と一致する場合、スルー(選択)されます 948 * 大文字小文字の区別は、ignoreCase で切り替えます。 949 * ignoreCase ? Pattern.compile( str,Pattern.CASE_INSENSITIVE ) : Pattern.compile( str ) ; 950 * pattern.matcher( pathname.getName() ).find() == true と同じ結果が得られます。 951 * 引数が null の場合は、追加しません。 952 * 953 * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。 954 * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。 955 * 956 * @param str ファイル名文字列(正規表現) 957 * @return 自分自身(this) 958 * @see java.util.regex.Pattern#compile(String,int) 959 * @see java.util.regex.Matcher#find() 960 */ 961 public HybsFileFilter matches( final String str ) { 962 return matches( str, notEquals ); // notEquals 属性 963 } 964 965 /** 966 * 内部判定フィルタ: ファイル名が、指定された 967 * <a href="/java/api14/api/java/util/regex/Pattern.html#sum">正規表現</a> 968 * と一致する場合、スルー(選択)されます 969 * 大文字小文字の区別は、ignoreCase で切り替えます。 970 * ignoreCase ? Pattern.compile( str,Pattern.CASE_INSENSITIVE ) : Pattern.compile( str ) ; 971 * pattern.matcher( pathname.getName() ).find() == true と同じ結果が得られます。 972 * 引数が null の場合は、追加しません。 973 * reverse = true に設定すると、結果を反転させます。 974 * 975 * @og.rev 5.1.2.0 (2010/01/01) reverse属性の追加 976 * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。 977 * @og.rev 7.2.6.0 (2020/06/30) ディレクトリ処理を統一します。 978 * 979 * @param str ファイル名文字列(正規表現) 980 * @param reverse true:結果を反転する 981 * @return 自分自身(this) 982 * @see java.util.regex.Pattern#compile(String,int) 983 * @see java.util.regex.Matcher#find() 984 */ 985 public HybsFileFilter matches( final String str,final boolean reverse ) { 986 if( str != null ) { 987// list.add( new MatchesFilter( str,reverse,ignoreCase ) ); 988 989 final Pattern pattern = ignoreCase 990 ? Pattern.compile( str,Pattern.CASE_INSENSITIVE ) 991 : Pattern.compile( str ) ; 992 // フォルダは、無条件でOK 993// list.add( file -> file.isDirectory() || pattern.matcher( file.getName() ).find() ^ reverse ); 994 listF.add( file -> pattern.matcher( file.getName() ).find() ^ reverse ); 995 } 996 997 return this; // 6.3.1.1 (2015/07/10) 998 } 999 1000 /** 1001 * 内部判定フィルタ: フォルダが、指定された 1002 * <a href="/java/api14/api/java/util/regex/Pattern.html#sum">正規表現</a> 1003 * と一致する場合、スルー(選択)されます 1004 * 大文字小文字の区別は、ignoreCase で切り替えます。 1005 * ignoreCase ? Pattern.compile( str,Pattern.CASE_INSENSITIVE ) : Pattern.compile( str ) ; 1006 * pattern.matcher( pathname.getName() ).find() == true と同じ結果が得られます。 1007 * 引数が null の場合は、追加しません。 1008 * 1009 * @og.rev 7.2.6.0 (2020/06/30) ディレクトリ処理を統一します。 1010 * 1011 * @param str ファイル名文字列(正規表現) 1012 * @return 自分自身(this) 1013 * @see java.util.regex.Pattern#compile(String,int) 1014 * @see java.util.regex.Matcher#find() 1015 */ 1016 public HybsFileFilter matchDir( final String str ) { 1017 return matchDir( str, notEquals ); // notEquals 属性 1018 } 1019 1020 /** 1021 * 内部判定フィルタ: フォルダが、指定された 1022 * <a href="/java/api14/api/java/util/regex/Pattern.html#sum">正規表現</a> 1023 * と一致する場合、スルー(選択)されます 1024 * 大文字小文字の区別は、ignoreCase で切り替えます。 1025 * ignoreCase ? Pattern.compile( str,Pattern.CASE_INSENSITIVE ) : Pattern.compile( str ) ; 1026 * pattern.matcher( pathname.getName() ).find() == true と同じ結果が得られます。 1027 * 引数が null の場合は、追加しません。 1028 * reverse = true に設定すると、結果を反転させます。 1029 * 1030 * @og.rev 7.2.6.0 (2020/06/30) ディレクトリ処理を統一します。 1031 * 1032 * @param str ファイル名文字列(正規表現) 1033 * @param reverse true:結果を反転する 1034 * @return 自分自身(this) 1035 * @see java.util.regex.Pattern#compile(String,int) 1036 * @see java.util.regex.Matcher#find() 1037 */ 1038 public HybsFileFilter matchDir( final String str,final boolean reverse ) { 1039 if( str != null ) { 1040// list.add( new MatchesFilter( str,reverse,ignoreCase,true ) ); 1041 1042 final Pattern pattern = ignoreCase 1043 ? Pattern.compile( str,Pattern.CASE_INSENSITIVE ) 1044 : Pattern.compile( str ) ; 1045 // ファイルは、無条件でOK 1046// list.add( file -> file.isFile() || pattern.matcher( file.getName() ).find() ^ reverse ); 1047 listD.add( file -> pattern.matcher( file.getName() ).find() ^ reverse ); 1048 } 1049 return this; // 6.3.1.1 (2015/07/10) 1050 } 1051 1052// /** 1053// * ファイル名が、指定された正規表現と一致する場合に選択される FileFilter インターフェースの実装内部クラスです。 1054// * 1055// * @og.rev 5.1.2.0 (2010/01/01) reverse属性の追加 1056// * @og.rev 6.3.1.1 (2015/07/10) ignoreCase による 大文字小文字の判定方法指定 1057// * @og.rev 7.2.6.0 (2020/06/30) ディレクトリ処理を統一します。 1058// * 1059// * @version 4.0 1060// * @author Kazuhiko Hasegawa 1061// * @since JDK5.0, 1062// */ 1063// private static final class MatchesFilter implements FileFilter { 1064// private final Pattern pattern ; 1065// private final boolean rvse ; 1066// private final boolean isDir ; // 7.2.6.0 (2020/06/30) 1067// 1068// /** 1069// * 正規表現一致フィルターオブジェクトを作成します。 1070// * 大文字小文字の区別は、ignoreCase で切り替えます。 1071// * ignoreCase ? Pattern.compile( str,Pattern.CASE_INSENSITIVE ) : Pattern.compile( str ) ; 1072// * 1073// * @param str 正規表現一致 1074// * @param reverse true:結果を反転する 1075// * @param ignoreCase 大文字/小文字の区別[true:しない/false:する] 1076// * @param isDirectory ディレクトリに対して処理する場合は、true 1077// */ 1078//// MatchesFilter( final String str,final boolean reverse,final boolean ignoreCase ) { 1079// MatchesFilter( final String str,final boolean reverse,final boolean ignoreCase,final boolean isDirectory ) { 1080// pattern = ignoreCase ? Pattern.compile( str,Pattern.CASE_INSENSITIVE ) : Pattern.compile( str ) ; 1081// rvse = reverse; 1082// isDir = isDirectory; // 7.2.6.0 (2020/06/30) 1083// } 1084// 1085// /** 1086// * FileFilter インターフェースの accept( File ) メソッド。 1087// * 1088// * @param pathname ファイルオブジェクト 1089// * @return true:処理対象 / false:処理非対象 1090// * @see java.io.FileFilter#accept( File ) 1091// */ 1092// public boolean accept( final File pathname ) { 1093// return isDir ? check( pathname.getParentFile() ) : check( pathname ) ; 1094// 1095//// final Matcher match = pattern.matcher( pathname.getName() ); 1096//// // 6.4.1.1 (2016/01/16) PMD refactoring. A method should have only one exit point, and that should be the last statement in the method 1097//// // 排他的論理輪 1098//// return match.find() ^ rvse ; 1099// } 1100// 1101// /** 1102// * FileFilter インターフェースの accept( File ) メソッド。 1103// * 1104// * @param pathname ファイルオブジェクト 1105// * @return true:処理対象 / false:処理非対象 1106// * @see java.io.FileFilter#accept( File ) 1107// */ 1108// private boolean check( final File pathname ) { 1109// if( pathname != null ) { // 7.2.6.0 (2020/06/30) 1110// final Matcher match = pattern.matcher( pathname.getName() ); 1111// // 6.4.1.1 (2016/01/16) PMD refactoring. A method should have only one exit point, and that should be the last statement in the method 1112// // 排他的論理輪 1113// return match.find() ^ rvse ; 1114// } 1115// return rvse; // false ^ rvse 1116// } 1117// 1118// /** 1119// * このオブジェクトの文字列表現を返します。 1120// * 基本的にデバッグ目的に使用します。 1121// * 1122// * @return このクラスの文字列表現 1123// * @og.rtnNotNull 1124// */ 1125// @Override 1126// public String toString() { 1127// final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE ) 1128// .append( getClass() ).append( ':' ) 1129// .append( " pattern=" ).append( pattern ) 1130// .append( " reverse=" ).append( rvse ); 1131// 1132// return buf.toString(); 1133// } 1134// } 1135 1136 /** 1137 * 内部判定フィルタ: 指定のタイムスタンプ以後に変更されている場合、スルー(選択)されます。 1138 * ディレクトリは、ここの判定では無視します。(必ず true を返します) 1139 * 日付けの指定に、YYYYMMDD 形式の 8文字数字文字列以外に、 1140 * TODAY や YESTERDAY なども使用できます。 1141 * TODAY は、実行日の 00:00:00 を基準時刻とし、YESTERDAY は、その前日になります。 1142 * 引数が null の場合は、追加しません。 1143 * 1144 * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。 1145 * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。 1146 * 1147 * @param modify 時刻を表す long 値(ミリ秒単位) 1148 * @return 自分自身(this) 1149 */ 1150 public HybsFileFilter lastModified( final String modify ) { 1151 return lastModified( modify, notEquals ); // notEquals 属性 1152 } 1153 1154 /** 1155 * 内部判定フィルタ: 指定のタイムスタンプ以後に変更されている場合、スルー(選択)されます。 1156 * ディレクトリは、ここの判定では無視します。(必ず true を返します) 1157 * 日付けの指定に、YYYYMMDD 形式の 8文字数字文字列以外に、 1158 * TODAY や YESTERDAY なども使用できます。 1159 * TODAY は、実行日の 00:00:00 を基準時刻とし、YESTERDAY は、その前日になります。 1160 * 引数が null の場合は、追加しません。 1161 * 1162 * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。 1163 * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。 1164 * @og.rev 7.2.6.0 (2020/06/30) ディレクトリ処理を統一します。 1165 * 1166 * @param modify 時刻を表す long 値(ミリ秒単位) 1167 * @return 自分自身(this) 1168 * @param reverse true:結果を反転する 1169 */ 1170 public HybsFileFilter lastModified( final String modify,final boolean reverse ) { 1171 if( modify != null ) { 1172// list.add( new ModifyFileFilter( modify,reverse ) ); 1173 1174 final long time = modifyTime( modify ); 1175 // 反転は日付判定の箇所のみ。 6.9.7.0 (2018/05/14) PMD Useless parentheses. 1176// list.add( file -> file.isDirectory() || file.lastModified() >= time ^ reverse ); 1177 listF.add( file -> file.lastModified() >= time ^ reverse ); 1178 } 1179 return this; // 6.3.1.1 (2015/07/10) 1180 } 1181 1182 /** 1183 * 日付けの指定に対するミリ秒で表される現在の時間を返します。 1184 * 1185 * 日付けの指定方法には、実日付け(YYYYMMDD形式 例:20040323)と 1186 * 仮想日付け(TODAY,YESTERDAY など)が指定できます。 1187 * 1188 * YYYYMMDD YYYYMMDD形式の指定日の 00:00:00 を基準時刻 1189 * TODAY 実行日の 00:00:00 を基準時刻 1190 * YESTERDAY 実行日前日の 00:00:00 を基準時刻 1191 * LAST_WEEK 実行日の先週(7日前) 00:00:00 を基準時刻 1192 * MONTH 実行月の 1日 00:00:00 を基準時刻 1193 * LAST_MONTH 実行前月の 同日 00:00:00 を基準時刻 1194 * LAST_YEAR 実行前年の 同月同日 00:00:00 を基準時刻 1195 * 1196 * @og.rev 7.2.6.0 (2020/06/30) ディレクトリ処理を統一します。 1197 * 1198 * @param value 指定日付け 1199 * @return ミリ秒で表される現在の時間 1200 */ 1201 private static long modifyTime( final String value ) { 1202 // 6.4.1.1 (2016/01/16) PMD refactoring. Avoid if (x != y) ..; else ..; 1203 if( value == null ) { 1204 throw new OgRuntimeException( "ModifyTime Error! modify valus is not null" ); 1205 } 1206 1207 final Calendar cal = Calendar.getInstance(); 1208 1209 cal.set( Calendar.HOUR_OF_DAY, 0 ); // 5.3.5.0 (2011/05/01) 時間の解決規則が適用されるため、「時」だけは、setメソッドで 0 にセットする。 1210 cal.clear( Calendar.MINUTE ); 1211 cal.clear( Calendar.SECOND ); 1212 cal.clear( Calendar.MILLISECOND ); 1213 1214 if( "YESTERDAY".equalsIgnoreCase( value ) ) { 1215 cal.add( Calendar.DATE, -1 ); 1216 } 1217 else if( "LAST_WEEK".equalsIgnoreCase( value ) ) { 1218 cal.add( Calendar.DATE, -7 ); 1219 } 1220 else if( "MONTH".equalsIgnoreCase( value ) ) { 1221 cal.set( Calendar.DATE, 1 ); 1222 } 1223 else if( "LAST_MONTH".equalsIgnoreCase( value ) ) { 1224 cal.add( Calendar.MONTH, -1 ); 1225 } 1226 else if( "LAST_YEAR".equalsIgnoreCase( value ) ) { 1227 cal.add( Calendar.YEAR, -1 ); 1228 } 1229 else if( value.length() == 8 ) { 1230 cal.set( Integer.parseInt( value.substring( 0,4 ) ) , 1231 Integer.parseInt( value.substring( 4,6 ) ) - 1, 1232 Integer.parseInt( value.substring( 6,8 ) ) ); 1233 } 1234 else if( ! "TODAY".equalsIgnoreCase( value ) ) { 1235 final String errMsg = "ModifyFileFilter Error! modify Format [" + value + "]" + CR 1236 + "日付けの指定方法には、実日付け(YYYYMMDD形式 例:20040323)と" + CR 1237 + "仮想日付け(TODAY,YESTERDAY など)が指定できます。" + CR 1238 + " YYYYMMDD YYYYMMDD形式の指定日の 00:00:00 を基準時刻" + CR 1239 + " TODAY 実行日の 00:00:00 を基準時刻" + CR 1240 + " YESTERDAY 実行日前日の 00:00:00 を基準時刻" + CR 1241 + " LAST_WEEK 実行日の先週(7日前) 00:00:00 を基準時刻" + CR 1242 + " MONTH 実行月の 1日 00:00:00 を基準時刻" + CR 1243 + " LAST_MONTH 実行前月の 同日 00:00:00 を基準時刻" + CR 1244 + " LAST_YEAR 実行前年の 同月同日 00:00:00 を基準時刻" + CR ; 1245 throw new OgRuntimeException( errMsg ); 1246 } 1247 return cal.getTimeInMillis() ; 1248 } 1249 1250// /** 1251// * ModifyFileFilter.java は、最終変更日付けのフィルタークラスです。 1252// * 1253// * FileFilter インターフェースを継承し、コンストラクタで指定の日付けよりも 1254// * 最終変更日付け が新しいファイルを、選択します。 1255// * このクラスでは、ディレクトリは、変更日付けに無関係に選択します。 1256// * 1257// * 日付けの指定に、YYYYMMDD 形式の 8文字数字文字列以外に、TODAY や YESTERDAY なども使用できます。 1258// * TODAY は、実行日の 00:00:00 を基準時刻とし、YESTERDAY は、その前日になります。 1259// * バッチ処理等で、前日分の再編成や、先月分を再編成する場合に、実日付けを指定せずに 1260// * 使用できます。 1261// * 1262// * この実装は同期化されません。 1263// * 1264// * @version 4.0 1265// * @author Kazuhiko Hasegawa 1266// * @since JDK5.0, 1267// */ 1268// private static final class ModifyFileFilter implements FileFilter { 1269// private final long modify ; 1270// private final boolean rvse ; // 6.8.0.0 (2017/06/02) 1271// 1272// /** 1273// * コンストラクター 1274// * 1275// * 日付けの指定方法には、実日付け(YYYYMMDD形式 例:20040323)と 1276// * 仮想日付け(TODAY,YESTERDAY など)が指定できます。 1277// * 1278// * YYYYMMDD YYYYMMDD形式の指定日の 00:00:00 を基準時刻 1279// * TODAY 実行日の 00:00:00 を基準時刻 1280// * YESTERDAY 実行日前日の 00:00:00 を基準時刻 1281// * LAST_WEEK 実行日の先週(7日前) 00:00:00 を基準時刻 1282// * MONTH 実行月の 1日 00:00:00 を基準時刻 1283// * LAST_MONTH 実行前月の 同日 00:00:00 を基準時刻 1284// * LAST_YEAR 実行前年の 同月同日 00:00:00 を基準時刻 1285// * 1286// * @og.rev 5.3.5.0 (2011/05/01) 「時」のクリアミスの修正 1287// * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。 1288// * 1289// * @param value 指定日付け 1290// * @param reverse true:結果を反転する 1291// */ 1292// ModifyFileFilter( final String value , final boolean reverse ) { 1293// rvse = reverse; // 6.8.0.0 (2017/06/02) 1294// 1295// // 6.4.1.1 (2016/01/16) PMD refactoring. Avoid if (x != y) ..; else ..; 1296// if( value == null ) { 1297// throw new OgRuntimeException( "ModifyFileFilter Error! modify valus is not null" ); 1298// } 1299// 1300// // if( value != null ) { 1301// final Calendar cal = Calendar.getInstance(); 1302// 1303// cal.set( Calendar.HOUR_OF_DAY, 0 ); // 5.3.5.0 (2011/05/01) 時間の解決規則が適用されるため、「時」だけは、setメソッドで 0 にセットする。 1304// cal.clear( Calendar.MINUTE ); 1305// cal.clear( Calendar.SECOND ); 1306// cal.clear( Calendar.MILLISECOND ); 1307// 1308// if( "YESTERDAY".equalsIgnoreCase( value ) ) { 1309// cal.add( Calendar.DATE, -1 ); 1310// } 1311// else if( "LAST_WEEK".equalsIgnoreCase( value ) ) { 1312// cal.add( Calendar.DATE, -7 ); 1313// } 1314// else if( "MONTH".equalsIgnoreCase( value ) ) { 1315// cal.set( Calendar.DATE, 1 ); 1316// } 1317// else if( "LAST_MONTH".equalsIgnoreCase( value ) ) { 1318// cal.add( Calendar.MONTH, -1 ); 1319// } 1320// else if( "LAST_YEAR".equalsIgnoreCase( value ) ) { 1321// cal.add( Calendar.YEAR, -1 ); 1322// } 1323// else if( value.length() == 8 ) { 1324// cal.set( Integer.parseInt( value.substring( 0,4 ) ) , 1325// Integer.parseInt( value.substring( 4,6 ) ) - 1, 1326// Integer.parseInt( value.substring( 6,8 ) ) ); 1327// } 1328// else if( ! "TODAY".equalsIgnoreCase( value ) ) { 1329// final String errMsg = "ModifyFileFilter Error! modify Format [" + value + "]" + CR 1330// + "日付けの指定方法には、実日付け(YYYYMMDD形式 例:20040323)と" + CR 1331// + "仮想日付け(TODAY,YESTERDAY など)が指定できます。" + CR 1332// + " YYYYMMDD YYYYMMDD形式の指定日の 00:00:00 を基準時刻" + CR 1333// + " TODAY 実行日の 00:00:00 を基準時刻" + CR 1334// + " YESTERDAY 実行日前日の 00:00:00 を基準時刻" + CR 1335// + " LAST_WEEK 実行日の先週(7日前) 00:00:00 を基準時刻" + CR 1336// + " MONTH 実行月の 1日 00:00:00 を基準時刻" + CR 1337// + " LAST_MONTH 実行前月の 同日 00:00:00 を基準時刻" + CR 1338// + " LAST_YEAR 実行前年の 同月同日 00:00:00 を基準時刻" + CR ; 1339// throw new OgRuntimeException( errMsg ); 1340// } 1341// modify = cal.getTimeInMillis() ; 1342// // } 1343// // else { 1344// // throw new OgRuntimeException( "ModifyFileFilter Error! modify valus is not null" ); 1345// // } 1346// } 1347// 1348// /** 1349// * FileFilter インターフェースの accept( File ) メソッド。 1350// * 1351// * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。 1352// * 1353// * @param file ファイルオブジェクト 1354// * 1355// * @return true:処理対象 / false:処理非対象 1356// * @see java.io.FileFilter#accept( File ) 1357// */ 1358// public boolean accept( final File file ) { 1359//// return file.isDirectory() || ( ( file.lastModified() >= modify ) ^ rvse ) ; // 反転は日付判定の箇所のみ。 1360// return file.isDirectory() || file.lastModified() >= modify ^ rvse ; // 反転は日付判定の箇所のみ。 6.9.7.0 (2018/05/14) PMD Useless parentheses. 1361// } 1362// 1363// /** 1364// * このオブジェクトの文字列表現を返します。 1365// * 基本的にデバッグ目的に使用します。 1366// * 1367// * @return このクラスの文字列表現 1368// * @og.rtnNotNull 1369// */ 1370// @Override 1371// public String toString() { 1372// final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE ) 1373// .append( getClass() ).append( ':' ) 1374// .append( " modify=" ).append( DateSet.getDate( modify,"yyyy/MM/dd" ) ) 1375// .append( " reverse=" ).append( rvse ); 1376// 1377// return buf.toString(); 1378// } 1379// } 1380 1381 /** 1382 * 共通処理:単位記号の付与されたバイト文字列から、long値であるバイトを求めます。 1383 * 現時点では、K , KB , M , MB , G , GB のみ単位指定可能です。 1384 * それぞれ、元の値に対して、1024倍されます。 1385 * 1386 * 処理が正常に出来ない場合は、-1L を返します。 1387 * 1388 * @og.rev 5.7.4.3 (2014/03/28) 新規追加 1389 * 1390 * @param slen 単位記号付きバイト値 1391 * @return longに換算したバイト値 1392 */ 1393// private long getByteSize( final String slen ) { 1394 private static long getByteSize( final String slen ) { 1395 if( slen == null ) { return -1L; } 1396 1397 String buf = slen; 1398 int size = buf.length(); 1399 1400 // 'B' は、単位換算に関係ない為、あれば削除します。 1401 if( size > 0 && 'B' == buf.charAt( size-1 ) ) { 1402 buf = buf.substring( 0,size-1 ); // 'B' が削除された文字列 1403 size--; 1404 } 1405 1406 long rtn = -1L; 1407 1408 long tani = -1L; // 変換されたかどうかの判定も兼ねる。 1409 if( size > 0 ) { 1410 final char ch = buf.charAt( size-1 ); // 'K' , 'M' , 'G' のチェック 1411 switch( ch ) { 1412 case 'K' : tani=1024L; break; 1413 case 'M' : tani=1024L * 1024L ; break; 1414 case 'G' : tani=1024L * 1024L * 1024L ; break; 1415 default : break; 1416 } 1417 if( tani > 0L ) { // つまり、単位換算が行われた場合。 1418 buf = buf.substring( 0,size-1 ); // 'K','M','G' が削除された文字列 1419 size--; // ここで空文字列になる可能性がある。 1420 } 1421 else { 1422 tani = 1L; // 単位換算がない場合は、1倍。 1423 } 1424 } 1425 1426 if( size > 0 ) { 1427 // 先の単位換算で、1L(=1倍)を設定して、if を無くしたが、long の掛け算なので、なんとなく抵抗がある。 1428 rtn = tani * Long.parseLong( buf ); // buf はすでに数字だけになっているハズ。 1429 } 1430 1431 return rtn ; 1432 } 1433 1434 /** 1435 * 内部判定フィルタ: 指定の大きさより大きいファイルの場合、スルー(選択)されます。 1436 * 1437 * 指定はバイト単位ですが、**KB , **MB , **GB などの単位を付ける事も可能です。 1438 * 現時点では、K , KB , M , MB , G , GB のみ指定可能です。 1439 * 1440 * @og.rev 5.7.4.3 (2014/03/28) isLarger,isSmaller属性を文字列に変更 1441 * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。 1442 * 1443 * @param slen ファイルの大きさ(バイト単位)。同値を含む 1444 * @return 自分自身(this) 1445 */ 1446 public HybsFileFilter isLarger( final String slen ) { 1447 final long size = getByteSize( slen ); 1448 1449 if( size >= 0L ) { 1450// list.add( new IsLargerFilter( len ) ); 1451 1452// list.add( file -> file.isDirectory() || file.length() >= size ); 1453 listF.add( file -> file.length() >= size ); 1454 } 1455 return this; // 6.3.1.1 (2015/07/10) 1456 } 1457 1458// /** 1459// * 指定の大きさより大きいファイルの場合に選択される FileFilter インターフェースの実装内部クラスです。 1460// * 1461// * @version 4.0 1462// * @author Kazuhiko Hasegawa 1463// * @since JDK5.0, 1464// */ 1465// private static final class IsLargerFilter implements FileFilter { 1466// private final long size ; 1467// 1468// /** 1469// * 大きいファイルフィルターオブジェクトを作成します。 1470// * 1471// * @og.rev 5.7.4.3 (2014/03/28) isLarger,isSmaller属性をlongに変更 1472// * 1473// * @param len ファイルの大きさ(バイト単位)。同値を含む 1474// */ 1475// IsLargerFilter( final long len ) { 1476// size = len ; 1477// } 1478// 1479// /** 1480// * FileFilter インターフェースの accept( File ) メソッド。 1481// * 1482// * @param pathname ファイルオブジェクト 1483// * @return true:処理対象 / false:処理非対象 1484// * @see java.io.FileFilter#accept( File ) 1485// */ 1486// public boolean accept( final File pathname ) { 1487// return pathname.length() >= size; 1488// } 1489// 1490// /** 1491// * このオブジェクトの文字列表現を返します。 1492// * 基本的にデバッグ目的に使用します。 1493// * 1494// * @return このクラスの文字列表現 1495// * @og.rtnNotNull 1496// */ 1497// @Override 1498// public String toString() { 1499// final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE ) 1500// .append( getClass() ).append( ':' ) 1501// .append( " size=" ).append( size ); 1502// 1503// return buf.toString(); 1504// } 1505// } 1506 1507 /** 1508 * 内部判定フィルタ: 指定の大きさより小さいファイルの場合、スルー(選択)されます。 1509 * 引数が 0以下(マイナス) の場合は、追加しません。 1510 * 1511 * @og.rev 5.7.4.3 (2014/03/28) isLarger,isSmaller属性を文字列に変更 1512 * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。 1513 * 1514 * @param slen ファイルの大きさ(バイト単位)。同値を含まない。 1515 * @return 自分自身(this) 1516 */ 1517 public HybsFileFilter isSmaller( final String slen ) { 1518 final long size = getByteSize( slen ); 1519 1520 if( size >= 0L ) { 1521// list.add( new IsSmallerFilter( len ) ); 1522 1523// list.add( file -> file.isDirectory() || file.length() < size ); 1524 listF.add( file -> file.length() < size ); 1525 } 1526 return this; // 6.3.1.1 (2015/07/10) 1527 } 1528 1529// /** 1530// * 指定の大きさより小さいファイルの場合選択される FileFilter インターフェースの実装内部クラスです。 1531// * 1532// * @version 4.0 1533// * @author Kazuhiko Hasegawa 1534// * @since JDK5.0, 1535// */ 1536// private static final class IsSmallerFilter implements FileFilter { 1537// private final long size ; 1538// 1539// /** 1540// * 小さいファイルフィルターオブジェクトを作成します。 1541// * 1542// * @og.rev 5.7.4.3 (2014/03/28) isLarger,isSmaller属性をlongに変更 1543// * 1544// * @param len ファイルの大きさ(バイト単位)。同値を含まない。 1545// */ 1546// IsSmallerFilter( final long len ) { 1547// size = len ; 1548// } 1549// 1550// /** 1551// * FileFilter インターフェースの accept( File ) メソッド。 1552// * 1553// * @param pathname ファイルオブジェクト 1554// * @return true:処理対象 / false:処理非対象 1555// * @see java.io.FileFilter#accept( File ) 1556// */ 1557// public boolean accept( final File pathname ) { 1558// return pathname.length() < size; 1559// } 1560// 1561// /** 1562// * このオブジェクトの文字列表現を返します。 1563// * 基本的にデバッグ目的に使用します。 1564// * 1565// * @return このクラスの文字列表現 1566// * @og.rtnNotNull 1567// */ 1568// @Override 1569// public String toString() { 1570// final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE ) 1571// .append( getClass() ).append( ':' ) 1572// .append( " size=" ).append( size ); 1573// 1574// return buf.toString(); 1575// } 1576// } 1577 1578 /** 1579 * 内部判定フィルタ: ファイルが hidden の場合、スルー(選択)されます。 1580 * 引数がtrueの場合は、hiddenファイルのみを選択します。 1581 * falseの場合は、hiddenファイル以外を選択します。(つまり hiddenファイルをブロックします。) 1582 * hidden をブロックしたい場合は、false を設定し、すべて選択したい場合は、filter設定をしない事になります。 1583 * 引数が null の場合は、追加しません。 1584 * 1585 * @og.rev 5.7.5.0 (2014/04/04) 新規追加 1586 * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。 1587 * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。 1588 * 1589 * @param flag [true:/false] 1590 * @return 自分自身(this) 1591 */ 1592 public HybsFileFilter isHidden( final String flag ) { 1593 return isHidden( flag, notEquals ); // notEquals 属性 1594 } 1595 1596 /** 1597 * 内部判定フィルタ: ファイルが hidden の場合、スルー(選択)されます。 1598 * 引数がtrueの場合は、hiddenファイルのみを選択します。 1599 * falseの場合は、hiddenファイル以外を選択します。(つまり hiddenファイルをブロックします。) 1600 * hidden をブロックしたい場合は、false を設定し、すべて選択したい場合は、filter設定をしない事になります。 1601 * reverse = true に設定すると、結果を反転させます。 1602 * 1603 * @og.rev 5.7.5.0 (2014/04/04) 新規追加 1604 * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。 1605 * 1606 * @param flag [true:/false] 1607 * @param reverse true:結果を反転する 1608 * @return 自分自身(this) 1609 */ 1610 public HybsFileFilter isHidden( final String flag,final boolean reverse ) { 1611 if( flag != null ) { 1612// list.add( new IsHiddenFilter( flag,reverse ) ); 1613 1614 final boolean flg = Boolean.parseBoolean( flag ); 1615// list.add( file -> (file.isHidden() ^ !flg) ^ reverse ); 1616 listF.add( file -> (file.isHidden() ^ !flg) ^ reverse ); // レアケースなので、fileのみcheckします 1617 // isHidden() flg !flg rvse ⇒ 結果 1618 // ====================================================== 1619 // true(hidden) true false false ⇒ true 選択 1620 // true(hidden) false true false ⇒ false 除外 1621 // false(normal) true false false ⇒ false 除外 1622 // false(normal) false true false ⇒ true 選択 1623 1624 // true(hidden) true false true ⇒ false 除外 1625 // true(hidden) false true true ⇒ true 選択 1626 // false(normal) true false true ⇒ true 選択 1627 // false(normal) false true true ⇒ false 除外 1628 } 1629 return this; // 6.3.1.1 (2015/07/10) 1630 } 1631 1632// /** 1633// * ファイルが hidden の場合に選択される FileFilter インターフェースの実装内部クラスです。 1634// * 引数がtrueの場合は、hiddenファイルのみを選択します。 1635// * falseの場合は、hiddenファイル以外を選択します。(つまり hiddenファイルをブロックします。) 1636// * hidden をブロックしたい場合は、false を設定し、すべて選択したい場合は、filter設定をしない事になります。 1637// * 1638// * @og.rev 5.7.5.0 (2014/04/04) 新規追加 1639// * 1640// * @version 6.0 1641// * @author Kazuhiko Hasegawa 1642// * @since JDK6.0, 1643// */ 1644// private static final class IsHiddenFilter implements FileFilter { 1645// private final boolean flg ; 1646// private final boolean rvse ; 1647// 1648// /** 1649// * hiddenフィルターオブジェクトを作成します。 1650// * 1651// * @param flag true:hiddenのみ / false: 1652// * @param reverse true:結果を反転する 1653// */ 1654// IsHiddenFilter( final String flag,final boolean reverse ) { 1655// flg = Boolean.parseBoolean( flag ); 1656// rvse = reverse; 1657// } 1658// 1659// /** 1660// * FileFilter インターフェースの accept( File ) メソッド。 1661// * 1662// * @param pathname ファイルオブジェクト 1663// * @return true:処理対象 / false:処理非対象 1664// * @see java.io.FileFilter#accept( File ) 1665// */ 1666// public boolean accept( final File pathname ) { 1667// return (pathname.isHidden() ^ !flg) ^ rvse ; 1668// // isHidden() flg !flg rvse ⇒ 結果 1669// // ====================================================== 1670// // true(hidden) true false false ⇒ true 選択 1671// // true(hidden) false true false ⇒ false 除外 1672// // false(normal) true false false ⇒ false 除外 1673// // false(normal) false true false ⇒ true 選択 1674// 1675// // true(hidden) true false true ⇒ false 除外 1676// // true(hidden) false true true ⇒ true 選択 1677// // false(normal) true false true ⇒ true 選択 1678// // false(normal) false true true ⇒ false 除外 1679// } 1680// 1681// /** 1682// * このオブジェクトの文字列表現を返します。 1683// * 基本的にデバッグ目的に使用します。 1684// * 1685// * @return このクラスの文字列表現 1686// * @og.rtnNotNull 1687// */ 1688// @Override 1689// public String toString() { 1690// final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE ) 1691// .append( getClass() ).append( ':' ) 1692// .append( " flag=" ).append( flg ) 1693// .append( " reverse=" ).append( rvse ); 1694// 1695// return buf.toString(); 1696// } 1697// } 1698 1699// /** 1700// * このオブジェクトの文字列表現を返します。 1701// * 基本的にデバッグ目的に使用します。 1702// * 1703// * @return このクラスの文字列表現 1704// * @og.rtnNotNull 1705// */ 1706// @Override 1707// public String toString() { 1708// final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE ); 1709// final int size = list.size(); 1710// for( int i=0; i<size; i++ ) { 1711// buf.append( "no[" ).append( i ).append( "]=" ); 1712// buf.append( list.get(i) ).append( CR ); 1713// } 1714// 1715// return buf.toString(); 1716// } 1717}