View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    * 
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   * 
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.apache.commons.lang3.builder;
18  
19  /**
20   * <p>Works with {@link ToStringBuilder} to create a <code>toString</code>.</p>
21   *
22   * <p>This class is intended to be used as a singleton.
23   * There is no need to instantiate a new style each time.
24   * Simply instantiate the class once, customize the values as required, and
25   * store the result in a public static final variable for the rest of the
26   * program to access.</p>
27   *
28   * @since 1.0
29   */
30  public class StandardToStringStyle extends ToStringStyle {
31      
32      /**
33       * Required for serialization support.
34       * 
35       * @see java.io.Serializable
36       */
37      private static final long serialVersionUID = 1L;
38  
39      /**
40       * <p>Constructor.</p>
41       */
42      public StandardToStringStyle() {
43          super();
44      }
45      
46      //---------------------------------------------------------------------
47      
48      /**
49       * <p>Gets whether to use the class name.</p>
50       *
51       * @return the current useClassName flag
52       */
53      @Override
54      public boolean isUseClassName() { // NOPMD as this is implementing the abstract class
55          return super.isUseClassName();
56      }
57  
58      /**
59       * <p>Sets whether to use the class name.</p>
60       *
61       * @param useClassName  the new useClassName flag
62       */
63      @Override
64      public void setUseClassName(final boolean useClassName) { // NOPMD as this is implementing the abstract class
65          super.setUseClassName(useClassName);
66      }
67  
68      //---------------------------------------------------------------------
69      
70      /**
71       * <p>Gets whether to output short or long class names.</p>
72       *
73       * @return the current useShortClassName flag
74       * @since 2.0
75       */
76      @Override
77      public boolean isUseShortClassName() { // NOPMD as this is implementing the abstract class
78          return super.isUseShortClassName();
79      }
80  
81      /**
82       * <p>Sets whether to output short or long class names.</p>
83       *
84       * @param useShortClassName  the new useShortClassName flag
85       * @since 2.0
86       */
87      @Override
88      public void setUseShortClassName(final boolean useShortClassName) { // NOPMD as this is implementing the abstract class
89          super.setUseShortClassName(useShortClassName);
90      }
91  
92      //---------------------------------------------------------------------
93      
94      /**
95       * <p>Gets whether to use the identity hash code.</p>
96       * @return the current useIdentityHashCode flag
97       */
98      @Override
99      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</code> 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</code> 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</code> 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</code> 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</code> 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</code> 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</code> 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</code> found.</p>
412      *
413      * @return the current text to output when <code>null</code> 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</code> found.</p>
422      *
423      * <p><code>null</code> is accepted, but will be converted
424      * to an empty String.</p>
425      *
426      * @param nullText  the new text to output when <code>null</code> 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</code>,
437      * <code>Map</code> or <code>Array</code> 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</code>,
450      * <code>Map</code> or <code>Array</code> size is output.</p>
451      *
452      * <p>This is output before the size value.</p>
453      *
454      * <p><code>null</code> 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</code>,
468      * <code>Map</code> or <code>Array</code> 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</code>,
481      * <code>Map</code> or <code>Array</code> size is output.</p>
482      *
483      * <p>This is output after the size value.</p>
484      *
485      * <p><code>null</code> 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</code> 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</code> is
512      * output in summary mode.</p>
513      *
514      * <p>This is output before the size value.</p>
515      *
516      * <p><code>null</code> 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</code> 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</code> is
543      * output in summary mode.</p>
544      *
545      * <p>This is output after the size value.</p>
546      *
547      * <p><code>null</code> 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 }