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