001/* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017package org.apache.commons.lang3.builder; 018 019import org.apache.commons.lang3.ObjectUtils; 020 021/** 022 * <p>Assists in implementing {@link Object#toString()} methods.</p> 023 * 024 * <p>This class enables a good and consistent <code>toString()</code> to be built for any 025 * class or object. This class aims to simplify the process by:</p> 026 * <ul> 027 * <li>allowing field names</li> 028 * <li>handling all types consistently</li> 029 * <li>handling nulls consistently</li> 030 * <li>outputting arrays and multi-dimensional arrays</li> 031 * <li>enabling the detail level to be controlled for Objects and Collections</li> 032 * <li>handling class hierarchies</li> 033 * </ul> 034 * 035 * <p>To use this class write code as follows:</p> 036 * 037 * <pre> 038 * public class Person { 039 * String name; 040 * int age; 041 * boolean smoker; 042 * 043 * ... 044 * 045 * public String toString() { 046 * return new ToStringBuilder(this). 047 * append("name", name). 048 * append("age", age). 049 * append("smoker", smoker). 050 * toString(); 051 * } 052 * } 053 * </pre> 054 * 055 * <p>This will produce a toString of the format: 056 * <code>Person@7f54[name=Stephen,age=29,smoker=false]</code></p> 057 * 058 * <p>To add the superclass <code>toString</code>, use {@link #appendSuper}. 059 * To append the <code>toString</code> from an object that is delegated 060 * to (or any other object), use {@link #appendToString}.</p> 061 * 062 * <p>Alternatively, there is a method that uses reflection to determine 063 * the fields to test. Because these fields are usually private, the method, 064 * <code>reflectionToString</code>, uses <code>AccessibleObject.setAccessible</code> to 065 * change the visibility of the fields. This will fail under a security manager, 066 * unless the appropriate permissions are set up correctly. It is also 067 * slower than testing explicitly.</p> 068 * 069 * <p>A typical invocation for this method would look like:</p> 070 * 071 * <pre> 072 * public String toString() { 073 * return ToStringBuilder.reflectionToString(this); 074 * } 075 * </pre> 076 * 077 * <p>You can also use the builder to debug 3rd party objects:</p> 078 * 079 * <pre> 080 * System.out.println("An object: " + ToStringBuilder.reflectionToString(anObject)); 081 * </pre> 082 * 083 * <p>The exact format of the <code>toString</code> is determined by 084 * the {@link ToStringStyle} passed into the constructor.</p> 085 * 086 * @since 1.0 087 * @version $Id: ToStringBuilder.java 1533551 2013-10-18 16:49:15Z sebb $ 088 */ 089public class ToStringBuilder implements Builder<String> { 090 091 /** 092 * The default style of output to use, not null. 093 */ 094 private static volatile ToStringStyle defaultStyle = ToStringStyle.DEFAULT_STYLE; 095 096 //---------------------------------------------------------------------------- 097 098 /** 099 * <p>Gets the default <code>ToStringStyle</code> to use.</p> 100 * 101 * <p>This method gets a singleton default value, typically for the whole JVM. 102 * Changing this default should generally only be done during application startup. 103 * It is recommended to pass a <code>ToStringStyle</code> to the constructor instead 104 * of using this global default.</p> 105 * 106 * <p>This method can be used from multiple threads. 107 * Internally, a <code>volatile</code> variable is used to provide the guarantee 108 * that the latest value set using {@link #setDefaultStyle} is the value returned. 109 * It is strongly recommended that the default style is only changed during application startup.</p> 110 * 111 * <p>One reason for changing the default could be to have a verbose style during 112 * development and a compact style in production.</p> 113 * 114 * @return the default <code>ToStringStyle</code>, never null 115 */ 116 public static ToStringStyle getDefaultStyle() { 117 return defaultStyle; 118 } 119 120 /** 121 * <p>Sets the default <code>ToStringStyle</code> to use.</p> 122 * 123 * <p>This method sets a singleton default value, typically for the whole JVM. 124 * Changing this default should generally only be done during application startup. 125 * It is recommended to pass a <code>ToStringStyle</code> to the constructor instead 126 * of changing this global default.</p> 127 * 128 * <p>This method is not intended for use from multiple threads. 129 * Internally, a <code>volatile</code> variable is used to provide the guarantee 130 * that the latest value set is the value returned from {@link #getDefaultStyle}.</p> 131 * 132 * @param style the default <code>ToStringStyle</code> 133 * @throws IllegalArgumentException if the style is <code>null</code> 134 */ 135 public static void setDefaultStyle(final ToStringStyle style) { 136 if (style == null) { 137 throw new IllegalArgumentException("The style must not be null"); 138 } 139 defaultStyle = style; 140 } 141 142 //---------------------------------------------------------------------------- 143 /** 144 * <p>Uses <code>ReflectionToStringBuilder</code> to generate a 145 * <code>toString</code> for the specified object.</p> 146 * 147 * @param object the Object to be output 148 * @return the String result 149 * @see ReflectionToStringBuilder#toString(Object) 150 */ 151 public static String reflectionToString(final Object object) { 152 return ReflectionToStringBuilder.toString(object); 153 } 154 155 /** 156 * <p>Uses <code>ReflectionToStringBuilder</code> to generate a 157 * <code>toString</code> for the specified object.</p> 158 * 159 * @param object the Object to be output 160 * @param style the style of the <code>toString</code> to create, may be <code>null</code> 161 * @return the String result 162 * @see ReflectionToStringBuilder#toString(Object,ToStringStyle) 163 */ 164 public static String reflectionToString(final Object object, final ToStringStyle style) { 165 return ReflectionToStringBuilder.toString(object, style); 166 } 167 168 /** 169 * <p>Uses <code>ReflectionToStringBuilder</code> to generate a 170 * <code>toString</code> for the specified object.</p> 171 * 172 * @param object the Object to be output 173 * @param style the style of the <code>toString</code> to create, may be <code>null</code> 174 * @param outputTransients whether to include transient fields 175 * @return the String result 176 * @see ReflectionToStringBuilder#toString(Object,ToStringStyle,boolean) 177 */ 178 public static String reflectionToString(final Object object, final ToStringStyle style, final boolean outputTransients) { 179 return ReflectionToStringBuilder.toString(object, style, outputTransients, false, null); 180 } 181 182 /** 183 * <p>Uses <code>ReflectionToStringBuilder</code> to generate a 184 * <code>toString</code> for the specified object.</p> 185 * 186 * @param <T> the type of the object 187 * @param object the Object to be output 188 * @param style the style of the <code>toString</code> to create, may be <code>null</code> 189 * @param outputTransients whether to include transient fields 190 * @param reflectUpToClass the superclass to reflect up to (inclusive), may be <code>null</code> 191 * @return the String result 192 * @see ReflectionToStringBuilder#toString(Object,ToStringStyle,boolean,boolean,Class) 193 * @since 2.0 194 */ 195 public static <T> String reflectionToString( 196 final T object, 197 final ToStringStyle style, 198 final boolean outputTransients, 199 final Class<? super T> reflectUpToClass) { 200 return ReflectionToStringBuilder.toString(object, style, outputTransients, false, reflectUpToClass); 201 } 202 203 //---------------------------------------------------------------------------- 204 205 /** 206 * Current toString buffer, not null. 207 */ 208 private final StringBuffer buffer; 209 /** 210 * The object being output, may be null. 211 */ 212 private final Object object; 213 /** 214 * The style of output to use, not null. 215 */ 216 private final ToStringStyle style; 217 218 /** 219 * <p>Constructs a builder for the specified object using the default output style.</p> 220 * 221 * <p>This default style is obtained from {@link #getDefaultStyle()}.</p> 222 * 223 * @param object the Object to build a <code>toString</code> for, not recommended to be null 224 */ 225 public ToStringBuilder(final Object object) { 226 this(object, null, null); 227 } 228 229 /** 230 * <p>Constructs a builder for the specified object using the a defined output style.</p> 231 * 232 * <p>If the style is <code>null</code>, the default style is used.</p> 233 * 234 * @param object the Object to build a <code>toString</code> for, not recommended to be null 235 * @param style the style of the <code>toString</code> to create, null uses the default style 236 */ 237 public ToStringBuilder(final Object object, final ToStringStyle style) { 238 this(object, style, null); 239 } 240 241 /** 242 * <p>Constructs a builder for the specified object.</p> 243 * 244 * <p>If the style is <code>null</code>, the default style is used.</p> 245 * 246 * <p>If the buffer is <code>null</code>, a new one is created.</p> 247 * 248 * @param object the Object to build a <code>toString</code> for, not recommended to be null 249 * @param style the style of the <code>toString</code> to create, null uses the default style 250 * @param buffer the <code>StringBuffer</code> to populate, may be null 251 */ 252 public ToStringBuilder(final Object object, ToStringStyle style, StringBuffer buffer) { 253 if (style == null) { 254 style = getDefaultStyle(); 255 } 256 if (buffer == null) { 257 buffer = new StringBuffer(512); 258 } 259 this.buffer = buffer; 260 this.style = style; 261 this.object = object; 262 263 style.appendStart(buffer, object); 264 } 265 266 //---------------------------------------------------------------------------- 267 268 /** 269 * <p>Append to the <code>toString</code> a <code>boolean</code> 270 * value.</p> 271 * 272 * @param value the value to add to the <code>toString</code> 273 * @return this 274 */ 275 public ToStringBuilder append(final boolean value) { 276 style.append(buffer, null, value); 277 return this; 278 } 279 280 //---------------------------------------------------------------------------- 281 282 /** 283 * <p>Append to the <code>toString</code> a <code>boolean</code> 284 * array.</p> 285 * 286 * @param array the array to add to the <code>toString</code> 287 * @return this 288 */ 289 public ToStringBuilder append(final boolean[] array) { 290 style.append(buffer, null, array, null); 291 return this; 292 } 293 294 //---------------------------------------------------------------------------- 295 296 /** 297 * <p>Append to the <code>toString</code> a <code>byte</code> 298 * value.</p> 299 * 300 * @param value the value to add to the <code>toString</code> 301 * @return this 302 */ 303 public ToStringBuilder append(final byte value) { 304 style.append(buffer, null, value); 305 return this; 306 } 307 308 //---------------------------------------------------------------------------- 309 310 /** 311 * <p>Append to the <code>toString</code> a <code>byte</code> 312 * array.</p> 313 * 314 * @param array the array to add to the <code>toString</code> 315 * @return this 316 */ 317 public ToStringBuilder append(final byte[] array) { 318 style.append(buffer, null, array, null); 319 return this; 320 } 321 322 //---------------------------------------------------------------------------- 323 324 /** 325 * <p>Append to the <code>toString</code> a <code>char</code> 326 * value.</p> 327 * 328 * @param value the value to add to the <code>toString</code> 329 * @return this 330 */ 331 public ToStringBuilder append(final char value) { 332 style.append(buffer, null, value); 333 return this; 334 } 335 336 //---------------------------------------------------------------------------- 337 338 /** 339 * <p>Append to the <code>toString</code> a <code>char</code> 340 * array.</p> 341 * 342 * @param array the array to add to the <code>toString</code> 343 * @return this 344 */ 345 public ToStringBuilder append(final char[] array) { 346 style.append(buffer, null, array, null); 347 return this; 348 } 349 350 //---------------------------------------------------------------------------- 351 352 /** 353 * <p>Append to the <code>toString</code> a <code>double</code> 354 * value.</p> 355 * 356 * @param value the value to add to the <code>toString</code> 357 * @return this 358 */ 359 public ToStringBuilder append(final double value) { 360 style.append(buffer, null, value); 361 return this; 362 } 363 364 //---------------------------------------------------------------------------- 365 366 /** 367 * <p>Append to the <code>toString</code> a <code>double</code> 368 * array.</p> 369 * 370 * @param array the array to add to the <code>toString</code> 371 * @return this 372 */ 373 public ToStringBuilder append(final double[] array) { 374 style.append(buffer, null, array, null); 375 return this; 376 } 377 378 //---------------------------------------------------------------------------- 379 380 /** 381 * <p>Append to the <code>toString</code> a <code>float</code> 382 * value.</p> 383 * 384 * @param value the value to add to the <code>toString</code> 385 * @return this 386 */ 387 public ToStringBuilder append(final float value) { 388 style.append(buffer, null, value); 389 return this; 390 } 391 392 //---------------------------------------------------------------------------- 393 394 /** 395 * <p>Append to the <code>toString</code> a <code>float</code> 396 * array.</p> 397 * 398 * @param array the array to add to the <code>toString</code> 399 * @return this 400 */ 401 public ToStringBuilder append(final float[] array) { 402 style.append(buffer, null, array, null); 403 return this; 404 } 405 406 //---------------------------------------------------------------------------- 407 408 /** 409 * <p>Append to the <code>toString</code> an <code>int</code> 410 * value.</p> 411 * 412 * @param value the value to add to the <code>toString</code> 413 * @return this 414 */ 415 public ToStringBuilder append(final int value) { 416 style.append(buffer, null, value); 417 return this; 418 } 419 420 //---------------------------------------------------------------------------- 421 422 /** 423 * <p>Append to the <code>toString</code> an <code>int</code> 424 * array.</p> 425 * 426 * @param array the array to add to the <code>toString</code> 427 * @return this 428 */ 429 public ToStringBuilder append(final int[] array) { 430 style.append(buffer, null, array, null); 431 return this; 432 } 433 434 //---------------------------------------------------------------------------- 435 436 /** 437 * <p>Append to the <code>toString</code> a <code>long</code> 438 * value.</p> 439 * 440 * @param value the value to add to the <code>toString</code> 441 * @return this 442 */ 443 public ToStringBuilder append(final long value) { 444 style.append(buffer, null, value); 445 return this; 446 } 447 448 //---------------------------------------------------------------------------- 449 450 /** 451 * <p>Append to the <code>toString</code> a <code>long</code> 452 * array.</p> 453 * 454 * @param array the array to add to the <code>toString</code> 455 * @return this 456 */ 457 public ToStringBuilder append(final long[] array) { 458 style.append(buffer, null, array, null); 459 return this; 460 } 461 462 //---------------------------------------------------------------------------- 463 464 /** 465 * <p>Append to the <code>toString</code> an <code>Object</code> 466 * value.</p> 467 * 468 * @param obj the value to add to the <code>toString</code> 469 * @return this 470 */ 471 public ToStringBuilder append(final Object obj) { 472 style.append(buffer, null, obj, null); 473 return this; 474 } 475 476 //---------------------------------------------------------------------------- 477 478 /** 479 * <p>Append to the <code>toString</code> an <code>Object</code> 480 * array.</p> 481 * 482 * @param array the array to add to the <code>toString</code> 483 * @return this 484 */ 485 public ToStringBuilder append(final Object[] array) { 486 style.append(buffer, null, array, null); 487 return this; 488 } 489 490 //---------------------------------------------------------------------------- 491 492 /** 493 * <p>Append to the <code>toString</code> a <code>short</code> 494 * value.</p> 495 * 496 * @param value the value to add to the <code>toString</code> 497 * @return this 498 */ 499 public ToStringBuilder append(final short value) { 500 style.append(buffer, null, value); 501 return this; 502 } 503 504 //---------------------------------------------------------------------------- 505 506 /** 507 * <p>Append to the <code>toString</code> a <code>short</code> 508 * array.</p> 509 * 510 * @param array the array to add to the <code>toString</code> 511 * @return this 512 */ 513 public ToStringBuilder append(final short[] array) { 514 style.append(buffer, null, array, null); 515 return this; 516 } 517 518 /** 519 * <p>Append to the <code>toString</code> a <code>boolean</code> 520 * value.</p> 521 * 522 * @param fieldName the field name 523 * @param value the value to add to the <code>toString</code> 524 * @return this 525 */ 526 public ToStringBuilder append(final String fieldName, final boolean value) { 527 style.append(buffer, fieldName, value); 528 return this; 529 } 530 531 /** 532 * <p>Append to the <code>toString</code> a <code>boolean</code> 533 * array.</p> 534 * 535 * @param fieldName the field name 536 * @param array the array to add to the <code>hashCode</code> 537 * @return this 538 */ 539 public ToStringBuilder append(final String fieldName, final boolean[] array) { 540 style.append(buffer, fieldName, array, null); 541 return this; 542 } 543 544 /** 545 * <p>Append to the <code>toString</code> a <code>boolean</code> 546 * array.</p> 547 * 548 * <p>A boolean parameter controls the level of detail to show. 549 * Setting <code>true</code> will output the array in full. Setting 550 * <code>false</code> will output a summary, typically the size of 551 * the array.</p> 552 * 553 * @param fieldName the field name 554 * @param array the array to add to the <code>toString</code> 555 * @param fullDetail <code>true</code> for detail, <code>false</code> 556 * for summary info 557 * @return this 558 */ 559 public ToStringBuilder append(final String fieldName, final boolean[] array, final boolean fullDetail) { 560 style.append(buffer, fieldName, array, Boolean.valueOf(fullDetail)); 561 return this; 562 } 563 564 /** 565 * <p>Append to the <code>toString</code> an <code>byte</code> 566 * value.</p> 567 * 568 * @param fieldName the field name 569 * @param value the value to add to the <code>toString</code> 570 * @return this 571 */ 572 public ToStringBuilder append(final String fieldName, final byte value) { 573 style.append(buffer, fieldName, value); 574 return this; 575 } 576 577 /** 578 * <p>Append to the <code>toString</code> a <code>byte</code> array.</p> 579 * 580 * @param fieldName the field name 581 * @param array the array to add to the <code>toString</code> 582 * @return this 583 */ 584 public ToStringBuilder append(final String fieldName, final byte[] array) { 585 style.append(buffer, fieldName, array, null); 586 return this; 587 } 588 589 /** 590 * <p>Append to the <code>toString</code> a <code>byte</code> 591 * array.</p> 592 * 593 * <p>A boolean parameter controls the level of detail to show. 594 * Setting <code>true</code> will output the array in full. Setting 595 * <code>false</code> will output a summary, typically the size of 596 * the array. 597 * 598 * @param fieldName the field name 599 * @param array the array to add to the <code>toString</code> 600 * @param fullDetail <code>true</code> for detail, <code>false</code> 601 * for summary info 602 * @return this 603 */ 604 public ToStringBuilder append(final String fieldName, final byte[] array, final boolean fullDetail) { 605 style.append(buffer, fieldName, array, Boolean.valueOf(fullDetail)); 606 return this; 607 } 608 609 /** 610 * <p>Append to the <code>toString</code> a <code>char</code> 611 * value.</p> 612 * 613 * @param fieldName the field name 614 * @param value the value to add to the <code>toString</code> 615 * @return this 616 */ 617 public ToStringBuilder append(final String fieldName, final char value) { 618 style.append(buffer, fieldName, value); 619 return this; 620 } 621 622 /** 623 * <p>Append to the <code>toString</code> a <code>char</code> 624 * array.</p> 625 * 626 * @param fieldName the field name 627 * @param array the array to add to the <code>toString</code> 628 * @return this 629 */ 630 public ToStringBuilder append(final String fieldName, final char[] array) { 631 style.append(buffer, fieldName, array, null); 632 return this; 633 } 634 635 /** 636 * <p>Append to the <code>toString</code> a <code>char</code> 637 * array.</p> 638 * 639 * <p>A boolean parameter controls the level of detail to show. 640 * Setting <code>true</code> will output the array in full. Setting 641 * <code>false</code> will output a summary, typically the size of 642 * the array.</p> 643 * 644 * @param fieldName the field name 645 * @param array the array to add to the <code>toString</code> 646 * @param fullDetail <code>true</code> for detail, <code>false</code> 647 * for summary info 648 * @return this 649 */ 650 public ToStringBuilder append(final String fieldName, final char[] array, final boolean fullDetail) { 651 style.append(buffer, fieldName, array, Boolean.valueOf(fullDetail)); 652 return this; 653 } 654 655 /** 656 * <p>Append to the <code>toString</code> a <code>double</code> 657 * value.</p> 658 * 659 * @param fieldName the field name 660 * @param value the value to add to the <code>toString</code> 661 * @return this 662 */ 663 public ToStringBuilder append(final String fieldName, final double value) { 664 style.append(buffer, fieldName, value); 665 return this; 666 } 667 668 /** 669 * <p>Append to the <code>toString</code> a <code>double</code> 670 * array.</p> 671 * 672 * @param fieldName the field name 673 * @param array the array to add to the <code>toString</code> 674 * @return this 675 */ 676 public ToStringBuilder append(final String fieldName, final double[] array) { 677 style.append(buffer, fieldName, array, null); 678 return this; 679 } 680 681 /** 682 * <p>Append to the <code>toString</code> a <code>double</code> 683 * array.</p> 684 * 685 * <p>A boolean parameter controls the level of detail to show. 686 * Setting <code>true</code> will output the array in full. Setting 687 * <code>false</code> will output a summary, typically the size of 688 * the array.</p> 689 * 690 * @param fieldName the field name 691 * @param array the array to add to the <code>toString</code> 692 * @param fullDetail <code>true</code> for detail, <code>false</code> 693 * for summary info 694 * @return this 695 */ 696 public ToStringBuilder append(final String fieldName, final double[] array, final boolean fullDetail) { 697 style.append(buffer, fieldName, array, Boolean.valueOf(fullDetail)); 698 return this; 699 } 700 701 /** 702 * <p>Append to the <code>toString</code> an <code>float</code> 703 * value.</p> 704 * 705 * @param fieldName the field name 706 * @param value the value to add to the <code>toString</code> 707 * @return this 708 */ 709 public ToStringBuilder append(final String fieldName, final float value) { 710 style.append(buffer, fieldName, value); 711 return this; 712 } 713 714 /** 715 * <p>Append to the <code>toString</code> a <code>float</code> 716 * array.</p> 717 * 718 * @param fieldName the field name 719 * @param array the array to add to the <code>toString</code> 720 * @return this 721 */ 722 public ToStringBuilder append(final String fieldName, final float[] array) { 723 style.append(buffer, fieldName, array, null); 724 return this; 725 } 726 727 /** 728 * <p>Append to the <code>toString</code> a <code>float</code> 729 * array.</p> 730 * 731 * <p>A boolean parameter controls the level of detail to show. 732 * Setting <code>true</code> will output the array in full. Setting 733 * <code>false</code> will output a summary, typically the size of 734 * the array.</p> 735 * 736 * @param fieldName the field name 737 * @param array the array to add to the <code>toString</code> 738 * @param fullDetail <code>true</code> for detail, <code>false</code> 739 * for summary info 740 * @return this 741 */ 742 public ToStringBuilder append(final String fieldName, final float[] array, final boolean fullDetail) { 743 style.append(buffer, fieldName, array, Boolean.valueOf(fullDetail)); 744 return this; 745 } 746 747 /** 748 * <p>Append to the <code>toString</code> an <code>int</code> 749 * value.</p> 750 * 751 * @param fieldName the field name 752 * @param value the value to add to the <code>toString</code> 753 * @return this 754 */ 755 public ToStringBuilder append(final String fieldName, final int value) { 756 style.append(buffer, fieldName, value); 757 return this; 758 } 759 760 /** 761 * <p>Append to the <code>toString</code> an <code>int</code> 762 * array.</p> 763 * 764 * @param fieldName the field name 765 * @param array the array to add to the <code>toString</code> 766 * @return this 767 */ 768 public ToStringBuilder append(final String fieldName, final int[] array) { 769 style.append(buffer, fieldName, array, null); 770 return this; 771 } 772 773 /** 774 * <p>Append to the <code>toString</code> an <code>int</code> 775 * array.</p> 776 * 777 * <p>A boolean parameter controls the level of detail to show. 778 * Setting <code>true</code> will output the array in full. Setting 779 * <code>false</code> will output a summary, typically the size of 780 * the array.</p> 781 * 782 * @param fieldName the field name 783 * @param array the array to add to the <code>toString</code> 784 * @param fullDetail <code>true</code> for detail, <code>false</code> 785 * for summary info 786 * @return this 787 */ 788 public ToStringBuilder append(final String fieldName, final int[] array, final boolean fullDetail) { 789 style.append(buffer, fieldName, array, Boolean.valueOf(fullDetail)); 790 return this; 791 } 792 793 /** 794 * <p>Append to the <code>toString</code> a <code>long</code> 795 * value.</p> 796 * 797 * @param fieldName the field name 798 * @param value the value to add to the <code>toString</code> 799 * @return this 800 */ 801 public ToStringBuilder append(final String fieldName, final long value) { 802 style.append(buffer, fieldName, value); 803 return this; 804 } 805 806 /** 807 * <p>Append to the <code>toString</code> a <code>long</code> 808 * array.</p> 809 * 810 * @param fieldName the field name 811 * @param array the array to add to the <code>toString</code> 812 * @return this 813 */ 814 public ToStringBuilder append(final String fieldName, final long[] array) { 815 style.append(buffer, fieldName, array, null); 816 return this; 817 } 818 819 /** 820 * <p>Append to the <code>toString</code> a <code>long</code> 821 * array.</p> 822 * 823 * <p>A boolean parameter controls the level of detail to show. 824 * Setting <code>true</code> will output the array in full. Setting 825 * <code>false</code> will output a summary, typically the size of 826 * the array.</p> 827 * 828 * @param fieldName the field name 829 * @param array the array to add to the <code>toString</code> 830 * @param fullDetail <code>true</code> for detail, <code>false</code> 831 * for summary info 832 * @return this 833 */ 834 public ToStringBuilder append(final String fieldName, final long[] array, final boolean fullDetail) { 835 style.append(buffer, fieldName, array, Boolean.valueOf(fullDetail)); 836 return this; 837 } 838 839 /** 840 * <p>Append to the <code>toString</code> an <code>Object</code> 841 * value.</p> 842 * 843 * @param fieldName the field name 844 * @param obj the value to add to the <code>toString</code> 845 * @return this 846 */ 847 public ToStringBuilder append(final String fieldName, final Object obj) { 848 style.append(buffer, fieldName, obj, null); 849 return this; 850 } 851 852 /** 853 * <p>Append to the <code>toString</code> an <code>Object</code> 854 * value.</p> 855 * 856 * @param fieldName the field name 857 * @param obj the value to add to the <code>toString</code> 858 * @param fullDetail <code>true</code> for detail, 859 * <code>false</code> for summary info 860 * @return this 861 */ 862 public ToStringBuilder append(final String fieldName, final Object obj, final boolean fullDetail) { 863 style.append(buffer, fieldName, obj, Boolean.valueOf(fullDetail)); 864 return this; 865 } 866 867 /** 868 * <p>Append to the <code>toString</code> an <code>Object</code> 869 * array.</p> 870 * 871 * @param fieldName the field name 872 * @param array the array to add to the <code>toString</code> 873 * @return this 874 */ 875 public ToStringBuilder append(final String fieldName, final Object[] array) { 876 style.append(buffer, fieldName, array, null); 877 return this; 878 } 879 880 /** 881 * <p>Append to the <code>toString</code> an <code>Object</code> 882 * array.</p> 883 * 884 * <p>A boolean parameter controls the level of detail to show. 885 * Setting <code>true</code> will output the array in full. Setting 886 * <code>false</code> will output a summary, typically the size of 887 * the array.</p> 888 * 889 * @param fieldName the field name 890 * @param array the array to add to the <code>toString</code> 891 * @param fullDetail <code>true</code> for detail, <code>false</code> 892 * for summary info 893 * @return this 894 */ 895 public ToStringBuilder append(final String fieldName, final Object[] array, final boolean fullDetail) { 896 style.append(buffer, fieldName, array, Boolean.valueOf(fullDetail)); 897 return this; 898 } 899 900 /** 901 * <p>Append to the <code>toString</code> an <code>short</code> 902 * value.</p> 903 * 904 * @param fieldName the field name 905 * @param value the value to add to the <code>toString</code> 906 * @return this 907 */ 908 public ToStringBuilder append(final String fieldName, final short value) { 909 style.append(buffer, fieldName, value); 910 return this; 911 } 912 913 /** 914 * <p>Append to the <code>toString</code> a <code>short</code> 915 * array.</p> 916 * 917 * @param fieldName the field name 918 * @param array the array to add to the <code>toString</code> 919 * @return this 920 */ 921 public ToStringBuilder append(final String fieldName, final short[] array) { 922 style.append(buffer, fieldName, array, null); 923 return this; 924 } 925 926 /** 927 * <p>Append to the <code>toString</code> a <code>short</code> 928 * array.</p> 929 * 930 * <p>A boolean parameter controls the level of detail to show. 931 * Setting <code>true</code> will output the array in full. Setting 932 * <code>false</code> will output a summary, typically the size of 933 * the array. 934 * 935 * @param fieldName the field name 936 * @param array the array to add to the <code>toString</code> 937 * @param fullDetail <code>true</code> for detail, <code>false</code> 938 * for summary info 939 * @return this 940 */ 941 public ToStringBuilder append(final String fieldName, final short[] array, final boolean fullDetail) { 942 style.append(buffer, fieldName, array, Boolean.valueOf(fullDetail)); 943 return this; 944 } 945 946 /** 947 * <p>Appends with the same format as the default <code>Object toString() 948 * </code> method. Appends the class name followed by 949 * {@link System#identityHashCode(java.lang.Object)}.</p> 950 * 951 * @param srcObject the <code>Object</code> whose class name and id to output 952 * @return this 953 * @since 2.0 954 */ 955 public ToStringBuilder appendAsObjectToString(final Object srcObject) { 956 ObjectUtils.identityToString(this.getStringBuffer(), srcObject); 957 return this; 958 } 959 960 //---------------------------------------------------------------------------- 961 962 /** 963 * <p>Append the <code>toString</code> from the superclass.</p> 964 * 965 * <p>This method assumes that the superclass uses the same <code>ToStringStyle</code> 966 * as this one.</p> 967 * 968 * <p>If <code>superToString</code> is <code>null</code>, no change is made.</p> 969 * 970 * @param superToString the result of <code>super.toString()</code> 971 * @return this 972 * @since 2.0 973 */ 974 public ToStringBuilder appendSuper(final String superToString) { 975 if (superToString != null) { 976 style.appendSuper(buffer, superToString); 977 } 978 return this; 979 } 980 981 /** 982 * <p>Append the <code>toString</code> from another object.</p> 983 * 984 * <p>This method is useful where a class delegates most of the implementation of 985 * its properties to another class. You can then call <code>toString()</code> on 986 * the other class and pass the result into this method.</p> 987 * 988 * <pre> 989 * private AnotherObject delegate; 990 * private String fieldInThisClass; 991 * 992 * public String toString() { 993 * return new ToStringBuilder(this). 994 * appendToString(delegate.toString()). 995 * append(fieldInThisClass). 996 * toString(); 997 * }</pre> 998 * 999 * <p>This method assumes that the other object uses the same <code>ToStringStyle</code> 1000 * as this one.</p> 1001 * 1002 * <p>If the <code>toString</code> is <code>null</code>, no change is made.</p> 1003 * 1004 * @param toString the result of <code>toString()</code> on another object 1005 * @return this 1006 * @since 2.0 1007 */ 1008 public ToStringBuilder appendToString(final String toString) { 1009 if (toString != null) { 1010 style.appendToString(buffer, toString); 1011 } 1012 return this; 1013 } 1014 1015 /** 1016 * <p>Returns the <code>Object</code> being output.</p> 1017 * 1018 * @return The object being output. 1019 * @since 2.0 1020 */ 1021 public Object getObject() { 1022 return object; 1023 } 1024 1025 /** 1026 * <p>Gets the <code>StringBuffer</code> being populated.</p> 1027 * 1028 * @return the <code>StringBuffer</code> being populated 1029 */ 1030 public StringBuffer getStringBuffer() { 1031 return buffer; 1032 } 1033 1034 //---------------------------------------------------------------------------- 1035 1036 /** 1037 * <p>Gets the <code>ToStringStyle</code> being used.</p> 1038 * 1039 * @return the <code>ToStringStyle</code> being used 1040 * @since 2.0 1041 */ 1042 public ToStringStyle getStyle() { 1043 return style; 1044 } 1045 1046 /** 1047 * <p>Returns the built <code>toString</code>.</p> 1048 * 1049 * <p>This method appends the end of data indicator, and can only be called once. 1050 * Use {@link #getStringBuffer} to get the current string state.</p> 1051 * 1052 * <p>If the object is <code>null</code>, return the style's <code>nullText</code></p> 1053 * 1054 * @return the String <code>toString</code> 1055 */ 1056 @Override 1057 public String toString() { 1058 if (this.getObject() == null) { 1059 this.getStringBuffer().append(this.getStyle().getNullText()); 1060 } else { 1061 style.appendEnd(this.getStringBuffer(), this.getObject()); 1062 } 1063 return this.getStringBuffer().toString(); 1064 } 1065 1066 /** 1067 * Returns the String that was build as an object representation. The 1068 * default implementation utilizes the {@link #toString()} implementation. 1069 * 1070 * @return the String <code>toString</code> 1071 * 1072 * @see #toString() 1073 * 1074 * @since 3.0 1075 */ 1076 @Override 1077 public String build() { 1078 return toString(); 1079 } 1080}