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}