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.hayabusa.taglib;
017
018import org.opengion.hayabusa.common.HybsSystemException;
019import org.opengion.fukurou.util.StringUtil ;
020import org.opengion.fukurou.util.ToString;                                              // 6.1.1.0 (2015/01/17)
021import org.opengion.fukurou.util.ArraySet;                                              // 6.4.3.4 (2016/03/11)
022
023import static org.opengion.fukurou.util.StringUtil.nval ;
024
025import java.util.Locale ;
026import java.util.Set;                                                                                   // 6.4.3.4 (2016/03/11)
027
028/**
029 * val1 属性 と val2 属性の文字列表現の比較により BODY を表示/非表示を切り替えるタグです。
030 *
031 * val1.equals( val2 ) が 成立すれば、 BODY を表示します。
032 * val1 が null( or ゼロ文字列) の場合は、無条件で非成立になります。
033 *  ( val1 == val2 ) はチェックしないというイメージです。
034 * val1 が null( or ゼロ文字列) かどうか判断する場合は、nullCheck="true" を使用してください。
035 * その他の属性は、比較方法を指定します。
036 *
037 * ※ 6.9.3.0 (2018/03/26) isException 追加
038 * val1,val2 の処理で、Exceptionが発生した場合、true と判手され、BODY内部が処理されます。
039 * これは、{@DBF.CON @DBID} のように、データベース接続の存在チェックを行うケースを
040 * 想定しています。なので、通常は、useStop="true" とともに、エラーメッセージを表示して、処理を止めます。
041 *
042 * @og.formSample
043 * ●形式:<og:equals val1="…" val2="[…]" ・・・ >・・・</og:equals>
044 * ●body:あり(EVAL_BODY_INCLUDE:BODYをインクルードし、{@XXXX} は解析しません)
045 *
046 * ●Tag定義:
047 *   <og:equals
048 *       val1             ○【TAG】equals で比較するときの、第1引数(左辺)を指定します(必須)。
049 *       val2               【TAG】equals で比較するときの、第2引数(右辺)を指定します
050 *       ignoreCase         【TAG】大文字/小文字を区別しないかどうか[true/false]を指定します(初期値:false(区別する))
051 *       useTrim            【TAG】比較対象の引数を、trim()するかどうか[true/false]を指定します(初期値:false(trimしない))
052 *       startsWith         【TAG】この文字列が、指定された接頭辞で始まるかどうか[true/false]を判定します(初期値:false)
053 *       endsWith           【TAG】指定された接尾辞で終るかどうか[true/false]を判定します(初期値:false)
054 *       nullCheck          【TAG】null チェックを行うかどうか[true/false]を指定します(初期値:false)
055 *       notEquals          【TAG】判定結果を反転させるかどうか[true/false]を指定します(初期値:false)
056 *       contains           【TAG】文字列が含まれているかどうか[true/false]の判定します(初期値:false)
057 *       matches            【TAG】指定された正規表現と一致するかどうか[true/false]を判定します(初期値:false)
058 *       useStop            【TAG】BODYを処理後に停止するかどうか[true/false]を指定します(初期値:false)
059 *       isException        【TAG】val1,val2 の設定で、エラーが発生したかどうか[true/false]の判定します(初期値:false)
060 *       operator           【TAG】比較する操作を EQ,LT,LE,GT,GE から指定します(初期値:EQ)
061 *       compareType        【TAG】大小比較する方法(STRING:前方比較 、NUMBER:数値比較)を指定します(初期値:STRING)
062 *       debug              【TAG】デバッグ情報を出力するかどうか[true/false]を指定します(初期値:false)
063 *   >   ... Body ...
064 *   </og:equals>
065 *
066 * ●使用例
067 *      ・<og:equals val1="ABCD" val2="{@value}" >
068 *            val1.equals( val2 ) 時に実行したい内容
069 *        </og:equals>
070 *
071 *      ・<og:equals val1="{@value}" nullCheck="true" >
072 *            val1がnullの時に実行したい内容
073 *        </og:equals>
074 *
075 *      ・<og:equals val1="AbcD" val2="{@value}" ignoreCase="true" >
076 *            val1.equalsIgnoreCase( val2 ) 時に実行したい内容
077 *        </og:equals>
078 *
079 *      ・<og:equals val1="ABCD" val2="{@value}" startsWith="true" >
080 *            val1.startsWith( val2 ) 時に実行したい内容
081 *        </og:equals>
082 *
083 * @og.group 画面制御
084 * @og.rev 6.4.2.0 (2016/01/29) ソースの内部構造の全体的な見直し。
085 *
086 * @version  4.0
087 * @author   Kazuhiko Hasegawa
088 * @since    JDK5.0,
089 */
090public class EqualsTag extends CommonTagSupport {
091        /** このプログラムのVERSION文字列を設定します。   {@value} */
092        private static final String VERSION = "6.9.3.0 (2018/03/26)" ;
093        private static final long serialVersionUID = 693020180326L ;
094
095        // 6.4.3.4 (2016/03/11) String配列 から、Setに置き換えます。
096        private static final Set<String> OPERATOR_SET = new ArraySet<>( "EQ","LT","LE","GT","GE","GE" );
097        private static final Set<String> COMP_TYPE_SET = new ArraySet<>( "STRING","NUMBER" );
098
099        private String  value1          ;
100        private String  value2          ;
101        // 5.1.2.0 (2010/01/01)
102        private boolean ignoreCase      ;       // 大文字/小文字の区別
103        private boolean useTrim         ;       // 6.4.2.0 (2016/01/29) trimするかどうか
104        private boolean isStartsWith;   // 先頭から始まるかどうかのチェック(startsWith)
105        private boolean nullCheck       ;       // null チェックを行う場合うかどうか?
106        private boolean notEquals       ;       // 判定結果を反転させて処理します。
107
108        // 3.2.0.0 (2003/05/22) 判定方法に以下の3方法を追加します。
109        private boolean isContains      ;       // 文字列が含まれているかどうかの判定
110        private boolean isEndsWith      ;       // 指定された接尾辞で終るかどうかを判定(endsWith)
111        private boolean isMatches       ;       // 指定された正規表現と一致するかどうかを判定
112
113        // 3.8.1.2 (2005/12/19) BODYを処理後に停止するかどうかを指定します。
114        private boolean useStop         ;       // BODYを処理後に停止(true)するかどうか
115
116        // 3.8.1.3B (2006/01/30) operator、compareType 属性を追加します。
117        private String  operator        = "EQ";
118        private String  compareType     = "STRING";
119
120        // 6.9.3.0 (2018/03/26) val1,val2 の設定で、エラーが発生した場合に、true にセットされます。
121        private boolean isException     ;
122        private boolean isOccurExce     ;       // 6.9.3.0 (2018/03/26) isException 属性判定用のエラーが発生したかどうかの判定フラグ(内部変数)
123
124        /**
125         * デフォルトコンストラクター
126         *
127         * @og.rev 6.4.2.0 (2016/01/29) PMD refactoring. Each class should declare at least one constructor.
128         */
129        public EqualsTag() { super(); }         // これも、自動的に呼ばれるが、空のメソッドを作成すると警告されるので、明示的にしておきます。
130
131        /**
132         * Taglibの開始タグが見つかったときに処理する doStartTag() を オーバーライドします。
133         *
134         * @og.rev 3.2.0.0 (2003/05/22) 判定方法に,contains,endsWith,matches の方法を追加
135         * @og.rev 3.8.1.3B (2006/01/30) operator、compareType 属性を追加します。
136         * @og.rev 3.8.5.1 (2006/04/28) equals の結果が true 時のみ、useStop="true" を有効にする。
137         * @og.rev 6.4.2.0 (2016/01/29) ソースの内部構造の全体的な見直し。
138         * @og.rev 6.9.3.0 (2018/03/26) isException 属性を追加します。
139         *
140         * @return      後続処理の指示
141         */
142        @Override
143        public int doStartTag() {
144                // 6.4.2.0 (2016/01/29) useTrim の追加。
145                if( useTrim ) {
146                        if( value1 != null ) { value1 = value1.trim(); }
147                        if( value2 != null ) { value2 = value2.trim(); }
148                }
149
150                // 6.4.2.0 (2016/01/29) ignoreCase の先行対応。
151                if( ignoreCase ) {
152                        if( value1 != null ) { value1 = value1.toUpperCase(Locale.JAPAN); }
153                        if( value2 != null ) { value2 = value2.toUpperCase(Locale.JAPAN); }
154                }
155
156                // 6.4.2.0 (2016/01/29) 排他的論理和 で、判定結果の反転。
157                final boolean flag =                                                                                            // 6.9.7.0 (2018/05/14) PMD Useless parentheses.
158                                        (       isStartsWith    && startsWith(  value1,value2 ) ||      // 先に isStartsWith をチェック
159                                                isContains              && contains(    value1,value2 ) ||
160                                                isEndsWith              && endsWith(    value1,value2 ) ||
161                                                isMatches               && matches(             value1,value2 ) ||
162                                                nullCheck               && isNullCheck( value1            )     ||
163                                                isException             && isOccurExce                                  ||      // 6.9.3.0 (2018/03/26)
164                                                operation( value1,value2,operator,compareType )
165                                        ) ^ notEquals;
166
167                // 3.8.5.1 (2006/04/28) equals の結果が true 時のみ、useStop="true" を有効にする。
168                useStop = useStop && flag ;             // 少し回りくどいが判りやすいでしょ。
169
170                return flag ? EVAL_BODY_INCLUDE : SKIP_BODY ; 
171        }
172
173        /**
174         * Taglibの終了タグが見つかったときに処理する doEndTag() を オーバーライドします。
175         *
176         * @og.rev 3.8.1.2 (2005/12/19) useStop 属性を処理します。
177         * @og.rev 6.4.2.0 (2016/01/29) ソースの内部構造の全体的な見直し。
178         * @og.rev 6.4.2.1 (2016/02/05) debugPrint() の追加。
179         *
180         * @return      後続処理の指示
181         */
182        @Override
183        public int doEndTag() {
184                debugPrint();                           // 6.4.2.1 (2016/02/05)
185
186                return useStop ? SKIP_PAGE : EVAL_PAGE ; 
187        }
188
189        /**
190         * タグリブオブジェクトをリリースします。
191         * キャッシュされて再利用されるので、フィールドの初期設定を行います。
192         *
193         * @og.rev 2.0.0.4 (2002/09/27) カスタムタグの release() メソッドを、追加
194         * @og.rev 3.1.1.2 (2003/04/04) Tomcat4.1 対応。release2() を doEndTag()で呼ぶ。
195         * @og.rev 3.2.0.0 (2003/05/22) 判定方法に,contains,endsWith,matches の方法を追加
196         * @og.rev 3.8.1.2 (2005/12/19) useStop 属性の追加
197         * @og.rev 3.8.1.3 (2006/01/30) operator、compareType 属性を追加します。
198         * @og.rev 5.1.2.0 (2010/01/01) ignoreCase属性の初期値をfalse(大文字、小文字を区別する)
199         * @og.rev 6.4.2.0 (2016/01/29) trim属性を追加します。
200         * @og.rev 6.4.2.0 (2016/01/29) trim属性を追加します。
201         * @og.rev 6.9.3.0 (2018/03/26) isException 属性を追加します。
202         */
203        @Override
204        protected void release2() {
205                super.release2();
206                value1          = null;
207                value2          = null;
208                ignoreCase      = false;        // 5.1.2.0 (2010/01/01) 大文字/小文字の区別
209                useTrim         = false;        // 6.4.2.0 (2016/01/29) trimするかどうか
210                isStartsWith= false;    // 先頭から始まるかどうかのチェック
211                nullCheck       = false;        // null チェックを行う場合うかどうか?
212                notEquals       = false;        // 判定結果を反転させて処理します。
213                isContains      = false;        // 文字列が含まれているかどうかの判定
214                isEndsWith      = false;        // 指定された接尾辞で終るかどうかを判定
215                isMatches       = false;        // 指定された正規表現と一致するかどうかを判定
216                useStop         = false;        // 3.8.1.2 (2005/12/19)
217                operator        = "EQ";         // 3.8.1.3B (2006/01/30)
218                compareType     = "STRING";     // 3.8.1.3B (2006/01/30)
219                isException     = false;        // 6.9.3.0 (2018/03/26)
220                isOccurExce     = false;        // 6.9.3.0 (2018/03/26) isException 属性判定用のエラーが発生したかどうかの判定フラグ(内部変数)
221        }
222
223        /**
224         * operator に対応した比較処理を行います。
225         * val1 または、val2 が null の場合は、無条件で false を返します。
226         *
227         * @og.rev 3.8.1.3 (2006/02/06) 判定方法に, LT, GT, LE, GE, EQ追加
228         * @og.rev 6.4.2.0 (2016/01/29) ソースの内部構造の全体的な見直し。
229         *
230         * @param   val1 第1引数
231         * @param   val2 第2引数
232         * @param   op 比較方法
233         * @param   ty 比較種類
234         *
235         * @return  第1,第2引数が null/ゼロストリング でなく、且つ opeに対応した比較結果を返します。
236         */
237        private boolean operation( final String val1,final String val2,final String op,final String ty ) {
238                if( isNullCheck( val1 ) || isNullCheck( val2 )) { return false; }
239                // 文字列比較
240                final boolean rtn;
241                if( "STRING".equals( ty ) ) {
242                        switch( op ) {
243                                case "LT" : rtn = val1.compareTo( val2 ) < 0 ;  break;
244                                case "GT" : rtn = val1.compareTo( val2 ) > 0 ;  break;
245                                case "LE" : rtn = val1.compareTo( val2 ) <= 0;  break;
246                                case "GE" : rtn = val1.compareTo( val2 ) >= 0;  break;
247                                default   : rtn = val1.equals(    val2 );               break;
248                        }
249
250                // 数字比較
251                } else {
252                        // 厳密に処理しなくて良いと思うのでBigDecimalは使わない
253                        final double d1  = StringUtil.parseDouble( val1 );
254                        final double d2  = StringUtil.parseDouble( val2 );
255                        switch( op ) {
256                                case "LT" : rtn = d1 < d2 ;                                                     break;
257                                case "GT" : rtn = d1 > d2 ;                                                     break;
258                                case "LE" : rtn = d1 <= d2;                                                     break;
259                                case "GE" : rtn = d1 >= d2;                                                     break;
260                                default   : rtn = Math.abs(d1 - d2) < 0.0000001;        break;                  // d1 == d2 の事
261                        }
262
263                }
264                return rtn ;
265        }
266
267        /**
268         * startsWith で比較するときの、比較メソッド。
269         *
270         * val1 が、比較元の文字列で、val2 が部分文字列になります。
271         * val1.startsWith( val2 );
272         *
273         * @og.rev 6.4.2.0 (2016/01/29) ソースの内部構造の全体的な見直し。
274         *
275         * @param   val1 第1引数
276         * @param   val2 第2引数
277         *
278         * @return  第1,第2引数が null/ゼロストリング でなく、且つ val1.startsWith( val2 ) の結果
279         */
280        private boolean startsWith( final String val1,final String val2 ) {
281                return ! isNullCheck( val1 ) && ! isNullCheck( val2 ) && val1.startsWith( val2 ) ; 
282        }
283
284        /**
285         * nullCheck で判定するときの、判定メソッド。
286         *
287         * @og.rev 6.4.2.0 (2016/01/29) ソースの内部構造の全体的な見直し。
288         *
289         * @param   val1 第1引数
290         *
291         * @return  第1引数が null/ゼロストリング の場合 true
292         */
293        private boolean isNullCheck( final String val1 ) {
294                return val1 == null || val1.isEmpty() ;
295        }
296
297        /**
298         * contains で比較するときの、比較メソッド。
299         *
300         * val1 が、比較元の文字列で、val2 が部分文字列になります。
301         * val1.contains( val2 );
302         *
303         * @og.rev 3.2.0.0 (2003/05/22) 判定方法に,contains,endsWith,matches の方法を追加
304         * @og.rev 6.4.2.0 (2016/01/29) ソースの内部構造の全体的な見直し。
305         *
306         * @param   val1 第1引数
307         * @param   val2 第2引数
308         *
309         * @return  第1,第2引数が null/ゼロストリング でなく、且つ val1.contains( val2 ) の結果
310         */
311        private boolean contains( final String val1,final String val2 ) {
312                return ! isNullCheck( val1 ) && ! isNullCheck( val2 ) && val1.contains( val2 ) ;
313        }
314
315        /**
316         * endsWith で比較するときの、比較メソッド。
317         *
318         * val1 が、比較元の文字列で、val2 が部分文字列になります。
319         * val1.endsWith( val2 ) ;
320         *
321         * @og.rev 3.2.0.0 (2003/05/22) 判定方法に,contains,endsWith,matches の方法を追加
322         * @og.rev 6.4.2.0 (2016/01/29) ソースの内部構造の全体的な見直し。
323         *
324         * @param   val1 第1引数
325         * @param   val2 第2引数
326         *
327         * @return  第1,第2引数が null/ゼロストリング でなく、且つ val1.endsWith( val2 ) の結果
328         */
329        private boolean endsWith( final String val1,final String val2 ) {
330                return ! isNullCheck( val1 ) && ! isNullCheck( val2 ) && val1.endsWith( val2 ) ;
331        }
332
333        /**
334         * matches で比較するときの、比較メソッド。
335         *
336         * val1 が、比較元の文字列で、val2 が正規表現の文字列になります。
337         * val1.matches( val2 );
338         *
339         * @og.rev 3.2.0.0 (2003/05/22) 判定方法に,contains,endsWith,matches の方法を追加
340         * @og.rev 6.4.2.0 (2016/01/29) ソースの内部構造の全体的な見直し。
341         *
342         * @param   val1 第1引数
343         * @param   val2 第2引数
344         *
345         * @return  第1,第2引数が null/ゼロストリング でなく、且つ val1.matches( val2 ) の結果
346         */
347        private boolean matches( final String val1,final String val2 ) {
348                return ! isNullCheck( val1 ) && ! isNullCheck( val2 ) && val1.matches( val2 ) ;
349        }
350
351        /**
352         * 【TAG】equals で比較するときの、第1引数(左辺)を指定します。
353         *
354         * @og.tag equals で比較するときの、第1引数を指定します。
355         * val1 が null の場合は、無条件で非成立になります。
356         *  ( val1 == val2 ) はチェックしないというイメージです。
357         * val1 が null かどうか判断する場合は、nullCheck="true" を使用してください。
358         *
359         * @og.rev 6.9.3.0 (2018/03/26) isException 属性を追加します。
360         *
361         * @param   val 第1引数
362         */
363        public void setVal1( final String val ) {
364                try {
365                        this.value1 = getRequestParameter( val );
366                }
367                catch( final Throwable th ) {
368                        isOccurExce = true;                     // isException 属性判定用のエラーが発生したかどうかの判定フラグ
369                }
370        }
371
372        /**
373         * 【TAG】equals で比較するときの、第2引数(右辺)を指定します。
374         *
375         * @og.tag equals で比較するときの、第2引数を指定します。
376         *
377         * @og.rev 6.9.3.0 (2018/03/26) isException 属性を追加します。
378         *
379         * @param   val 第2引数
380         */
381        public void setVal2( final String val ) {
382                try {
383                        this.value2 = getRequestParameter( val );
384                }
385                catch( final Throwable th ) {
386                        isOccurExce = true;                     // isException 属性判定用のエラーが発生したかどうかの判定フラグ
387                }
388        }
389
390        /**
391         * 【TAG】大文字/小文字を区別しないかどうか[true/false]を指定します(初期値:false(区別する))。
392         *
393         * @og.tag
394         * startsWith , contains , endsWith , equalsIgnoreCase での比較時に、比較対象の
395         * 大文字/小文字を区別しないかどうかを指定します。
396         * 区別しない ("true") 場合、aaa と AAA は、一致したとみなされます。
397         * 初期値は、区別する ("false") です。
398         *
399         * @param   flag 大文字/小文字を区別しないかどうか [true:しない/それ以外:する]
400         */
401        public void setIgnoreCase( final String flag ) {
402                ignoreCase = nval( getRequestParameter( flag ),ignoreCase );
403        }
404
405        /**
406         * 【TAG】比較対象の引数を、trim()するかどうか[true/false]を指定します(初期値:false(trimしない))。
407         *
408         * @og.tag
409         * equals , startsWith , contains , endsWith 等での比較時に、比較対象の
410         * 引数を、両端空白文字(スペース、タブ、改行など)を削除します。
411         * この処理を行う場合は、一番最初に行います。nullCheck などは、trim() された結果を使用します。
412         * 初期値は、trimしない ("false") です。
413         *
414         * @og.rev 6.4.2.0 (2016/01/29) trim属性を追加します。
415         *
416         * @param   flag trimするかどうか [true:する/それ以外:しない]
417         */
418        public void setUseTrim( final String flag ) {
419                useTrim = nval( getRequestParameter( flag ),useTrim );
420        }
421
422        /**
423         * 【TAG】この文字列が、指定された接頭辞で始まるかどうか[true/false]を判定します(初期値:false)。
424         *
425         * @og.tag
426         * val1.startsWith( val2 ) の書式で判定されます。この場合、"ABCDEFG".startsWith( "ABC" )
427         * の場合に、条件成立します。(つまり、val1 に対して、val2 で始まっているかどうか問合せる)
428         * 初期値は、判定しない ("false")
429         *
430         * @param   flag 接頭辞で始まるかどうか [true:判定する/それ以外:しない]
431         */
432        public void setStartsWith( final String flag ) {
433                isStartsWith = nval( getRequestParameter( flag ),isStartsWith );
434        }
435
436        /**
437         * 【TAG】null チェックを行うかどうか[true/false]を指定します(初期値:false)。
438         *
439         * @og.tag
440         * チェックを行うように指定("true")した場合に、第一引数が null の場合は,
441         * 条件成立して、タグのBody は実行されます。
442         * 初期値は、行わない (true 以外)です。
443         *
444         * @param   flag nullチェックを行うかどうか [true:行う/それ以外:行わない]
445         */
446        public void setNullCheck( final String flag ) {
447                nullCheck = nval( getRequestParameter( flag ),nullCheck );
448        }
449
450        /**
451         * 【TAG】判定結果を反転させるかどうか[true/false]を指定します(初期値:false)。
452         *
453         * @og.tag
454         * 通常の成立条件において、不成立の場合に、BODY を実行します。
455         * 通常の処理結果を求めて、最後に、反転処理を行います。
456         * 初期値は、通常 (true 以外)です。
457         *
458         * @param   flag 反転させるか [true:反転する/それ以外:通常]
459         */
460        public void setNotEquals( final String flag ) {
461                notEquals = nval( getRequestParameter( flag ),notEquals );
462        }
463
464        /**
465         * 【TAG】文字列が含まれているかどうか[true/false]の判定します(初期値:false)。
466         *
467         * @og.tag
468         * val1.indexOf( val2 ) &gt;= 0 の書式で判定されます。この場合、"ABCDEFG".indexOf( "CDE" )
469         * の場合に、条件成立します。(つまり、val1 に対して、val2 が含まれているかどうか問合せる)
470         * 初期値は、判定しない ("false")
471         *
472         * @og.rev 3.2.0.0 (2003/05/22) 判定方法に,contains,endsWith,matches の方法を追加
473         *
474         * @param   flag 含む判定 [true:判定する/それ以外:しない]
475         */
476        public void setContains( final String flag ) {
477                isContains = nval( getRequestParameter( flag ),isContains );
478        }
479
480        /**
481         * 【TAG】指定された接尾辞で終るかどうか[true/false]を判定します(初期値:false)。
482         *
483         * @og.tag
484         * val1.endsWith( val2 ) の書式で判定されます。この場合、"ABCDEFG".endsWith( "EFG" )
485         * の場合に、条件成立します。(つまり、val1 に対して、val2 で終わっているかどうか問合せる)
486         * 初期値は、判定しない ("false")
487         *
488         * @og.rev 3.2.0.0 (2003/05/22) 判定方法に,contains,endsWith,matches の方法を追加
489         *
490         * @param   flag 接尾辞判定 [true:判定する/それ以外:しない]
491         */
492        public void setEndsWith( final String flag ) {
493                isEndsWith = nval( getRequestParameter( flag ),isEndsWith );
494        }
495
496        /**
497         * 【TAG】指定された正規表現と一致するかどうか[true/false]を判定します(初期値:false)。
498         *
499         * @og.tag
500         * val1.matches( val2 ) の書式で判定されます。val2 に指定された正規表現で、
501         * 一致するかどうかを判定します。ここでの正規表現とは、
502         * java.util.regex.Pattern.matches(val1, val2) での判定結果と同じです。
503         * 初期値は、判定しない ("false")
504         *
505         * @og.rev 3.2.0.0 (2003/05/22) 判定方法に,contains,endsWith,matches の方法を追加
506         *
507         * @param   flag 正規表現一致判定 [true:判定する/それ以外:しない]
508         */
509        public void setMatches( final String flag ) {
510                isMatches = nval( getRequestParameter( flag ),isMatches );
511        }
512
513        /**
514         * 【TAG】BODYを処理後に停止するかどうか[true/false]を指定します(初期値:false)。
515         *
516         * @og.tag
517         * 処理結果などに応じて、以下の処理を停止したい場合に、使用します。
518         * ここでは、条件を判定後、true の場合に、BODY部を出力(処理)した後に、
519         * ここにセットされた値に応じて、以下のページ処理を行うかどうかを指定します。
520         * true を指定すると、以下の処理は、行われません。
521         * 初期値は、停止しない ("false")
522         *
523         * @og.rev 3.8.1.2 (2005/12/19) 新規追加
524         *
525         * @param   flag 処理後停止 [true:する/それ以外:しない]
526         */
527        public void setUseStop( final String flag ) {
528                useStop = nval( getRequestParameter( flag ),useStop );
529        }
530
531        /**
532         * 【TAG】val1,val2 の設定で、エラーが発生したかどうか[true/false]の判定します(初期値:false)。
533         *
534         * @og.tag
535         * val1,val2 の処理で、Exceptionが発生した場合、true と判手され、BODY内部が処理されます。
536         * これは、{&#064;DBF.CON &#064;DBID} のように、データベース接続の存在チェックを行うケースを
537         * 想定しています。なので、通常は、useStop="true" とともに、エラーメッセージを表示して、処理を止めます。
538         * 初期値は、判定しない ("false")
539         *
540         * @og.rev 6.9.3.0 (2018/03/26) isException 属性を追加します
541         *
542         * @param   flag エラーが発生したかどうか [true:判定する/判定しない]
543         */
544        public void setIsException( final String flag ) {
545                isException = nval( getRequestParameter( flag ),isException );
546        }
547
548        /**
549         * 【TAG】比較する操作を EQ,LT,LE,GT,GE から指定します(初期値:EQ)。
550         *
551         * @og.tag
552         * 比較方法として、EQ(==)、LT(&lt;)、LE(&lt;=)、GT(&gt;)、GE(&gt;=) があります。
553         * 初期値は、EQ(同じかどうか)です。
554         * 比較は、val1 に対して行われます。val1 または val2 が null の場合は、常にfalseが
555         * 返されます。通常の A &lt; B ならば、not( B &gt;= A ) の関係は成立しません。
556         * val1 が null でない場合は、val1(5) LT vla2(8) は、true を返します。
557         * ignoreCase属性(大文字/小文字の区別)を指定することで、比較する文字列の
558         * 大文字小文字を統一させることが可能です。
559         * なお、比較時には、compareType 属性にもご注意ください。これは、文字列比較か
560         * 数字比較を指定します。
561         *
562         * @og.rev 3.8.1.3B (2006/01/30) 新規追加
563         * @og.rev 6.3.4.0 (2015/08/01) Arrays.toString から String.join に置き換え。
564         * @og.rev 6.4.3.4 (2016/03/11) String配列 から、Setに置き換えます。
565         *
566         * @param       ope     比較する操作 [EQ/LT/LE/GT/GE]
567         * @see     #setIgnoreCase( String )
568         * @see     #setCompareType( String )
569         */
570        public void setOperator( final String ope ) {
571                operator = nval( getRequestParameter( ope ),operator );
572
573                if( !check( operator, OPERATOR_SET ) ) {
574                        final String errMsg = "指定のオペレーションはサポートされていません。オペレーションエラー"       + CR
575                                                        + "operator=[" + ope + "] "                                                                                                     + CR
576                                                        + "operatorList=" + String.join( ", " , OPERATOR_SET ) ;
577                        throw new HybsSystemException( errMsg );
578                }
579        }
580
581        /**
582         * 【TAG】大小比較する方法(STRING:前方比較 、NUMBER:数値比較)を指定します(初期値:STRING)。
583         *
584         * @og.tag
585         * operator 属性で大小を比較する場合、比較方法として、前方比較と数値比較を指定できます。
586         * STRING(前方比較)とは、お互いの文字列を前方から順に比較していきます。例えば、
587         * ABC と AABBCC や、123 と 112233 では、AABBCC や 112233 が小さいと判断されます。
588         * NUMBER(数値比較)では、123 と 112233 では、123 が小さいと判断されます。
589         * NUMBER は、数字に変換できる値である必要があります。
590         * STRING は、ignoreCase属性(大文字/小文字の区別)を指定することで、比較する文字列の
591         * 大文字小文字を統一させることが可能です。
592         * 初期値は、STRING(前方比較)です。
593         *
594         * @og.rev 3.8.1.3B (2006/01/30) 新規追加
595         * @og.rev 6.3.4.0 (2015/08/01) Arrays.toString から String.join に置き換え。
596         * @og.rev 6.4.3.4 (2016/03/11) String配列 から、Setに置き換えます。
597         *
598         * @param   type 判定方法 [STRING:前方比較/NUMBER(数値比較)]
599         * @see     #setIgnoreCase( String )
600         * @see     #setOperator( String )
601         */
602        public void setCompareType( final String type ) {
603                compareType = nval( getRequestParameter( type ),compareType );
604
605                if( !check( compareType, COMP_TYPE_SET ) ) {
606                        final String errMsg = "指定のcompareTypeはサポートされていません。compareTypeエラー"       + CR
607                                                        + "compareType=[" + type + "] "                                                                                 + CR
608                                                        + "compareTypeList=" + String.join( ", " , COMP_TYPE_SET ) ;
609                        throw new HybsSystemException( errMsg );
610                }
611        }
612
613        /**
614         * このオブジェクトの文字列表現を返します。
615         * 基本的にデバッグ目的に使用します。
616         *
617         * @og.rev 3.2.0.0 (2003/05/22) 判定方法に,contains,endsWith,matches の方法を追加
618         *
619         * @return このクラスの文字列表現
620         * @og.rtnNotNull
621         */
622        @Override
623        public String toString() {
624                return ToString.title( this.getClass().getName() )
625                                .println( "VERSION"             ,VERSION        )
626                                .println( "value1"              ,value1         )
627                                .println( "value2"              ,value2         )
628                                .println( "ignoreCase"  ,ignoreCase     )
629                                .println( "useTrim"             ,useTrim        )                                       // 6.4.2.0 (2016/01/29)
630                                .println( "startsWith"  ,isStartsWith   )
631                                .println( "nullCheck"   ,nullCheck      )
632                                .println( "notEquals"   ,notEquals      )
633                                .println( "contains"    ,isContains     )
634                                .println( "endsWith"    ,isEndsWith     )
635                                .println( "matches"             ,isMatches      )
636                                .println( "useStop"             ,useStop        )
637                                .println( "Other..."    ,getAttributes().getAttribute() )
638                                .fixForm().toString() ;
639        }
640}