    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
    018import 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)
    031
    032import java.util.regex.Pattern;
    033import 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 *
    052 * この実装は同期化されません。
    053 *
    054 * @og.rev 6.3.1.1 (2015/07/10) メソッドチェーン化と、大文字/小文字の区別なし(ignoreCase=true)対応
    055 *
    056 * @version  4.0
    057 * @author   Kazuhiko Hasegawa
    058 * @since    JDK5.0,
    059 */
    060public final class HybsFileFilter implements FileFilter {
    061
    062        private final List<FileFilter> list = new ArrayList<>();
    063        private final boolean isUseDIR  ;
    064        private final boolean isUseFile ;               // 6.4.0.2 (2015/12/11) useDIR 属性に、onlyパラメータを追加[false:File/true:File+Dir/only:Dir]。
    065
    066        private final boolean ignoreCase ;              // 6.3.1.1 (2015/07/10) 大文字/小文字の区別[true:しない/false:する]
    067        private final boolean notEquals ;               // 6.8.0.0 (2017/06/02) 判定結果を反転させて処理します。
    068
    069        /**
    070         * 指定された抽象パス名がパス名リストに含まれる必要がある場合、スルー(選択)されます。
    071         * ここでの判定ロジックでは、ファイルについてのみ処理します。
    072         * ディレクトリは、常に、true を返します。
    073         * notEquals 属性で、判定結果を反転させることができます。
    074         *
    075         * ignoreCase の初期値は、大文字/小文字の区別しない(true)です。
    076         *
    077         * @og.rev 6.3.1.1 (2015/07/10) 大文字/小文字の区別[true:しない/false:する]
    078         * @og.rev 6.4.0.2 (2015/12/11) useDIR 属性に、onlyパラメータを追加します[false:File/true:File+Dir/only:Dir]。
    079         * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。
    080         */
    081        public HybsFileFilter() {
    082                this( "false" , true , false );         // 6.8.0.0 (2017/06/02)
    083        }
    084
    085        /**
    086         * 引数に、ディレクトリの判定を行うかどうかを指定するコンストラクタです。
    087         * ここで、true を指定すると、ファイル、ディレクトリの両方に対して
    088         * 処理を実施します。
    089         * ディレクトリの判定の場合、acceptメソッドで、false が返ると
    090         * それ以下の処理も実行されません。
    091         *
    092         * @og.rev 5.1.2.0 (2010/01/01) 引数つきコンストラクタ追加
    093         * @og.rev 6.3.1.1 (2015/07/10) 大文字/小文字の区別[true:しない/false:する]
    094         * @og.rev 6.4.0.2 (2015/12/11) useDIR 属性に、onlyパラメータを追加します[false:File/true:File+Dir/only:Dir]。
    095         * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。
    096         *
    097         * @param       useDIR          判定対象を指定します[false:File/true:File+Dir/only:Dir]。
    098         * @param       ignoreCase      大文字/小文字の区別[true:しない/false:する]
    099         */
    100        public HybsFileFilter( final String useDIR , final boolean ignoreCase ) {
    101                this( useDIR , ignoreCase , false );            // 6.8.0.0 (2017/06/02)
    102        }
    103
    104        /**
    105         * 引数に、ディレクトリの判定を行うかどうかを指定するコンストラクタです。
    106         * ここで、true を指定すると、ファイル、ディレクトリの両方に対して
    107         * 処理を実施します。
    108         * ディレクトリの判定の場合、acceptメソッドで、false が返ると
    109         * それ以下の処理も実行されません。
    110         *
    111         * @og.rev 5.1.2.0 (2010/01/01) 引数つきコンストラクタ追加
    112         * @og.rev 6.3.1.1 (2015/07/10) 大文字/小文字の区別[true:しない/false:する]
    113         * @og.rev 6.4.0.2 (2015/12/11) useDIR 属性に、onlyパラメータを追加します[false:File/true:File+Dir/only:Dir]。
    114         * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。
    115         *
    116         * @param       useDIR          判定対象を指定します[false:File/true:File+Dir/only:Dir]。
    117         * @param       ignoreCase      大文字/小文字の区別[true:しない/false:する]
    118         * @param       notEquals       判定結果を反転させて処理するかどうか[true:反転する/false:通常]
    119         */
    120        public HybsFileFilter( final String useDIR , final boolean ignoreCase , final boolean notEquals ) {
    121                super();
    122
    123                this.ignoreCase = ignoreCase;           // 6.3.1.1 (2015/07/10)
    124                // 6.4.0.2 (2015/12/11) useDIR 属性に、onlyパラメータを追加[false:File/true:File+Dir/only:Dir]。
    125                isUseDIR  = "true".equalsIgnoreCase( useDIR ) || "only".equalsIgnoreCase( useDIR ) ;
    126                // 6.8.0.0 (2017/06/02) only 以外にします。(nullも許容します。)
    127                isUseFile = !"only".equalsIgnoreCase( useDIR );
    128                this.notEquals = notEquals;                     // 6.8.0.0 (2017/06/02)
    129        }
    130
    131        /**
    132         * 指定された抽象パス名がパス名リストに含まれる必要がある場合、スルー(選択)されます。
    133         * ここでの判定ロジックでは、ファイルについてのみ処理します。
    134         * ディレクトリは、常に、true を返します。
    135         *
    136         * @og.rev 6.4.0.2 (2015/12/11) useDIR 属性に、onlyパラメータを追加します[false:File/true:File+Dir/only:Dir]。
    137         *
    138         * @param       pathname        ファイルオブジェクト
    139         *
    140         * @return      パス名リストに含まれるかどうか
    141         * @see java.io.FileFilter#accept(File)
    142         */
    143        public boolean accept( final File pathname ) {
    144                if( pathname != null && (pathname.isFile() && isUseFile || pathname.isDirectory() && isUseDIR) ) {      // 6.4.0.2 (2015/12/11)
    145                        final int size = list.size();
    146                        for( int i=0; i<size; i++ ) {
    147                                final FileFilter filter = list.get(i);
    148                                if( !filter.accept( pathname ) ) {
    149                                        return false;
    150                                }
    151                        }
    152                }
    153                return true;
    154        }
    155
    156        /**
    157         * 外部指定フィルタ： 内部判定条件に、フィルタを追加します。
    158         * 引数が null の場合は、追加しません。
    159         *
    160         * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。
    161         *
    162         * @param    filter 外部指定フィルタ
    163         * @return      自分自身(this)
    164         */
    165        public HybsFileFilter addFileFilter( final FileFilter filter ) {
    166                if( filter != null ) { list.add( filter ); }
    167                return this;            // 6.3.1.1 (2015/07/10)
    168        }
    169
    170        /**
    171         * 内部判定フィルタ： 指定された接頭辞で始まる場合、スルー(選択)されます。
    172         * 引数が null の場合は、追加しません。
    173         * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。
    174         *
    175         * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。
    176         * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。
    177         *
    178         * @param    prefix 接頭辞("|"で複数指定可)
    179         * @return      自分自身(this)
    180         * @see java.lang.String#startsWith(String)
    181         */
    182        public HybsFileFilter startsWith( final String prefix ) {
    183                return startsWith( prefix, notEquals ); // notEquals 属性
    184        }
    185
    186        /**
    187         * 内部判定フィルタ： 指定された接頭辞で始まる場合、スルー(選択)されます。
    188         * 引数が null の場合は、追加しません。
    189         * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。
    190         * reverse = true に設定すると、結果を反転させます。
    191         *
    192         * @og.rev 5.1.2.0 (2010/01/01) reverse属性の追加
    193         * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。
    194         *
    195         * @param    prefix             接頭辞("|"で複数指定可)
    196         * @param    reverse    true:結果を反転する
    197         * @return      自分自身(this)
    198         * @see java.lang.String#startsWith(String)
    199         */
    200        public HybsFileFilter startsWith( final String prefix,final boolean reverse ) {
    201                if( prefix != null ) {
    202                        list.add( new StartsWithFilter( prefix,reverse,ignoreCase ) );
    203                }
    204                return this;            // 6.3.1.1 (2015/07/10)
    205        }
    206
    207        /**
    208         * 指定された接頭辞で始まる場合に選択される FileFilter インターフェースの実装内部クラスです。
    209         * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。
    210         *
    211         * @og.rev 5.1.2.0 (2010/01/01) '|' 区切り文字で複数設定処理の追加、reverse属性の追加
    212         * @og.rev 6.3.1.1 (2015/07/10) ignoreCase による 大文字小文字の判定方法指定
    213         *
    214         * @version  4.0
    215         * @author   Kazuhiko Hasegawa
    216         * @since    JDK5.0,
    217         */
    218        private static final class StartsWithFilter implements FileFilter {
    219                private final String[] pfix ;
    220                private final int      cnt  ;
    221                private final boolean  rvse ;
    222                private final boolean  igCase ;         // 6.3.1.1 (2015/07/10)
    223
    224                /**
    225                 * 接頭辞フィルターオブジェクトを作成します。
    226                 *
    227                 * @param       prefix  接頭辞("|"で複数指定可)
    228                 * @param       reverse true:結果を反転する
    229                 * @param       ignoreCase      大文字/小文字の区別[true:しない/false:する]
    230                 */
    231                StartsWithFilter( final String prefix,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( prefix, "|" );
    236                        cnt = token.countTokens();
    237
    238                        pfix = 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                                pfix[i] = igCase ? tkn.toLowerCase( Locale.JAPAN ) : tkn ;
    243                        }
    244                }
    245
    246                /**
    247                 * FileFilter インターフェースの accept( File ) メソッド。
    248                 *
    249                 * @param       pathname        ファイルオブジェクト
    250                 * @return      true:処理対象 / false:処理非対象
    251                 * @see java.io.FileFilter#accept( File )
    252                 */
    253                public boolean accept( final File pathname ) {
    254                        // 6.3.1.1 (2015/07/10) ignoreCase 対応
    255                        final String org  = pathname.getName() ;
    256                        final String name = igCase ? org.toLowerCase( Locale.JAPAN ) : org ;
    257                        for( int i=0; i<cnt; i++ ) {
    258                                if( name.startsWith( pfix[i] ) ) {
    259                                        return !rvse;                                           // true ^ rvse
    260                                }
    261                        }
    262                        return rvse;                                                            // false ^ rvse
    263                }
    264
    265                /**
    266                 * このオブジェクトの文字列表現を返します。
    267                 * 基本的にデバッグ目的に使用します。
    268                 *
    269                 * @return このクラスの文字列表現
    270                 * @og.rtnNotNull
    271                 */
    272                @Override
    273                public String toString() {
    274                        final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE )
    275                                .append( getClass() ).append( ':' )
    276                                .append( " prefix=" ).append( Arrays.toString( pfix ) )
    277                                .append( " reverse=" ).append( rvse )
    278                                .append( " ignoreCase=" ).append( igCase );
    279
    280                        return buf.toString();
    281                }
    282        }
    283
    284        /**
    285         * 内部判定フィルタ： 指定された接頭辞で始まるディレクトリの場合、スルー(選択)されます。
    286         * 引数が null の場合は、追加しません。
    287         * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。
    288         *
    289         * @og.rev 6.4.3.2 (2016/02/19) ディレクトリの先頭一致対応
    290         * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。
    291         *
    292         * @param    prefix 接頭辞("|"で複数指定可)
    293         * @return      自分自身(this)
    294         * @see java.lang.String#startsWith(String)
    295         */
    296        public HybsFileFilter startsDir( final String prefix ) {
    297                return startsDir( prefix, notEquals );  // notEquals 属性
    298        }
    299
    300        /**
    301         * 内部判定フィルタ： 指定された接頭辞で始まるディレクトリの場合、スルー(選択)されます。
    302         * 引数が null の場合は、追加しません。
    303         * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。
    304         * reverse = true に設定すると、結果を反転させます。
    305         *
    306         * @og.rev 6.4.3.2 (2016/02/19) ディレクトリの先頭一致対応
    307         *
    308         * @param    prefix             接頭辞("|"で複数指定可)
    309         * @param    reverse    true:結果を反転する
    310         * @return      自分自身(this)
    311         * @see java.lang.String#startsWith(String)
    312         */
    313        public HybsFileFilter startsDir( final String prefix,final boolean reverse ) {
    314                if( prefix != null ) {
    315                        list.add( new StartsDirFilter( prefix,reverse,ignoreCase ) );
    316                }
    317                return this;            // 6.3.1.1 (2015/07/10)
    318        }
    319
    320        /**
    321         * 指定された接頭辞で始まるディレクトリが選択される FileFilter インターフェースの実装内部クラスです。
    322         * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。
    323         *
    324         * @og.rev 6.4.3.2 (2016/02/19) ディレクトリの先頭一致対応
    325         *
    326         * @version  4.0
    327         * @author   Kazuhiko Hasegawa
    328         * @since    JDK5.0,
    329         */
    330        private static final class StartsDirFilter implements FileFilter {
    331                private final String[] pfix ;
    332                private final int      cnt  ;
    333                private final boolean  rvse ;
    334                private final boolean  igCase ;         // 6.3.1.1 (2015/07/10)
    335
    336                /**
    337                 * 接頭辞フィルターオブジェクトを作成します。
    338                 *
    339                 * @param       prefix  接頭辞("|"で複数指定可)
    340                 * @param       reverse true:結果を反転する
    341                 * @param       ignoreCase      大文字/小文字の区別[true:しない/false:する]
    342                 */
    343                StartsDirFilter( final String prefix,final boolean reverse,final boolean ignoreCase ) {
    344                        rvse   = reverse;
    345                        igCase = ignoreCase;                    // 6.3.1.1 (2015/07/10)
    346
    347                        final StringTokenizer token = new StringTokenizer( prefix, "|" );
    348                        cnt = token.countTokens();
    349
    350                        pfix = new String[cnt];
    351                        for( int i=0; i<cnt; i++ ) {
    352                                // 6.3.1.1 (2015/07/10) ignoreCase 対応
    353                                final String tkn = token.nextToken();
    354                                pfix[i] = igCase ? tkn.toLowerCase( Locale.JAPAN ) : tkn ;
    355                        }
    356                }
    357
    358                /**
    359                 * FileFilter インターフェースの accept( File ) メソッド。
    360                 *
    361                 * @param       pathname        ファイルオブジェクト
    362                 * @return      true:処理対象 / false:処理非対象
    363                 * @see java.io.FileFilter#accept( File )
    364                 */
    365                public boolean accept( final File pathname ) {
    366                        final File parent = pathname.getParentFile();
    367                        if( parent != null && parent.isDirectory() ) {          // まず、ディレクトリのはず
    368                                final String org = parent.getName();
    369                                final String name = igCase ? org.toLowerCase( Locale.JAPAN ) : org ;
    370                                for( int i=0; i<cnt; i++ ) {
    371                                        if( name.startsWith( pfix[i] ) ) {
    372                                                return !rvse;
    373                                        }
    374                                }
    375                        }
    376                        return rvse;
    377                }
    378
    379                /**
    380                 * このオブジェクトの文字列表現を返します。
    381                 * 基本的にデバッグ目的に使用します。
    382                 *
    383                 * @return このクラスの文字列表現
    384                 * @og.rtnNotNull
    385                 */
    386                @Override
    387                public String toString() {
    388                        final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE )
    389                                .append( getClass() ).append( ':' )
    390                                .append( " prefix=" ).append( Arrays.toString( pfix ) )
    391                                .append( " reverse=" ).append( rvse )
    392                                .append( " ignoreCase=" ).append( igCase );
    393
    394                        return buf.toString();
    395                }
    396        }
    397
    398        /**
    399         * 内部判定フィルタ： 指定された接頭辞で終わる場合、スルー(選択)されます。
    400         * 引数が null の場合は、追加しません。
    401         * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。
    402         *
    403         * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。
    404         * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。
    405         *
    406         * @param    suffix 接尾辞("|"で複数指定可)
    407         * @return      自分自身(this)
    408         * @see java.lang.String#endsWith(String)
    409         */
    410        public HybsFileFilter endsWith( final String suffix ) {
    411                return endsWith( suffix, notEquals );   // notEquals 属性
    412        }
    413
    414        /**
    415         * 内部判定フィルタ： 指定された接頭辞で終わる場合、スルー(選択)されます。
    416         * 引数が null の場合は、追加しません。
    417         * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。
    418         * reverse = true に設定すると、結果を反転させます。
    419         *
    420         * @og.rev 5.1.2.0 (2010/01/01) reverse属性の追加
    421         * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。
    422         * @return      自分自身(this)
    423         *
    424         * @param       suffix  接尾辞("|"で複数指定可)
    425         * @param       reverse true:結果を反転する
    426         * @see java.lang.String#endsWith(String)
    427         */
    428        public HybsFileFilter endsWith( final String suffix,final boolean reverse ) {
    429                if( suffix != null ) {
    430                        list.add( new EndsWithFilter( suffix,reverse,ignoreCase ) );
    431                }
    432                return this;            // 6.3.1.1 (2015/07/10)
    433        }
    434
    435        /**
    436         * 指定された接頭辞で終わる場合に選択される FileFilter インターフェースの実装内部クラスです。
    437         * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。
    438         *
    439         * @og.rev 5.1.2.0 (2010/01/01) '|' 区切り文字で複数設定処理の追加、reverse属性の追加
    440         * @og.rev 6.3.1.1 (2015/07/10) ignoreCase による 大文字小文字の判定方法指定
    441         *
    442         * @version  4.0
    443         * @author   Kazuhiko Hasegawa
    444         * @since    JDK5.0,
    445         */
    446        private static final class EndsWithFilter implements FileFilter {
    447                private final String[] sfix ;
    448                private final int      cnt  ;
    449                private final boolean  rvse ;
    450                private final boolean  igCase ;         // 6.3.1.1 (2015/07/10)
    451
    452                /**
    453                 * 接頭辞フィルターオブジェクトを作成します。
    454                 *
    455                 * @param       suffix  接頭辞("|"で複数指定可)
    456                 * @param       reverse true:結果を反転する
    457                 * @param       ignoreCase      大文字/小文字の区別[true:しない/false:する]
    458                 */
    459                EndsWithFilter( final String suffix,final boolean reverse,final boolean ignoreCase ) {
    460                        rvse = reverse;
    461                        igCase = ignoreCase;                    // 6.3.1.1 (2015/07/10)
    462
    463                        final StringTokenizer token = new StringTokenizer( suffix, "|" );
    464                        cnt = token.countTokens();
    465
    466                        sfix = new String[cnt];
    467                        for( int i=0; i<cnt; i++ ) {
    468                                // 6.3.1.1 (2015/07/10) ignoreCase 対応
    469                                final String tkn = token.nextToken();
    470                                sfix[i] = igCase ? tkn.toLowerCase( Locale.JAPAN ) : tkn ;
    471                        }
    472                }
    473
    474                /**
    475                 * FileFilter インターフェースの accept( File ) メソッド。
    476                 *
    477                 * @param       pathname        ファイルオブジェクト
    478                 * @return      true:処理対象 / false:処理非対象
    479                 * @see java.io.FileFilter#accept( File )
    480                 */
    481                public boolean accept( final File pathname ) {
    482                        // 6.3.1.1 (2015/07/10) ignoreCase 対応
    483                        final String org  = pathname.getName() ;
    484                        final String name = igCase ? org.toLowerCase( Locale.JAPAN ) : org ;
    485                        for( int i=0; i<cnt; i++ ) {
    486                                if( name.endsWith( sfix[i] ) ) {
    487                                        return !rvse;
    488                                }
    489                        }
    490                        return rvse;
    491                }
    492
    493                /**
    494                 * このオブジェクトの文字列表現を返します。
    495                 * 基本的にデバッグ目的に使用します。
    496                 *
    497                 * @return このクラスの文字列表現
    498                 * @og.rtnNotNull
    499                 */
    500                @Override
    501                public String toString() {
    502                        final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE )
    503                                .append( getClass() ).append( ':' )
    504                                .append( " suffix=" ).append( Arrays.toString( sfix ) )
    505                                .append( " reverse=" ).append( rvse )
    506                                .append( " ignoreCase=" ).append( igCase );
    507
    508                        return buf.toString();
    509                }
    510        }
    511
    512        /**
    513         * 内部判定フィルタ： 指定された文字列がファイル名に含まれる場合、スルー(選択)されます。
    514         * 引数が null の場合は、追加しません。
    515         * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。
    516         *
    517         * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。
    518         * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。
    519         *
    520         * @param    str 指定の部分文字列("|"で複数指定可)
    521         * @return      自分自身(this)
    522         */
    523        public HybsFileFilter instr( final String str ) {
    524                return instr( str, notEquals ); // notEquals 属性
    525        }
    526
    527        /**
    528         * 内部判定フィルタ： 指定された文字列がファイル名に含まれる場合、スルー(選択)されます。
    529         * 引数が null の場合は、追加しません。
    530         * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。
    531         * reverse = true に設定すると、結果を反転させます。
    532         *
    533         * @og.rev 5.1.2.0 (2010/01/01) reverse属性の追加
    534         * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。
    535         *
    536         * @param       str     指定の部分文字列("|"で複数指定可)
    537         * @param       reverse 結果を反転させるかどうか(true:反転)
    538         * @return      自分自身(this)
    539         */
    540        public HybsFileFilter instr( final String str,final boolean reverse ) {
    541                if( str != null ) {
    542                        list.add( new InstrFilter( str,reverse,ignoreCase ) );
    543                }
    544                return this;            // 6.3.1.1 (2015/07/10)
    545        }
    546
    547        /**
    548         * 指定された文字列がファイル名に含まれる場合に選択される FileFilter インターフェースの実装内部クラスです。
    549         * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。
    550         *
    551         * @og.rev 5.1.2.0 (2010/01/01) '|' 区切り文字で複数設定処理の追加、reverse属性の追加
    552         * @og.rev 6.3.1.1 (2015/07/10) ignoreCase による 大文字小文字の判定方法指定
    553         *
    554         * @version  4.0
    555         * @author   Kazuhiko Hasegawa
    556         * @since    JDK5.0,
    557         */
    558        private static final class InstrFilter implements FileFilter {
    559                private final String[] instr ;
    560                private final int      cnt  ;
    561                private final boolean  rvse ;
    562                private final boolean  igCase ;         // 6.3.1.1 (2015/07/10)
    563
    564                /**
    565                 * 文字列包含フィルターオブジェクトを作成します。
    566                 *
    567                 * @param       str     包含を判定する文字列("|"で複数指定可)
    568                 * @param       reverse true:結果を反転する
    569                 * @param       ignoreCase      大文字/小文字の区別[true:しない/false:する]
    570                 */
    571                InstrFilter( final String str,final boolean reverse,final boolean ignoreCase ) {
    572                        rvse   = reverse;
    573                        igCase = ignoreCase;                    // 6.3.1.1 (2015/07/10)
    574
    575                        final StringTokenizer token = new StringTokenizer( str, "|" );
    576                        cnt = token.countTokens();
    577
    578                        instr = new String[cnt];
    579                        for( int i=0; i<cnt; i++ ) {
    580                                // 6.3.1.1 (2015/07/10) ignoreCase 対応
    581                                final String tkn = token.nextToken();
    582                                instr[i] = igCase ? tkn.toLowerCase( Locale.JAPAN ) : tkn ;
    583                        }
    584                }
    585
    586                /**
    587                 * FileFilter インターフェースの accept( File ) メソッド。
    588                 *
    589                 * @param       pathname        ファイルオブジェクト
    590                 * @return      true:処理対象 / false:処理非対象
    591                 * @see java.io.FileFilter#accept( File )
    592                 */
    593                public boolean accept( final File pathname ) {
    594                        // 6.3.1.1 (2015/07/10) ignoreCase 対応
    595                        final String org  = pathname.getName() ;
    596                        final String name = igCase ? org.toLowerCase( Locale.JAPAN ) : org ;
    597                        for( int i=0; i<cnt; i++ ) {
    598                                if( name.indexOf( instr[i] ) >= 0 ) {
    599                                        return !rvse;
    600                                }
    601                        }
    602                        return rvse;
    603                }
    604
    605                /**
    606                 * このオブジェクトの文字列表現を返します。
    607                 * 基本的にデバッグ目的に使用します。
    608                 *
    609                 * @return このクラスの文字列表現
    610                 * @og.rtnNotNull
    611                 */
    612                @Override
    613                public String toString() {
    614                        final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE )
    615                                .append( getClass() ).append( ':' )
    616                                .append( " instr=" ).append( Arrays.toString( instr ) )
    617                                .append( " reverse=" ).append( rvse )
    618                                .append( " ignoreCase=" ).append( igCase );
    619
    620                        return buf.toString();
    621                }
    622        }
    623
    624        /**
    625         * 内部判定フィルタ： ファイル名が一致する場合、スルー(選択)されます。
    626         * 引数が null の場合は、追加しません。
    627         * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。
    628         *
    629         * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。
    630         *
    631         * @param    str ファイル名文字列("|"で複数指定可)
    632         * @return      自分自身(this)
    633         */
    634        public HybsFileFilter fileEquals( final String str ) {
    635                return fileEquals( str, false );        // 反転しない
    636        }
    637
    638        /**
    639         * 内部判定フィルタ： ファイル名が一致する場合、スルー(選択)されます。
    640         * 引数が null の場合は、追加しません。
    641         * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。
    642         * reverse = true に設定すると、結果を反転させます。
    643         *
    644         * @og.rev 5.1.2.0 (2010/01/01) reverse属性の追加
    645         * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。
    646         *
    647         * @param    str ファイル名文字列("|"で複数指定可)
    648         * @param    reverse    true:結果を反転する
    649         * @return      自分自身(this)
    650         */
    651        public HybsFileFilter fileEquals( final String str,final boolean reverse ) {
    652                if( str != null ) {
    653                        list.add( new EqualsFilter( str,reverse,ignoreCase ) );
    654                }
    655                return this;            // 6.3.1.1 (2015/07/10)
    656        }
    657
    658        /**
    659         * ファイル名が一致する場合に選択される FileFilter インターフェースの実装内部クラスです。
    660         * 引数に、'|' 区切り文字で複数設定した場合は、OR 判断(どれかが一致)します。
    661         *
    662         * @og.rev 5.1.2.0 (2010/01/01) '|' 区切り文字で複数設定処理の追加、reverse属性の追加
    663         * @og.rev 6.3.1.1 (2015/07/10) ignoreCase による 大文字小文字の判定方法指定
    664         *
    665         * @version  4.0
    666         * @author   Kazuhiko Hasegawa
    667         * @since    JDK5.0,
    668         */
    669        private static final class EqualsFilter implements FileFilter {
    670                private final String[] eqstr ;
    671                private final int      cnt  ;
    672                private final boolean  rvse ;
    673                private final boolean  igCase ;         // 6.3.1.1 (2015/07/10)
    674
    675                /**
    676                 * ファイル名一致フィルターオブジェクトを作成します。
    677                 *
    678                 * @param       str     ファイル名一致判定用文字列("|"で複数指定可)
    679                 * @param       reverse true:結果を反転する
    680                 * @param       ignoreCase      大文字/小文字の区別[true:しない/false:する]
    681                 */
    682                EqualsFilter( final String str,final boolean reverse,final boolean ignoreCase ) {
    683                        rvse   = reverse;
    684                        igCase = ignoreCase;                    // 6.3.1.1 (2015/07/10)
    685
    686                        final StringTokenizer token = new StringTokenizer( str, "|" );
    687                        cnt = token.countTokens();
    688
    689                        eqstr = new String[cnt];
    690                        for( int i=0; i<cnt; i++ ) {
    691                                eqstr[i] = token.nextToken();
    692                        }
    693                }
    694
    695                /**
    696                 * FileFilter インターフェースの accept( File ) メソッド。
    697                 *
    698                 * @param       pathname        ファイルオブジェクト
    699                 * @return      true:処理対象 / false:処理非対象
    700                 * @see java.io.FileFilter#accept( File )
    701                 */
    702                public boolean accept( final File pathname ) {
    703                        // 6.3.1.1 (2015/07/10) ignoreCase 対応
    704                        final String name  = pathname.getName() ;
    705                        for( int i=0; i<cnt; i++ ) {
    706                                if( ( igCase ? name.equalsIgnoreCase( eqstr[i] ) : name.equals( eqstr[i] ) ) ) {
    707                                        return !rvse;
    708                                }
    709                        }
    710                        return rvse;
    711                }
    712
    713                /**
    714                 * このオブジェクトの文字列表現を返します。
    715                 * 基本的にデバッグ目的に使用します。
    716                 *
    717                 * @return このクラスの文字列表現
    718                 * @og.rtnNotNull
    719                 */
    720                @Override
    721                public String toString() {
    722                        final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE )
    723                                .append( getClass() ).append( ':' )
    724                                .append( " eqstr=" ).append( Arrays.toString( eqstr ) )
    725                                .append( " reverse=" ).append( rvse )
    726                                .append( " ignoreCase=" ).append( igCase );
    727
    728                        return buf.toString();
    729                }
    730        }
    731
    732        /**
    733         * 内部判定フィルタ： ファイル名が、指定された
    734         * <a href="/java/api14/api/java/util/regex/Pattern.html#sum">正規表現</a>
    735         * と一致する場合、スルー(選択)されます
    736         * 大文字小文字の区別は、ignoreCase で切り替えます。
    737         * ignoreCase ? Pattern.compile( str,Pattern.CASE_INSENSITIVE ) : Pattern.compile( str ) ;
    738         * pattern.matcher( pathname.getName() ).find() == true と同じ結果が得られます。
    739         * 引数が null の場合は、追加しません。
    740         *
    741         * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。
    742         * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。
    743         *
    744         * @param    str ファイル名文字列(正規表現)
    745         * @return      自分自身(this)
    746         * @see java.util.regex.Pattern#compile(String,int)
    747         * @see java.util.regex.Matcher#find()
    748         */
    749        public HybsFileFilter matches( final String str ) {
    750                return matches( str, notEquals );       // notEquals 属性
    751        }
    752
    753        /**
    754         * 内部判定フィルタ： ファイル名が、指定された
    755         * <a href="/java/api14/api/java/util/regex/Pattern.html#sum">正規表現</a>
    756         * と一致する場合、スルー(選択)されます
    757         * 大文字小文字の区別は、ignoreCase で切り替えます。
    758         * ignoreCase ? Pattern.compile( str,Pattern.CASE_INSENSITIVE ) : Pattern.compile( str ) ;
    759         * pattern.matcher( pathname.getName() ).find() == true と同じ結果が得られます。
    760         * 引数が null の場合は、追加しません。
    761         * reverse = true に設定すると、結果を反転させます。
    762         *
    763         * @og.rev 5.1.2.0 (2010/01/01) reverse属性の追加
    764         * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。
    765         *
    766         * @param    str ファイル名文字列(正規表現)
    767         * @param    reverse    true:結果を反転する
    768         * @return      自分自身(this)
    769         * @see java.util.regex.Pattern#compile(String,int)
    770         * @see java.util.regex.Matcher#find()
    771         */
    772        public HybsFileFilter matches( final String str,final boolean reverse ) {
    773                if( str != null ) {
    774                        list.add( new MatchesFilter( str,reverse,ignoreCase ) );
    775                }
    776                return this;            // 6.3.1.1 (2015/07/10)
    777        }
    778
    779        /**
    780         * ファイル名が、指定された正規表現と一致する場合に選択される FileFilter インターフェースの実装内部クラスです。
    781         *
    782         * @og.rev 5.1.2.0 (2010/01/01) reverse属性の追加
    783         * @og.rev 6.3.1.1 (2015/07/10) ignoreCase による 大文字小文字の判定方法指定
    784         *
    785         * @version  4.0
    786         * @author   Kazuhiko Hasegawa
    787         * @since    JDK5.0,
    788         */
    789        private static final class MatchesFilter implements FileFilter {
    790                private final Pattern pattern ;
    791                private final boolean  rvse ;
    792
    793                /**
    794                 * 正規表現一致フィルターオブジェクトを作成します。
    795                 * 大文字小文字の区別は、ignoreCase で切り替えます。
    796                 * ignoreCase ? Pattern.compile( str,Pattern.CASE_INSENSITIVE ) : Pattern.compile( str ) ;
    797                 *
    798                 * @param       str     正規表現一致
    799                 * @param       reverse true:結果を反転する
    800                 * @param       ignoreCase      大文字/小文字の区別[true:しない/false:する]
    801                 */
    802                MatchesFilter( final String str,final boolean reverse,final boolean ignoreCase ) {
    803                        pattern = ignoreCase ? Pattern.compile( str,Pattern.CASE_INSENSITIVE ) : Pattern.compile( str ) ;
    804                        rvse = reverse;
    805                }
    806
    807                /**
    808                 * FileFilter インターフェースの accept( File ) メソッド。
    809                 *
    810                 * @param       pathname        ファイルオブジェクト
    811                 * @return      true:処理対象 / false:処理非対象
    812                 * @see java.io.FileFilter#accept( File )
    813                 */
    814                public boolean accept( final File pathname ) {
    815                        final Matcher match = pattern.matcher( pathname.getName() );
    816                        // 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
    817                        // 排他的論理輪
    818                        return match.find() ^ rvse ;
    819                }
    820
    821                /**
    822                 * このオブジェクトの文字列表現を返します。
    823                 * 基本的にデバッグ目的に使用します。
    824                 *
    825                 * @return このクラスの文字列表現
    826                 * @og.rtnNotNull
    827                 */
    828                @Override
    829                public String toString() {
    830                        final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE )
    831                                .append( getClass() ).append( ':' )
    832                                .append( " pattern=" ).append( pattern )
    833                                .append( " reverse=" ).append( rvse );
    834
    835                        return buf.toString();
    836                }
    837        }
    838
    839        /**
    840         * 内部判定フィルタ： 指定のタイムスタンプ以後に変更されている場合、スルー(選択)されます。
    841         * ディレクトリは、ここの判定では無視します。(必ず true を返します)
    842         * 日付けの指定に、YYYYMMDD 形式の ８文字数字文字列以外に、
    843         * TODAY や YESTERDAY なども使用できます。
    844         * TODAY は、実行日の 00:00:00 を基準時刻とし、YESTERDAY は、その前日になります。
    845         * 引数が null の場合は、追加しません。
    846         *
    847         * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。
    848         * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。
    849         *
    850         * @param    modify 時刻を表す long 値(ミリ秒単位)
    851         * @return      自分自身(this)
    852         */
    853        public HybsFileFilter lastModified( final String modify ) {
    854                return lastModified( modify, notEquals );       // notEquals 属性
    855        }
    856
    857        /**
    858         * 内部判定フィルタ： 指定のタイムスタンプ以後に変更されている場合、スルー(選択)されます。
    859         * ディレクトリは、ここの判定では無視します。(必ず true を返します)
    860         * 日付けの指定に、YYYYMMDD 形式の ８文字数字文字列以外に、
    861         * TODAY や YESTERDAY なども使用できます。
    862         * TODAY は、実行日の 00:00:00 を基準時刻とし、YESTERDAY は、その前日になります。
    863         * 引数が null の場合は、追加しません。
    864         *
    865         * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。
    866         * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。
    867         *
    868         * @param       modify 時刻を表す long 値(ミリ秒単位)
    869         * @return      自分自身(this)
    870         * @param       reverse true:結果を反転する
    871         */
    872        public HybsFileFilter lastModified( final String modify,final boolean reverse ) {
    873                if( modify != null ) {
    874                        list.add( new ModifyFileFilter( modify,reverse ) );
    875                }
    876                return this;            // 6.3.1.1 (2015/07/10)
    877        }
    878
    879        /**
    880         * ModifyFileFilter.java は、最終変更日付けのフィルタークラスです。
    881         *
    882         * FileFilter インターフェースを継承し、コンストラクタで指定の日付けよりも
    883         * 最終変更日付け が新しいファイルを、選択します。
    884         * このクラスでは、ディレクトリは、変更日付けに無関係に選択します。
    885         *
    886         * 日付けの指定に、YYYYMMDD 形式の ８文字数字文字列以外に、TODAY や YESTERDAY なども使用できます。
    887         * TODAY は、実行日の 00:00:00 を基準時刻とし、YESTERDAY は、その前日になります。
    888         * バッチ処理等で、前日分の再編成や、先月分を再編成する場合に、実日付けを指定せずに
    889         * 使用できます。
    890         *
    891         * この実装は同期化されません。
    892         *
    893         * @version  4.0
    894         * @author   Kazuhiko Hasegawa
    895         * @since    JDK5.0,
    896         */
    897        private static final class ModifyFileFilter implements FileFilter {
    898                private final long              modify ;
    899                private final boolean   rvse ;          // 6.8.0.0 (2017/06/02)
    900
    901                /**
    902                 * コンストラクター
    903                 *
    904                 * 日付けの指定方法には、実日付け(YYYYMMDD形式 例：20040323)と
    905                 * 仮想日付け(TODAY,YESTERDAY など)が指定できます。
    906                 *
    907                 *     YYYYMMDD   YYYYMMDD形式の指定日の 00:00:00 を基準時刻
    908                 *     TODAY      実行日の 00:00:00 を基準時刻
    909                 *     YESTERDAY  実行日前日の 00:00:00 を基準時刻
    910                 *     LAST_WEEK  実行日の先週(7日前) 00:00:00 を基準時刻
    911                 *     MONTH      実行月の 1日 00:00:00 を基準時刻
    912                 *     LAST_MONTH 実行前月の 同日 00:00:00 を基準時刻
    913                 *     LAST_YEAR  実行前年の 同月同日 00:00:00 を基準時刻
    914                 *
    915                 * @og.rev 5.3.5.0 (2011/05/01) ｢時｣のクリアミスの修正
    916                 * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。
    917                 *
    918                 * @param value 指定日付け
    919                 * @param       reverse true:結果を反転する
    920                 */
    921                ModifyFileFilter( final String value , final boolean reverse ) {
    922                        rvse = reverse;                         // 6.8.0.0 (2017/06/02)
    923
    924                        // 6.4.1.1 (2016/01/16) PMD refactoring. Avoid if (x != y) ..; else ..;
    925                        if( value == null ) {
    926                                throw new OgRuntimeException( "ModifyFileFilter Error! modify valus is not null" );
    927                        }
    928
    929        //              if( value != null ) {
    930                                final Calendar cal = Calendar.getInstance();
    931
    932                                cal.set( Calendar.HOUR_OF_DAY, 0 );             // 5.3.5.0 (2011/05/01) 時間の解決規則が適用されるため、｢時｣だけは、setメソッドで 0 にセットする。
    933                                cal.clear( Calendar.MINUTE );
    934                                cal.clear( Calendar.SECOND );
    935                                cal.clear( Calendar.MILLISECOND );
    936
    937                                if( "YESTERDAY".equalsIgnoreCase( value ) ) {
    938                                        cal.add( Calendar.DATE, -1 );
    939                                }
    940                                else if( "LAST_WEEK".equalsIgnoreCase( value ) ) {
    941                                        cal.add( Calendar.DATE, -7 );
    942                                }
    943                                else if( "MONTH".equalsIgnoreCase( value ) ) {
    944                                        cal.set( Calendar.DATE, 1 );
    945                                }
    946                                else if( "LAST_MONTH".equalsIgnoreCase( value ) ) {
    947                                        cal.add( Calendar.MONTH, -1 );
    948                                }
    949                                else if( "LAST_YEAR".equalsIgnoreCase( value ) ) {
    950                                        cal.add( Calendar.YEAR, -1 );
    951                                }
    952                                else if( value.length() == 8 ) {
    953                                        cal.set( Integer.parseInt( value.substring( 0,4 ) ) ,
    954                                                         Integer.parseInt( value.substring( 4,6 ) ) - 1,
    955                                                         Integer.parseInt( value.substring( 6,8 ) ) );
    956                                }
    957                                else if( ! "TODAY".equalsIgnoreCase( value ) ) {
    958                                        final String errMsg = "ModifyFileFilter Error! modify Format [" + value + "]"   + CR
    959                                                         + "日付けの指定方法には、実日付け(YYYYMMDD形式 例：20040323)と"            + CR
    960                                                         + "仮想日付け(TODAY,YESTERDAY など)が指定できます。"                                  + CR
    961                                                         + "    YYYYMMDD   YYYYMMDD形式の指定日の 00:00:00 を基準時刻"                      + CR
    962                                                         + "    TODAY      実行日の 00:00:00 を基準時刻"                                         + CR
    963                                                         + "    YESTERDAY  実行日前日の 00:00:00 を基準時刻"                                       + CR
    964                                                         + "    LAST_WEEK  実行日の先週(7日前) 00:00:00 を基準時刻"                          + CR
    965                                                         + "    MONTH      実行月の 1日 00:00:00 を基準時刻"                                      + CR
    966                                                         + "    LAST_MONTH 実行前月の 同日 00:00:00 を基準時刻"                                     + CR
    967                                                         + "    LAST_YEAR  実行前年の 同月同日 00:00:00 を基準時刻"                           + CR ;
    968                                        throw new OgRuntimeException( errMsg );
    969                                }
    970                                modify = cal.getTimeInMillis() ;
    971        //              }
    972        //              else {
    973        //                      throw new OgRuntimeException( "ModifyFileFilter Error! modify valus is not null" );
    974        //              }
    975                }
    976
    977                /**
    978                 * FileFilter インターフェースの accept( File ) メソッド。
    979                 *
    980                 * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。
    981                 *
    982                 * @param       file    ファイルオブジェクト
    983                 *
    984                 * @return      true:処理対象 / false:処理非対象
    985                 * @see java.io.FileFilter#accept( File )
    986                 */
    987                public boolean accept( final File file ) {
    988//                      return file.isDirectory() || ( ( file.lastModified() >= modify ) ^ rvse ) ;             // 反転は日付判定の箇所のみ。
    989                        return file.isDirectory() || file.lastModified() >= modify ^ rvse ;                             // 反転は日付判定の箇所のみ。        6.9.7.0 (2018/05/14) PMD Useless parentheses.
    990                }
    991
    992                /**
    993                 * このオブジェクトの文字列表現を返します。
    994                 * 基本的にデバッグ目的に使用します。
    995                 *
    996                 * @return このクラスの文字列表現
    997                 * @og.rtnNotNull
    998                 */
    999                @Override
    1000                public String toString() {
    1001                        final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE )
    1002                                .append( getClass()  ).append( ':' )
    1003                                .append( " modify="  ).append( DateSet.getDate( modify,"yyyy/MM/dd" ) )
    1004                                .append( " reverse=" ).append( rvse );
    1005
    1006                        return buf.toString();
    1007                }
    1008        }
    1009
    1010        /**
    1011         * 共通処理：単位記号の付与されたバイト文字列から、long値であるバイトを求めます。
    1012         * 現時点では、K , KB , M , MB , G , GB のみ単位指定可能です。
    1013         * それぞれ、元の値に対して、1024倍されます。
    1014         *
    1015         * 処理が正常に出来ない場合は、-1L を返します。
    1016         *
    1017         * @og.rev 5.7.4.3 (2014/03/28) 新規追加
    1018         *
    1019         * @param       slen 単位記号付きバイト値
    1020         * @return      longに換算したバイト値
    1021         */
    1022        private long getByteSize( final String slen ) {
    1023                if( slen == null ) { return -1L; }
    1024
    1025                String buf  = slen;
    1026                int    size = buf.length();
    1027
    1028                // 'B' は、単位換算に関係ない為、あれば削除します。
    1029                if( size > 0 && 'B' == buf.charAt( size-1 ) ) {
    1030                        buf = buf.substring( 0,size-1 );                        // 'B' が削除された文字列
    1031                        size--;
    1032                }
    1033
    1034                long rtn = -1L;
    1035
    1036                long tani = -1L;                                                                // 変換されたかどうかの判定も兼ねる。
    1037                if( size > 0 ) {
    1038                        final char ch = buf.charAt( size-1 );                           // 'K' , 'M' , 'G' のチェック
    1039                        switch( ch ) {
    1040                                case 'K' : tani=1024L; break;
    1041                                case 'M' : tani=1024L * 1024L ; break;
    1042                                case 'G' : tani=1024L * 1024L * 1024L ; break;
    1043                                default  : break;
    1044                        }
    1045                        if( tani > 0L ) {       // つまり、単位換算が行われた場合。
    1046                                buf = buf.substring( 0,size-1 );                // 'K','M','G' が削除された文字列
    1047                                size--;                                                                 // ここで空文字列になる可能性がある。
    1048                        }
    1049                        else {
    1050                                tani = 1L;              // 単位換算がない場合は、１倍。
    1051                        }
    1052                }
    1053
    1054                if( size > 0 ) {
    1055                        // 先の単位換算で、1L(=１倍)を設定して、if を無くしたが、long の掛け算なので、なんとなく抵抗がある。
    1056                        rtn = tani * Long.parseLong( buf );                     // buf はすでに数字だけになっているハズ。
    1057                }
    1058
    1059                return rtn ;
    1060        }
    1061
    1062        /**
    1063         * 内部判定フィルタ： 指定の大きさより大きいファイルの場合、スルー(選択)されます。
    1064         *
    1065         * 指定はバイト単位ですが、**KB , **MB , **GB などの単位を付ける事も可能です。
    1066         * 現時点では、K , KB , M , MB , G , GB のみ指定可能です。
    1067         *
    1068         * @og.rev 5.7.4.3 (2014/03/28) isLarger,isSmaller属性を文字列に変更
    1069         * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。
    1070         *
    1071         * @param       slen    ファイルの大きさ(バイト単位)。同値を含む
    1072         * @return      自分自身(this)
    1073         */
    1074        public HybsFileFilter isLarger( final String slen ) {
    1075                final long len = getByteSize( slen );
    1076
    1077                if( len >= 0L ) {
    1078                        list.add( new IsLargerFilter( len ) );
    1079                }
    1080                return this;            // 6.3.1.1 (2015/07/10)
    1081        }
    1082
    1083        /**
    1084         * 指定の大きさより大きいファイルの場合に選択される FileFilter インターフェースの実装内部クラスです。
    1085         *
    1086         * @version  4.0
    1087         * @author   Kazuhiko Hasegawa
    1088         * @since    JDK5.0,
    1089         */
    1090        private static final class IsLargerFilter implements FileFilter {
    1091                private final long size ;
    1092
    1093                /**
    1094                 * 大きいファイルフィルターオブジェクトを作成します。
    1095                 *
    1096                 * @og.rev 5.7.4.3 (2014/03/28) isLarger,isSmaller属性をlongに変更
    1097                 *
    1098                 * @param       len     ファイルの大きさ(バイト単位)。同値を含む
    1099                 */
    1100                IsLargerFilter( final long len ) {
    1101                        size = len ;
    1102                }
    1103
    1104                /**
    1105                 * FileFilter インターフェースの accept( File ) メソッド。
    1106                 *
    1107                 * @param       pathname        ファイルオブジェクト
    1108                 * @return      true:処理対象 / false:処理非対象
    1109                 * @see java.io.FileFilter#accept( File )
    1110                 */
    1111                public boolean accept( final File pathname ) {
    1112                        return pathname.length() >= size;
    1113                }
    1114
    1115                /**
    1116                 * このオブジェクトの文字列表現を返します。
    1117                 * 基本的にデバッグ目的に使用します。
    1118                 *
    1119                 * @return このクラスの文字列表現
    1120                 * @og.rtnNotNull
    1121                 */
    1122                @Override
    1123                public String toString() {
    1124                        final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE )
    1125                                .append( getClass() ).append( ':' )
    1126                                .append( " size=" ).append( size );
    1127
    1128                        return buf.toString();
    1129                }
    1130        }
    1131
    1132        /**
    1133         * 内部判定フィルタ： 指定の大きさより小さいファイルの場合、スルー(選択)されます。
    1134         * 引数が 0以下(マイナス) の場合は、追加しません。
    1135         *
    1136         * @og.rev 5.7.4.3 (2014/03/28) isLarger,isSmaller属性を文字列に変更
    1137         * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。
    1138         *
    1139         * @param    slen ファイルの大きさ(バイト単位)。同値を含まない。
    1140         * @return      自分自身(this)
    1141         */
    1142        public HybsFileFilter isSmaller( final String slen ) {
    1143                final long len = getByteSize( slen );
    1144
    1145                if( len >= 0L ) {
    1146                        list.add( new IsSmallerFilter( len ) );
    1147                }
    1148                return this;            // 6.3.1.1 (2015/07/10)
    1149        }
    1150
    1151        /**
    1152         * 指定の大きさより小さいファイルの場合選択される FileFilter インターフェースの実装内部クラスです。
    1153         *
    1154         * @version  4.0
    1155         * @author   Kazuhiko Hasegawa
    1156         * @since    JDK5.0,
    1157         */
    1158        private static final class IsSmallerFilter implements FileFilter {
    1159                private final long size ;
    1160
    1161                /**
    1162                 * 小さいファイルフィルターオブジェクトを作成します。
    1163                 *
    1164                 * @og.rev 5.7.4.3 (2014/03/28) isLarger,isSmaller属性をlongに変更
    1165                 *
    1166                 * @param    len ファイルの大きさ(バイト単位)。同値を含まない。
    1167                 */
    1168                IsSmallerFilter( final long len ) {
    1169                        size = len ;
    1170                }
    1171
    1172                /**
    1173                 * FileFilter インターフェースの accept( File ) メソッド。
    1174                 *
    1175                 * @param       pathname        ファイルオブジェクト
    1176                 * @return      true:処理対象 / false:処理非対象
    1177                 * @see java.io.FileFilter#accept( File )
    1178                 */
    1179                public boolean accept( final File pathname ) {
    1180                        return pathname.length() < size;
    1181                }
    1182
    1183                /**
    1184                 * このオブジェクトの文字列表現を返します。
    1185                 * 基本的にデバッグ目的に使用します。
    1186                 *
    1187                 * @return このクラスの文字列表現
    1188                 * @og.rtnNotNull
    1189                 */
    1190                @Override
    1191                public String toString() {
    1192                        final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE )
    1193                                .append( getClass() ).append( ':' )
    1194                                .append( " size=" ).append( size );
    1195
    1196                        return buf.toString();
    1197                }
    1198        }
    1199
    1200        /**
    1201         * 内部判定フィルタ： ファイルが hidden の場合、スルー(選択)されます。
    1202         * 引数がtrueの場合は、hiddenファイルのみを選択します。
    1203         * falseの場合は、hiddenファイル以外を選択します。(つまり hiddenファイルをブロックします。)
    1204         * hidden をブロックしたい場合は、false を設定し、すべて選択したい場合は、filter設定をしない事になります。
    1205         * 引数が null の場合は、追加しません。
    1206         *
    1207         * @og.rev 5.7.5.0 (2014/04/04) 新規追加
    1208         * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。
    1209         * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。
    1210         *
    1211         * @param       flag [true:/false]
    1212         * @return      自分自身(this)
    1213         */
    1214        public HybsFileFilter isHidden( final String flag ) {
    1215                return isHidden( flag, notEquals );                     // notEquals 属性
    1216        }
    1217
    1218        /**
    1219         * 内部判定フィルタ： ファイルが hidden の場合、スルー(選択)されます。
    1220         * 引数がtrueの場合は、hiddenファイルのみを選択します。
    1221         * falseの場合は、hiddenファイル以外を選択します。(つまり hiddenファイルをブロックします。)
    1222         * hidden をブロックしたい場合は、false を設定し、すべて選択したい場合は、filter設定をしない事になります。
    1223         * reverse = true に設定すると、結果を反転させます。
    1224         *
    1225         * @og.rev 5.7.5.0 (2014/04/04) 新規追加
    1226         * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。
    1227         *
    1228         * @param       flag [true:/false]
    1229         * @param       reverse true:結果を反転する
    1230         * @return      自分自身(this)
    1231         */
    1232        public HybsFileFilter isHidden( final String flag,final boolean reverse ) {
    1233                if( flag != null ) {
    1234                        list.add( new IsHiddenFilter( flag,reverse ) );
    1235                }
    1236                return this;            // 6.3.1.1 (2015/07/10)
    1237        }
    1238
    1239        /**
    1240         * ファイルが hidden の場合に選択される FileFilter インターフェースの実装内部クラスです。
    1241         * 引数がtrueの場合は、hiddenファイルのみを選択します。
    1242         * falseの場合は、hiddenファイル以外を選択します。(つまり hiddenファイルをブロックします。)
    1243         * hidden をブロックしたい場合は、false を設定し、すべて選択したい場合は、filter設定をしない事になります。
    1244         *
    1245         * @og.rev 5.7.5.0 (2014/04/04) 新規追加
    1246         *
    1247         * @version  6.0
    1248         * @author   Kazuhiko Hasegawa
    1249         * @since    JDK6.0,
    1250         */
    1251        private static final class IsHiddenFilter implements FileFilter {
    1252                private final boolean  flg  ;
    1253                private final boolean  rvse ;
    1254
    1255                /**
    1256                 * hiddenフィルターオブジェクトを作成します。
    1257                 *
    1258                 * @param       flag    true:hiddenのみ / false:
    1259                 * @param       reverse true:結果を反転する
    1260                 */
    1261                IsHiddenFilter( final String flag,final boolean reverse ) {
    1262                        flg  = Boolean.parseBoolean( flag );
    1263                        rvse = reverse;
    1264                }
    1265
    1266                /**
    1267                 * FileFilter インターフェースの accept( File ) メソッド。
    1268                 *
    1269                 * @param       pathname        ファイルオブジェクト
    1270                 * @return      true:処理対象 / false:処理非対象
    1271                 * @see java.io.FileFilter#accept( File )
    1272                 */
    1273                public boolean accept( final File pathname ) {
    1274                        return (pathname.isHidden()  ^  !flg) ^ rvse ;
    1275                                //  isHidden()          flg             !flg    rvse    ⇒ 結果
    1276                                // ======================================================
    1277                                //      true(hidden)    true    false   false   ⇒ true   選択
    1278                                //      true(hidden)    false   true    false   ⇒ false 除外
    1279                                //      false(normal)   true    false   false   ⇒ false 除外
    1280                                //      false(normal)   false   true    false   ⇒ true   選択
    1281
    1282                                //      true(hidden)    true    false   true    ⇒ false 除外
    1283                                //      true(hidden)    false   true    true    ⇒ true   選択
    1284                                //      false(normal)   true    false   true    ⇒ true   選択
    1285                                //      false(normal)   false   true    true    ⇒ false 除外
    1286                }
    1287
    1288                /**
    1289                 * このオブジェクトの文字列表現を返します。
    1290                 * 基本的にデバッグ目的に使用します。
    1291                 *
    1292                 * @return このクラスの文字列表現
    1293                 * @og.rtnNotNull
    1294                 */
    1295                @Override
    1296                public String toString() {
    1297                        final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE )
    1298                                .append( getClass() ).append( ':' )
    1299                                .append( " flag=" ).append( flg )
    1300                                .append( " reverse=" ).append( rvse );
    1301
    1302                        return buf.toString();
    1303                }
    1304        }
    1305
    1306        /**
    1307         * このオブジェクトの文字列表現を返します。
    1308         * 基本的にデバッグ目的に使用します。
    1309         *
    1310         * @return このクラスの文字列表現
    1311         * @og.rtnNotNull
    1312         */
    1313        @Override
    1314        public String toString() {
    1315                final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE );
    1316                final int size = list.size();
    1317                for( int i=0; i<size; i++ ) {
    1318                        buf.append( "no[" ).append( i ).append( "]=" );
    1319                        buf.append( list.get(i) ).append( CR );
    1320                }
    1321
    1322                return buf.toString();
    1323        }
    1324}