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