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