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