    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 形式の ８文字数字文字列以外に、
    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 形式の ８文字数字文字列以外に、
    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 形式の ８文字数字文字列以外に、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;              // 単位換算がない場合は、１倍。
    1423                        }
    1424                }
    1425
    1426                if( size > 0 ) {
    1427                        // 先の単位換算で、1L(=１倍)を設定して、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}