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    *      https://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  
18  package org.apache.commons.lang3.builder;
19  
20  import java.io.Serializable;
21  import java.lang.ref.Reference;
22  import java.lang.ref.ReferenceQueue;
23  import java.lang.ref.WeakReference;
24  import java.lang.reflect.Array;
25  import java.util.Collection;
26  import java.util.HashSet;
27  import java.util.IdentityHashMap;
28  import java.util.Map;
29  import java.util.Map.Entry;
30  import java.util.Objects;
31  import java.util.Set;
32  import java.util.WeakHashMap;
33  
34  import org.apache.commons.lang3.ClassUtils;
35  import org.apache.commons.lang3.ObjectUtils;
36  import org.apache.commons.lang3.StringEscapeUtils;
37  import org.apache.commons.lang3.StringUtils;
38  import org.apache.commons.lang3.Strings;
39  
40  /**
41   * Controls {@link String} formatting for {@link ToStringBuilder}. The main public interface is always via {@link ToStringBuilder}.
42   *
43   * <p>
44   * These classes are intended to be used as <em>singletons</em>. There is no need to instantiate a new style each time. A program will generally use one of the
45   * predefined constants on this class. Alternatively, the {@link StandardToStringStyle} class can be used to set the individual settings. Thus most styles can
46   * be achieved without subclassing.
47   * </p>
48   *
49   * <p>
50   * If required, a subclass can override as many or as few of the methods as it requires. Each object type (from {@code boolean} to {@code long} to
51   * {@link Object} to {@code int[]}) has its own methods to output it. Most have two versions, detail and summary.
52   *
53   * <p>
54   * For example, the detail version of the array based methods will output the whole array, whereas the summary method will just output the array length.
55   * </p>
56   *
57   * <p>
58   * If you want to format the output of certain objects, such as dates, you must create a subclass and override a method.
59   * </p>
60   *
61   * <pre>
62   * public class MyStyle extends ToStringStyle {
63   *
64   *     protected void appendDetail(StringBuffer buffer, String fieldName, Object value) {
65   *         if (value instanceof Date) {
66   *             value = new SimpleDateFormat("yyyy-MM-dd").format(value);
67   *         }
68   *         buffer.append(value);
69   *     }
70   * }
71   * </pre>
72   *
73   * @since 1.0
74   */
75  @SuppressWarnings("deprecation") // StringEscapeUtils
76  public abstract class ToStringStyle implements Serializable {
77  
78      /**
79       * Default {@link ToStringStyle}.
80       *
81       * <p>
82       * This is an inner class rather than using {@link StandardToStringStyle} to ensure its immutability.
83       * </p>
84       */
85      private static final class DefaultToStringStyle extends ToStringStyle {
86  
87          /**
88           * Required for serialization support.
89           *
90           * @see Serializable
91           */
92          private static final long serialVersionUID = 1L;
93  
94          /**
95           * Constructs a new instance.
96           *
97           * <p>
98           * Use the static constant rather than instantiating.
99           * </p>
100          */
101         DefaultToStringStyle() {
102         }
103 
104         /**
105          * Ensure Singleton after serialization.
106          *
107          * @return The singleton.
108          */
109         private Object readResolve() {
110             return DEFAULT_STYLE;
111         }
112     }
113 
114     /**
115      * {@link ToStringStyle} that outputs with JSON format.
116      *
117      * <p>
118      * This is an inner class rather than using {@link StandardToStringStyle} to ensure its immutability.
119      * </p>
120      *
121      * @since 3.4
122      * @see <a href="https://www.json.org/">json.org</a>
123      */
124     private static final class JsonToStringStyle extends ToStringStyle {
125 
126         private static final long serialVersionUID = 1L;
127         private static final String FIELD_NAME_QUOTE = "\"";
128 
129         /**
130          * Constructs a new instance.
131          *
132          * <p>
133          * Use the static constant rather than instantiating.
134          * </p>
135          */
136         JsonToStringStyle() {
137             setUseClassName(false);
138             setUseIdentityHashCode(false);
139             setContentStart("{");
140             setContentEnd("}");
141             setArrayStart("[");
142             setArrayEnd("]");
143             setFieldSeparator(",");
144             setFieldNameValueSeparator(":");
145             setNullText("null");
146             setSummaryObjectStartText("\"<");
147             setSummaryObjectEndText(">\"");
148             setSizeStartText("\"<size=");
149             setSizeEndText(">\"");
150         }
151 
152         @Override
153         public void append(final StringBuffer buffer, final String fieldName, final boolean[] array, final Boolean fullDetail) {
154             checkAppendInput(fieldName, fullDetail);
155             super.append(buffer, fieldName, array, fullDetail);
156         }
157 
158         @Override
159         public void append(final StringBuffer buffer, final String fieldName, final byte[] array, final Boolean fullDetail) {
160             checkAppendInput(fieldName, fullDetail);
161             super.append(buffer, fieldName, array, fullDetail);
162         }
163 
164         @Override
165         public void append(final StringBuffer buffer, final String fieldName, final char[] array, final Boolean fullDetail) {
166             checkAppendInput(fieldName, fullDetail);
167             super.append(buffer, fieldName, array, fullDetail);
168         }
169 
170         @Override
171         public void append(final StringBuffer buffer, final String fieldName, final double[] array, final Boolean fullDetail) {
172             checkAppendInput(fieldName, fullDetail);
173             super.append(buffer, fieldName, array, fullDetail);
174         }
175 
176         @Override
177         public void append(final StringBuffer buffer, final String fieldName, final float[] array, final Boolean fullDetail) {
178             checkAppendInput(fieldName, fullDetail);
179             super.append(buffer, fieldName, array, fullDetail);
180         }
181 
182         @Override
183         public void append(final StringBuffer buffer, final String fieldName, final int[] array, final Boolean fullDetail) {
184             checkAppendInput(fieldName, fullDetail);
185             super.append(buffer, fieldName, array, fullDetail);
186         }
187 
188         @Override
189         public void append(final StringBuffer buffer, final String fieldName, final long[] array, final Boolean fullDetail) {
190             checkAppendInput(fieldName, fullDetail);
191             super.append(buffer, fieldName, array, fullDetail);
192         }
193 
194         @Override
195         public void append(final StringBuffer buffer, final String fieldName, final Object value, final Boolean fullDetail) {
196             checkAppendInput(fieldName, fullDetail);
197             super.append(buffer, fieldName, value, fullDetail);
198         }
199 
200         @Override
201         public void append(final StringBuffer buffer, final String fieldName, final Object[] array, final Boolean fullDetail) {
202             checkAppendInput(fieldName, fullDetail);
203             super.append(buffer, fieldName, array, fullDetail);
204         }
205 
206         @Override
207         public void append(final StringBuffer buffer, final String fieldName, final short[] array, final Boolean fullDetail) {
208             checkAppendInput(fieldName, fullDetail);
209             super.append(buffer, fieldName, array, fullDetail);
210         }
211 
212         @Override
213         protected void appendDetail(final StringBuffer buffer, final String fieldName, final char value) {
214             appendValueAsString(buffer, String.valueOf(value));
215         }
216 
217         @Override
218         protected void appendDetail(final StringBuffer buffer, final String fieldName, final Collection<?> coll) {
219             if (coll != null && !coll.isEmpty()) {
220                 buffer.append(getArrayStart());
221                 int i = 0;
222                 for (final Object item : coll) {
223                     appendDetail(buffer, fieldName, i++, item);
224                 }
225                 buffer.append(getArrayEnd());
226                 return;
227             }
228             buffer.append(coll);
229         }
230 
231         @Override
232         protected void appendDetail(final StringBuffer buffer, final String fieldName, final Map<?, ?> map) {
233             if (map != null && !map.isEmpty()) {
234                 buffer.append(getContentStart());
235                 boolean firstItem = true;
236                 for (final Entry<?, ?> entry : map.entrySet()) {
237                     final String keyStr = Objects.toString(entry.getKey(), null);
238                     if (keyStr != null) {
239                         if (firstItem) {
240                             firstItem = false;
241                         } else {
242                             appendFieldEnd(buffer, keyStr);
243                         }
244                         appendFieldStart(buffer, keyStr);
245                         final Object value = entry.getValue();
246                         if (value == null) {
247                             appendNullText(buffer, keyStr);
248                         } else {
249                             appendInternal(buffer, keyStr, value, true);
250                         }
251                     }
252                 }
253                 buffer.append(getContentEnd());
254                 return;
255             }
256             buffer.append(map);
257         }
258 
259         @Override
260         protected void appendDetail(final StringBuffer buffer, final String fieldName, final Object value) {
261             if (value == null) {
262                 appendNullText(buffer, fieldName);
263                 return;
264             }
265             if (value instanceof CharSequence || value instanceof Character) {
266                 appendValueAsString(buffer, value.toString());
267                 return;
268             }
269             if (value instanceof Number || value instanceof Boolean) {
270                 buffer.append(value);
271                 return;
272             }
273             final String valueAsString = value.toString();
274             if (isJsonObject(valueAsString) || isJsonArray(valueAsString)) {
275                 buffer.append(value);
276                 return;
277             }
278             appendDetail(buffer, fieldName, valueAsString);
279         }
280 
281         @Override
282         protected void appendFieldStart(final StringBuffer buffer, final String fieldName) {
283             checkFieldName(fieldName);
284             super.appendFieldStart(buffer, FIELD_NAME_QUOTE + StringEscapeUtils.escapeJson(fieldName) + FIELD_NAME_QUOTE);
285         }
286 
287         /**
288          * Appends the given String enclosed in double-quotes to the given StringBuffer.
289          *
290          * @param buffer The StringBuffer to append the value to.
291          * @param value  The value to append.
292          */
293         private void appendValueAsString(final StringBuffer buffer, final String value) {
294             buffer.append('"').append(StringEscapeUtils.escapeJson(value)).append('"');
295         }
296 
297         private void checkAppendInput(final String fieldName, final Boolean fullDetail) {
298             checkFieldName(fieldName);
299             checkIsFullDetail(fullDetail);
300         }
301 
302         private void checkFieldName(final String fieldName) {
303             if (fieldName == null) {
304                 throw new UnsupportedOperationException("Field names are mandatory when using JsonToStringStyle");
305             }
306         }
307 
308         private void checkIsFullDetail(final Boolean fullDetail) {
309             if (!isFullDetail(fullDetail)) {
310                 throw new UnsupportedOperationException("FullDetail must be true when using JsonToStringStyle");
311             }
312         }
313 
314         private boolean isJsonArray(final String valueAsString) {
315             return valueAsString.startsWith(getArrayStart()) && valueAsString.endsWith(getArrayEnd());
316         }
317 
318         private boolean isJsonObject(final String valueAsString) {
319             return valueAsString.startsWith(getContentStart()) && valueAsString.endsWith(getContentEnd());
320         }
321 
322         /**
323          * Ensure Singleton after serialization.
324          *
325          * @return The singleton
326          */
327         private Object readResolve() {
328             return JSON_STYLE;
329         }
330     }
331 
332     /**
333      * {@link ToStringStyle} that outputs on multiple lines.
334      *
335      * <p>
336      * This is an inner class rather than using {@link StandardToStringStyle} to ensure its immutability.
337      * </p>
338      */
339     private static final class MultiLineToStringStyle extends ToStringStyle {
340 
341         private static final long serialVersionUID = 1L;
342 
343         /**
344          * Constructs a new instance.
345          *
346          * <p>
347          * Use the static constant rather than instantiating.
348          * </p>
349          */
350         MultiLineToStringStyle() {
351             setContentStart("[");
352             setFieldSeparator(System.lineSeparator() + "  ");
353             setFieldSeparatorAtStart(true);
354             setContentEnd(System.lineSeparator() + "]");
355         }
356 
357         /**
358          * Ensure Singleton after serialization.
359          *
360          * @return The singleton.
361          */
362         private Object readResolve() {
363             return MULTI_LINE_STYLE;
364         }
365     }
366 
367     /**
368      * {@link ToStringStyle} that does not print out the class name and identity hash code but prints content start and field names.
369      *
370      * <p>
371      * This is an inner class rather than using {@link StandardToStringStyle} to ensure its immutability.
372      * </p>
373      */
374     private static final class NoClassNameToStringStyle extends ToStringStyle {
375 
376         private static final long serialVersionUID = 1L;
377 
378         /**
379          * Constructs a new instance.
380          *
381          * <p>
382          * Use the static constant rather than instantiating.
383          * </p>
384          */
385         NoClassNameToStringStyle() {
386             setUseClassName(false);
387             setUseIdentityHashCode(false);
388         }
389 
390         /**
391          * Ensure Singleton after serialization.
392          *
393          * @return The singleton
394          */
395         private Object readResolve() {
396             return NO_CLASS_NAME_STYLE;
397         }
398     }
399 
400     /**
401      * {@link ToStringStyle} that does not print out the field names.
402      *
403      * <p>
404      * This is an inner class rather than using {@link StandardToStringStyle} to ensure its immutability.
405      * </p>
406      */
407     private static final class NoFieldNameToStringStyle extends ToStringStyle {
408 
409         private static final long serialVersionUID = 1L;
410 
411         /**
412          * Constructs a new instance.
413          *
414          * <p>
415          * Use the static constant rather than instantiating.
416          * </p>
417          */
418         NoFieldNameToStringStyle() {
419             setUseFieldNames(false);
420         }
421 
422         /**
423          * Ensure Singleton after serialization.
424          *
425          * @return The singleton
426          */
427         private Object readResolve() {
428             return NO_FIELD_NAMES_STYLE;
429         }
430     }
431 
432     /**
433      * {@link ToStringStyle} that prints out the short class name and no identity hash code.
434      *
435      * <p>
436      * This is an inner class rather than using {@link StandardToStringStyle} to ensure its immutability.
437      * </p>
438      */
439     private static final class ShortPrefixToStringStyle extends ToStringStyle {
440 
441         private static final long serialVersionUID = 1L;
442 
443         /**
444          * Constructs a new instance.
445          *
446          * <p>
447          * Use the static constant rather than instantiating.
448          * </p>
449          */
450         ShortPrefixToStringStyle() {
451             setUseShortClassName(true);
452             setUseIdentityHashCode(false);
453         }
454 
455         /**
456          * Ensure {@code Singleton} after serialization.
457          *
458          * @return The singleton.
459          */
460         private Object readResolve() {
461             return SHORT_PREFIX_STYLE;
462         }
463     }
464 
465     /**
466      * {@link ToStringStyle} that does not print out the class name, identity hash code, content start or field name.
467      *
468      * <p>
469      * This is an inner class rather than using {@link StandardToStringStyle} to ensure its immutability.
470      * </p>
471      */
472     private static final class SimpleToStringStyle extends ToStringStyle {
473 
474         private static final long serialVersionUID = 1L;
475 
476         /**
477          * Constructs a new instance.
478          *
479          * <p>
480          * Use the static constant rather than instantiating.
481          * </p>
482          */
483         SimpleToStringStyle() {
484             setUseClassName(false);
485             setUseIdentityHashCode(false);
486             setUseFieldNames(false);
487             setContentStart(StringUtils.EMPTY);
488             setContentEnd(StringUtils.EMPTY);
489         }
490 
491         /**
492          * Ensure <code>Singleton</code> after serialization.
493          *
494          * @return The singleton
495          */
496         private Object readResolve() {
497             return SIMPLE_STYLE;
498         }
499     }
500 
501     /**
502      * Visited objects belonging to one output buffer.
503      *
504      * <p>
505      * Weak identity keys prevent visited objects that refer back to the output buffer from keeping a weakly registered buffer alive.
506      * </p>
507      */
508     static final class Traversal {
509 
510         private ReferenceQueue<Object> collected;
511 
512         private Set<VisitedReference> visited;
513 
514         private void add(final Object value) {
515             if (visited == null) {
516                 collected = new ReferenceQueue<>();
517                 visited = new HashSet<>();
518             } else {
519                 removeCollected();
520             }
521             visited.add(new VisitedReference(value, collected));
522         }
523 
524         private void addAll(final Traversal other) {
525             if (other.visited != null) {
526                 other.removeCollected();
527                 for (final VisitedReference reference : other.visited) {
528                     final Object value = reference.get();
529                     if (value != null) {
530                         add(value);
531                     }
532                 }
533             }
534         }
535 
536         private void clear() {
537             visited = null;
538             collected = null;
539         }
540 
541         private boolean contains(final Object value) {
542             if (visited == null) {
543                 return false;
544             }
545             removeCollected();
546             return visited.contains(new VisitedReference(value, null));
547         }
548 
549         Set<VisitedReference> getVisited() {
550             return visited;
551         }
552 
553 
554         private void removeCollected() {
555             Reference<?> reference;
556             while ((reference = collected.poll()) != null) {
557                 visited.remove(reference);
558             }
559         }
560     }
561 
562     /**
563      * A weak identity key that does not invoke a visited object's {@code equals()} or {@code hashCode()}.
564      */
565     private static final class VisitedReference extends WeakReference<Object> {
566 
567         private final int hashCode;
568 
569         private VisitedReference(final Object value, final ReferenceQueue<Object> queue) {
570             super(value, queue);
571             hashCode = System.identityHashCode(value);
572         }
573 
574         @Override
575         public boolean equals(final Object other) {
576             if (this == other) {
577                 return true;
578             }
579             if (!(other instanceof VisitedReference)) {
580                 return false;
581             }
582             final Object value = get();
583             return value != null && value == ((VisitedReference) other).get();
584         }
585 
586         @Override
587         public int hashCode() {
588             return hashCode;
589         }
590     }
591 
592     /**
593      * Serialization version ID.
594      */
595     private static final long serialVersionUID = -2587890625525655916L;
596 
597     /**
598      * The default toString style. Using the {@code Person} example from {@link ToStringBuilder}, the output would look like this:
599      *
600      * <pre>
601      * Person@182f0db[name=John Doe,age=33,smoker=false]
602      * </pre>
603      */
604     public static final ToStringStyle DEFAULT_STYLE = new DefaultToStringStyle();
605 
606     /**
607      * The multi line toString style. Using the {@code Person} example from {@link ToStringBuilder}, the output would look like this:
608      *
609      * <pre>
610      * Person@182f0db[
611      *   name=John Doe
612      *   age=33
613      *   smoker=false
614      * ]
615      * </pre>
616      */
617     public static final ToStringStyle MULTI_LINE_STYLE = new MultiLineToStringStyle();
618 
619     /**
620      * The no field names toString style. Using the {@code Person} example from {@link ToStringBuilder}, the output would look like this:
621      *
622      * <pre>
623      * Person@182f0db[John Doe,33,false]
624      * </pre>
625      */
626     public static final ToStringStyle NO_FIELD_NAMES_STYLE = new NoFieldNameToStringStyle();
627 
628     /**
629      * The short prefix toString style. Using the {@code Person} example from {@link ToStringBuilder}, the output would look like this:
630      *
631      * <pre>
632      * Person[name=John Doe,age=33,smoker=false]
633      * </pre>
634      *
635      * @since 2.1
636      */
637     public static final ToStringStyle SHORT_PREFIX_STYLE = new ShortPrefixToStringStyle();
638 
639     /**
640      * The simple toString style. Using the {@code Person} example from {@link ToStringBuilder}, the output would look like this:
641      *
642      * <pre>
643      * John Doe,33,false
644      * </pre>
645      */
646     public static final ToStringStyle SIMPLE_STYLE = new SimpleToStringStyle();
647 
648     /**
649      * The no class name toString style. Using the {@code Person} example from {@link ToStringBuilder}, the output would look like this:
650      *
651      * <pre>
652      * [name=John Doe,age=33,smoker=false]
653      * </pre>
654      *
655      * @since 3.4
656      */
657     public static final ToStringStyle NO_CLASS_NAME_STYLE = new NoClassNameToStringStyle();
658 
659     /**
660      * The JSON toString style. Using the {@code Person} example from {@link ToStringBuilder}, the output would look like this:
661      *
662      * <pre>
663      * {"name": "John Doe", "age": 33, "smoker": true}
664      * </pre>
665      * <p>
666      * Values implementing {@link CharSequence}, including {@link String}, {@link StringBuilder}, and {@link StringBuffer}, are quoted and escaped as JSON
667      * strings, even when their text resembles a JSON object or array.
668      * </p>
669      * <p>
670      * <strong>Note:</strong> Since field names are mandatory in JSON, this ToStringStyle will throw an {@link UnsupportedOperationException} if no field name
671      * is passed in while appending. Furthermore This ToStringStyle will only generate valid JSON if referenced objects also produce JSON when calling
672      * {@code toString()} on them.
673      * </p>
674      *
675      * @since 3.4
676      * @see <a href="https://www.json.org/">json.org</a>
677      */
678     public static final ToStringStyle JSON_STYLE = new JsonToStringStyle();
679 
680     /**
681      * A registry of objects used by {@code reflectionToString} methods to detect cyclical object references and avoid infinite loops.
682      * Identity-based comparison is required so that cyclic objects (e.g. an ArrayList whose hashCode() would recurse) can be
683      * registered and looked up without triggering infinite recursion through equals/hashCode.
684      */
685     private static final ThreadLocal<IdentityHashMap<Object, Object>> REGISTRY = ThreadLocal.withInitial(IdentityHashMap::new);
686     /*
687      * Note that objects of this class are generally shared between threads, so an instance variable would not be suitable here.
688      *
689      * In normal use the registry should always be left empty, because the caller should call toString() which will clean up.
690      *
691      * See LANG-792
692      */
693 
694     /**
695      * Traversals opened by direct style calls and retained until {@link #appendEnd(StringBuffer, Object)}.
696      */
697     private static final ThreadLocal<Map<StringBuffer, Traversal>> DIRECT_TRAVERSALS = new ThreadLocal<>();
698 
699     /**
700      * The traversal shared by synchronous nested builders and style callbacks in this thread.
701      */
702     private static final ThreadLocal<Traversal> TRAVERSAL_ACTIVE = new ThreadLocal<>();
703 
704     /**
705      * Weak associations between output buffers and their traversal state.
706      *
707      * <p>
708      * Builders retain their own traversal state between appends. Weak keys and values allow abandoned builders and their visited objects to be collected
709      * without waiting for unrelated entries in {@link #REGISTRY} to disappear. Direct style calls on a builder's buffer find the same state here.
710      * </p>
711      */
712     private static final ThreadLocal<Map<StringBuffer, WeakReference<Traversal>>> TRAVERSALS = new ThreadLocal<>();
713 
714     /**
715      * Releases completed output state unless it is shared with an active enclosing traversal.
716      *
717      * @param buffer the completed output buffer.
718      * @param traversal its traversal state.
719      */
720     private static void clearTraversal(final StringBuffer buffer, final Traversal traversal) {
721         if (traversal != TRAVERSAL_ACTIVE.get()) {
722             traversal.clear();
723             final Map<StringBuffer, Traversal> direct = DIRECT_TRAVERSALS.get();
724             if (direct != null) {
725                 direct.remove(buffer);
726                 if (direct.isEmpty()) {
727                     DIRECT_TRAVERSALS.remove();
728                 }
729             }
730         }
731     }
732 
733     /**
734      * Ends a direct recursive-style traversal.
735      *
736      * @param owner whether the caller started the traversal.
737      */
738     static void endStyleTraversal(final boolean owner) {
739         if (owner) {
740             TRAVERSAL_ACTIVE.remove();
741         }
742     }
743 
744     /**
745      * Ends a builder traversal, retaining marks only for successful appends.
746      *
747      * @param buffer the builder's output buffer.
748      * @param traversal the builder's traversal state.
749      * @param owner whether the builder started the active traversal.
750      * @param clear whether the builder completed or an append failed.
751      */
752     static void endTraversal(final StringBuffer buffer, final Traversal traversal, final boolean owner, final boolean clear) {
753         if (owner) {
754             TRAVERSAL_ACTIVE.remove();
755         }
756         if (clear) {
757             clearTraversal(buffer, traversal);
758         }
759     }
760 
761     /**
762      * Finds existing traversal state without creating it.
763      *
764      * @param buffer the output buffer.
765      * @return its traversal state, or {@code null}.
766      */
767     private static Traversal findTraversal(final StringBuffer buffer) {
768         final Map<StringBuffer, WeakReference<Traversal>> traversals = TRAVERSALS.get();
769         final WeakReference<Traversal> reference = traversals == null ? null : traversals.get(buffer);
770         return reference == null ? null : reference.get();
771     }
772 
773     /**
774      * Gets the active traversal for the current thread.
775      *
776      * @return the active traversal, or {@code null} if no traversal is active.
777      */
778     static Traversal getActiveTraversal() {
779         return TRAVERSAL_ACTIVE.get();
780     }
781 
782     static ThreadLocal<Map<StringBuffer, Traversal>> getDirectTraversals() {
783         return DIRECT_TRAVERSALS;
784     }
785 
786     /**
787      * Gets the registry of objects being traversed by the {@code reflectionToString} methods in the current thread.
788      *
789      * @return Set the registry of objects being traversed.
790      */
791     public static Map<Object, Object> getRegistry() {
792         return REGISTRY.get();
793     }
794 
795     /**
796      * Gets traversal state for an output buffer, sharing an enclosing traversal when necessary.
797      *
798      * @param buffer the output buffer.
799      * @return its traversal state.
800      */
801     static Traversal getTraversal(final StringBuffer buffer) {
802         Traversal traversal = findTraversal(buffer);
803         if (traversal == null) {
804             traversal = TRAVERSAL_ACTIVE.get();
805             if (traversal == null) {
806                 traversal = new Traversal();
807             }
808             Map<StringBuffer, WeakReference<Traversal>> traversals = TRAVERSALS.get();
809             if (traversals == null) {
810                 traversals = new WeakHashMap<>();
811                 TRAVERSALS.set(traversals);
812             }
813             traversals.put(buffer, new WeakReference<>(traversal));
814         }
815         return traversal;
816     }
817 
818     /**
819      * Tests whether the registry contains the given object. Used by the reflection methods to avoid infinite loops.
820      *
821      * @param value The object to lookup in the registry.
822      * @return boolean {@code true} if the registry contains the given object.
823      */
824     static boolean isRegistered(final Object value) {
825         return getRegistry().containsKey(value);
826     }
827 
828     /**
829      * Tests whether the given object has already been rendered in detail during the active traversal.
830      *
831      * <p>
832      * Recursive styles use this to avoid exponential re-traversal of shared (acyclic) references.
833      * </p>
834      *
835      * @param value The object to look up in the visited set.
836      * @return {@code true} if the object was already visited in this traversal.
837      */
838     static boolean isVisited(final Object value) {
839         final Traversal traversal = TRAVERSAL_ACTIVE.get();
840         return traversal != null && traversal.contains(value);
841     }
842 
843     /**
844      * Marks the given object as rendered in detail for the active traversal.
845      *
846      * <p>
847      * Builders retain these marks between appends and release them on completion, independently of {@link #REGISTRY}.
848      * </p>
849      *
850      * @param value The object to mark as visited.
851      */
852     static void markVisited(final Object value) {
853         if (value != null) {
854             TRAVERSAL_ACTIVE.get().add(value);
855         }
856     }
857 
858     /**
859      * Registers the given object. Used by the reflection methods to avoid infinite loops.
860      *
861      * @param value The object to register.
862      */
863     static void register(final Object value) {
864         if (value != null) {
865             getRegistry().put(value, null);
866         }
867     }
868 
869     /**
870      * Starts a direct recursive-style traversal unless a builder or style is already rendering.
871      *
872      * @param buffer the output buffer.
873      * @return whether the caller owns the traversal and must end it.
874      */
875     static boolean startStyleTraversal(final StringBuffer buffer) {
876         return startTraversal(getTraversal(buffer));
877     }
878 
879     /**
880      * Starts a traversal, sharing the active traversal when called by a nested builder.
881      *
882      * @param traversal the output buffer's traversal state.
883      * @return whether the caller owns the traversal and must end it.
884      */
885     static boolean startTraversal(final Traversal traversal) {
886         final Traversal active = TRAVERSAL_ACTIVE.get();
887         if (active != null) {
888             if (active != traversal) {
889                 active.addAll(traversal);
890             }
891             return false;
892         }
893         TRAVERSAL_ACTIVE.set(traversal);
894         return true;
895     }
896 
897     /**
898      * Unregisters the given object.
899      *
900      * <p>
901      * Used by the reflection methods to avoid infinite loops.
902      * </p>
903      *
904      * @param value The object to unregister.
905      */
906     static void unregister(final Object value) {
907         if (value != null) {
908             final Map<Object, Object> m = getRegistry();
909             m.remove(value);
910             if (m.isEmpty()) {
911                 REGISTRY.remove();
912             }
913         }
914     }
915 
916     /**
917      * Whether to use the field names, the default is {@code true}.
918      */
919     private boolean useFieldNames = true;
920 
921     /**
922      * Whether to use the class name, the default is {@code true}.
923      */
924     private boolean useClassName = true;
925 
926     /**
927      * Whether to use short class names, the default is {@code false}.
928      */
929     private boolean useShortClassName;
930 
931     /**
932      * Whether to use the identity hash code, the default is {@code true}.
933      */
934     private boolean useIdentityHashCode = true;
935 
936     /**
937      * The content start {@code '['}.
938      */
939     private String contentStart = "[";
940 
941     /**
942      * The content end {@code ']'}.
943      */
944     private String contentEnd = "]";
945 
946     /**
947      * The field name value separator {@code '='}.
948      */
949     private String fieldNameValueSeparator = "=";
950 
951     /**
952      * Whether the field separator should be added before any other fields.
953      */
954     private boolean fieldSeparatorAtStart;
955 
956     /**
957      * Whether the field separator should be added after any other fields.
958      */
959     private boolean fieldSeparatorAtEnd;
960 
961     /**
962      * The field separator {@code ','}.
963      */
964     private String fieldSeparator = ",";
965 
966     /**
967      * The array start <code>'{'</code>.
968      */
969     private String arrayStart = "{";
970 
971     /**
972      * The array separator {@code ','}.
973      */
974     private String arraySeparator = ",";
975 
976     /**
977      * The detail for array content.
978      */
979     private boolean arrayContentDetail = true;
980 
981     /**
982      * The array end {@code '}'}.
983      */
984     private String arrayEnd = "}";
985 
986     /**
987      * The value to use when fullDetail is {@code null}, the default value is {@code true}.
988      */
989     private boolean defaultFullDetail = true;
990 
991     /**
992      * The {@code null} text {@code "<null>"}.
993      */
994     private String nullText = "<null>";
995 
996     /**
997      * The summary size text start {@code "<size="}.
998      */
999     private String sizeStartText = "<size=";
1000 
1001     /**
1002      * The summary size text start {@code ">"}.
1003      */
1004     private String sizeEndText = ">";
1005 
1006     /**
1007      * The summary object text start {@code "<"}.
1008      */
1009     private String summaryObjectStartText = "<";
1010 
1011     /**
1012      * The summary object text start {@code ">"}.
1013      */
1014     private String summaryObjectEndText = ">";
1015 
1016     /**
1017      * Constructs a new instance.
1018      */
1019     protected ToStringStyle() {
1020     }
1021 
1022     /**
1023      * Appends to the {@code toString} a {@code boolean} value.
1024      *
1025      * @param buffer    The {@link StringBuffer} to populate.
1026      * @param fieldName The field name.
1027      * @param value     The value to add to the {@code toString}.
1028      */
1029     public void append(final StringBuffer buffer, final String fieldName, final boolean value) {
1030         appendFieldStart(buffer, fieldName);
1031         appendDetail(buffer, fieldName, value);
1032         appendFieldEnd(buffer, fieldName);
1033     }
1034 
1035     /**
1036      * Appends to the {@code toString} a {@code boolean} array.
1037      *
1038      * @param buffer     The {@link StringBuffer} to populate.
1039      * @param fieldName  The field name.
1040      * @param array      The array to add to the toString.
1041      * @param fullDetail {@code true} for detail, {@code false} for summary info, {@code null} for style decides.
1042      */
1043     public void append(final StringBuffer buffer, final String fieldName, final boolean[] array, final Boolean fullDetail) {
1044         appendFieldStart(buffer, fieldName);
1045         if (array == null) {
1046             appendNullText(buffer, fieldName);
1047         } else if (isFullDetail(fullDetail)) {
1048             appendDetail(buffer, fieldName, array);
1049         } else {
1050             appendSummary(buffer, fieldName, array);
1051         }
1052         appendFieldEnd(buffer, fieldName);
1053     }
1054 
1055     /**
1056      * Appends to the {@code toString} a {@code byte} value.
1057      *
1058      * @param buffer    The {@link StringBuffer} to populate.
1059      * @param fieldName The field name.
1060      * @param value     The value to add to the {@code toString}.
1061      */
1062     public void append(final StringBuffer buffer, final String fieldName, final byte value) {
1063         appendFieldStart(buffer, fieldName);
1064         appendDetail(buffer, fieldName, value);
1065         appendFieldEnd(buffer, fieldName);
1066     }
1067 
1068     /**
1069      * Appends to the {@code toString} a {@code byte} array.
1070      *
1071      * @param buffer     The {@link StringBuffer} to populate.
1072      * @param fieldName  The field name.
1073      * @param array      The array to add to the {@code toString}.
1074      * @param fullDetail {@code true} for detail, {@code false} for summary info, {@code null} for style decides.
1075      */
1076     public void append(final StringBuffer buffer, final String fieldName, final byte[] array, final Boolean fullDetail) {
1077         appendFieldStart(buffer, fieldName);
1078         if (array == null) {
1079             appendNullText(buffer, fieldName);
1080         } else if (isFullDetail(fullDetail)) {
1081             appendDetail(buffer, fieldName, array);
1082         } else {
1083             appendSummary(buffer, fieldName, array);
1084         }
1085         appendFieldEnd(buffer, fieldName);
1086     }
1087 
1088     /**
1089      * Appends to the {@code toString} a {@code char} value.
1090      *
1091      * @param buffer    The {@link StringBuffer} to populate.
1092      * @param fieldName The field name.
1093      * @param value     The value to add to the {@code toString}.
1094      */
1095     public void append(final StringBuffer buffer, final String fieldName, final char value) {
1096         appendFieldStart(buffer, fieldName);
1097         appendDetail(buffer, fieldName, value);
1098         appendFieldEnd(buffer, fieldName);
1099     }
1100 
1101     /**
1102      * Appends to the {@code toString} a {@code char} array.
1103      *
1104      * @param buffer     The {@link StringBuffer} to populate.
1105      * @param fieldName  The field name.
1106      * @param array      The array to add to the {@code toString}.
1107      * @param fullDetail {@code true} for detail, {@code false} for summary info, {@code null} for style decides.
1108      */
1109     public void append(final StringBuffer buffer, final String fieldName, final char[] array, final Boolean fullDetail) {
1110         appendFieldStart(buffer, fieldName);
1111         if (array == null) {
1112             appendNullText(buffer, fieldName);
1113         } else if (isFullDetail(fullDetail)) {
1114             appendDetail(buffer, fieldName, array);
1115         } else {
1116             appendSummary(buffer, fieldName, array);
1117         }
1118         appendFieldEnd(buffer, fieldName);
1119     }
1120 
1121     /**
1122      * Appends to the {@code toString} a {@code double} value.
1123      *
1124      * @param buffer    The {@link StringBuffer} to populate.
1125      * @param fieldName The field name.
1126      * @param value     The value to add to the {@code toString}.
1127      */
1128     public void append(final StringBuffer buffer, final String fieldName, final double value) {
1129         appendFieldStart(buffer, fieldName);
1130         appendDetail(buffer, fieldName, value);
1131         appendFieldEnd(buffer, fieldName);
1132     }
1133 
1134     /**
1135      * Appends to the {@code toString} a {@code double} array.
1136      *
1137      * @param buffer     The {@link StringBuffer} to populate.
1138      * @param fieldName  The field name.
1139      * @param array      The array to add to the toString.
1140      * @param fullDetail {@code true} for detail, {@code false} for summary info, {@code null} for style decides.
1141      */
1142     public void append(final StringBuffer buffer, final String fieldName, final double[] array, final Boolean fullDetail) {
1143         appendFieldStart(buffer, fieldName);
1144         if (array == null) {
1145             appendNullText(buffer, fieldName);
1146         } else if (isFullDetail(fullDetail)) {
1147             appendDetail(buffer, fieldName, array);
1148         } else {
1149             appendSummary(buffer, fieldName, array);
1150         }
1151         appendFieldEnd(buffer, fieldName);
1152     }
1153 
1154     /**
1155      * Appends to the {@code toString} a {@code float} value.
1156      *
1157      * @param buffer    The {@link StringBuffer} to populate.
1158      * @param fieldName The field name.
1159      * @param value     The value to add to the {@code toString}.
1160      */
1161     public void append(final StringBuffer buffer, final String fieldName, final float value) {
1162         appendFieldStart(buffer, fieldName);
1163         appendDetail(buffer, fieldName, value);
1164         appendFieldEnd(buffer, fieldName);
1165     }
1166 
1167     /**
1168      * Appends to the {@code toString} a {@code float} array.
1169      *
1170      * @param buffer     The {@link StringBuffer} to populate.
1171      * @param fieldName  The field name.
1172      * @param array      The array to add to the toString.
1173      * @param fullDetail {@code true} for detail, {@code false} for summary info, {@code null} for style decides.
1174      */
1175     public void append(final StringBuffer buffer, final String fieldName, final float[] array, final Boolean fullDetail) {
1176         appendFieldStart(buffer, fieldName);
1177         if (array == null) {
1178             appendNullText(buffer, fieldName);
1179         } else if (isFullDetail(fullDetail)) {
1180             appendDetail(buffer, fieldName, array);
1181         } else {
1182             appendSummary(buffer, fieldName, array);
1183         }
1184         appendFieldEnd(buffer, fieldName);
1185     }
1186 
1187     /**
1188      * Appends to the {@code toString} an {@code int} value.
1189      *
1190      * @param buffer    The {@link StringBuffer} to populate.
1191      * @param fieldName The field name.
1192      * @param value     The value to add to the {@code toString}.
1193      */
1194     public void append(final StringBuffer buffer, final String fieldName, final int value) {
1195         appendFieldStart(buffer, fieldName);
1196         appendDetail(buffer, fieldName, value);
1197         appendFieldEnd(buffer, fieldName);
1198     }
1199 
1200     /**
1201      * Appends to the {@code toString} an {@code int} array.
1202      *
1203      * @param buffer     The {@link StringBuffer} to populate.
1204      * @param fieldName  The field name.
1205      * @param array      The array to add to the {@code toString}.
1206      * @param fullDetail {@code true} for detail, {@code false} for summary info, {@code null} for style decides.
1207      */
1208     public void append(final StringBuffer buffer, final String fieldName, final int[] array, final Boolean fullDetail) {
1209         appendFieldStart(buffer, fieldName);
1210         if (array == null) {
1211             appendNullText(buffer, fieldName);
1212         } else if (isFullDetail(fullDetail)) {
1213             appendDetail(buffer, fieldName, array);
1214         } else {
1215             appendSummary(buffer, fieldName, array);
1216         }
1217         appendFieldEnd(buffer, fieldName);
1218     }
1219 
1220     /**
1221      * Appends to the {@code toString} a {@code long} value.
1222      *
1223      * @param buffer    The {@link StringBuffer} to populate.
1224      * @param fieldName The field name.
1225      * @param value     The value to add to the {@code toString}.
1226      */
1227     public void append(final StringBuffer buffer, final String fieldName, final long value) {
1228         appendFieldStart(buffer, fieldName);
1229         appendDetail(buffer, fieldName, value);
1230         appendFieldEnd(buffer, fieldName);
1231     }
1232 
1233     /**
1234      * Appends to the {@code toString} a {@code long} array.
1235      *
1236      * @param buffer     The {@link StringBuffer} to populate.
1237      * @param fieldName  The field name.
1238      * @param array      The array to add to the {@code toString}.
1239      * @param fullDetail {@code true} for detail, {@code false} for summary info, {@code null} for style decides.
1240      */
1241     public void append(final StringBuffer buffer, final String fieldName, final long[] array, final Boolean fullDetail) {
1242         appendFieldStart(buffer, fieldName);
1243         if (array == null) {
1244             appendNullText(buffer, fieldName);
1245         } else if (isFullDetail(fullDetail)) {
1246             appendDetail(buffer, fieldName, array);
1247         } else {
1248             appendSummary(buffer, fieldName, array);
1249         }
1250         appendFieldEnd(buffer, fieldName);
1251     }
1252 
1253     /**
1254      * Appends to the {@code toString} an {@link Object} value, printing the full {@code toString} of the {@link Object} passed in.
1255      *
1256      * @param buffer     The {@link StringBuffer} to populate.
1257      * @param fieldName  The field name.
1258      * @param value      The value to add to the {@code toString}.
1259      * @param fullDetail {@code true} for detail, {@code false} for summary info, {@code null} for style decides.
1260      */
1261     public void append(final StringBuffer buffer, final String fieldName, final Object value, final Boolean fullDetail) {
1262         appendFieldStart(buffer, fieldName);
1263         if (value == null) {
1264             appendNullText(buffer, fieldName);
1265         } else {
1266             appendInternal(buffer, fieldName, value, isFullDetail(fullDetail));
1267         }
1268         appendFieldEnd(buffer, fieldName);
1269     }
1270 
1271     /**
1272      * Appends to the {@code toString} an {@link Object} array.
1273      *
1274      * @param buffer     The {@link StringBuffer} to populate.
1275      * @param fieldName  The field name.
1276      * @param array      The array to add to the toString.
1277      * @param fullDetail {@code true} for detail, {@code false} for summary info, {@code null} for style decides.
1278      */
1279     public void append(final StringBuffer buffer, final String fieldName, final Object[] array, final Boolean fullDetail) {
1280         appendFieldStart(buffer, fieldName);
1281         if (array == null) {
1282             appendNullText(buffer, fieldName);
1283         } else if (isFullDetail(fullDetail)) {
1284             appendDetail(buffer, fieldName, array);
1285         } else {
1286             appendSummary(buffer, fieldName, array);
1287         }
1288         appendFieldEnd(buffer, fieldName);
1289     }
1290 
1291     /**
1292      * Appends to the {@code toString} a {@code short} value.
1293      *
1294      * @param buffer    The {@link StringBuffer} to populate.
1295      * @param fieldName The field name.
1296      * @param value     The value to add to the {@code toString}.
1297      */
1298     public void append(final StringBuffer buffer, final String fieldName, final short value) {
1299         appendFieldStart(buffer, fieldName);
1300         appendDetail(buffer, fieldName, value);
1301         appendFieldEnd(buffer, fieldName);
1302     }
1303 
1304     /**
1305      * Appends to the {@code toString} a {@code short} array.
1306      *
1307      * @param buffer     The {@link StringBuffer} to populate.
1308      * @param fieldName  The field name.
1309      * @param array      The array to add to the {@code toString}.
1310      * @param fullDetail {@code true} for detail, {@code false} for summary info, {@code null} for style decides.
1311      */
1312     public void append(final StringBuffer buffer, final String fieldName, final short[] array, final Boolean fullDetail) {
1313         appendFieldStart(buffer, fieldName);
1314         if (array == null) {
1315             appendNullText(buffer, fieldName);
1316         } else if (isFullDetail(fullDetail)) {
1317             appendDetail(buffer, fieldName, array);
1318         } else {
1319             appendSummary(buffer, fieldName, array);
1320         }
1321         appendFieldEnd(buffer, fieldName);
1322     }
1323 
1324     /**
1325      * Appends to the {@code toString} the class name.
1326      *
1327      * @param buffer The {@link StringBuffer} to populate.
1328      * @param object The {@link Object} whose name to output.
1329      */
1330     protected void appendClassName(final StringBuffer buffer, final Object object) {
1331         if (isUseClassName() && object != null) {
1332             register(object);
1333             if (isUseShortClassName()) {
1334                 buffer.append(getShortClassName(object.getClass()));
1335             } else {
1336                 buffer.append(object.getClass().getName());
1337             }
1338         }
1339     }
1340 
1341     /**
1342      * Appends to the {@code toString} the content end.
1343      *
1344      * @param buffer The {@link StringBuffer} to populate.
1345      */
1346     protected void appendContentEnd(final StringBuffer buffer) {
1347         buffer.append(getContentEnd());
1348     }
1349 
1350     /**
1351      * Appends to the {@code toString} the content start.
1352      *
1353      * @param buffer The {@link StringBuffer} to populate.
1354      */
1355     protected void appendContentStart(final StringBuffer buffer) {
1356         buffer.append(getContentStart());
1357     }
1358 
1359     /**
1360      * Appends to the {@code toString} an {@link Object} value that has been detected to participate in a cycle. This implementation will print the standard
1361      * string value of the value.
1362      *
1363      * @param buffer    The {@link StringBuffer} to populate.
1364      * @param fieldName The field name, typically not used as already appended
1365      * @param value     The value to add to the {@code toString}, not {@code null}.
1366      * @since 2.2
1367      */
1368     protected void appendCyclicObject(final StringBuffer buffer, final String fieldName, final Object value) {
1369         ObjectUtils.identityToString(buffer, value);
1370     }
1371 
1372     /**
1373      * Appends to the {@code toString} a {@code boolean} value.
1374      *
1375      * @param buffer    The {@link StringBuffer} to populate.
1376      * @param fieldName The field name, typically not used as already appended.
1377      * @param value     The value to add to the {@code toString}.
1378      */
1379     protected void appendDetail(final StringBuffer buffer, final String fieldName, final boolean value) {
1380         buffer.append(value);
1381     }
1382 
1383     /**
1384      * Appends to the {@code toString} the detail of a {@code boolean} array.
1385      *
1386      * @param buffer    The {@link StringBuffer} to populate.
1387      * @param fieldName The field name, typically not used as already appended.
1388      * @param array     The array to add to the {@code toString}, not {@code null}.
1389      */
1390     protected void appendDetail(final StringBuffer buffer, final String fieldName, final boolean[] array) {
1391         buffer.append(getArrayStart());
1392         for (int i = 0; i < array.length; i++) {
1393             if (i > 0) {
1394                 buffer.append(getArraySeparator());
1395             }
1396             appendDetail(buffer, fieldName, array[i]);
1397         }
1398         buffer.append(getArrayEnd());
1399     }
1400 
1401     /**
1402      * Appends to the {@code toString} a {@code byte} value.
1403      *
1404      * @param buffer    The {@link StringBuffer} to populate.
1405      * @param fieldName The field name, typically not used as already appended.
1406      * @param value     The value to add to the {@code toString}.
1407      */
1408     protected void appendDetail(final StringBuffer buffer, final String fieldName, final byte value) {
1409         buffer.append(value);
1410     }
1411 
1412     /**
1413      * Appends to the {@code toString} the detail of a {@code byte} array.
1414      *
1415      * @param buffer    The {@link StringBuffer} to populate.
1416      * @param fieldName The field name, typically not used as already appended.
1417      * @param array     The array to add to the {@code toString}, not {@code null}.
1418      */
1419     protected void appendDetail(final StringBuffer buffer, final String fieldName, final byte[] array) {
1420         buffer.append(getArrayStart());
1421         for (int i = 0; i < array.length; i++) {
1422             if (i > 0) {
1423                 buffer.append(getArraySeparator());
1424             }
1425             appendDetail(buffer, fieldName, array[i]);
1426         }
1427         buffer.append(getArrayEnd());
1428     }
1429 
1430     /**
1431      * Appends to the {@code toString} a {@code char} value.
1432      *
1433      * @param buffer    The {@link StringBuffer} to populate.
1434      * @param fieldName The field name, typically not used as already appended.
1435      * @param value     The value to add to the {@code toString}.
1436      */
1437     protected void appendDetail(final StringBuffer buffer, final String fieldName, final char value) {
1438         buffer.append(value);
1439     }
1440 
1441     /**
1442      * Appends to the {@code toString} the detail of a {@code char} array.
1443      *
1444      * @param buffer    The {@link StringBuffer} to populate.
1445      * @param fieldName The field name, typically not used as already appended.
1446      * @param array     The array to add to the {@code toString}, not {@code null}.
1447      */
1448     protected void appendDetail(final StringBuffer buffer, final String fieldName, final char[] array) {
1449         buffer.append(getArrayStart());
1450         for (int i = 0; i < array.length; i++) {
1451             if (i > 0) {
1452                 buffer.append(getArraySeparator());
1453             }
1454             appendDetail(buffer, fieldName, array[i]);
1455         }
1456         buffer.append(getArrayEnd());
1457     }
1458 
1459     /**
1460      * Appends to the {@code toString} a {@link Collection}.
1461      *
1462      * @param buffer    The {@link StringBuffer} to populate.
1463      * @param fieldName The field name, typically not used as already appended.
1464      * @param coll      The {@link Collection} to add to the {@code toString}, not {@code null}.
1465      */
1466     protected void appendDetail(final StringBuffer buffer, final String fieldName, final Collection<?> coll) {
1467         buffer.append('['); // backward compatibility
1468         boolean first = true;
1469         for (final Object item : coll) {
1470             if (!first) {
1471                 buffer.append(", "); // backward compatibility
1472             }
1473             first = false;
1474             if (item == null) {
1475                 appendNullText(buffer, fieldName);
1476             } else {
1477                 appendInternal(buffer, fieldName, item, true);
1478             }
1479         }
1480         buffer.append(']'); // backward compatibility
1481     }
1482 
1483     /**
1484      * Appends to the {@code toString} a {@code double} value.
1485      *
1486      * @param buffer    The {@link StringBuffer} to populate.
1487      * @param fieldName The field name, typically not used as already appended.
1488      * @param value     The value to add to the {@code toString}.
1489      */
1490     protected void appendDetail(final StringBuffer buffer, final String fieldName, final double value) {
1491         buffer.append(value);
1492     }
1493 
1494     /**
1495      * Appends to the {@code toString} the detail of a {@code double} array.
1496      *
1497      * @param buffer    The {@link StringBuffer} to populate.
1498      * @param fieldName The field name, typically not used as already appended
1499      * @param array     The array to add to the {@code toString}, not {@code null}.
1500      */
1501     protected void appendDetail(final StringBuffer buffer, final String fieldName, final double[] array) {
1502         buffer.append(getArrayStart());
1503         for (int i = 0; i < array.length; i++) {
1504             if (i > 0) {
1505                 buffer.append(getArraySeparator());
1506             }
1507             appendDetail(buffer, fieldName, array[i]);
1508         }
1509         buffer.append(getArrayEnd());
1510     }
1511 
1512     /**
1513      * Appends to the {@code toString} a {@code float} value.
1514      *
1515      * @param buffer    The {@link StringBuffer} to populate.
1516      * @param fieldName The field name, typically not used as already appended.
1517      * @param value     The value to add to the {@code toString}.
1518      */
1519     protected void appendDetail(final StringBuffer buffer, final String fieldName, final float value) {
1520         buffer.append(value);
1521     }
1522 
1523     /**
1524      * Appends to the {@code toString} the detail of a {@code float} array.
1525      *
1526      * @param buffer    The {@link StringBuffer} to populate.
1527      * @param fieldName The field name, typically not used as already appended.
1528      * @param array     The array to add to the {@code toString}, not {@code null}.
1529      */
1530     protected void appendDetail(final StringBuffer buffer, final String fieldName, final float[] array) {
1531         buffer.append(getArrayStart());
1532         for (int i = 0; i < array.length; i++) {
1533             if (i > 0) {
1534                 buffer.append(getArraySeparator());
1535             }
1536             appendDetail(buffer, fieldName, array[i]);
1537         }
1538         buffer.append(getArrayEnd());
1539     }
1540 
1541     /**
1542      * Appends to the {@code toString} an {@code int} value.
1543      *
1544      * @param buffer    The {@link StringBuffer} to populate.
1545      * @param fieldName The field name, typically not used as already appended.
1546      * @param value     The value to add to the {@code toString}.
1547      */
1548     protected void appendDetail(final StringBuffer buffer, final String fieldName, final int value) {
1549         buffer.append(value);
1550     }
1551 
1552     /**
1553      * Appends to the {@code toString} the detail of an {@link Object} array item.
1554      *
1555      * @param buffer    The {@link StringBuffer} to populate.
1556      * @param fieldName The field name, typically not used as already appended.
1557      * @param i         The array item index to add.
1558      * @param item      The array item to add.
1559      * @since 3.11
1560      */
1561     protected void appendDetail(final StringBuffer buffer, final String fieldName, final int i, final Object item) {
1562         if (i > 0) {
1563             buffer.append(getArraySeparator());
1564         }
1565         if (item == null) {
1566             appendNullText(buffer, fieldName);
1567         } else {
1568             appendInternal(buffer, fieldName, item, isArrayContentDetail());
1569         }
1570     }
1571 
1572     /**
1573      * Appends to the {@code toString} the detail of an {@code int} array.
1574      *
1575      * @param buffer    The {@link StringBuffer} to populate.
1576      * @param fieldName The field name, typically not used as already appended.
1577      * @param array     The array to add to the {@code toString}, not {@code null}.
1578      */
1579     protected void appendDetail(final StringBuffer buffer, final String fieldName, final int[] array) {
1580         buffer.append(getArrayStart());
1581         for (int i = 0; i < array.length; i++) {
1582             if (i > 0) {
1583                 buffer.append(getArraySeparator());
1584             }
1585             appendDetail(buffer, fieldName, array[i]);
1586         }
1587         buffer.append(getArrayEnd());
1588     }
1589 
1590     /**
1591      * Appends to the {@code toString} a {@code long} value.
1592      *
1593      * @param buffer    The {@link StringBuffer} to populate.
1594      * @param fieldName The field name, typically not used as already appended.
1595      * @param value     The value to add to the {@code toString}.
1596      */
1597     protected void appendDetail(final StringBuffer buffer, final String fieldName, final long value) {
1598         buffer.append(value);
1599     }
1600 
1601     /**
1602      * Appends to the {@code toString} the detail of a {@code long} array.
1603      *
1604      * @param buffer    The {@link StringBuffer} to populate.
1605      * @param fieldName The field name, typically not used as already appended.
1606      * @param array     The array to add to the {@code toString}, not {@code null}.
1607      */
1608     protected void appendDetail(final StringBuffer buffer, final String fieldName, final long[] array) {
1609         buffer.append(getArrayStart());
1610         for (int i = 0; i < array.length; i++) {
1611             if (i > 0) {
1612                 buffer.append(getArraySeparator());
1613             }
1614             appendDetail(buffer, fieldName, array[i]);
1615         }
1616         buffer.append(getArrayEnd());
1617     }
1618 
1619     /**
1620      * Appends to the {@code toString} a {@link Map}.
1621      *
1622      * @param buffer    The {@link StringBuffer} to populate.
1623      * @param fieldName The field name, typically not used as already appended.
1624      * @param map       The {@link Map} to add to the {@code toString}, not {@code null}.
1625      */
1626     protected void appendDetail(final StringBuffer buffer, final String fieldName, final Map<?, ?> map) {
1627         buffer.append('{'); // backward compatibility
1628         boolean first = true;
1629         for (final Map.Entry<?, ?> item : map.entrySet()) {
1630             if (!first) {
1631                 buffer.append(getArraySeparator());
1632                 buffer.append(' '); // backward compatibility
1633             }
1634             first = false;
1635             if (item == null) {
1636                 appendNullText(buffer, fieldName);
1637             } else {
1638                 appendInternal(buffer, fieldName, item.getKey(), true);
1639                 buffer.append(getFieldNameValueSeparator());
1640                 appendInternal(buffer, fieldName, item.getValue(), true);
1641             }
1642         }
1643         buffer.append('}'); // backward compatibility
1644     }
1645 
1646     /**
1647      * Appends to the {@code toString} an {@link Object} value, printing the full detail of the {@link Object}.
1648      *
1649      * @param buffer    The {@link StringBuffer} to populate.
1650      * @param fieldName The field name, typically not used as already appended.
1651      * @param value     The value to add to the {@code toString}, not {@code null}.
1652      */
1653     protected void appendDetail(final StringBuffer buffer, final String fieldName, final Object value) {
1654         buffer.append(value);
1655     }
1656 
1657     /**
1658      * Appends to the {@code toString} the detail of an {@link Object} array.
1659      *
1660      * @param buffer    The {@link StringBuffer} to populate.
1661      * @param fieldName The field name, typically not used as already appended.
1662      * @param array     The array to add to the {@code toString}, not {@code null}.
1663      */
1664     protected void appendDetail(final StringBuffer buffer, final String fieldName, final Object[] array) {
1665         buffer.append(getArrayStart());
1666         for (int i = 0; i < array.length; i++) {
1667             appendDetail(buffer, fieldName, i, array[i]);
1668         }
1669         buffer.append(getArrayEnd());
1670     }
1671 
1672     /**
1673      * Appends to the {@code toString} a {@code short} value.
1674      *
1675      * @param buffer    The {@link StringBuffer} to populate.
1676      * @param fieldName The field name, typically not used as already appended.
1677      * @param value     The value to add to the {@code toString}.
1678      */
1679     protected void appendDetail(final StringBuffer buffer, final String fieldName, final short value) {
1680         buffer.append(value);
1681     }
1682 
1683     /**
1684      * Appends to the {@code toString} the detail of a {@code short} array.
1685      *
1686      * @param buffer    The {@link StringBuffer} to populate.
1687      * @param fieldName The field name, typically not used as already appended.
1688      * @param array     The array to add to the {@code toString}, not {@code null}.
1689      */
1690     protected void appendDetail(final StringBuffer buffer, final String fieldName, final short[] array) {
1691         buffer.append(getArrayStart());
1692         for (int i = 0; i < array.length; i++) {
1693             if (i > 0) {
1694                 buffer.append(getArraySeparator());
1695             }
1696             appendDetail(buffer, fieldName, array[i]);
1697         }
1698         buffer.append(getArrayEnd());
1699     }
1700 
1701     /**
1702      * Appends to the {@code toString} the end of data indicator.
1703      *
1704      * <p>
1705      * Completing an output buffer releases its traversal state unless it is still shared by an active enclosing traversal.
1706      * </p>
1707      *
1708      * @param buffer The {@link StringBuffer} to populate.
1709      * @param object The {@link Object} to build a {@code toString} for.
1710      */
1711     public void appendEnd(final StringBuffer buffer, final Object object) {
1712         try {
1713             if (!isFieldSeparatorAtEnd()) {
1714                 removeLastFieldSeparator(buffer);
1715             }
1716             appendContentEnd(buffer);
1717         } finally {
1718             unregister(object);
1719             final Traversal traversal = findTraversal(buffer);
1720             if (traversal != null) {
1721                 clearTraversal(buffer, traversal);
1722             }
1723         }
1724     }
1725 
1726     /**
1727      * Appends to the {@code toString} the field end.
1728      *
1729      * @param buffer    The {@link StringBuffer} to populate.
1730      * @param fieldName The field name, typically not used as already appended.
1731      */
1732     protected void appendFieldEnd(final StringBuffer buffer, final String fieldName) {
1733         appendFieldSeparator(buffer);
1734     }
1735 
1736     /**
1737      * Appends to the {@code toString} the field separator.
1738      *
1739      * @param buffer The {@link StringBuffer} to populate.
1740      */
1741     protected void appendFieldSeparator(final StringBuffer buffer) {
1742         buffer.append(getFieldSeparator());
1743     }
1744 
1745     /**
1746      * Appends to the {@code toString} the field start.
1747      *
1748      * @param buffer    The {@link StringBuffer} to populate.
1749      * @param fieldName The field name.
1750      */
1751     protected void appendFieldStart(final StringBuffer buffer, final String fieldName) {
1752         if (isUseFieldNames() && fieldName != null) {
1753             buffer.append(fieldName);
1754             buffer.append(getFieldNameValueSeparator());
1755         }
1756     }
1757 
1758     /**
1759      * Appends the {@link System#identityHashCode(java.lang.Object)}.
1760      *
1761      * @param buffer The {@link StringBuffer} to populate.
1762      * @param object The {@link Object} whose id to output.
1763      */
1764     protected void appendIdentityHashCode(final StringBuffer buffer, final Object object) {
1765         if (isUseIdentityHashCode() && object != null) {
1766             register(object);
1767             buffer.append('@');
1768             buffer.append(ObjectUtils.identityHashCodeHex(object));
1769         }
1770     }
1771 
1772     /**
1773      * Appends to the {@code toString} an {@link Object}, correctly interpreting its type.
1774      *
1775      * <p>
1776      * This method performs the main lookup by Class type to correctly route arrays, {@link Collection}s, {@link Map}s and {@link Objects} to the appropriate
1777      * method.
1778      * </p>
1779      *
1780      * <p>
1781      * Either detail or summary views can be specified.
1782      * </p>
1783      *
1784      * <p>
1785      * If a cycle is detected, an object will be appended with the {@code Object.toString()} format.
1786      * </p>
1787      *
1788      * @param buffer    The {@link StringBuffer} to populate.
1789      * @param fieldName The field name, typically not used as already appended.
1790      * @param value     The value to add to the {@code toString}, not {@code null}.
1791      * @param detail    output detail or not.
1792      */
1793     protected void appendInternal(final StringBuffer buffer, final String fieldName, final Object value, final boolean detail) {
1794         if (isRegistered(value) && !(value instanceof Number || value instanceof Boolean || value instanceof Character)) {
1795             appendCyclicObject(buffer, fieldName, value);
1796             return;
1797         }
1798         register(value);
1799         try {
1800             if (value instanceof Collection<?>) {
1801                 if (detail) {
1802                     appendDetail(buffer, fieldName, (Collection<?>) value);
1803                 } else {
1804                     appendSummarySize(buffer, fieldName, ((Collection<?>) value).size());
1805                 }
1806             } else if (value instanceof Map<?, ?>) {
1807                 if (detail) {
1808                     appendDetail(buffer, fieldName, (Map<?, ?>) value);
1809                 } else {
1810                     appendSummarySize(buffer, fieldName, ((Map<?, ?>) value).size());
1811                 }
1812             } else if (value instanceof long[]) {
1813                 if (detail) {
1814                     appendDetail(buffer, fieldName, (long[]) value);
1815                 } else {
1816                     appendSummary(buffer, fieldName, (long[]) value);
1817                 }
1818             } else if (value instanceof int[]) {
1819                 if (detail) {
1820                     appendDetail(buffer, fieldName, (int[]) value);
1821                 } else {
1822                     appendSummary(buffer, fieldName, (int[]) value);
1823                 }
1824             } else if (value instanceof short[]) {
1825                 if (detail) {
1826                     appendDetail(buffer, fieldName, (short[]) value);
1827                 } else {
1828                     appendSummary(buffer, fieldName, (short[]) value);
1829                 }
1830             } else if (value instanceof byte[]) {
1831                 if (detail) {
1832                     appendDetail(buffer, fieldName, (byte[]) value);
1833                 } else {
1834                     appendSummary(buffer, fieldName, (byte[]) value);
1835                 }
1836             } else if (value instanceof char[]) {
1837                 if (detail) {
1838                     appendDetail(buffer, fieldName, (char[]) value);
1839                 } else {
1840                     appendSummary(buffer, fieldName, (char[]) value);
1841                 }
1842             } else if (value instanceof double[]) {
1843                 if (detail) {
1844                     appendDetail(buffer, fieldName, (double[]) value);
1845                 } else {
1846                     appendSummary(buffer, fieldName, (double[]) value);
1847                 }
1848             } else if (value instanceof float[]) {
1849                 if (detail) {
1850                     appendDetail(buffer, fieldName, (float[]) value);
1851                 } else {
1852                     appendSummary(buffer, fieldName, (float[]) value);
1853                 }
1854             } else if (value instanceof boolean[]) {
1855                 if (detail) {
1856                     appendDetail(buffer, fieldName, (boolean[]) value);
1857                 } else {
1858                     appendSummary(buffer, fieldName, (boolean[]) value);
1859                 }
1860             } else if (ObjectUtils.isArray(value)) {
1861                 if (detail) {
1862                     appendDetail(buffer, fieldName, (Object[]) value);
1863                 } else {
1864                     appendSummary(buffer, fieldName, (Object[]) value);
1865                 }
1866             } else if (detail) {
1867                 appendDetail(buffer, fieldName, value);
1868             } else {
1869                 appendSummary(buffer, fieldName, value);
1870             }
1871         } finally {
1872             unregister(value);
1873         }
1874     }
1875 
1876     /**
1877      * Appends to the {@code toString} an indicator for {@code null}.
1878      *
1879      * <p>
1880      * The default indicator is {@code "<null>"}.
1881      * </p>
1882      *
1883      * @param buffer    The {@link StringBuffer} to populate.
1884      * @param fieldName The field name, typically not used as already appended.
1885      */
1886     protected void appendNullText(final StringBuffer buffer, final String fieldName) {
1887         buffer.append(getNullText());
1888     }
1889 
1890     /**
1891      * Appends to the {@code toString} the start of data indicator.
1892      *
1893      * <p>
1894      * Direct calls open traversal state for this buffer. Complete the output with {@link #appendEnd(StringBuffer, Object)} or the owning builder's
1895      * {@link ToStringBuilder#toString()} to release its traversal state.
1896      * </p>
1897      *
1898      * @param buffer The {@link StringBuffer} to populate.
1899      * @param object The {@link Object} to build a {@code toString} for.
1900      */
1901     public void appendStart(final StringBuffer buffer, final Object object) {
1902         if (TRAVERSAL_ACTIVE.get() == null) {
1903             Map<StringBuffer, Traversal> direct = DIRECT_TRAVERSALS.get();
1904             if (direct == null) {
1905                 direct = new WeakHashMap<>();
1906                 DIRECT_TRAVERSALS.set(direct);
1907             }
1908             direct.put(buffer, getTraversal(buffer));
1909         }
1910         if (object != null) {
1911             appendClassName(buffer, object);
1912             appendIdentityHashCode(buffer, object);
1913             appendContentStart(buffer);
1914             if (isFieldSeparatorAtStart()) {
1915                 appendFieldSeparator(buffer);
1916             }
1917         }
1918     }
1919 
1920     /**
1921      * Appends to the {@code toString} a summary of a {@code boolean} array.
1922      *
1923      * @param buffer    The {@link StringBuffer} to populate.
1924      * @param fieldName The field name, typically not used as already appended.
1925      * @param array     The array to add to the {@code toString}, not {@code null}.
1926      */
1927     protected void appendSummary(final StringBuffer buffer, final String fieldName, final boolean[] array) {
1928         appendSummarySize(buffer, fieldName, array.length);
1929     }
1930 
1931     /**
1932      * Appends to the {@code toString} a summary of a {@code byte} array.
1933      *
1934      * @param buffer    The {@link StringBuffer} to populate.
1935      * @param fieldName The field name, typically not used as already appended.
1936      * @param array     The array to add to the {@code toString}, not {@code null}.
1937      */
1938     protected void appendSummary(final StringBuffer buffer, final String fieldName, final byte[] array) {
1939         appendSummarySize(buffer, fieldName, array.length);
1940     }
1941 
1942     /**
1943      * Appends to the {@code toString} a summary of a {@code char} array.
1944      *
1945      * @param buffer    The {@link StringBuffer} to populate.
1946      * @param fieldName The field name, typically not used as already appended.
1947      * @param array     The array to add to the {@code toString}, not {@code null}.
1948      */
1949     protected void appendSummary(final StringBuffer buffer, final String fieldName, final char[] array) {
1950         appendSummarySize(buffer, fieldName, array.length);
1951     }
1952 
1953     /**
1954      * Appends to the {@code toString} a summary of a {@code double} array.
1955      *
1956      * @param buffer    The {@link StringBuffer} to populate
1957      * @param fieldName The field name, typically not used as already appended
1958      * @param array     The array to add to the {@code toString}, not {@code null}
1959      */
1960     protected void appendSummary(final StringBuffer buffer, final String fieldName, final double[] array) {
1961         appendSummarySize(buffer, fieldName, array.length);
1962     }
1963 
1964     /**
1965      * Appends to the {@code toString} a summary of a {@code float} array.
1966      *
1967      * @param buffer    The {@link StringBuffer} to populate.
1968      * @param fieldName The field name, typically not used as already appended.
1969      * @param array     The array to add to the {@code toString}, not {@code null}.
1970      */
1971     protected void appendSummary(final StringBuffer buffer, final String fieldName, final float[] array) {
1972         appendSummarySize(buffer, fieldName, array.length);
1973     }
1974 
1975     /**
1976      * Appends to the {@code toString} a summary of an {@code int} array.
1977      *
1978      * @param buffer    The {@link StringBuffer} to populate.
1979      * @param fieldName The field name, typically not used as already appended.
1980      * @param array     The array to add to the {@code toString}, not {@code null}.
1981      */
1982     protected void appendSummary(final StringBuffer buffer, final String fieldName, final int[] array) {
1983         appendSummarySize(buffer, fieldName, array.length);
1984     }
1985 
1986     /**
1987      * Appends to the {@code toString} a summary of a {@code long} array.
1988      *
1989      * @param buffer    The {@link StringBuffer} to populate.
1990      * @param fieldName The field name, typically not used as already appended.
1991      * @param array     The array to add to the {@code toString}, not {@code null}.
1992      */
1993     protected void appendSummary(final StringBuffer buffer, final String fieldName, final long[] array) {
1994         appendSummarySize(buffer, fieldName, array.length);
1995     }
1996 
1997     /**
1998      * Appends to the {@code toString} an {@link Object} value, printing a summary of the {@link Object}.
1999      *
2000      * @param buffer    The {@link StringBuffer} to populate.
2001      * @param fieldName The field name, typically not used as already appended.
2002      * @param value     The value to add to the {@code toString}, not {@code null}.
2003      */
2004     protected void appendSummary(final StringBuffer buffer, final String fieldName, final Object value) {
2005         buffer.append(getSummaryObjectStartText());
2006         buffer.append(getShortClassName(value.getClass()));
2007         buffer.append(getSummaryObjectEndText());
2008     }
2009 
2010     /**
2011      * Appends to the {@code toString} a summary of an {@link Object} array.
2012      *
2013      * @param buffer    The {@link StringBuffer} to populate.
2014      * @param fieldName The field name, typically not used as already appended.
2015      * @param array     The array to add to the {@code toString}, not {@code null}.
2016      */
2017     protected void appendSummary(final StringBuffer buffer, final String fieldName, final Object[] array) {
2018         appendSummarySize(buffer, fieldName, array.length);
2019     }
2020 
2021     /**
2022      * Appends to the {@code toString} a summary of a {@code short} array.
2023      *
2024      * @param buffer    The {@link StringBuffer} to populate.
2025      * @param fieldName The field name, typically not used as already appended.
2026      * @param array     The array to add to the {@code toString}, not {@code null}.
2027      */
2028     protected void appendSummary(final StringBuffer buffer, final String fieldName, final short[] array) {
2029         appendSummarySize(buffer, fieldName, array.length);
2030     }
2031 
2032     /**
2033      * Appends to the {@code toString} a size summary.
2034      *
2035      * <p>
2036      * The size summary is used to summarize the contents of {@link Collection}s, {@link Map}s and arrays.
2037      * </p>
2038      *
2039      * <p>
2040      * The output consists of a prefix, the passed in size and a suffix.
2041      * </p>
2042      *
2043      * <p>
2044      * The default format is {@code "<size=n>"}.
2045      * </p>
2046      *
2047      * @param buffer    The {@link StringBuffer} to populate.
2048      * @param fieldName The field name, typically not used as already appended.
2049      * @param size      The size to append.
2050      */
2051     protected void appendSummarySize(final StringBuffer buffer, final String fieldName, final int size) {
2052         buffer.append(getSizeStartText());
2053         buffer.append(size);
2054         buffer.append(getSizeEndText());
2055     }
2056 
2057     /**
2058      * Appends to the {@code toString} the superclass toString.
2059      * <p>
2060      * NOTE: It assumes that the toString has been created from the same ToStringStyle.
2061      * </p>
2062      *
2063      * <p>
2064      * A {@code null} {@code superToString} is ignored.
2065      * </p>
2066      *
2067      * @param buffer        The {@link StringBuffer} to populate.
2068      * @param superToString The {@code super.toString()}.
2069      * @since 2.0
2070      */
2071     public void appendSuper(final StringBuffer buffer, final String superToString) {
2072         appendToString(buffer, superToString);
2073     }
2074 
2075     /**
2076      * Appends to the {@code toString} another toString.
2077      * <p>
2078      * NOTE: It assumes that the toString has been created from the same ToStringStyle.
2079      * </p>
2080      *
2081      * <p>
2082      * A {@code null} {@code toString} is ignored.
2083      * </p>
2084      *
2085      * @param buffer   The {@link StringBuffer} to populate.
2086      * @param toString The additional {@code toString}.
2087      * @since 2.0
2088      */
2089     public void appendToString(final StringBuffer buffer, final String toString) {
2090         if (toString != null) {
2091             final int pos1 = toString.indexOf(getContentStart()) + getContentStart().length();
2092             final int pos2 = toString.lastIndexOf(getContentEnd());
2093             if (pos1 != pos2 && pos1 >= 0 && pos2 >= 0) {
2094                 if (isFieldSeparatorAtStart()) {
2095                     removeLastFieldSeparator(buffer);
2096                 }
2097                 buffer.append(toString, pos1, pos2);
2098                 appendFieldSeparator(buffer);
2099             }
2100         }
2101     }
2102 
2103     /**
2104      * Gets the array end text.
2105      *
2106      * @return The current array end text.
2107      */
2108     protected String getArrayEnd() {
2109         return arrayEnd;
2110     }
2111 
2112     /**
2113      * Gets the array separator text.
2114      *
2115      * @return The current array separator text.
2116      */
2117     protected String getArraySeparator() {
2118         return arraySeparator;
2119     }
2120 
2121     /**
2122      * Gets the array start text.
2123      *
2124      * @return The current array start text.
2125      */
2126     protected String getArrayStart() {
2127         return arrayStart;
2128     }
2129 
2130     /**
2131      * Gets the content end text.
2132      *
2133      * @return The current content end text.
2134      */
2135     protected String getContentEnd() {
2136         return contentEnd;
2137     }
2138 
2139     /**
2140      * Gets the content start text.
2141      *
2142      * @return The current content start text.
2143      */
2144     protected String getContentStart() {
2145         return contentStart;
2146     }
2147 
2148     /**
2149      * Gets the field name value separator text.
2150      *
2151      * @return The current field name value separator text.
2152      */
2153     protected String getFieldNameValueSeparator() {
2154         return fieldNameValueSeparator;
2155     }
2156 
2157     /**
2158      * Gets the field separator text.
2159      *
2160      * @return The current field separator text.
2161      */
2162     protected String getFieldSeparator() {
2163         return fieldSeparator;
2164     }
2165 
2166     /**
2167      * Gets the text to output when {@code null} found.
2168      *
2169      * @return The current text to output when null found.
2170      */
2171     protected String getNullText() {
2172         return nullText;
2173     }
2174 
2175     /**
2176      * Gets the short class name for a class.
2177      *
2178      * <p>
2179      * The short class name is the class name excluding the package name.
2180      * </p>
2181      *
2182      * @param cls The {@link Class} to get the short name of.
2183      * @return The short name.
2184      */
2185     protected String getShortClassName(final Class<?> cls) {
2186         return ClassUtils.getShortClassName(cls);
2187     }
2188 
2189     /**
2190      * Gets the end text to output when a {@link Collection}, {@link Map} or array size is output.
2191      *
2192      * <p>
2193      * This is output after the size value.
2194      * </p>
2195      *
2196      * @return The current end of size text.
2197      */
2198     protected String getSizeEndText() {
2199         return sizeEndText;
2200     }
2201 
2202     /**
2203      * Gets the start text to output when a {@link Collection}, {@link Map} or array size is output.
2204      *
2205      * <p>
2206      * This is output before the size value.
2207      * </p>
2208      *
2209      * @return The current start of size text.
2210      */
2211     protected String getSizeStartText() {
2212         return sizeStartText;
2213     }
2214 
2215     /**
2216      * Gets the end text to output when an {@link Object} is output in summary mode.
2217      *
2218      * <p>
2219      * This is output after the size value.
2220      * </p>
2221      *
2222      * @return The current end of summary text.
2223      */
2224     protected String getSummaryObjectEndText() {
2225         return summaryObjectEndText;
2226     }
2227 
2228     /**
2229      * Gets the start text to output when an {@link Object} is output in summary mode.
2230      *
2231      * <p>
2232      * This is output before the size value.
2233      * </p>
2234      *
2235      * @return The current start of summary text.
2236      */
2237     protected String getSummaryObjectStartText() {
2238         return summaryObjectStartText;
2239     }
2240 
2241     /**
2242      * Tests whether to output array content detail.
2243      *
2244      * @return The current array content detail setting.
2245      */
2246     protected boolean isArrayContentDetail() {
2247         return arrayContentDetail;
2248     }
2249 
2250     /**
2251      * Tests whether full detail is used when the caller does not specify a detail level.
2252      *
2253      * @return The current defaultFullDetail flag.
2254      */
2255     protected boolean isDefaultFullDetail() {
2256         return defaultFullDetail;
2257     }
2258 
2259     /**
2260      * Tests whether the field separator should be added at the end of each buffer.
2261      *
2262      * @return fieldSeparatorAtEnd flag.
2263      * @since 2.0
2264      */
2265     protected boolean isFieldSeparatorAtEnd() {
2266         return fieldSeparatorAtEnd;
2267     }
2268 
2269     /**
2270      * Tests whether the field separator should be added at the start of each buffer.
2271      *
2272      * @return The fieldSeparatorAtStart flag.
2273      * @since 2.0
2274      */
2275     protected boolean isFieldSeparatorAtStart() {
2276         return fieldSeparatorAtStart;
2277     }
2278 
2279     /**
2280      * Tests whether this field should be output in full detail.
2281      *
2282      * <p>
2283      * This method converts a detail request into a detail level. The calling code may request full detail ({@code true}), but a subclass might ignore that and
2284      * always return {@code false}. The calling code may pass in {@code null} indicating that it doesn't care about the detail level. In this case the default
2285      * detail level is used.
2286      * </p>
2287      *
2288      * @param fullDetailRequest The detail level requested.
2289      * @return whether full detail is to be shown.
2290      */
2291     protected boolean isFullDetail(final Boolean fullDetailRequest) {
2292         if (fullDetailRequest == null) {
2293             return isDefaultFullDetail();
2294         }
2295         return fullDetailRequest.booleanValue();
2296     }
2297 
2298     // Setters and getters for the customizable parts of the style
2299     // These methods are not expected to be overridden, except to make public
2300     // (They are not public so that immutable subclasses can be written)
2301     /**
2302      * Tests whether to use the class name.
2303      *
2304      * @return The current useClassName flag.
2305      */
2306     protected boolean isUseClassName() {
2307         return useClassName;
2308     }
2309 
2310     /**
2311      * Tests whether to use the field names passed in.
2312      *
2313      * @return The current useFieldNames flag.
2314      */
2315     protected boolean isUseFieldNames() {
2316         return useFieldNames;
2317     }
2318 
2319     /**
2320      * Tests whether to use the identity hash code.
2321      *
2322      * @return The current useIdentityHashCode flag.
2323      */
2324     protected boolean isUseIdentityHashCode() {
2325         return useIdentityHashCode;
2326     }
2327 
2328     /**
2329      * Tests whether short class names should be output.
2330      *
2331      * @return The current useShortClassName flag.
2332      * @since 2.0
2333      */
2334     protected boolean isUseShortClassName() {
2335         return useShortClassName;
2336     }
2337 
2338     /**
2339      * Appends to the {@code toString} the detail of an array type.
2340      *
2341      * @param buffer    The {@link StringBuffer} to populate.
2342      * @param fieldName The field name, typically not used as already appended.
2343      * @param array     The array to add to the {@code toString}, not {@code null}.
2344      * @since 2.0
2345      */
2346     protected void reflectionAppendArrayDetail(final StringBuffer buffer, final String fieldName, final Object array) {
2347         buffer.append(getArrayStart());
2348         final int length = Array.getLength(array);
2349         for (int i = 0; i < length; i++) {
2350             appendDetail(buffer, fieldName, i, Array.get(array, i));
2351         }
2352         buffer.append(getArrayEnd());
2353     }
2354 
2355     /**
2356      * Remove the last field separator from the buffer.
2357      *
2358      * @param buffer The {@link StringBuffer} to populate.
2359      * @since 2.0
2360      */
2361     protected void removeLastFieldSeparator(final StringBuffer buffer) {
2362         if (Strings.CS.endsWith(buffer, getFieldSeparator())) {
2363             buffer.setLength(buffer.length() - getFieldSeparator().length());
2364         }
2365     }
2366 
2367     /**
2368      * Sets whether to output array content detail.
2369      *
2370      * @param arrayContentDetail The new arrayContentDetail flag.
2371      */
2372     protected void setArrayContentDetail(final boolean arrayContentDetail) {
2373         this.arrayContentDetail = arrayContentDetail;
2374     }
2375 
2376     /**
2377      * Sets the array end text.
2378      *
2379      * <p>
2380      * {@code null} is accepted, but will be converted to an empty String.
2381      * </p>
2382      *
2383      * @param arrayEnd The new array end text.
2384      */
2385     protected void setArrayEnd(final String arrayEnd) {
2386         this.arrayEnd = ObjectUtils.toString(arrayEnd);
2387     }
2388 
2389     /**
2390      * Sets the array separator text.
2391      *
2392      * <p>
2393      * {@code null} is accepted, but will be converted to an empty String.
2394      * </p>
2395      *
2396      * @param arraySeparator The new array separator text.
2397      */
2398     protected void setArraySeparator(final String arraySeparator) {
2399         this.arraySeparator = ObjectUtils.toString(arraySeparator);
2400     }
2401 
2402     /**
2403      * Sets the array start text.
2404      *
2405      * <p>
2406      * {@code null} is accepted, but will be converted to an empty String.
2407      * </p>
2408      *
2409      * @param arrayStart The new array start text.
2410      */
2411     protected void setArrayStart(final String arrayStart) {
2412         this.arrayStart = ObjectUtils.toString(arrayStart);
2413     }
2414 
2415     /**
2416      * Sets the content end text.
2417      *
2418      * <p>
2419      * {@code null} is accepted, but will be converted to an empty String.
2420      * </p>
2421      *
2422      * @param contentEnd The new content end text.
2423      */
2424     protected void setContentEnd(final String contentEnd) {
2425         this.contentEnd = ObjectUtils.toString(contentEnd);
2426     }
2427 
2428     /**
2429      * Sets the content start text.
2430      *
2431      * <p>
2432      * {@code null} is accepted, but will be converted to an empty String.
2433      * </p>
2434      *
2435      * @param contentStart The new content start text.
2436      */
2437     protected void setContentStart(final String contentStart) {
2438         this.contentStart = ObjectUtils.toString(contentStart);
2439     }
2440 
2441     /**
2442      * Sets whether to use full detail when the caller doesn't specify.
2443      *
2444      * @param defaultFullDetail The new defaultFullDetail flag.
2445      */
2446     protected void setDefaultFullDetail(final boolean defaultFullDetail) {
2447         this.defaultFullDetail = defaultFullDetail;
2448     }
2449 
2450     /**
2451      * Sets the field name value separator text.
2452      *
2453      * <p>
2454      * {@code null} is accepted, but will be converted to an empty String.
2455      * </p>
2456      *
2457      * @param fieldNameValueSeparator The new field name value separator text.
2458      */
2459     protected void setFieldNameValueSeparator(final String fieldNameValueSeparator) {
2460         this.fieldNameValueSeparator = ObjectUtils.toString(fieldNameValueSeparator);
2461     }
2462 
2463     /**
2464      * Sets the field separator text.
2465      *
2466      * <p>
2467      * {@code null} is accepted, but will be converted to an empty String.
2468      * </p>
2469      *
2470      * @param fieldSeparator The new field separator text.
2471      */
2472     protected void setFieldSeparator(final String fieldSeparator) {
2473         this.fieldSeparator = ObjectUtils.toString(fieldSeparator);
2474     }
2475 
2476     /**
2477      * Sets whether the field separator should be added at the end of each buffer.
2478      *
2479      * @param fieldSeparatorAtEnd The fieldSeparatorAtEnd flag.
2480      * @since 2.0
2481      */
2482     protected void setFieldSeparatorAtEnd(final boolean fieldSeparatorAtEnd) {
2483         this.fieldSeparatorAtEnd = fieldSeparatorAtEnd;
2484     }
2485 
2486     /**
2487      * Sets whether the field separator should be added at the start of each buffer.
2488      *
2489      * @param fieldSeparatorAtStart The fieldSeparatorAtStart flag.
2490      * @since 2.0
2491      */
2492     protected void setFieldSeparatorAtStart(final boolean fieldSeparatorAtStart) {
2493         this.fieldSeparatorAtStart = fieldSeparatorAtStart;
2494     }
2495 
2496     /**
2497      * Sets the text to output when {@code null} found.
2498      *
2499      * <p>
2500      * {@code null} is accepted, but will be converted to an empty String.
2501      * </p>
2502      *
2503      * @param nullText The new text to output when null found.
2504      */
2505     protected void setNullText(final String nullText) {
2506         this.nullText = ObjectUtils.toString(nullText);
2507     }
2508 
2509     /**
2510      * Sets the end text to output when a {@link Collection}, {@link Map} or array size is output.
2511      *
2512      * <p>
2513      * This is output after the size value.
2514      * </p>
2515      *
2516      * <p>
2517      * {@code null} is accepted, but will be converted to an empty String.
2518      * </p>
2519      *
2520      * @param sizeEndText The new end of size text.
2521      */
2522     protected void setSizeEndText(final String sizeEndText) {
2523         this.sizeEndText = ObjectUtils.toString(sizeEndText);
2524     }
2525 
2526     /**
2527      * Sets the start text to output when a {@link Collection}, {@link Map} or array size is output.
2528      *
2529      * <p>
2530      * This is output before the size value.
2531      * </p>
2532      *
2533      * <p>
2534      * {@code null} is accepted, but will be converted to an empty String.
2535      * </p>
2536      *
2537      * @param sizeStartText The new start of size text.
2538      */
2539     protected void setSizeStartText(final String sizeStartText) {
2540         this.sizeStartText = ObjectUtils.toString(sizeStartText);
2541     }
2542 
2543     /**
2544      * Sets the end text to output when an {@link Object} is output in summary mode.
2545      *
2546      * <p>
2547      * This is output after the size value.
2548      * </p>
2549      *
2550      * <p>
2551      * {@code null} is accepted, but will be converted to an empty String.
2552      * </p>
2553      *
2554      * @param summaryObjectEndText The new end of summary text.
2555      */
2556     protected void setSummaryObjectEndText(final String summaryObjectEndText) {
2557         this.summaryObjectEndText = ObjectUtils.toString(summaryObjectEndText);
2558     }
2559 
2560     /**
2561      * Sets the start text to output when an {@link Object} is output in summary mode.
2562      *
2563      * <p>
2564      * This is output before the size value.
2565      * </p>
2566      *
2567      * <p>
2568      * {@code null} is accepted, but will be converted to an empty String.
2569      * </p>
2570      *
2571      * @param summaryObjectStartText The new start of summary text.
2572      */
2573     protected void setSummaryObjectStartText(final String summaryObjectStartText) {
2574         this.summaryObjectStartText = ObjectUtils.toString(summaryObjectStartText);
2575     }
2576 
2577     /**
2578      * Sets whether to use the class name.
2579      *
2580      * @param useClassName The new useClassName flag.
2581      */
2582     protected void setUseClassName(final boolean useClassName) {
2583         this.useClassName = useClassName;
2584     }
2585 
2586     /**
2587      * Sets whether to use the field names passed in.
2588      *
2589      * @param useFieldNames The new useFieldNames flag.
2590      */
2591     protected void setUseFieldNames(final boolean useFieldNames) {
2592         this.useFieldNames = useFieldNames;
2593     }
2594 
2595     /**
2596      * Sets whether to use the identity hash code.
2597      *
2598      * @param useIdentityHashCode The new useIdentityHashCode flag.
2599      */
2600     protected void setUseIdentityHashCode(final boolean useIdentityHashCode) {
2601         this.useIdentityHashCode = useIdentityHashCode;
2602     }
2603 
2604 
2605     /**
2606      * Sets whether to output short or long class names.
2607      *
2608      * @param useShortClassName The new useShortClassName flag.
2609      * @since 2.0
2610      */
2611     protected void setUseShortClassName(final boolean useShortClassName) {
2612         this.useShortClassName = useShortClassName;
2613     }
2614 }