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