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.internal.CollectionUtils.*; 016import static org.apache.juneau.parser.InputStreamParser.*; 017import static org.apache.juneau.parser.ReaderParser.*; 018 019import java.lang.reflect.*; 020import java.nio.charset.*; 021import java.util.*; 022 023import org.apache.juneau.*; 024import org.apache.juneau.http.*; 025import org.apache.juneau.internal.*; 026import org.apache.juneau.reflect.*; 027import org.apache.juneau.svl.*; 028 029/** 030 * Builder class for creating instances of {@link ParserGroup}. 031 */ 032public class ParserGroupBuilder extends BeanContextBuilder { 033 034 private final List<Object> parsers; 035 036 /** 037 * Create an empty parser group builder. 038 */ 039 public ParserGroupBuilder() { 040 this.parsers = new ArrayList<>(); 041 } 042 043 /** 044 * Clone an existing parser group builder. 045 * 046 * @param copyFrom The parser group that we're copying settings and parsers from. 047 */ 048 public ParserGroupBuilder(ParserGroup copyFrom) { 049 super(copyFrom.getPropertyStore()); 050 this.parsers = new ArrayList<>(); 051 addReverse(parsers, 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 addReverse(parsers, 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 addReverse(parsers, 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 addReverse(parsers, 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 addReverse(parsers, 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 @Override /* BeanContextBuilder */ 374 public ParserGroupBuilder beanClassVisibility(Visibility value) { 375 super.beanClassVisibility(value); 376 return this; 377 } 378 379 @Override /* BeanContextBuilder */ 380 public ParserGroupBuilder beanConstructorVisibility(Visibility value) { 381 super.beanConstructorVisibility(value); 382 return this; 383 } 384 385 @Override /* BeanContextBuilder */ 386 @Deprecated 387 public ParserGroupBuilder beanDictionary(Class<?>...values) { 388 super.beanDictionary(values); 389 return this; 390 } 391 392 @Override /* BeanContextBuilder */ 393 @Deprecated 394 public ParserGroupBuilder beanDictionary(Object...values) { 395 super.beanDictionary(values); 396 return this; 397 } 398 399 @Override /* BeanContextBuilder */ 400 @Deprecated 401 public ParserGroupBuilder beanDictionaryReplace(Class<?>...values) { 402 super.beanDictionaryReplace(values); 403 return this; 404 } 405 406 @Override /* BeanContextBuilder */ 407 @Deprecated 408 public ParserGroupBuilder beanDictionaryReplace(Object...values) { 409 super.beanDictionaryReplace(values); 410 return this; 411 } 412 413 @Override /* BeanContextBuilder */ 414 @Deprecated 415 public ParserGroupBuilder beanDictionaryRemove(Class<?>...values) { 416 super.beanDictionaryRemove(values); 417 return this; 418 } 419 420 @Override /* BeanContextBuilder */ 421 @Deprecated 422 public ParserGroupBuilder beanDictionaryRemove(Object...values) { 423 super.beanDictionaryRemove(values); 424 return this; 425 } 426 427 @Override /* BeanContextBuilder */ 428 public ParserGroupBuilder beanFieldVisibility(Visibility value) { 429 super.beanFieldVisibility(value); 430 return this; 431 } 432 433 @Override /* BeanContextBuilder */ 434 public ParserGroupBuilder beanFilters(Class<?>...values) { 435 super.beanFilters(values); 436 return this; 437 } 438 439 @Override /* BeanContextBuilder */ 440 public ParserGroupBuilder beanFilters(Object...values) { 441 super.beanFilters(values); 442 return this; 443 } 444 445 @Override /* BeanContextBuilder */ 446 public ParserGroupBuilder beanFiltersReplace(Class<?>...values) { 447 super.beanFiltersReplace(values); 448 return this; 449 } 450 451 @Override /* BeanContextBuilder */ 452 public ParserGroupBuilder beanFiltersReplace(Object...values) { 453 super.beanFiltersReplace(values); 454 return this; 455 } 456 457 @Override /* BeanContextBuilder */ 458 public ParserGroupBuilder beanFiltersRemove(Class<?>...values) { 459 super.beanFiltersRemove(values); 460 return this; 461 } 462 463 @Override /* BeanContextBuilder */ 464 public ParserGroupBuilder beanFiltersRemove(Object...values) { 465 super.beanFiltersRemove(values); 466 return this; 467 } 468 469 @Override /* BeanContextBuilder */ 470 public ParserGroupBuilder beanMapPutReturnsOldValue(boolean value) { 471 super.beanMapPutReturnsOldValue(value); 472 return this; 473 } 474 475 @Override /* BeanContextBuilder */ 476 public ParserGroupBuilder beanMapPutReturnsOldValue() { 477 super.beanMapPutReturnsOldValue(); 478 return this; 479 } 480 481 @Override /* BeanContextBuilder */ 482 public ParserGroupBuilder beanMethodVisibility(Visibility value) { 483 super.beanMethodVisibility(value); 484 return this; 485 } 486 487 @Override /* BeanContextBuilder */ 488 public ParserGroupBuilder beansRequireDefaultConstructor(boolean value) { 489 super.beansRequireDefaultConstructor(value); 490 return this; 491 } 492 493 @Override /* BeanContextBuilder */ 494 public ParserGroupBuilder beansRequireDefaultConstructor() { 495 super.beansRequireDefaultConstructor(); 496 return this; 497 } 498 499 @Override /* BeanContextBuilder */ 500 public ParserGroupBuilder beansRequireSerializable(boolean value) { 501 super.beansRequireSerializable(value); 502 return this; 503 } 504 505 @Override /* BeanContextBuilder */ 506 public ParserGroupBuilder beansRequireSerializable() { 507 super.beansRequireSerializable(); 508 return this; 509 } 510 511 @Override /* BeanContextBuilder */ 512 public ParserGroupBuilder beansRequireSettersForGetters(boolean value) { 513 super.beansRequireSettersForGetters(value); 514 return this; 515 } 516 517 @Override /* BeanContextBuilder */ 518 public ParserGroupBuilder beansRequireSettersForGetters() { 519 super.beansRequireSettersForGetters(); 520 return this; 521 } 522 523 @Override /* BeanContextBuilder */ 524 public ParserGroupBuilder beansRequireSomeProperties(boolean value) { 525 super.beansRequireSomeProperties(value); 526 return this; 527 } 528 529 @Override /* BeanContextBuilder */ 530 public ParserGroupBuilder beanTypePropertyName(String value) { 531 super.beanTypePropertyName(value); 532 return this; 533 } 534 535 @Override /* BeanContextBuilder */ 536 public ParserGroupBuilder bpi(Class<?> beanClass, String value) { 537 super.bpi(beanClass, value); 538 return this; 539 } 540 541 @Override /* BeanContextBuilder */ 542 public ParserGroupBuilder bpi(Map<String,String> values) { 543 super.bpi(values); 544 return this; 545 } 546 547 @Override /* BeanContextBuilder */ 548 public ParserGroupBuilder bpi(String beanClassName, String value) { 549 super.bpi(beanClassName, value); 550 return this; 551 } 552 553 @Override /* BeanContextBuilder */ 554 public ParserGroupBuilder bpx(Class<?> beanClass, String properties) { 555 super.bpx(beanClass, properties); 556 return this; 557 } 558 559 @Override /* BeanContextBuilder */ 560 public ParserGroupBuilder bpx(Map<String,String> values) { 561 super.bpx(values); 562 return this; 563 } 564 565 @Override /* BeanContextBuilder */ 566 public ParserGroupBuilder bpx(String beanClassName, String value) { 567 super.bpx(beanClassName, value); 568 return this; 569 } 570 571 @Override /* BeanContextBuilder */ 572 public ParserGroupBuilder bpro(Class<?> beanClass, String value) { 573 super.bpro(beanClass, value); 574 return this; 575 } 576 577 @Override /* BeanContextBuilder */ 578 public ParserGroupBuilder bpro(Map<String,String> values) { 579 super.bpro(values); 580 return this; 581 } 582 583 @Override /* BeanContextBuilder */ 584 public ParserGroupBuilder bpro(String beanClassName, String value) { 585 super.bpro(beanClassName, value); 586 return this; 587 } 588 589 @Override /* BeanContextBuilder */ 590 public ParserGroupBuilder bpwo(Class<?> beanClass, String properties) { 591 super.bpwo(beanClass, properties); 592 return this; 593 } 594 595 @Override /* BeanContextBuilder */ 596 public ParserGroupBuilder bpwo(Map<String,String> values) { 597 super.bpwo(values); 598 return this; 599 } 600 601 @Override /* BeanContextBuilder */ 602 public ParserGroupBuilder bpwo(String beanClassName, String value) { 603 super.bpwo(beanClassName, value); 604 return this; 605 } 606 607 @Override /* BeanContextBuilder */ 608 public ParserGroupBuilder debug() { 609 super.debug(); 610 return this; 611 } 612 613 @Override /* BeanContextBuilder */ 614 public ParserGroupBuilder dictionary(Class<?>...values) { 615 super.dictionary(values); 616 return this; 617 } 618 619 @Override /* BeanContextBuilder */ 620 public ParserGroupBuilder dictionary(Object...values) { 621 super.dictionary(values); 622 return this; 623 } 624 625 @Override /* BeanContextBuilder */ 626 public ParserGroupBuilder dictionaryReplace(Class<?>...values) { 627 super.dictionaryReplace(values); 628 return this; 629 } 630 631 @Override /* BeanContextBuilder */ 632 public ParserGroupBuilder dictionaryReplace(Object...values) { 633 super.dictionaryReplace(values); 634 return this; 635 } 636 637 @Override /* BeanContextBuilder */ 638 public ParserGroupBuilder dictionaryRemove(Class<?>...values) { 639 super.dictionaryRemove(values); 640 return this; 641 } 642 643 @Override /* BeanContextBuilder */ 644 public ParserGroupBuilder dictionaryRemove(Object...values) { 645 super.dictionaryRemove(values); 646 return this; 647 } 648 649 @Override /* BeanContextBuilder */ 650 public <T> ParserGroupBuilder example(Class<T> c, T o) { 651 super.example(c, o); 652 return this; 653 } 654 655 @Override /* BeanContextBuilder */ 656 public <T> ParserGroupBuilder exampleJson(Class<T> c, String value) { 657 super.exampleJson(c, value); 658 return this; 659 } 660 661 @Override /* BeanContextBuilder */ 662 public ParserGroupBuilder ignoreInvocationExceptionsOnGetters(boolean value) { 663 super.ignoreInvocationExceptionsOnGetters(value); 664 return this; 665 } 666 667 @Override /* BeanContextBuilder */ 668 public ParserGroupBuilder ignoreInvocationExceptionsOnGetters() { 669 super.ignoreInvocationExceptionsOnGetters(); 670 return this; 671 } 672 673 @Override /* BeanContextBuilder */ 674 public ParserGroupBuilder ignoreInvocationExceptionsOnSetters(boolean value) { 675 super.ignoreInvocationExceptionsOnSetters(value); 676 return this; 677 } 678 679 @Override /* BeanContextBuilder */ 680 public ParserGroupBuilder ignoreInvocationExceptionsOnSetters() { 681 super.ignoreInvocationExceptionsOnSetters(); 682 return this; 683 } 684 685 @Override /* BeanContextBuilder */ 686 public ParserGroupBuilder ignorePropertiesWithoutSetters(boolean value) { 687 super.ignorePropertiesWithoutSetters(value); 688 return this; 689 } 690 691 @Override /* BeanContextBuilder */ 692 public ParserGroupBuilder ignoreUnknownBeanProperties(boolean value) { 693 super.ignoreUnknownBeanProperties(value); 694 return this; 695 } 696 697 @Override /* BeanContextBuilder */ 698 public ParserGroupBuilder ignoreUnknownBeanProperties() { 699 super.ignoreUnknownBeanProperties(); 700 return this; 701 } 702 703 @Override /* BeanContextBuilder */ 704 public ParserGroupBuilder ignoreUnknownNullBeanProperties(boolean value) { 705 super.ignoreUnknownNullBeanProperties(value); 706 return this; 707 } 708 709 @Override /* BeanContextBuilder */ 710 public ParserGroupBuilder implClass(Class<?> interfaceClass, Class<?> implClass) { 711 super.implClass(interfaceClass, implClass); 712 return this; 713 } 714 715 @Override /* BeanContextBuilder */ 716 public ParserGroupBuilder implClasses(Map<String,Class<?>> values) { 717 super.implClasses(values); 718 return this; 719 } 720 721 @Override /* BeanContextBuilder */ 722 public ParserGroupBuilder locale(Locale value) { 723 super.locale(value); 724 return this; 725 } 726 727 @Override /* BeanContextBuilder */ 728 public ParserGroupBuilder mediaType(MediaType value) { 729 super.mediaType(value); 730 return this; 731 } 732 733 @Override /* BeanContextBuilder */ 734 public ParserGroupBuilder notBeanClasses(Class<?>...values) { 735 super.notBeanClasses(values); 736 return this; 737 } 738 739 @Override /* BeanContextBuilder */ 740 public ParserGroupBuilder notBeanClasses(Object...values) { 741 super.notBeanClasses(values); 742 return this; 743 } 744 745 @Override /* BeanContextBuilder */ 746 public ParserGroupBuilder notBeanClassesReplace(Class<?>...values) { 747 super.notBeanClassesReplace(values); 748 return this; 749 } 750 751 @Override /* BeanContextBuilder */ 752 public ParserGroupBuilder notBeanClassesReplace(Object...values) { 753 super.notBeanClassesReplace(values); 754 return this; 755 } 756 757 @Override /* BeanContextBuilder */ 758 public ParserGroupBuilder notBeanClassesRemove(Class<?>...values) { 759 super.notBeanClassesRemove(values); 760 return this; 761 } 762 763 @Override /* BeanContextBuilder */ 764 public ParserGroupBuilder notBeanClassesRemove(Object...values) { 765 super.notBeanClassesRemove(values); 766 return this; 767 } 768 769 @Override /* BeanContextBuilder */ 770 public ParserGroupBuilder notBeanPackages(Object...values) { 771 super.notBeanPackages(values); 772 return this; 773 } 774 775 @Override /* BeanContextBuilder */ 776 public ParserGroupBuilder notBeanPackages(String...values) { 777 super.notBeanPackages(values); 778 return this; 779 } 780 781 @Override /* BeanContextBuilder */ 782 public ParserGroupBuilder notBeanPackagesReplace(String...values) { 783 super.notBeanPackagesReplace(values); 784 return this; 785 } 786 787 @Override /* BeanContextBuilder */ 788 public ParserGroupBuilder notBeanPackagesReplace(Object...values) { 789 super.notBeanPackagesReplace(values); 790 return this; 791 } 792 793 @Override /* BeanContextBuilder */ 794 public ParserGroupBuilder notBeanPackagesRemove(String...values) { 795 super.notBeanPackagesRemove(values); 796 return this; 797 } 798 799 @Override /* BeanContextBuilder */ 800 public ParserGroupBuilder notBeanPackagesRemove(Object...values) { 801 super.notBeanPackagesRemove(values); 802 return this; 803 } 804 805 @Override /* BeanContextBuilder */ 806 public ParserGroupBuilder pojoSwaps(Class<?>...values) { 807 super.pojoSwaps(values); 808 return this; 809 } 810 811 @Override /* BeanContextBuilder */ 812 public ParserGroupBuilder pojoSwaps(Object...values) { 813 super.pojoSwaps(values); 814 return this; 815 } 816 817 @Override /* BeanContextBuilder */ 818 public ParserGroupBuilder pojoSwapsReplace(Class<?>...values) { 819 super.pojoSwapsReplace(values); 820 return this; 821 } 822 823 @Override /* BeanContextBuilder */ 824 public ParserGroupBuilder pojoSwapsReplace(Object...values) { 825 super.pojoSwapsReplace(values); 826 return this; 827 } 828 829 @Override /* BeanContextBuilder */ 830 public ParserGroupBuilder pojoSwapsRemove(Class<?>...values) { 831 super.pojoSwapsRemove(values); 832 return this; 833 } 834 835 @Override /* BeanContextBuilder */ 836 public ParserGroupBuilder pojoSwapsRemove(Object...values) { 837 super.pojoSwapsRemove(values); 838 return this; 839 } 840 841 @Override /* BeanContextBuilder */ 842 public ParserGroupBuilder sortProperties(boolean value) { 843 super.sortProperties(value); 844 return this; 845 } 846 847 @Override /* BeanContextBuilder */ 848 public ParserGroupBuilder sortProperties() { 849 super.sortProperties(); 850 return this; 851 } 852 853 @Override /* BeanContextBuilder */ 854 public ParserGroupBuilder timeZone(TimeZone value) { 855 super.timeZone(value); 856 return this; 857 } 858 859 @Override /* BeanContextBuilder */ 860 public ParserGroupBuilder useEnumNames(boolean value) { 861 super.useEnumNames(value); 862 return this; 863 } 864 865 @Override /* BeanContextBuilder */ 866 public ParserGroupBuilder useEnumNames() { 867 super.useEnumNames(); 868 return this; 869 } 870 871 @Override /* BeanContextBuilder */ 872 public ParserGroupBuilder useInterfaceProxies(boolean value) { 873 super.useInterfaceProxies(value); 874 return this; 875 } 876 877 @Override /* BeanContextBuilder */ 878 public ParserGroupBuilder useJavaBeanIntrospector(boolean value) { 879 super.useJavaBeanIntrospector(value); 880 return this; 881 } 882 883 @Override /* BeanContextBuilder */ 884 public ParserGroupBuilder useJavaBeanIntrospector() { 885 super.useJavaBeanIntrospector(); 886 return this; 887 } 888 889 @Override /* ContextBuilder */ 890 public ParserGroupBuilder set(String name, Object value) { 891 super.set(name, value); 892 return this; 893 } 894 895 @Override /* ContextBuilder */ 896 public ParserGroupBuilder set(Map<String,Object> properties) { 897 super.set(properties); 898 return this; 899 } 900 901 @Override /* ContextBuilder */ 902 public ParserGroupBuilder add(Map<String,Object> properties) { 903 super.add(properties); 904 return this; 905 } 906 907 @Override /* ContextBuilder */ 908 public ParserGroupBuilder addTo(String name, Object value) { 909 super.addTo(name, value); 910 return this; 911 } 912 913 @Override /* ContextBuilder */ 914 public ParserGroupBuilder addTo(String name, String key, Object value) { 915 super.addTo(name, key, value); 916 return this; 917 } 918 919 @Override /* ContextBuilder */ 920 public ParserGroupBuilder removeFrom(String name, Object value) { 921 super.removeFrom(name, value); 922 return this; 923 } 924 925 @Override /* ContextBuilder */ 926 public ParserGroupBuilder apply(PropertyStore copyFrom) { 927 super.apply(copyFrom); 928 return this; 929 } 930 931 @Override /* ContextBuilder */ 932 public ParserGroupBuilder applyAnnotations(AnnotationList al, VarResolverSession vrs) { 933 super.applyAnnotations(al, vrs); 934 return this; 935 } 936 937 @Override /* ContextBuilder */ 938 public ParserGroupBuilder applyAnnotations(Class<?> fromClass) { 939 super.applyAnnotations(fromClass); 940 return this; 941 } 942 943 @Override /* ContextBuilder */ 944 public ParserGroupBuilder applyAnnotations(Method fromMethod) { 945 super.applyAnnotations(fromMethod); 946 return this; 947 } 948}