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