    001    /*
    002     * Licensed to the Apache Software Foundation (ASF) under one or more
    003     * contributor license agreements.  See the NOTICE file distributed with
    004     * this work for additional information regarding copyright ownership.
    005     * The ASF licenses this file to You under the Apache License, Version 2.0
    006     * (the "License"); you may not use this file except in compliance with
    007     * the License.  You may obtain a copy of the License at
    008     *
    009     *      http://www.apache.org/licenses/LICENSE-2.0
    010     *
    011     * Unless required by applicable law or agreed to in writing, software
    012     * distributed under the License is distributed on an "AS IS" BASIS,
    013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014     * See the License for the specific language governing permissions and
    015     * limitations under the License.
    016     */
    017    package org.apache.commons.lang3.builder;
    018
    019    /**
    020     * <p>Works with {@link ToStringBuilder} to create a <code>toString</code>.</p>
    021     *
    022     * <p>This class is intended to be used as a singleton.
    023     * There is no need to instantiate a new style each time.
    024     * Simply instantiate the class once, customize the values as required, and
    025     * store the result in a public static final variable for the rest of the
    026     * program to access.</p>
    027     *
    028     * @since 1.0
    029     * @version $Id: StandardToStringStyle.java 1089740 2011-04-07 05:01:54Z bayard $
    030     */
    031    public class StandardToStringStyle extends ToStringStyle {
    032
    033        /**
    034         * Required for serialization support.
    035         *
    036         * @see java.io.Serializable
    037         */
    038        private static final long serialVersionUID = 1L;
    039
    040        /**
    041         * <p>Constructor.</p>
    042         */
    043        public StandardToStringStyle() {
    044            super();
    045        }
    046
    047        //---------------------------------------------------------------------
    048
    049        /**
    050         * <p>Gets whether to use the class name.</p>
    051         *
    052         * @return the current useClassName flag
    053         */
    054        @Override
    055        public boolean isUseClassName() { // NOPMD as this is implementing the abstract class
    056            return super.isUseClassName();
    057        }
    058
    059        /**
    060         * <p>Sets whether to use the class name.</p>
    061         *
    062         * @param useClassName  the new useClassName flag
    063         */
    064        @Override
    065        public void setUseClassName(boolean useClassName) { // NOPMD as this is implementing the abstract class
    066            super.setUseClassName(useClassName);
    067        }
    068
    069        //---------------------------------------------------------------------
    070
    071        /**
    072         * <p>Gets whether to output short or long class names.</p>
    073         *
    074         * @return the current useShortClassName flag
    075         * @since 2.0
    076         */
    077        @Override
    078        public boolean isUseShortClassName() { // NOPMD as this is implementing the abstract class
    079            return super.isUseShortClassName();
    080        }
    081
    082        /**
    083         * <p>Sets whether to output short or long class names.</p>
    084         *
    085         * @param useShortClassName  the new useShortClassName flag
    086         * @since 2.0
    087         */
    088        @Override
    089        public void setUseShortClassName(boolean useShortClassName) { // NOPMD as this is implementing the abstract class
    090            super.setUseShortClassName(useShortClassName);
    091        }
    092
    093        //---------------------------------------------------------------------
    094
    095        /**
    096         * <p>Gets whether to use the identity hash code.</p>
    097         * @return the current useIdentityHashCode flag
    098         */
    099        @Override
    100        public boolean isUseIdentityHashCode() { // NOPMD as this is implementing the abstract class
    101            return super.isUseIdentityHashCode();
    102        }
    103
    104        /**
    105         * <p>Sets whether to use the identity hash code.</p>
    106         *
    107         * @param useIdentityHashCode  the new useIdentityHashCode flag
    108         */
    109        @Override
    110        public void setUseIdentityHashCode(boolean useIdentityHashCode) { // NOPMD as this is implementing the abstract class
    111            super.setUseIdentityHashCode(useIdentityHashCode);
    112        }
    113
    114        //---------------------------------------------------------------------
    115
    116        /**
    117         * <p>Gets whether to use the field names passed in.</p>
    118         *
    119         * @return the current useFieldNames flag
    120         */
    121        @Override
    122        public boolean isUseFieldNames() { // NOPMD as this is implementing the abstract class
    123            return super.isUseFieldNames();
    124        }
    125
    126        /**
    127         * <p>Sets whether to use the field names passed in.</p>
    128         *
    129         * @param useFieldNames  the new useFieldNames flag
    130         */
    131        @Override
    132        public void setUseFieldNames(boolean useFieldNames) { // NOPMD as this is implementing the abstract class
    133            super.setUseFieldNames(useFieldNames);
    134        }
    135
    136        //---------------------------------------------------------------------
    137
    138        /**
    139         * <p>Gets whether to use full detail when the caller doesn't
    140         * specify.</p>
    141         *
    142         * @return the current defaultFullDetail flag
    143         */
    144        @Override
    145        public boolean isDefaultFullDetail() { // NOPMD as this is implementing the abstract class
    146            return super.isDefaultFullDetail();
    147        }
    148
    149        /**
    150         * <p>Sets whether to use full detail when the caller doesn't
    151         * specify.</p>
    152         *
    153         * @param defaultFullDetail  the new defaultFullDetail flag
    154         */
    155        @Override
    156        public void setDefaultFullDetail(boolean defaultFullDetail) { // NOPMD as this is implementing the abstract class
    157            super.setDefaultFullDetail(defaultFullDetail);
    158        }
    159
    160        //---------------------------------------------------------------------
    161
    162        /**
    163         * <p>Gets whether to output array content detail.</p>
    164         *
    165         * @return the current array content detail setting
    166         */
    167        @Override
    168        public boolean isArrayContentDetail() { // NOPMD as this is implementing the abstract class
    169            return super.isArrayContentDetail();
    170        }
    171
    172        /**
    173         * <p>Sets whether to output array content detail.</p>
    174         *
    175         * @param arrayContentDetail  the new arrayContentDetail flag
    176         */
    177        @Override
    178        public void setArrayContentDetail(boolean arrayContentDetail) { // NOPMD as this is implementing the abstract class
    179            super.setArrayContentDetail(arrayContentDetail);
    180        }
    181
    182        //---------------------------------------------------------------------
    183
    184        /**
    185         * <p>Gets the array start text.</p>
    186         *
    187         * @return the current array start text
    188         */
    189        @Override
    190        public String getArrayStart() { // NOPMD as this is implementing the abstract class
    191            return super.getArrayStart();
    192        }
    193
    194        /**
    195         * <p>Sets the array start text.</p>
    196         *
    197         * <p><code>null</code> is accepted, but will be converted
    198         * to an empty String.</p>
    199         *
    200         * @param arrayStart  the new array start text
    201         */
    202        @Override
    203        public void setArrayStart(String arrayStart) { // NOPMD as this is implementing the abstract class
    204            super.setArrayStart(arrayStart);
    205        }
    206
    207        //---------------------------------------------------------------------
    208
    209        /**
    210         * <p>Gets the array end text.</p>
    211         *
    212         * @return the current array end text
    213         */
    214        @Override
    215        public String getArrayEnd() { // NOPMD as this is implementing the abstract class
    216            return super.getArrayEnd();
    217        }
    218
    219        /**
    220         * <p>Sets the array end text.</p>
    221         *
    222         * <p><code>null</code> is accepted, but will be converted
    223         * to an empty String.</p>
    224         *
    225         * @param arrayEnd  the new array end text
    226         */
    227        @Override
    228        public void setArrayEnd(String arrayEnd) { // NOPMD as this is implementing the abstract class
    229            super.setArrayEnd(arrayEnd);
    230        }
    231
    232        //---------------------------------------------------------------------
    233
    234        /**
    235         * <p>Gets the array separator text.</p>
    236         *
    237         * @return the current array separator text
    238         */
    239        @Override
    240        public String getArraySeparator() { // NOPMD as this is implementing the abstract class
    241            return super.getArraySeparator();
    242        }
    243
    244        /**
    245         * <p>Sets the array separator text.</p>
    246         *
    247         * <p><code>null</code> is accepted, but will be converted
    248         * to an empty String.</p>
    249         *
    250         * @param arraySeparator  the new array separator text
    251         */
    252        @Override
    253        public void setArraySeparator(String arraySeparator) { // NOPMD as this is implementing the abstract class
    254            super.setArraySeparator(arraySeparator);
    255        }
    256
    257        //---------------------------------------------------------------------
    258
    259        /**
    260         * <p>Gets the content start text.</p>
    261         *
    262         * @return the current content start text
    263         */
    264        @Override
    265        public String getContentStart() { // NOPMD as this is implementing the abstract class
    266            return super.getContentStart();
    267        }
    268
    269        /**
    270         * <p>Sets the content start text.</p>
    271         *
    272         * <p><code>null</code> is accepted, but will be converted
    273         * to an empty String.</p>
    274         *
    275         * @param contentStart  the new content start text
    276         */
    277        @Override
    278        public void setContentStart(String contentStart) { // NOPMD as this is implementing the abstract class
    279            super.setContentStart(contentStart);
    280        }
    281
    282        //---------------------------------------------------------------------
    283
    284        /**
    285         * <p>Gets the content end text.</p>
    286         *
    287         * @return the current content end text
    288         */
    289        @Override
    290        public String getContentEnd() { // NOPMD as this is implementing the abstract class
    291            return super.getContentEnd();
    292        }
    293
    294        /**
    295         * <p>Sets the content end text.</p>
    296         *
    297         * <p><code>null</code> is accepted, but will be converted
    298         * to an empty String.</p>
    299         *
    300         * @param contentEnd  the new content end text
    301         */
    302        @Override
    303        public void setContentEnd(String contentEnd) { // NOPMD as this is implementing the abstract class
    304            super.setContentEnd(contentEnd);
    305        }
    306
    307        //---------------------------------------------------------------------
    308
    309        /**
    310         * <p>Gets the field name value separator text.</p>
    311         *
    312         * @return the current field name value separator text
    313         */
    314        @Override
    315        public String getFieldNameValueSeparator() { // NOPMD as this is implementing the abstract class
    316            return super.getFieldNameValueSeparator();
    317        }
    318
    319        /**
    320         * <p>Sets the field name value separator text.</p>
    321         *
    322         * <p><code>null</code> is accepted, but will be converted
    323         * to an empty String.</p>
    324         *
    325         * @param fieldNameValueSeparator  the new field name value separator text
    326         */
    327        @Override
    328        public void setFieldNameValueSeparator(String fieldNameValueSeparator) { // NOPMD as this is implementing the abstract class
    329            super.setFieldNameValueSeparator(fieldNameValueSeparator);
    330        }
    331
    332        //---------------------------------------------------------------------
    333
    334        /**
    335         * <p>Gets the field separator text.</p>
    336         *
    337         * @return the current field separator text
    338         */
    339        @Override
    340        public String getFieldSeparator() { // NOPMD as this is implementing the abstract class
    341            return super.getFieldSeparator();
    342        }
    343
    344        /**
    345         * <p>Sets the field separator text.</p>
    346         *
    347         * <p><code>null</code> is accepted, but will be converted
    348         * to an empty String.</p>
    349         *
    350         * @param fieldSeparator  the new field separator text
    351         */
    352        @Override
    353        public void setFieldSeparator(String fieldSeparator) { // NOPMD as this is implementing the abstract class
    354            super.setFieldSeparator(fieldSeparator);
    355        }
    356
    357        //---------------------------------------------------------------------
    358
    359        /**
    360         * <p>Gets whether the field separator should be added at the start
    361         * of each buffer.</p>
    362         *
    363         * @return the fieldSeparatorAtStart flag
    364         * @since 2.0
    365         */
    366        @Override
    367        public boolean isFieldSeparatorAtStart() { // NOPMD as this is implementing the abstract class
    368            return super.isFieldSeparatorAtStart();
    369        }
    370
    371        /**
    372         * <p>Sets whether the field separator should be added at the start
    373         * of each buffer.</p>
    374         *
    375         * @param fieldSeparatorAtStart  the fieldSeparatorAtStart flag
    376         * @since 2.0
    377         */
    378        @Override
    379        public void setFieldSeparatorAtStart(boolean fieldSeparatorAtStart) { // NOPMD as this is implementing the abstract class
    380            super.setFieldSeparatorAtStart(fieldSeparatorAtStart);
    381        }
    382
    383        //---------------------------------------------------------------------
    384
    385        /**
    386         * <p>Gets whether the field separator should be added at the end
    387         * of each buffer.</p>
    388         *
    389         * @return fieldSeparatorAtEnd flag
    390         * @since 2.0
    391         */
    392        @Override
    393        public boolean isFieldSeparatorAtEnd() { // NOPMD as this is implementing the abstract class
    394            return super.isFieldSeparatorAtEnd();
    395        }
    396
    397        /**
    398         * <p>Sets whether the field separator should be added at the end
    399         * of each buffer.</p>
    400         *
    401         * @param fieldSeparatorAtEnd  the fieldSeparatorAtEnd flag
    402         * @since 2.0
    403         */
    404        @Override
    405        public void setFieldSeparatorAtEnd(boolean fieldSeparatorAtEnd) { // NOPMD as this is implementing the abstract class
    406            super.setFieldSeparatorAtEnd(fieldSeparatorAtEnd);
    407        }
    408
    409        //---------------------------------------------------------------------
    410
    411        /**
    412         * <p>Gets the text to output when <code>null</code> found.</p>
    413         *
    414         * @return the current text to output when <code>null</code> found
    415         */
    416        @Override
    417        public String getNullText() { // NOPMD as this is implementing the abstract class
    418            return super.getNullText();
    419        }
    420
    421        /**
    422         * <p>Sets the text to output when <code>null</code> found.</p>
    423         *
    424         * <p><code>null</code> is accepted, but will be converted
    425         * to an empty String.</p>
    426         *
    427         * @param nullText  the new text to output when <code>null</code> found
    428         */
    429        @Override
    430        public void setNullText(String nullText) { // NOPMD as this is implementing the abstract class
    431            super.setNullText(nullText);
    432        }
    433
    434        //---------------------------------------------------------------------
    435
    436        /**
    437         * <p>Gets the text to output when a <code>Collection</code>,
    438         * <code>Map</code> or <code>Array</code> size is output.</p>
    439         *
    440         * <p>This is output before the size value.</p>
    441         *
    442         * @return the current start of size text
    443         */
    444        @Override
    445        public String getSizeStartText() { // NOPMD as this is implementing the abstract class
    446            return super.getSizeStartText();
    447        }
    448
    449        /**
    450         * <p>Sets the start text to output when a <code>Collection</code>,
    451         * <code>Map</code> or <code>Array</code> size is output.</p>
    452         *
    453         * <p>This is output before the size value.</p>
    454         *
    455         * <p><code>null</code> is accepted, but will be converted to
    456         * an empty String.</p>
    457         *
    458         * @param sizeStartText  the new start of size text
    459         */
    460        @Override
    461        public void setSizeStartText(String sizeStartText) { // NOPMD as this is implementing the abstract class
    462            super.setSizeStartText(sizeStartText);
    463        }
    464
    465        //---------------------------------------------------------------------
    466
    467        /**
    468         * Gets the end text to output when a <code>Collection</code>,
    469         * <code>Map</code> or <code>Array</code> size is output.</p>
    470         *
    471         * <p>This is output after the size value.</p>
    472         *
    473         * @return the current end of size text
    474         */
    475        @Override
    476        public String getSizeEndText() { // NOPMD as this is implementing the abstract class
    477            return super.getSizeEndText();
    478        }
    479
    480        /**
    481         * <p>Sets the end text to output when a <code>Collection</code>,
    482         * <code>Map</code> or <code>Array</code> size is output.</p>
    483         *
    484         * <p>This is output after the size value.</p>
    485         *
    486         * <p><code>null</code> is accepted, but will be converted
    487         * to an empty String.</p>
    488         *
    489         * @param sizeEndText  the new end of size text
    490         */
    491        @Override
    492        public void setSizeEndText(String sizeEndText) { // NOPMD as this is implementing the abstract class
    493            super.setSizeEndText(sizeEndText);
    494        }
    495
    496        //---------------------------------------------------------------------
    497
    498        /**
    499         * <p>Gets the start text to output when an <code>Object</code> is
    500         * output in summary mode.</p>
    501         *
    502         * <P>This is output before the size value.</p>
    503         *
    504         * @return the current start of summary text
    505         */
    506        @Override
    507        public String getSummaryObjectStartText() { // NOPMD as this is implementing the abstract class
    508            return super.getSummaryObjectStartText();
    509        }
    510
    511        /**
    512         * <p>Sets the start text to output when an <code>Object</code> is
    513         * output in summary mode.</p>
    514         *
    515         * <p>This is output before the size value.</p>
    516         *
    517         * <p><code>null</code> is accepted, but will be converted to
    518         * an empty String.</p>
    519         *
    520         * @param summaryObjectStartText  the new start of summary text
    521         */
    522        @Override
    523        public void setSummaryObjectStartText(String summaryObjectStartText) { // NOPMD as this is implementing the abstract class
    524            super.setSummaryObjectStartText(summaryObjectStartText);
    525        }
    526
    527        //---------------------------------------------------------------------
    528
    529        /**
    530         * <p>Gets the end text to output when an <code>Object</code> is
    531         * output in summary mode.</p>
    532         *
    533         * <p>This is output after the size value.</p>
    534         *
    535         * @return the current end of summary text
    536         */
    537        @Override
    538        public String getSummaryObjectEndText() { // NOPMD as this is implementing the abstract class
    539            return super.getSummaryObjectEndText();
    540        }
    541
    542        /**
    543         * <p>Sets the end text to output when an <code>Object</code> is
    544         * output in summary mode.</p>
    545         *
    546         * <p>This is output after the size value.</p>
    547         *
    548         * <p><code>null</code> is accepted, but will be converted to
    549         * an empty String.</p>
    550         *
    551         * @param summaryObjectEndText  the new end of summary text
    552         */
    553        @Override
    554        public void setSummaryObjectEndText(String summaryObjectEndText) { // NOPMD as this is implementing the abstract class
    555            super.setSummaryObjectEndText(summaryObjectEndText);
    556        }
    557
    558        //---------------------------------------------------------------------
    559
    560    }