001// *************************************************************************************************************************** 002// * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file * 003// * distributed with this work for additional information regarding copyright ownership. The ASF licenses this file * 004// * to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance * 005// * with the License. You may obtain a copy of the License at * 006// * * 007// * http://www.apache.org/licenses/LICENSE-2.0 * 008// * * 009// * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an * 010// * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the * 011// * specific language governing permissions and limitations under the License. * 012// *************************************************************************************************************************** 013package org.apache.juneau.parser; 014 015import static org.apache.juneau.parser.InputStreamParser.*; 016import static org.apache.juneau.parser.ReaderParser.*; 017 018import java.lang.annotation.*; 019import java.lang.reflect.*; 020import java.nio.charset.*; 021import java.util.*; 022 023import org.apache.juneau.*; 024import org.apache.juneau.collections.*; 025import org.apache.juneau.http.*; 026import org.apache.juneau.internal.*; 027import org.apache.juneau.reflect.*; 028import org.apache.juneau.svl.*; 029 030/** 031 * Builder class for creating instances of {@link ParserGroup}. 032 */ 033public class ParserGroupBuilder extends BeanContextBuilder { 034 035 private final AList<Object> parsers; 036 037 /** 038 * Create an empty parser group builder. 039 */ 040 public ParserGroupBuilder() { 041 this.parsers = AList.of(); 042 } 043 044 /** 045 * Clone an existing parser group builder. 046 * 047 * @param copyFrom The parser group that we're copying settings and parsers from. 048 */ 049 public ParserGroupBuilder(ParserGroup copyFrom) { 050 super(copyFrom.getPropertyStore()); 051 this.parsers = AList.of().arev(copyFrom.getParsers()); 052 } 053 054 /** 055 * Registers the specified parsers with this group. 056 * 057 * @param p The parsers to append to this group. 058 * @return This object (for method chaining). 059 */ 060 public ParserGroupBuilder append(Class<?>...p) { 061 parsers.arev(p); 062 return this; 063 } 064 065 /** 066 * Registers the specified parsers with this group. 067 * 068 * <p> 069 * When passing in pre-instantiated parsers to this group, applying properties and transforms to the group 070 * do not affect them. 071 * 072 * @param p The parsers to append to this group. 073 * @return This object (for method chaining). 074 */ 075 public ParserGroupBuilder append(Parser...p) { 076 parsers.arev(p); 077 return this; 078 } 079 080 /** 081 * Registers the specified parsers with this group. 082 * 083 * <p> 084 * Objects can either be instances of parsers or parser classes. 085 * 086 * @param p The parsers to append to this group. 087 * @return This object (for method chaining). 088 */ 089 public ParserGroupBuilder append(List<Object> p) { 090 parsers.arev(p); 091 return this; 092 } 093 094 /** 095 * Registers the specified parsers with this group. 096 * 097 * <p> 098 * Objects can either be instances of parsers or parser classes. 099 * 100 * @param p The parsers to append to this group. 101 * @return This object (for method chaining). 102 */ 103 public ParserGroupBuilder append(Object...p) { 104 parsers.arev(p); 105 return this; 106 } 107 108 /** 109 * Creates a new {@link ParserGroup} object using a snapshot of the settings defined in this builder. 110 * 111 * <p> 112 * This method can be called multiple times to produce multiple parser groups. 113 * 114 * @return A new {@link ParserGroup} object. 115 */ 116 @Override /* Context */ 117 @SuppressWarnings("unchecked") 118 public ParserGroup build() { 119 List<Parser> l = new ArrayList<>(); 120 for (Object p : parsers) { 121 Class<? extends Parser> c = null; 122 PropertyStore ps = getPropertyStore(); 123 if (p instanceof Class) { 124 c = (Class<? extends Parser>)p; 125 l.add(ContextCache.INSTANCE.create(c, ps)); 126 } else { 127 l.add((Parser)p); 128 } 129 } 130 return new ParserGroup(getPropertyStore(), ArrayUtils.toReverseArray(Parser.class, l)); 131 } 132 133 //----------------------------------------------------------------------------------------------------------------- 134 // Properties 135 //----------------------------------------------------------------------------------------------------------------- 136 137 /** 138 * Configuration property: Auto-close streams. 139 * 140 * <p> 141 * If <jk>true</jk>, <l>InputStreams</l> and <l>Readers</l> passed into parsers will be closed 142 * after parsing is complete. 143 * 144 * <ul class='seealso'> 145 * <li class='jf'>{@link Parser#PARSER_autoCloseStreams} 146 * </ul> 147 * 148 * @param value 149 * The new value for this property. 150 * <br>The default value is <jk>false</jk>. 151 * @return This object (for method chaining). 152 */ 153 public ParserGroupBuilder autoCloseStreams(boolean value) { 154 return set(PARSER_autoCloseStreams, value); 155 } 156 157 /** 158 * Configuration property: Auto-close streams. 159 * <p> 160 * Shortcut for calling <code>autoCloseStreams(<jk>true</jk>)</code>. 161 * 162 * <ul class='seealso'> 163 * <li class='jf'>{@link Parser#PARSER_autoCloseStreams} 164 * </ul> 165 * 166 * @return This object (for method chaining). 167 */ 168 public ParserGroupBuilder autoCloseStreams() { 169 return set(PARSER_autoCloseStreams, true); 170 } 171 172 /** 173 * Configuration property: Debug output lines. 174 * 175 * When parse errors occur, this specifies the number of lines of input before and after the 176 * error location to be printed as part of the exception message. 177 * 178 * <ul class='seealso'> 179 * <li class='jf'>{@link Parser#PARSER_debugOutputLines} 180 * </ul> 181 * 182 * @param value 183 * The new value for this property. 184 * <br>The default value is <c>5</c>. 185 * @return This object (for method chaining). 186 */ 187 public ParserGroupBuilder debugOutputLines(int value) { 188 set(PARSER_debugOutputLines, value); 189 return this; 190 } 191 192 /** 193 * Configuration property: Parser listener. 194 * 195 * <p> 196 * Class used to listen for errors and warnings that occur during parsing. 197 * 198 * <ul class='seealso'> 199 * <li class='jf'>{@link Parser#PARSER_listener} 200 * </ul> 201 * 202 * @param value The new value for this property. 203 * @return This object (for method chaining). 204 */ 205 public ParserGroupBuilder listener(Class<? extends ParserListener> value) { 206 return set(PARSER_listener, value); 207 } 208 209 /** 210 * Configuration property: Strict mode. 211 * 212 * <p> 213 * If <jk>true</jk>, strict mode for the parsers are enabled. 214 * 215 * <ul class='seealso'> 216 * <li class='jf'>{@link Parser#PARSER_strict} 217 * </ul> 218 * 219 * @param value 220 * The new value for this property. 221 * <br>The default value is <jk>false</jk>. 222 * @return This object (for method chaining). 223 */ 224 public ParserGroupBuilder strict(boolean value) { 225 return set(PARSER_strict, value); 226 } 227 228 /** 229 * Configuration property: Strict mode. 230 * 231 * <p> 232 * Shortcut for calling <code>strict(<jk>true</jk>)</code>. 233 * 234 * <ul class='seealso'> 235 * <li class='jf'>{@link Parser#PARSER_strict} 236 * </ul> 237 * 238 * @return This object (for method chaining). 239 */ 240 public ParserGroupBuilder strict() { 241 return set(PARSER_strict, true); 242 } 243 244 /** 245 * Configuration property: Trim parsed strings. 246 * 247 * <p> 248 * If <jk>true</jk>, string values will be trimmed of whitespace using {@link String#trim()} before being added to 249 * the POJO. 250 * 251 * <ul class='seealso'> 252 * <li class='jf'>{@link Parser#PARSER_trimStrings} 253 * </ul> 254 * 255 * @param value 256 * The new value for this property. 257 * <br>The default value is <jk>false</jk>. 258 * @return This object (for method chaining). 259 */ 260 public ParserGroupBuilder trimStrings(boolean value) { 261 return set(PARSER_trimStrings, value); 262 } 263 264 /** 265 * Configuration property: Trim parsed strings. 266 * 267 * <p> 268 * Shortcut for calling <code>trimStrings(<jk>true</jk>)</code>. 269 * 270 * <ul class='seealso'> 271 * <li class='jf'>{@link Parser#PARSER_trimStrings} 272 * </ul> 273 * 274 * @return This object (for method chaining). 275 */ 276 public ParserGroupBuilder trimStrings() { 277 return set(PARSER_trimStrings, true); 278 } 279 280 /** 281 * Configuration property: Unbuffered. 282 * 283 * <p> 284 * If <jk>true</jk>, don't use internal buffering during parsing. 285 * 286 * <ul class='seealso'> 287 * <li class='jf'>{@link Parser#PARSER_unbuffered} 288 * </ul> 289 * 290 * @param value 291 * The new value for this property. 292 * <br>The default value is <jk>false</jk>. 293 * @return This object (for method chaining). 294 */ 295 public ParserGroupBuilder unbuffered(boolean value) { 296 return set(PARSER_unbuffered, value); 297 } 298 299 /** 300 * Configuration property: Unbuffered. 301 * 302 * <p> 303 * Shortcut for calling <code>unbuffered(<jk>true</jk>)</code>. 304 * 305 * <ul class='seealso'> 306 * <li class='jf'>{@link Parser#PARSER_unbuffered} 307 * </ul> 308 * 309 * @return This object (for method chaining). 310 */ 311 public ParserGroupBuilder unbuffered() { 312 return set(PARSER_unbuffered, true); 313 } 314 315 /** 316 * Configuration property: File charset. 317 * 318 * <p> 319 * The character set to use for reading <c>Files</c> from the file system. 320 * 321 * <ul class='seealso'> 322 * <li class='jf'>{@link ReaderParser#RPARSER_fileCharset} 323 * </ul> 324 * 325 * @param value 326 * The new value for this property. 327 * <br>The default value is <js>"DEFAULT"</js> which causes the system default to be used. 328 * @return This object (for method chaining). 329 */ 330 public ParserGroupBuilder fileCharset(Charset value) { 331 return set(RPARSER_fileCharset, value); 332 } 333 334 /** 335 * Configuration property: Input stream charset. 336 * 337 * <p> 338 * The character set to use for converting <c>InputStreams</c> and byte arrays to readers. 339 * 340 * <ul class='seealso'> 341 * <li class='jf'>{@link ReaderParser#RPARSER_streamCharset} 342 * </ul> 343 * 344 * @param value 345 * The new value for this property. 346 * <br>The default value is <js>"UTF-8"</js>. 347 * @return This object (for method chaining). 348 */ 349 public ParserGroupBuilder streamCharset(Charset value) { 350 return set(RPARSER_streamCharset, value); 351 } 352 353 /** 354 * Configuration property: Binary input format. 355 * 356 * <p> 357 * When using the {@link Parser#parse(Object,Class)} method on stream-based parsers and the input is a string, this defines the format to use 358 * when converting the string into a byte array. 359 * 360 * <ul class='seealso'> 361 * <li class='jf'>{@link InputStreamParser#ISPARSER_binaryFormat} 362 * </ul> 363 * 364 * @param value 365 * The new value for this property. 366 * <br>The default value is {@link BinaryFormat#HEX}. 367 * @return This object (for method chaining). 368 */ 369 public ParserGroupBuilder binaryFormat(BinaryFormat value) { 370 return set(ISPARSER_binaryFormat, value); 371 } 372 373 // <FluentSetters> 374 375 @Override /* GENERATED - ContextBuilder */ 376 public ParserGroupBuilder add(Map<String,Object> properties) { 377 super.add(properties); 378 return this; 379 } 380 381 @Override /* GENERATED - ContextBuilder */ 382 public ParserGroupBuilder addTo(String name, Object value) { 383 super.addTo(name, value); 384 return this; 385 } 386 387 @Override /* GENERATED - ContextBuilder */ 388 public ParserGroupBuilder appendTo(String name, Object value) { 389 super.appendTo(name, value); 390 return this; 391 } 392 393 @Override /* GENERATED - ContextBuilder */ 394 public ParserGroupBuilder apply(PropertyStore copyFrom) { 395 super.apply(copyFrom); 396 return this; 397 } 398 399 @Override /* GENERATED - ContextBuilder */ 400 public ParserGroupBuilder applyAnnotations(java.lang.Class<?>...fromClasses) { 401 super.applyAnnotations(fromClasses); 402 return this; 403 } 404 405 @Override /* GENERATED - ContextBuilder */ 406 public ParserGroupBuilder applyAnnotations(Method...fromMethods) { 407 super.applyAnnotations(fromMethods); 408 return this; 409 } 410 411 @Override /* GENERATED - ContextBuilder */ 412 public ParserGroupBuilder applyAnnotations(AnnotationList al, VarResolverSession r) { 413 super.applyAnnotations(al, r); 414 return this; 415 } 416 417 @Override /* GENERATED - ContextBuilder */ 418 public ParserGroupBuilder debug() { 419 super.debug(); 420 return this; 421 } 422 423 @Override /* GENERATED - ContextBuilder */ 424 public ParserGroupBuilder locale(Locale value) { 425 super.locale(value); 426 return this; 427 } 428 429 @Override /* GENERATED - ContextBuilder */ 430 public ParserGroupBuilder mediaType(MediaType value) { 431 super.mediaType(value); 432 return this; 433 } 434 435 @Override /* GENERATED - ContextBuilder */ 436 public ParserGroupBuilder prependTo(String name, Object value) { 437 super.prependTo(name, value); 438 return this; 439 } 440 441 @Override /* GENERATED - ContextBuilder */ 442 public ParserGroupBuilder putAllTo(String name, Object value) { 443 super.putAllTo(name, value); 444 return this; 445 } 446 447 @Override /* GENERATED - ContextBuilder */ 448 public ParserGroupBuilder putTo(String name, String key, Object value) { 449 super.putTo(name, key, value); 450 return this; 451 } 452 453 @Override /* GENERATED - ContextBuilder */ 454 public ParserGroupBuilder removeFrom(String name, Object value) { 455 super.removeFrom(name, value); 456 return this; 457 } 458 459 @Override /* GENERATED - ContextBuilder */ 460 public ParserGroupBuilder set(Map<String,Object> properties) { 461 super.set(properties); 462 return this; 463 } 464 465 @Override /* GENERATED - ContextBuilder */ 466 public ParserGroupBuilder set(String name, Object value) { 467 super.set(name, value); 468 return this; 469 } 470 471 @Override /* GENERATED - ContextBuilder */ 472 public ParserGroupBuilder timeZone(TimeZone value) { 473 super.timeZone(value); 474 return this; 475 } 476 477 @Override /* GENERATED - BeanContextBuilder */ 478 public ParserGroupBuilder annotations(Annotation...values) { 479 super.annotations(values); 480 return this; 481 } 482 483 @Override /* GENERATED - BeanContextBuilder */ 484 public ParserGroupBuilder beanClassVisibility(Visibility value) { 485 super.beanClassVisibility(value); 486 return this; 487 } 488 489 @Override /* GENERATED - BeanContextBuilder */ 490 public ParserGroupBuilder beanConstructorVisibility(Visibility value) { 491 super.beanConstructorVisibility(value); 492 return this; 493 } 494 495 @Override /* GENERATED - BeanContextBuilder */ 496 public ParserGroupBuilder beanFieldVisibility(Visibility value) { 497 super.beanFieldVisibility(value); 498 return this; 499 } 500 501 @Override /* GENERATED - BeanContextBuilder */ 502 public ParserGroupBuilder beanInterceptor(Class<?> on, Class<? extends org.apache.juneau.transform.BeanInterceptor<?>> value) { 503 super.beanInterceptor(on, value); 504 return this; 505 } 506 507 @Override /* GENERATED - BeanContextBuilder */ 508 public ParserGroupBuilder beanMapPutReturnsOldValue() { 509 super.beanMapPutReturnsOldValue(); 510 return this; 511 } 512 513 @Override /* GENERATED - BeanContextBuilder */ 514 public ParserGroupBuilder beanMethodVisibility(Visibility value) { 515 super.beanMethodVisibility(value); 516 return this; 517 } 518 519 @Override /* GENERATED - BeanContextBuilder */ 520 public ParserGroupBuilder beansDontRequireSomeProperties() { 521 super.beansDontRequireSomeProperties(); 522 return this; 523 } 524 525 @Override /* GENERATED - BeanContextBuilder */ 526 public ParserGroupBuilder beansRequireDefaultConstructor() { 527 super.beansRequireDefaultConstructor(); 528 return this; 529 } 530 531 @Override /* GENERATED - BeanContextBuilder */ 532 public ParserGroupBuilder beansRequireSerializable() { 533 super.beansRequireSerializable(); 534 return this; 535 } 536 537 @Override /* GENERATED - BeanContextBuilder */ 538 public ParserGroupBuilder beansRequireSettersForGetters() { 539 super.beansRequireSettersForGetters(); 540 return this; 541 } 542 543 @Override /* GENERATED - BeanContextBuilder */ 544 public ParserGroupBuilder bpi(Map<String,Object> values) { 545 super.bpi(values); 546 return this; 547 } 548 549 @Override /* GENERATED - BeanContextBuilder */ 550 public ParserGroupBuilder bpi(Class<?> beanClass, String properties) { 551 super.bpi(beanClass, properties); 552 return this; 553 } 554 555 @Override /* GENERATED - BeanContextBuilder */ 556 public ParserGroupBuilder bpi(String beanClassName, String properties) { 557 super.bpi(beanClassName, properties); 558 return this; 559 } 560 561 @Override /* GENERATED - BeanContextBuilder */ 562 public ParserGroupBuilder bpro(Map<String,Object> values) { 563 super.bpro(values); 564 return this; 565 } 566 567 @Override /* GENERATED - BeanContextBuilder */ 568 public ParserGroupBuilder bpro(Class<?> beanClass, String properties) { 569 super.bpro(beanClass, properties); 570 return this; 571 } 572 573 @Override /* GENERATED - BeanContextBuilder */ 574 public ParserGroupBuilder bpro(String beanClassName, String properties) { 575 super.bpro(beanClassName, properties); 576 return this; 577 } 578 579 @Override /* GENERATED - BeanContextBuilder */ 580 public ParserGroupBuilder bpwo(Map<String,Object> values) { 581 super.bpwo(values); 582 return this; 583 } 584 585 @Override /* GENERATED - BeanContextBuilder */ 586 public ParserGroupBuilder bpwo(Class<?> beanClass, String properties) { 587 super.bpwo(beanClass, properties); 588 return this; 589 } 590 591 @Override /* GENERATED - BeanContextBuilder */ 592 public ParserGroupBuilder bpwo(String beanClassName, String properties) { 593 super.bpwo(beanClassName, properties); 594 return this; 595 } 596 597 @Override /* GENERATED - BeanContextBuilder */ 598 public ParserGroupBuilder bpx(Map<String,Object> values) { 599 super.bpx(values); 600 return this; 601 } 602 603 @Override /* GENERATED - BeanContextBuilder */ 604 public ParserGroupBuilder bpx(Class<?> beanClass, String properties) { 605 super.bpx(beanClass, properties); 606 return this; 607 } 608 609 @Override /* GENERATED - BeanContextBuilder */ 610 public ParserGroupBuilder bpx(String beanClassName, String properties) { 611 super.bpx(beanClassName, properties); 612 return this; 613 } 614 615 @Override /* GENERATED - BeanContextBuilder */ 616 public ParserGroupBuilder dictionary(Object...values) { 617 super.dictionary(values); 618 return this; 619 } 620 621 @Override /* GENERATED - BeanContextBuilder */ 622 public ParserGroupBuilder dictionaryOn(Class<?> on, java.lang.Class<?>...values) { 623 super.dictionaryOn(on, values); 624 return this; 625 } 626 627 @Override /* GENERATED - BeanContextBuilder */ 628 public ParserGroupBuilder dontIgnorePropertiesWithoutSetters() { 629 super.dontIgnorePropertiesWithoutSetters(); 630 return this; 631 } 632 633 @Override /* GENERATED - BeanContextBuilder */ 634 public ParserGroupBuilder dontIgnoreTransientFields() { 635 super.dontIgnoreTransientFields(); 636 return this; 637 } 638 639 @Override /* GENERATED - BeanContextBuilder */ 640 public ParserGroupBuilder dontIgnoreUnknownNullBeanProperties() { 641 super.dontIgnoreUnknownNullBeanProperties(); 642 return this; 643 } 644 645 @Override /* GENERATED - BeanContextBuilder */ 646 public ParserGroupBuilder dontUseInterfaceProxies() { 647 super.dontUseInterfaceProxies(); 648 return this; 649 } 650 651 @Override /* GENERATED - BeanContextBuilder */ 652 public <T> ParserGroupBuilder example(Class<T> pojoClass, T o) { 653 super.example(pojoClass, o); 654 return this; 655 } 656 657 @Override /* GENERATED - BeanContextBuilder */ 658 public <T> ParserGroupBuilder exampleJson(Class<T> pojoClass, String json) { 659 super.exampleJson(pojoClass, json); 660 return this; 661 } 662 663 @Override /* GENERATED - BeanContextBuilder */ 664 public ParserGroupBuilder fluentSetters() { 665 super.fluentSetters(); 666 return this; 667 } 668 669 @Override /* GENERATED - BeanContextBuilder */ 670 public ParserGroupBuilder fluentSetters(Class<?> on) { 671 super.fluentSetters(on); 672 return this; 673 } 674 675 @Override /* GENERATED - BeanContextBuilder */ 676 public ParserGroupBuilder ignoreInvocationExceptionsOnGetters() { 677 super.ignoreInvocationExceptionsOnGetters(); 678 return this; 679 } 680 681 @Override /* GENERATED - BeanContextBuilder */ 682 public ParserGroupBuilder ignoreInvocationExceptionsOnSetters() { 683 super.ignoreInvocationExceptionsOnSetters(); 684 return this; 685 } 686 687 @Override /* GENERATED - BeanContextBuilder */ 688 public ParserGroupBuilder ignoreUnknownBeanProperties() { 689 super.ignoreUnknownBeanProperties(); 690 return this; 691 } 692 693 @Override /* GENERATED - BeanContextBuilder */ 694 public ParserGroupBuilder implClass(Class<?> interfaceClass, Class<?> implClass) { 695 super.implClass(interfaceClass, implClass); 696 return this; 697 } 698 699 @Override /* GENERATED - BeanContextBuilder */ 700 public ParserGroupBuilder implClasses(Map<Class<?>,Class<?>> values) { 701 super.implClasses(values); 702 return this; 703 } 704 705 @Override /* GENERATED - BeanContextBuilder */ 706 public ParserGroupBuilder interfaceClass(Class<?> on, Class<?> value) { 707 super.interfaceClass(on, value); 708 return this; 709 } 710 711 @Override /* GENERATED - BeanContextBuilder */ 712 public ParserGroupBuilder interfaces(java.lang.Class<?>...value) { 713 super.interfaces(value); 714 return this; 715 } 716 717 @Override /* GENERATED - BeanContextBuilder */ 718 public ParserGroupBuilder notBeanClasses(Object...values) { 719 super.notBeanClasses(values); 720 return this; 721 } 722 723 @Override /* GENERATED - BeanContextBuilder */ 724 public ParserGroupBuilder notBeanPackages(Object...values) { 725 super.notBeanPackages(values); 726 return this; 727 } 728 729 @Override /* GENERATED - BeanContextBuilder */ 730 public ParserGroupBuilder propertyNamer(Class<? extends org.apache.juneau.PropertyNamer> value) { 731 super.propertyNamer(value); 732 return this; 733 } 734 735 @Override /* GENERATED - BeanContextBuilder */ 736 public ParserGroupBuilder propertyNamer(Class<?> on, Class<? extends org.apache.juneau.PropertyNamer> value) { 737 super.propertyNamer(on, value); 738 return this; 739 } 740 741 @Override /* GENERATED - BeanContextBuilder */ 742 public ParserGroupBuilder sortProperties() { 743 super.sortProperties(); 744 return this; 745 } 746 747 @Override /* GENERATED - BeanContextBuilder */ 748 public ParserGroupBuilder sortProperties(java.lang.Class<?>...on) { 749 super.sortProperties(on); 750 return this; 751 } 752 753 @Override /* GENERATED - BeanContextBuilder */ 754 public ParserGroupBuilder stopClass(Class<?> on, Class<?> value) { 755 super.stopClass(on, value); 756 return this; 757 } 758 759 @Override /* GENERATED - BeanContextBuilder */ 760 public ParserGroupBuilder swaps(Object...values) { 761 super.swaps(values); 762 return this; 763 } 764 765 @Override /* GENERATED - BeanContextBuilder */ 766 public ParserGroupBuilder typeName(Class<?> on, String value) { 767 super.typeName(on, value); 768 return this; 769 } 770 771 @Override /* GENERATED - BeanContextBuilder */ 772 public ParserGroupBuilder typePropertyName(String value) { 773 super.typePropertyName(value); 774 return this; 775 } 776 777 @Override /* GENERATED - BeanContextBuilder */ 778 public ParserGroupBuilder typePropertyName(Class<?> on, String value) { 779 super.typePropertyName(on, value); 780 return this; 781 } 782 783 @Override /* GENERATED - BeanContextBuilder */ 784 public ParserGroupBuilder useEnumNames() { 785 super.useEnumNames(); 786 return this; 787 } 788 789 @Override /* GENERATED - BeanContextBuilder */ 790 public ParserGroupBuilder useJavaBeanIntrospector() { 791 super.useJavaBeanIntrospector(); 792 return this; 793 } 794 795 // </FluentSetters> 796}