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