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