    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                 *
    826                 * @return このクラスの文字列表現
    827                 * @og.rtnNotNull
    828                 */
    829                @Override
    830                public String toString() {
    831                        final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE )
    832                                .append( getClass() ).append( ':' )
    833                                .append( " pattern=" ).append( pattern )
    834                                .append( " reverse=" ).append( rvse );
    835
    836                        return buf.toString();
    837                }
    838        }
    839
    840        /**
    841         * 内部判定フィルタ： 指定のタイムスタンプ以後に変更されている場合、スルー(選択)されます。
    842         * ディレクトリは、ここの判定では無視します。(必ず true を返します)
    843         * 日付けの指定に、YYYYMMDD 形式の ８文字数字文字列以外に、
    844         * TODAY や YESTERDAY なども使用できます。
    845         * TODAY は、実行日の 00:00:00 を基準時刻とし、YESTERDAY は、その前日になります。
    846         * 引数が null の場合は、追加しません。
    847         *
    848         * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。
    849         * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。
    850         *
    851         * @param    modify 時刻を表す long 値(ミリ秒単位)
    852         * @return      自分自身(this)
    853         */
    854        public HybsFileFilter lastModified( final String modify ) {
    855                return lastModified( modify, notEquals );       // notEquals 属性
    856        }
    857
    858        /**
    859         * 内部判定フィルタ： 指定のタイムスタンプ以後に変更されている場合、スルー(選択)されます。
    860         * ディレクトリは、ここの判定では無視します。(必ず true を返します)
    861         * 日付けの指定に、YYYYMMDD 形式の ８文字数字文字列以外に、
    862         * TODAY や YESTERDAY なども使用できます。
    863         * TODAY は、実行日の 00:00:00 を基準時刻とし、YESTERDAY は、その前日になります。
    864         * 引数が null の場合は、追加しません。
    865         *
    866         * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。
    867         * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。
    868         *
    869         * @param       modify 時刻を表す long 値(ミリ秒単位)
    870         * @return      自分自身(this)
    871         * @param       reverse true:結果を反転する
    872         */
    873        public HybsFileFilter lastModified( final String modify,final boolean reverse ) {
    874                if( modify != null ) {
    875                        list.add( new ModifyFileFilter( modify,reverse ) );
    876                }
    877                return this;            // 6.3.1.1 (2015/07/10)
    878        }
    879
    880        /**
    881         * ModifyFileFilter.java は、最終変更日付けのフィルタークラスです。
    882         *
    883         * FileFilter インターフェースを継承し、コンストラクタで指定の日付けよりも
    884         * 最終変更日付け が新しいファイルを、選択します。
    885         * このクラスでは、ディレクトリは、変更日付けに無関係に選択します。
    886         *
    887         * 日付けの指定に、YYYYMMDD 形式の ８文字数字文字列以外に、TODAY や YESTERDAY なども使用できます。
    888         * TODAY は、実行日の 00:00:00 を基準時刻とし、YESTERDAY は、その前日になります。
    889         * バッチ処理等で、前日分の再編成や、先月分を再編成する場合に、実日付けを指定せずに
    890         * 使用できます。
    891         *
    892         * この実装は同期化されません。
    893         *
    894         * @version  4.0
    895         * @author   Kazuhiko Hasegawa
    896         * @since    JDK5.0,
    897         */
    898        private static final class ModifyFileFilter implements FileFilter {
    899                private final long              modify ;
    900                private final boolean   rvse ;          // 6.8.0.0 (2017/06/02)
    901
    902                /**
    903                 * コンストラクター
    904                 *
    905                 * 日付けの指定方法には、実日付け(YYYYMMDD形式 例：20040323)と
    906                 * 仮想日付け(TODAY,YESTERDAY など)が指定できます。
    907                 *
    908                 *     YYYYMMDD   YYYYMMDD形式の指定日の 00:00:00 を基準時刻
    909                 *     TODAY      実行日の 00:00:00 を基準時刻
    910                 *     YESTERDAY  実行日前日の 00:00:00 を基準時刻
    911                 *     LAST_WEEK  実行日の先週(7日前) 00:00:00 を基準時刻
    912                 *     MONTH      実行月の 1日 00:00:00 を基準時刻
    913                 *     LAST_MONTH 実行前月の 同日 00:00:00 を基準時刻
    914                 *     LAST_YEAR  実行前年の 同月同日 00:00:00 を基準時刻
    915                 *
    916                 * @og.rev 5.3.5.0 (2011/05/01) ｢時｣のクリアミスの修正
    917                 * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。
    918                 *
    919                 * @param value 指定日付け
    920                 * @param       reverse true:結果を反転する
    921                 */
    922                ModifyFileFilter( final String value , final boolean reverse ) {
    923                        rvse = reverse;                         // 6.8.0.0 (2017/06/02)
    924
    925                        // 6.4.1.1 (2016/01/16) PMD refactoring. Avoid if (x != y) ..; else ..;
    926                        if( value == null ) {
    927                                throw new OgRuntimeException( "ModifyFileFilter Error! modify valus is not null" );
    928                        }
    929
    930        //              if( value != null ) {
    931                                final Calendar cal = Calendar.getInstance();
    932
    933                                cal.set( Calendar.HOUR_OF_DAY, 0 );             // 5.3.5.0 (2011/05/01) 時間の解決規則が適用されるため、｢時｣だけは、setメソッドで 0 にセットする。
    934                                cal.clear( Calendar.MINUTE );
    935                                cal.clear( Calendar.SECOND );
    936                                cal.clear( Calendar.MILLISECOND );
    937
    938                                if( "YESTERDAY".equalsIgnoreCase( value ) ) {
    939                                        cal.add( Calendar.DATE, -1 );
    940                                }
    941                                else if( "LAST_WEEK".equalsIgnoreCase( value ) ) {
    942                                        cal.add( Calendar.DATE, -7 );
    943                                }
    944                                else if( "MONTH".equalsIgnoreCase( value ) ) {
    945                                        cal.set( Calendar.DATE, 1 );
    946                                }
    947                                else if( "LAST_MONTH".equalsIgnoreCase( value ) ) {
    948                                        cal.add( Calendar.MONTH, -1 );
    949                                }
    950                                else if( "LAST_YEAR".equalsIgnoreCase( value ) ) {
    951                                        cal.add( Calendar.YEAR, -1 );
    952                                }
    953                                else if( value.length() == 8 ) {
    954                                        cal.set( Integer.parseInt( value.substring( 0,4 ) ) ,
    955                                                         Integer.parseInt( value.substring( 4,6 ) ) - 1,
    956                                                         Integer.parseInt( value.substring( 6,8 ) ) );
    957                                }
    958                                else if( ! "TODAY".equalsIgnoreCase( value ) ) {
    959                                        final String errMsg = "ModifyFileFilter Error! modify Format [" + value + "]"   + CR
    960                                                         + "日付けの指定方法には、実日付け(YYYYMMDD形式 例：20040323)と"            + CR
    961                                                         + "仮想日付け(TODAY,YESTERDAY など)が指定できます。"                                  + CR
    962                                                         + "    YYYYMMDD   YYYYMMDD形式の指定日の 00:00:00 を基準時刻"                      + CR
    963                                                         + "    TODAY      実行日の 00:00:00 を基準時刻"                                         + CR
    964                                                         + "    YESTERDAY  実行日前日の 00:00:00 を基準時刻"                                       + CR
    965                                                         + "    LAST_WEEK  実行日の先週(7日前) 00:00:00 を基準時刻"                          + CR
    966                                                         + "    MONTH      実行月の 1日 00:00:00 を基準時刻"                                      + CR
    967                                                         + "    LAST_MONTH 実行前月の 同日 00:00:00 を基準時刻"                                     + CR
    968                                                         + "    LAST_YEAR  実行前年の 同月同日 00:00:00 を基準時刻"                           + CR ;
    969                                        throw new OgRuntimeException( errMsg );
    970                                }
    971                                modify = cal.getTimeInMillis() ;
    972        //              }
    973        //              else {
    974        //                      throw new OgRuntimeException( "ModifyFileFilter Error! modify valus is not null" );
    975        //              }
    976                }
    977
    978                /**
    979                 * FileFilter インターフェースの accept( File ) メソッド。
    980                 *
    981                 * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。
    982                 *
    983                 * @param       file    ファイルオブジェクト
    984                 *
    985                 * @return      true:処理対象 / false:処理非対象
    986                 * @see java.io.FileFilter#accept( File )
    987                 */
    988                public boolean accept( final File file ) {
    989//                      return file.isDirectory() || ( ( file.lastModified() >= modify ) ^ rvse ) ;             // 反転は日付判定の箇所のみ。
    990                        return file.isDirectory() || file.lastModified() >= modify ^ rvse ;                             // 反転は日付判定の箇所のみ。        6.9.7.0 (2018/05/14) PMD Useless parentheses.
    991                }
    992
    993                /**
    994                 * このオブジェクトの文字列表現を返します。
    995                 * 基本的にデバッグ目的に使用します。
    996                 *
    997                 * @return このクラスの文字列表現
    998                 * @og.rtnNotNull
    999                 */
    1000                @Override
    1001                public String toString() {
    1002                        final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE )
    1003                                .append( getClass()  ).append( ':' )
    1004                                .append( " modify="  ).append( DateSet.getDate( modify,"yyyy/MM/dd" ) )
    1005                                .append( " reverse=" ).append( rvse );
    1006
    1007                        return buf.toString();
    1008                }
    1009        }
    1010
    1011        /**
    1012         * 共通処理：単位記号の付与されたバイト文字列から、long値であるバイトを求めます。
    1013         * 現時点では、K , KB , M , MB , G , GB のみ単位指定可能です。
    1014         * それぞれ、元の値に対して、1024倍されます。
    1015         *
    1016         * 処理が正常に出来ない場合は、-1L を返します。
    1017         *
    1018         * @og.rev 5.7.4.3 (2014/03/28) 新規追加
    1019         *
    1020         * @param       slen 単位記号付きバイト値
    1021         * @return      longに換算したバイト値
    1022         */
    1023        private long getByteSize( final String slen ) {
    1024                if( slen == null ) { return -1L; }
    1025
    1026                String buf  = slen;
    1027                int    size = buf.length();
    1028
    1029                // 'B' は、単位換算に関係ない為、あれば削除します。
    1030                if( size > 0 && 'B' == buf.charAt( size-1 ) ) {
    1031                        buf = buf.substring( 0,size-1 );                        // 'B' が削除された文字列
    1032                        size--;
    1033                }
    1034
    1035                long rtn = -1L;
    1036
    1037                long tani = -1L;                                                                // 変換されたかどうかの判定も兼ねる。
    1038                if( size > 0 ) {
    1039                        final char ch = buf.charAt( size-1 );                           // 'K' , 'M' , 'G' のチェック
    1040                        switch( ch ) {
    1041                                case 'K' : tani=1024L; break;
    1042                                case 'M' : tani=1024L * 1024L ; break;
    1043                                case 'G' : tani=1024L * 1024L * 1024L ; break;
    1044                                default  : break;
    1045                        }
    1046                        if( tani > 0L ) {       // つまり、単位換算が行われた場合。
    1047                                buf = buf.substring( 0,size-1 );                // 'K','M','G' が削除された文字列
    1048                                size--;                                                                 // ここで空文字列になる可能性がある。
    1049                        }
    1050                        else {
    1051                                tani = 1L;              // 単位換算がない場合は、１倍。
    1052                        }
    1053                }
    1054
    1055                if( size > 0 ) {
    1056                        // 先の単位換算で、1L(=１倍)を設定して、if を無くしたが、long の掛け算なので、なんとなく抵抗がある。
    1057                        rtn = tani * Long.parseLong( buf );                     // buf はすでに数字だけになっているハズ。
    1058                }
    1059
    1060                return rtn ;
    1061        }
    1062
    1063        /**
    1064         * 内部判定フィルタ： 指定の大きさより大きいファイルの場合、スルー(選択)されます。
    1065         *
    1066         * 指定はバイト単位ですが、**KB , **MB , **GB などの単位を付ける事も可能です。
    1067         * 現時点では、K , KB , M , MB , G , GB のみ指定可能です。
    1068         *
    1069         * @og.rev 5.7.4.3 (2014/03/28) isLarger,isSmaller属性を文字列に変更
    1070         * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。
    1071         *
    1072         * @param       slen    ファイルの大きさ(バイト単位)。同値を含む
    1073         * @return      自分自身(this)
    1074         */
    1075        public HybsFileFilter isLarger( final String slen ) {
    1076                final long len = getByteSize( slen );
    1077
    1078                if( len >= 0L ) {
    1079                        list.add( new IsLargerFilter( len ) );
    1080                }
    1081                return this;            // 6.3.1.1 (2015/07/10)
    1082        }
    1083
    1084        /**
    1085         * 指定の大きさより大きいファイルの場合に選択される FileFilter インターフェースの実装内部クラスです。
    1086         *
    1087         * @version  4.0
    1088         * @author   Kazuhiko Hasegawa
    1089         * @since    JDK5.0,
    1090         */
    1091        private static final class IsLargerFilter implements FileFilter {
    1092                private final long size ;
    1093
    1094                /**
    1095                 * 大きいファイルフィルターオブジェクトを作成します。
    1096                 *
    1097                 * @og.rev 5.7.4.3 (2014/03/28) isLarger,isSmaller属性をlongに変更
    1098                 *
    1099                 * @param       len     ファイルの大きさ(バイト単位)。同値を含む
    1100                 */
    1101                IsLargerFilter( final long len ) {
    1102                        size = len ;
    1103                }
    1104
    1105                /**
    1106                 * FileFilter インターフェースの accept( File ) メソッド。
    1107                 *
    1108                 * @param       pathname        ファイルオブジェクト
    1109                 * @return      true:処理対象 / false:処理非対象
    1110                 * @see java.io.FileFilter#accept( File )
    1111                 */
    1112                public boolean accept( final File pathname ) {
    1113                        return pathname.length() >= size;
    1114                }
    1115
    1116                /**
    1117                 * このオブジェクトの文字列表現を返します。
    1118                 * 基本的にデバッグ目的に使用します。
    1119                 *
    1120                 * @return このクラスの文字列表現
    1121                 * @og.rtnNotNull
    1122                 */
    1123                @Override
    1124                public String toString() {
    1125                        final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE )
    1126                                .append( getClass() ).append( ':' )
    1127                                .append( " size=" ).append( size );
    1128
    1129                        return buf.toString();
    1130                }
    1131        }
    1132
    1133        /**
    1134         * 内部判定フィルタ： 指定の大きさより小さいファイルの場合、スルー(選択)されます。
    1135         * 引数が 0以下(マイナス) の場合は、追加しません。
    1136         *
    1137         * @og.rev 5.7.4.3 (2014/03/28) isLarger,isSmaller属性を文字列に変更
    1138         * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。
    1139         *
    1140         * @param    slen ファイルの大きさ(バイト単位)。同値を含まない。
    1141         * @return      自分自身(this)
    1142         */
    1143        public HybsFileFilter isSmaller( final String slen ) {
    1144                final long len = getByteSize( slen );
    1145
    1146                if( len >= 0L ) {
    1147                        list.add( new IsSmallerFilter( len ) );
    1148                }
    1149                return this;            // 6.3.1.1 (2015/07/10)
    1150        }
    1151
    1152        /**
    1153         * 指定の大きさより小さいファイルの場合選択される FileFilter インターフェースの実装内部クラスです。
    1154         *
    1155         * @version  4.0
    1156         * @author   Kazuhiko Hasegawa
    1157         * @since    JDK5.0,
    1158         */
    1159        private static final class IsSmallerFilter implements FileFilter {
    1160                private final long size ;
    1161
    1162                /**
    1163                 * 小さいファイルフィルターオブジェクトを作成します。
    1164                 *
    1165                 * @og.rev 5.7.4.3 (2014/03/28) isLarger,isSmaller属性をlongに変更
    1166                 *
    1167                 * @param    len ファイルの大きさ(バイト単位)。同値を含まない。
    1168                 */
    1169                IsSmallerFilter( final long len ) {
    1170                        size = len ;
    1171                }
    1172
    1173                /**
    1174                 * FileFilter インターフェースの accept( File ) メソッド。
    1175                 *
    1176                 * @param       pathname        ファイルオブジェクト
    1177                 * @return      true:処理対象 / false:処理非対象
    1178                 * @see java.io.FileFilter#accept( File )
    1179                 */
    1180                public boolean accept( final File pathname ) {
    1181                        return pathname.length() < size;
    1182                }
    1183
    1184                /**
    1185                 * このオブジェクトの文字列表現を返します。
    1186                 * 基本的にデバッグ目的に使用します。
    1187                 *
    1188                 * @return このクラスの文字列表現
    1189                 * @og.rtnNotNull
    1190                 */
    1191                @Override
    1192                public String toString() {
    1193                        final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE )
    1194                                .append( getClass() ).append( ':' )
    1195                                .append( " size=" ).append( size );
    1196
    1197                        return buf.toString();
    1198                }
    1199        }
    1200
    1201        /**
    1202         * 内部判定フィルタ： ファイルが hidden の場合、スルー(選択)されます。
    1203         * 引数がtrueの場合は、hiddenファイルのみを選択します。
    1204         * falseの場合は、hiddenファイル以外を選択します。(つまり hiddenファイルをブロックします。)
    1205         * hidden をブロックしたい場合は、false を設定し、すべて選択したい場合は、filter設定をしない事になります。
    1206         * 引数が null の場合は、追加しません。
    1207         *
    1208         * @og.rev 5.7.5.0 (2014/04/04) 新規追加
    1209         * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。
    1210         * @og.rev 6.8.0.0 (2017/06/02) 判定結果を反転させて処理する notEquals 属性を追加します。
    1211         *
    1212         * @param       flag [true:/false]
    1213         * @return      自分自身(this)
    1214         */
    1215        public HybsFileFilter isHidden( final String flag ) {
    1216                return isHidden( flag, notEquals );                     // notEquals 属性
    1217        }
    1218
    1219        /**
    1220         * 内部判定フィルタ： ファイルが hidden の場合、スルー(選択)されます。
    1221         * 引数がtrueの場合は、hiddenファイルのみを選択します。
    1222         * falseの場合は、hiddenファイル以外を選択します。(つまり hiddenファイルをブロックします。)
    1223         * hidden をブロックしたい場合は、false を設定し、すべて選択したい場合は、filter設定をしない事になります。
    1224         * reverse = true に設定すると、結果を反転させます。
    1225         *
    1226         * @og.rev 5.7.5.0 (2014/04/04) 新規追加
    1227         * @og.rev 6.3.1.1 (2015/07/10) 自分自身を返します。
    1228         *
    1229         * @param       flag [true:/false]
    1230         * @param       reverse true:結果を反転する
    1231         * @return      自分自身(this)
    1232         */
    1233        public HybsFileFilter isHidden( final String flag,final boolean reverse ) {
    1234                if( flag != null ) {
    1235                        list.add( new IsHiddenFilter( flag,reverse ) );
    1236                }
    1237                return this;            // 6.3.1.1 (2015/07/10)
    1238        }
    1239
    1240        /**
    1241         * ファイルが hidden の場合に選択される FileFilter インターフェースの実装内部クラスです。
    1242         * 引数がtrueの場合は、hiddenファイルのみを選択します。
    1243         * falseの場合は、hiddenファイル以外を選択します。(つまり hiddenファイルをブロックします。)
    1244         * hidden をブロックしたい場合は、false を設定し、すべて選択したい場合は、filter設定をしない事になります。
    1245         *
    1246         * @og.rev 5.7.5.0 (2014/04/04) 新規追加
    1247         *
    1248         * @version  6.0
    1249         * @author   Kazuhiko Hasegawa
    1250         * @since    JDK6.0,
    1251         */
    1252        private static final class IsHiddenFilter implements FileFilter {
    1253                private final boolean  flg  ;
    1254                private final boolean  rvse ;
    1255
    1256                /**
    1257                 * hiddenフィルターオブジェクトを作成します。
    1258                 *
    1259                 * @param       flag    true:hiddenのみ / false:
    1260                 * @param       reverse true:結果を反転する
    1261                 */
    1262                IsHiddenFilter( final String flag,final boolean reverse ) {
    1263                        flg  = Boolean.parseBoolean( flag );
    1264                        rvse = reverse;
    1265                }
    1266
    1267                /**
    1268                 * FileFilter インターフェースの accept( File ) メソッド。
    1269                 *
    1270                 * @param       pathname        ファイルオブジェクト
    1271                 * @return      true:処理対象 / false:処理非対象
    1272                 * @see java.io.FileFilter#accept( File )
    1273                 */
    1274                public boolean accept( final File pathname ) {
    1275                        return (pathname.isHidden()  ^  !flg) ^ rvse ;
    1276                                //  isHidden()          flg             !flg    rvse    ⇒ 結果
    1277                                // ======================================================
    1278                                //      true(hidden)    true    false   false   ⇒ true   選択
    1279                                //      true(hidden)    false   true    false   ⇒ false 除外
    1280                                //      false(normal)   true    false   false   ⇒ false 除外
    1281                                //      false(normal)   false   true    false   ⇒ true   選択
    1282
    1283                                //      true(hidden)    true    false   true    ⇒ false 除外
    1284                                //      true(hidden)    false   true    true    ⇒ true   選択
    1285                                //      false(normal)   true    false   true    ⇒ true   選択
    1286                                //      false(normal)   false   true    true    ⇒ false 除外
    1287                }
    1288
    1289                /**
    1290                 * このオブジェクトの文字列表現を返します。
    1291                 * 基本的にデバッグ目的に使用します。
    1292                 *
    1293                 * @return このクラスの文字列表現
    1294                 * @og.rtnNotNull
    1295                 */
    1296                @Override
    1297                public String toString() {
    1298                        final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE )
    1299                                .append( getClass() ).append( ':' )
    1300                                .append( " flag=" ).append( flg )
    1301                                .append( " reverse=" ).append( rvse );
    1302
    1303                        return buf.toString();
    1304                }
    1305        }
    1306
    1307        /**
    1308         * このオブジェクトの文字列表現を返します。
    1309         * 基本的にデバッグ目的に使用します。
    1310         *
    1311         * @return このクラスの文字列表現
    1312         * @og.rtnNotNull
    1313         */
    1314        @Override
    1315        public String toString() {
    1316                final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE );
    1317                final int size = list.size();
    1318                for( int i=0; i<size; i++ ) {
    1319                        buf.append( "no[" ).append( i ).append( "]=" );
    1320                        buf.append( list.get(i) ).append( CR );
    1321                }
    1322
    1323                return buf.toString();
    1324        }
    1325}