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