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