Coverage Report - org.apache.commons.lang3.builder.StandardToStringStyle
 
Classes in this File Line Coverage Branch Coverage Complexity
StandardToStringStyle
37%
23/62
N/A
1
 
 1  
 /*
 2  
  * Licensed to the Apache Software Foundation (ASF) under one or more
 3  
  * contributor license agreements.  See the NOTICE file distributed with
 4  
  * this work for additional information regarding copyright ownership.
 5  
  * The ASF licenses this file to You under the Apache License, Version 2.0
 6  
  * (the "License"); you may not use this file except in compliance with
 7  
  * the License.  You may obtain a copy of the License at
 8  
  * 
 9  
  *      http://www.apache.org/licenses/LICENSE-2.0
 10  
  * 
 11  
  * Unless required by applicable law or agreed to in writing, software
 12  
  * distributed under the License is distributed on an "AS IS" BASIS,
 13  
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 14  
  * See the License for the specific language governing permissions and
 15  
  * limitations under the License.
 16  
  */
 17  
 package org.apache.commons.lang3.builder;
 18  
 
 19  
 /**
 20  
  * <p>Works with {@link ToStringBuilder} to create a <code>toString</code>.</p>
 21  
  *
 22  
  * <p>This class is intended to be used as a singleton.
 23  
  * There is no need to instantiate a new style each time.
 24  
  * Simply instantiate the class once, customize the values as required, and
 25  
  * store the result in a public static final variable for the rest of the
 26  
  * program to access.</p>
 27  
  *
 28  
  * @since 1.0
 29  
  */
 30  
 public class StandardToStringStyle extends ToStringStyle {
 31  
     
 32  
     /**
 33  
      * Required for serialization support.
 34  
      * 
 35  
      * @see java.io.Serializable
 36  
      */
 37  
     private static final long serialVersionUID = 1L;
 38  
 
 39  
     /**
 40  
      * <p>Constructor.</p>
 41  
      */
 42  
     public StandardToStringStyle() {
 43  1
         super();
 44  1
     }
 45  
     
 46  
     //---------------------------------------------------------------------
 47  
     
 48  
     /**
 49  
      * <p>Gets whether to use the class name.</p>
 50  
      *
 51  
      * @return the current useClassName flag
 52  
      */
 53  
     @Override
 54  
     public boolean isUseClassName() { // NOPMD as this is implementing the abstract class
 55  0
         return super.isUseClassName();
 56  
     }
 57  
 
 58  
     /**
 59  
      * <p>Sets whether to use the class name.</p>
 60  
      *
 61  
      * @param useClassName  the new useClassName flag
 62  
      */
 63  
     @Override
 64  
     public void setUseClassName(final boolean useClassName) { // NOPMD as this is implementing the abstract class
 65  0
         super.setUseClassName(useClassName);
 66  0
     }
 67  
 
 68  
     //---------------------------------------------------------------------
 69  
     
 70  
     /**
 71  
      * <p>Gets whether to output short or long class names.</p>
 72  
      *
 73  
      * @return the current useShortClassName flag
 74  
      * @since 2.0
 75  
      */
 76  
     @Override
 77  
     public boolean isUseShortClassName() { // NOPMD as this is implementing the abstract class
 78  0
         return super.isUseShortClassName();
 79  
     }
 80  
 
 81  
     /**
 82  
      * <p>Sets whether to output short or long class names.</p>
 83  
      *
 84  
      * @param useShortClassName  the new useShortClassName flag
 85  
      * @since 2.0
 86  
      */
 87  
     @Override
 88  
     public void setUseShortClassName(final boolean useShortClassName) { // NOPMD as this is implementing the abstract class
 89  1
         super.setUseShortClassName(useShortClassName);
 90  1
     }
 91  
 
 92  
     //---------------------------------------------------------------------
 93  
     
 94  
     /**
 95  
      * <p>Gets whether to use the identity hash code.</p>
 96  
      * @return the current useIdentityHashCode flag
 97  
      */
 98  
     @Override
 99  
     public boolean isUseIdentityHashCode() { // NOPMD as this is implementing the abstract class
 100  34
         return super.isUseIdentityHashCode();
 101  
     }
 102  
 
 103  
     /**
 104  
      * <p>Sets whether to use the identity hash code.</p>
 105  
      *
 106  
      * @param useIdentityHashCode  the new useIdentityHashCode flag
 107  
      */
 108  
     @Override
 109  
     public void setUseIdentityHashCode(final boolean useIdentityHashCode) { // NOPMD as this is implementing the abstract class
 110  1
         super.setUseIdentityHashCode(useIdentityHashCode);
 111  1
     }
 112  
 
 113  
     //---------------------------------------------------------------------
 114  
     
 115  
     /**
 116  
      * <p>Gets whether to use the field names passed in.</p>
 117  
      *
 118  
      * @return the current useFieldNames flag
 119  
      */
 120  
     @Override
 121  
     public boolean isUseFieldNames() { // NOPMD as this is implementing the abstract class
 122  0
         return super.isUseFieldNames();
 123  
     }
 124  
 
 125  
     /**
 126  
      * <p>Sets whether to use the field names passed in.</p>
 127  
      *
 128  
      * @param useFieldNames  the new useFieldNames flag
 129  
      */
 130  
     @Override
 131  
     public void setUseFieldNames(final boolean useFieldNames) { // NOPMD as this is implementing the abstract class
 132  0
         super.setUseFieldNames(useFieldNames);
 133  0
     }
 134  
 
 135  
     //---------------------------------------------------------------------
 136  
     
 137  
     /**
 138  
      * <p>Gets whether to use full detail when the caller doesn't
 139  
      * specify.</p>
 140  
      *
 141  
      * @return the current defaultFullDetail flag
 142  
      */
 143  
     @Override
 144  
     public boolean isDefaultFullDetail() { // NOPMD as this is implementing the abstract class
 145  0
         return super.isDefaultFullDetail();
 146  
     }
 147  
 
 148  
     /**
 149  
      * <p>Sets whether to use full detail when the caller doesn't
 150  
      * specify.</p>
 151  
      *
 152  
      * @param defaultFullDetail  the new defaultFullDetail flag
 153  
      */
 154  
     @Override
 155  
     public void setDefaultFullDetail(final boolean defaultFullDetail) { // NOPMD as this is implementing the abstract class
 156  0
         super.setDefaultFullDetail(defaultFullDetail);
 157  0
     }
 158  
 
 159  
     //---------------------------------------------------------------------
 160  
     
 161  
     /**
 162  
      * <p>Gets whether to output array content detail.</p>
 163  
      *
 164  
      * @return the current array content detail setting
 165  
      */
 166  
     @Override
 167  
     public boolean isArrayContentDetail() { // NOPMD as this is implementing the abstract class
 168  0
         return super.isArrayContentDetail();
 169  
     }
 170  
     
 171  
     /**
 172  
      * <p>Sets whether to output array content detail.</p>
 173  
      *
 174  
      * @param arrayContentDetail  the new arrayContentDetail flag
 175  
      */
 176  
     @Override
 177  
     public void setArrayContentDetail(final boolean arrayContentDetail) { // NOPMD as this is implementing the abstract class
 178  0
         super.setArrayContentDetail(arrayContentDetail);
 179  0
     }
 180  
 
 181  
     //---------------------------------------------------------------------
 182  
     
 183  
     /**
 184  
      * <p>Gets the array start text.</p>
 185  
      *
 186  
      * @return the current array start text
 187  
      */
 188  
     @Override
 189  
     public String getArrayStart() { // NOPMD as this is implementing the abstract class
 190  0
         return super.getArrayStart();
 191  
     }
 192  
 
 193  
     /**
 194  
      * <p>Sets the array start text.</p>
 195  
      *
 196  
      * <p><code>null</code> is accepted, but will be converted
 197  
      * to an empty String.</p>
 198  
      *
 199  
      * @param arrayStart  the new array start text
 200  
      */
 201  
     @Override
 202  
     public void setArrayStart(final String arrayStart) { // NOPMD as this is implementing the abstract class
 203  1
         super.setArrayStart(arrayStart);
 204  1
     }
 205  
 
 206  
     //---------------------------------------------------------------------
 207  
     
 208  
     /**
 209  
      * <p>Gets the array end text.</p>
 210  
      *
 211  
      * @return the current array end text
 212  
      */
 213  
     @Override
 214  
     public String getArrayEnd() { // NOPMD as this is implementing the abstract class
 215  0
         return super.getArrayEnd();
 216  
     }
 217  
 
 218  
     /**
 219  
      * <p>Sets the array end text.</p>
 220  
      *
 221  
      * <p><code>null</code> is accepted, but will be converted
 222  
      * to an empty String.</p>
 223  
      *
 224  
      * @param arrayEnd  the new array end text
 225  
      */
 226  
     @Override
 227  
     public void setArrayEnd(final String arrayEnd) { // NOPMD as this is implementing the abstract class
 228  1
         super.setArrayEnd(arrayEnd);
 229  1
     }
 230  
 
 231  
     //---------------------------------------------------------------------
 232  
     
 233  
     /**
 234  
      * <p>Gets the array separator text.</p>
 235  
      *
 236  
      * @return the current array separator text
 237  
      */
 238  
     @Override
 239  
     public String getArraySeparator() { // NOPMD as this is implementing the abstract class
 240  0
         return super.getArraySeparator();
 241  
     }
 242  
 
 243  
     /**
 244  
      * <p>Sets the array separator text.</p>
 245  
      *
 246  
      * <p><code>null</code> is accepted, but will be converted
 247  
      * to an empty String.</p>
 248  
      *
 249  
      * @param arraySeparator  the new array separator text
 250  
      */
 251  
     @Override
 252  
     public void setArraySeparator(final String arraySeparator) { // NOPMD as this is implementing the abstract class
 253  1
         super.setArraySeparator(arraySeparator);
 254  1
     }
 255  
 
 256  
     //---------------------------------------------------------------------
 257  
     
 258  
     /**
 259  
      * <p>Gets the content start text.</p>
 260  
      *
 261  
      * @return the current content start text
 262  
      */
 263  
     @Override
 264  
     public String getContentStart() { // NOPMD as this is implementing the abstract class
 265  0
         return super.getContentStart();
 266  
     }
 267  
 
 268  
     /**
 269  
      * <p>Sets the content start text.</p>
 270  
      *
 271  
      * <p><code>null</code> is accepted, but will be converted
 272  
      * to an empty String.</p>
 273  
      *
 274  
      * @param contentStart  the new content start text
 275  
      */
 276  
     @Override
 277  
     public void setContentStart(final String contentStart) { // NOPMD as this is implementing the abstract class
 278  0
         super.setContentStart(contentStart);
 279  0
     }
 280  
 
 281  
     //---------------------------------------------------------------------
 282  
     
 283  
     /**
 284  
      * <p>Gets the content end text.</p>
 285  
      *
 286  
      * @return the current content end text
 287  
      */
 288  
     @Override
 289  
     public String getContentEnd() { // NOPMD as this is implementing the abstract class
 290  0
         return super.getContentEnd();
 291  
     }
 292  
 
 293  
     /**
 294  
      * <p>Sets the content end text.</p>
 295  
      *
 296  
      * <p><code>null</code> is accepted, but will be converted
 297  
      * to an empty String.</p>
 298  
      *
 299  
      * @param contentEnd  the new content end text
 300  
      */
 301  
     @Override
 302  
     public void setContentEnd(final String contentEnd) { // NOPMD as this is implementing the abstract class
 303  0
         super.setContentEnd(contentEnd);
 304  0
     }
 305  
 
 306  
     //---------------------------------------------------------------------
 307  
     
 308  
     /**
 309  
      * <p>Gets the field name value separator text.</p>
 310  
      *
 311  
      * @return the current field name value separator text
 312  
      */
 313  
     @Override
 314  
     public String getFieldNameValueSeparator() { // NOPMD as this is implementing the abstract class
 315  0
         return super.getFieldNameValueSeparator();
 316  
     }
 317  
 
 318  
     /**
 319  
      * <p>Sets the field name value separator text.</p>
 320  
      *
 321  
      * <p><code>null</code> is accepted, but will be converted
 322  
      * to an empty String.</p>
 323  
      *
 324  
      * @param fieldNameValueSeparator  the new field name value separator text
 325  
      */
 326  
     @Override
 327  
     public void setFieldNameValueSeparator(final String fieldNameValueSeparator) { // NOPMD as this is implementing the abstract class
 328  0
         super.setFieldNameValueSeparator(fieldNameValueSeparator);
 329  0
     }
 330  
 
 331  
     //---------------------------------------------------------------------
 332  
     
 333  
     /**
 334  
      * <p>Gets the field separator text.</p>
 335  
      *
 336  
      * @return the current field separator text
 337  
      */
 338  
     @Override
 339  
     public String getFieldSeparator() { // NOPMD as this is implementing the abstract class
 340  0
         return super.getFieldSeparator();
 341  
     }
 342  
 
 343  
     /**
 344  
      * <p>Sets the field separator text.</p>
 345  
      *
 346  
      * <p><code>null</code> is accepted, but will be converted
 347  
      * to an empty String.</p>
 348  
      *
 349  
      * @param fieldSeparator  the new field separator text
 350  
      */
 351  
     @Override
 352  
     public void setFieldSeparator(final String fieldSeparator) { // NOPMD as this is implementing the abstract class
 353  0
         super.setFieldSeparator(fieldSeparator);
 354  0
     }
 355  
 
 356  
     //---------------------------------------------------------------------
 357  
     
 358  
     /**
 359  
      * <p>Gets whether the field separator should be added at the start 
 360  
      * of each buffer.</p>
 361  
      * 
 362  
      * @return the fieldSeparatorAtStart flag
 363  
      * @since 2.0
 364  
      */
 365  
     @Override
 366  
     public boolean isFieldSeparatorAtStart() { // NOPMD as this is implementing the abstract class
 367  0
         return super.isFieldSeparatorAtStart();
 368  
     }
 369  
 
 370  
     /**
 371  
      * <p>Sets whether the field separator should be added at the start 
 372  
      * of each buffer.</p>
 373  
      * 
 374  
      * @param fieldSeparatorAtStart  the fieldSeparatorAtStart flag
 375  
      * @since 2.0
 376  
      */
 377  
     @Override
 378  
     public void setFieldSeparatorAtStart(final boolean fieldSeparatorAtStart) { // NOPMD as this is implementing the abstract class
 379  0
         super.setFieldSeparatorAtStart(fieldSeparatorAtStart);
 380  0
     }
 381  
 
 382  
     //---------------------------------------------------------------------
 383  
     
 384  
     /**
 385  
      * <p>Gets whether the field separator should be added at the end 
 386  
      * of each buffer.</p>
 387  
      * 
 388  
      * @return fieldSeparatorAtEnd flag
 389  
      * @since 2.0
 390  
      */
 391  
     @Override
 392  
     public boolean isFieldSeparatorAtEnd() { // NOPMD as this is implementing the abstract class
 393  0
         return super.isFieldSeparatorAtEnd();
 394  
     }
 395  
 
 396  
     /**
 397  
      * <p>Sets whether the field separator should be added at the end 
 398  
      * of each buffer.</p>
 399  
      * 
 400  
      * @param fieldSeparatorAtEnd  the fieldSeparatorAtEnd flag
 401  
      * @since 2.0
 402  
      */
 403  
     @Override
 404  
     public void setFieldSeparatorAtEnd(final boolean fieldSeparatorAtEnd) { // NOPMD as this is implementing the abstract class
 405  0
         super.setFieldSeparatorAtEnd(fieldSeparatorAtEnd);
 406  0
     }
 407  
 
 408  
     //---------------------------------------------------------------------
 409  
     
 410  
     /**
 411  
      * <p>Gets the text to output when <code>null</code> found.</p>
 412  
      *
 413  
      * @return the current text to output when <code>null</code> found
 414  
      */
 415  
     @Override
 416  
     public String getNullText() { // NOPMD as this is implementing the abstract class
 417  0
         return super.getNullText();
 418  
     }
 419  
 
 420  
     /**
 421  
      * <p>Sets the text to output when <code>null</code> found.</p>
 422  
      *
 423  
      * <p><code>null</code> is accepted, but will be converted
 424  
      * to an empty String.</p>
 425  
      *
 426  
      * @param nullText  the new text to output when <code>null</code> found
 427  
      */
 428  
     @Override
 429  
     public void setNullText(final String nullText) { // NOPMD as this is implementing the abstract class
 430  1
         super.setNullText(nullText);
 431  1
     }
 432  
 
 433  
     //---------------------------------------------------------------------
 434  
     
 435  
     /**
 436  
      * <p>Gets the text to output when a <code>Collection</code>,
 437  
      * <code>Map</code> or <code>Array</code> size is output.</p>
 438  
      *
 439  
      * <p>This is output before the size value.</p>
 440  
      *
 441  
      * @return the current start of size text
 442  
      */
 443  
     @Override
 444  
     public String getSizeStartText() { // NOPMD as this is implementing the abstract class
 445  0
         return super.getSizeStartText();
 446  
     }
 447  
 
 448  
     /**
 449  
      * <p>Sets the start text to output when a <code>Collection</code>,
 450  
      * <code>Map</code> or <code>Array</code> size is output.</p>
 451  
      *
 452  
      * <p>This is output before the size value.</p>
 453  
      *
 454  
      * <p><code>null</code> is accepted, but will be converted to
 455  
      * an empty String.</p>
 456  
      *
 457  
      * @param sizeStartText  the new start of size text
 458  
      */
 459  
     @Override
 460  
     public void setSizeStartText(final String sizeStartText) { // NOPMD as this is implementing the abstract class
 461  1
         super.setSizeStartText(sizeStartText);
 462  1
     }
 463  
 
 464  
     //---------------------------------------------------------------------
 465  
     
 466  
     /**
 467  
      * <p>Gets the end text to output when a <code>Collection</code>,
 468  
      * <code>Map</code> or <code>Array</code> size is output.</p>
 469  
      *
 470  
      * <p>This is output after the size value.</p>
 471  
      *
 472  
      * @return the current end of size text
 473  
      */
 474  
     @Override
 475  
     public String getSizeEndText() { // NOPMD as this is implementing the abstract class
 476  0
         return super.getSizeEndText();
 477  
     }
 478  
 
 479  
     /**
 480  
      * <p>Sets the end text to output when a <code>Collection</code>,
 481  
      * <code>Map</code> or <code>Array</code> size is output.</p>
 482  
      *
 483  
      * <p>This is output after the size value.</p>
 484  
      *
 485  
      * <p><code>null</code> is accepted, but will be converted
 486  
      * to an empty String.</p>
 487  
      *
 488  
      * @param sizeEndText  the new end of size text
 489  
      */
 490  
     @Override
 491  
     public void setSizeEndText(final String sizeEndText) { // NOPMD as this is implementing the abstract class
 492  1
         super.setSizeEndText(sizeEndText);
 493  1
     }
 494  
 
 495  
     //---------------------------------------------------------------------
 496  
     
 497  
     /**
 498  
      * <p>Gets the start text to output when an <code>Object</code> is
 499  
      * output in summary mode.</p>
 500  
      *
 501  
      * <P>This is output before the size value.</p>
 502  
      *
 503  
      * @return the current start of summary text
 504  
      */
 505  
     @Override
 506  
     public String getSummaryObjectStartText() { // NOPMD as this is implementing the abstract class
 507  0
         return super.getSummaryObjectStartText();
 508  
     }
 509  
 
 510  
     /**
 511  
      * <p>Sets the start text to output when an <code>Object</code> is
 512  
      * output in summary mode.</p>
 513  
      *
 514  
      * <p>This is output before the size value.</p>
 515  
      *
 516  
      * <p><code>null</code> is accepted, but will be converted to
 517  
      * an empty String.</p>
 518  
      *
 519  
      * @param summaryObjectStartText  the new start of summary text
 520  
      */
 521  
     @Override
 522  
     public void setSummaryObjectStartText(final String summaryObjectStartText) { // NOPMD as this is implementing the abstract class
 523  1
         super.setSummaryObjectStartText(summaryObjectStartText);
 524  1
     }
 525  
 
 526  
     //---------------------------------------------------------------------
 527  
     
 528  
     /**
 529  
      * <p>Gets the end text to output when an <code>Object</code> is
 530  
      * output in summary mode.</p>
 531  
      *
 532  
      * <p>This is output after the size value.</p>
 533  
      *
 534  
      * @return the current end of summary text
 535  
      */
 536  
     @Override
 537  
     public String getSummaryObjectEndText() { // NOPMD as this is implementing the abstract class
 538  0
         return super.getSummaryObjectEndText();
 539  
     }
 540  
 
 541  
     /**
 542  
      * <p>Sets the end text to output when an <code>Object</code> is
 543  
      * output in summary mode.</p>
 544  
      *
 545  
      * <p>This is output after the size value.</p>
 546  
      *
 547  
      * <p><code>null</code> is accepted, but will be converted to
 548  
      * an empty String.</p>
 549  
      *
 550  
      * @param summaryObjectEndText  the new end of summary text
 551  
      */
 552  
     @Override
 553  
     public void setSummaryObjectEndText(final String summaryObjectEndText) { // NOPMD as this is implementing the abstract class
 554  1
         super.setSummaryObjectEndText(summaryObjectEndText);
 555  1
     }
 556  
 
 557  
     //---------------------------------------------------------------------
 558  
     
 559  
 }