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