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}