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 形式の 8文字数字文字列以外に、
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;              // 単位換算がない場合は、1倍。
808                        }
809                }
810
811                if( size > 0 ) {
812                        // 先の単位換算で、1L(=1倍)を設定して、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 形式の 8文字数字文字列以外に、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}