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.Parser.*; 016 017import java.lang.annotation.*; 018import java.lang.reflect.*; 019import java.util.*; 020 021import org.apache.juneau.*; 022import org.apache.juneau.http.*; 023import org.apache.juneau.reflect.*; 024import org.apache.juneau.svl.*; 025 026/** 027 * Builder class for building instances of parsers. 028 */ 029public class ParserBuilder extends BeanContextBuilder { 030 031 /** 032 * Constructor, default settings. 033 */ 034 public ParserBuilder() { 035 super(); 036 } 037 038 /** 039 * Constructor. 040 * 041 * @param ps The initial configuration settings for this builder. 042 */ 043 public ParserBuilder(PropertyStore ps) { 044 super(ps); 045 } 046 047 //----------------------------------------------------------------------------------------------------------------- 048 // Properties 049 //----------------------------------------------------------------------------------------------------------------- 050 051 /** 052 * Configuration property: Auto-close streams. 053 * 054 * <p> 055 * If <jk>true</jk>, <l>InputStreams</l> and <l>Readers</l> passed into parsers will be closed 056 * after parsing is complete. 057 * 058 * <ul class='seealso'> 059 * <li class='jf'>{@link Parser#PARSER_autoCloseStreams} 060 * </ul> 061 * 062 * @param value 063 * The new value for this property. 064 * <br>The default value is <jk>false</jk>. 065 * @return This object (for method chaining). 066 */ 067 public ParserBuilder autoCloseStreams(boolean value) { 068 return set(PARSER_autoCloseStreams, value); 069 } 070 071 /** 072 * Configuration property: Auto-close streams. 073 * 074 * <p> 075 * Shortcut for calling <code>autoCloseStreams(<jk>true</jk>)</code>. 076 * 077 * <ul class='seealso'> 078 * <li class='jf'>{@link Parser#PARSER_autoCloseStreams} 079 * </ul> 080 * 081 * @return This object (for method chaining). 082 */ 083 public ParserBuilder autoCloseStreams() { 084 return set(PARSER_autoCloseStreams, true); 085 } 086 087 /** 088 * Configuration property: Debug output lines. 089 * 090 * <p> 091 * When parse errors occur, this specifies the number of lines of input before and after the 092 * error location to be printed as part of the exception message. 093 * 094 * <ul class='seealso'> 095 * <li class='jf'>{@link Parser#PARSER_debugOutputLines} 096 * </ul> 097 * 098 * @param value 099 * The new value for this property. 100 * <br>The default value is <c>5</c>. 101 * @return This object (for method chaining). 102 */ 103 public ParserBuilder debugOutputLines(int value) { 104 return set(PARSER_debugOutputLines, value); 105 } 106 107 /** 108 * Configuration property: Parser listener. 109 * 110 * <p> 111 * Class used to listen for errors and warnings that occur during parsing. 112 * 113 * <ul class='seealso'> 114 * <li class='jf'>{@link Parser#PARSER_listener} 115 * </ul> 116 * 117 * @param value The new value for this property. 118 * @return This object (for method chaining). 119 */ 120 public ParserBuilder listener(Class<? extends ParserListener> value) { 121 return set(PARSER_listener, value); 122 } 123 124 /** 125 * Configuration property: Strict mode. 126 * 127 * <p> 128 * If <jk>true</jk>, strict mode for the parser is enabled. 129 * 130 * <ul class='seealso'> 131 * <li class='jf'>{@link Parser#PARSER_strict} 132 * </ul> 133 * 134 * @param value 135 * The new value for this property. 136 * <br>The default value is <jk>false</jk>. 137 * @return This object (for method chaining). 138 */ 139 public ParserBuilder strict(boolean value) { 140 return set(PARSER_strict, value); 141 } 142 143 /** 144 * Configuration property: Strict mode. 145 * 146 * <p> 147 * Shortcut for calling <code>strict(<jk>true</jk>)</code>. 148 * 149 * <ul class='seealso'> 150 * <li class='jf'>{@link Parser#PARSER_strict} 151 * </ul> 152 * 153 * @return This object (for method chaining). 154 */ 155 public ParserBuilder strict() { 156 return set(PARSER_strict, true); 157 } 158 159 /** 160 * Configuration property: Trim parsed strings. 161 * 162 * <p> 163 * If <jk>true</jk>, string values will be trimmed of whitespace using {@link String#trim()} before being added to 164 * the POJO. 165 * 166 * <ul class='seealso'> 167 * <li class='jf'>{@link Parser#PARSER_trimStrings} 168 * </ul> 169 * 170 * @param value 171 * The new value for this property. 172 * <br>The default value is <jk>false</jk>. 173 * @return This object (for method chaining). 174 */ 175 public ParserBuilder trimStrings(boolean value) { 176 return set(PARSER_trimStrings, value); 177 } 178 179 /** 180 * Configuration property: Trim parsed strings. 181 * 182 * <p> 183 * Shortcut for calling <code>trimStrings(<jk>true</jk>)</code>. 184 * 185 * <ul class='seealso'> 186 * <li class='jf'>{@link Parser#PARSER_trimStrings} 187 * </ul> 188 * 189 * @return This object (for method chaining). 190 */ 191 public ParserBuilder trimStrings() { 192 return set(PARSER_trimStrings, true); 193 } 194 195 /** 196 * Configuration property: Unbuffered. 197 * 198 * <p> 199 * If <jk>true</jk>, don't use internal buffering during parsing. 200 * 201 * <ul class='seealso'> 202 * <li class='jf'>{@link Parser#PARSER_unbuffered} 203 * </ul> 204 * 205 * @param value 206 * The new value for this property. 207 * <br>The default value is <jk>false</jk>. 208 * @return This object (for method chaining). 209 */ 210 public ParserBuilder unbuffered(boolean value) { 211 return set(PARSER_unbuffered, value); 212 } 213 214 /** 215 * Configuration property: Unbuffered. 216 * 217 * <p> 218 * Shortcut for calling <code>unbuffered(<jk>true</jk>)</code>. 219 * 220 * <ul class='seealso'> 221 * <li class='jf'>{@link Parser#PARSER_unbuffered} 222 * </ul> 223 * 224 * @return This object (for method chaining). 225 */ 226 public ParserBuilder unbuffered() { 227 return set(PARSER_unbuffered, true); 228 } 229 230 @Override /* BeanContextBuilder */ 231 public ParserBuilder annotations(Annotation...values) { 232 super.annotations(values); 233 return this; 234 } 235 236 @Override /* BeanContextBuilder */ 237 public ParserBuilder beanClassVisibility(Visibility value) { 238 super.beanClassVisibility(value); 239 return this; 240 } 241 242 @Override /* BeanContextBuilder */ 243 public ParserBuilder beanConstructorVisibility(Visibility value) { 244 super.beanConstructorVisibility(value); 245 return this; 246 } 247 248 @Override /* BeanContextBuilder */ 249 @Deprecated 250 public ParserBuilder beanDictionary(Class<?>...values) { 251 super.beanDictionary(values); 252 return this; 253 } 254 255 @Override /* BeanContextBuilder */ 256 @Deprecated 257 public ParserBuilder beanDictionary(Object...values) { 258 super.beanDictionary(values); 259 return this; 260 } 261 262 @Override /* BeanContextBuilder */ 263 @Deprecated 264 public ParserBuilder beanDictionaryReplace(Class<?>...values) { 265 super.beanDictionaryReplace(values); 266 return this; 267 } 268 269 @Override /* BeanContextBuilder */ 270 @Deprecated 271 public ParserBuilder beanDictionaryReplace(Object...values) { 272 super.beanDictionaryReplace(values); 273 return this; 274 } 275 276 @Override /* BeanContextBuilder */ 277 @Deprecated 278 public ParserBuilder beanDictionaryRemove(Class<?>...values) { 279 super.beanDictionaryRemove(values); 280 return this; 281 } 282 283 @Override /* BeanContextBuilder */ 284 @Deprecated 285 public ParserBuilder beanDictionaryRemove(Object...values) { 286 super.beanDictionaryRemove(values); 287 return this; 288 } 289 290 @Override /* BeanContextBuilder */ 291 public ParserBuilder beanFieldVisibility(Visibility value) { 292 super.beanFieldVisibility(value); 293 return this; 294 } 295 296 @Override /* BeanContextBuilder */ 297 public ParserBuilder beanFilters(Class<?>...values) { 298 super.beanFilters(values); 299 return this; 300 } 301 302 @Override /* BeanContextBuilder */ 303 public ParserBuilder beanFilters(Object...values) { 304 super.beanFilters(values); 305 return this; 306 } 307 308 @Override /* BeanContextBuilder */ 309 public ParserBuilder beanFiltersReplace(Class<?>...values) { 310 super.beanFiltersReplace(values); 311 return this; 312 } 313 314 @Override /* BeanContextBuilder */ 315 public ParserBuilder beanFiltersReplace(Object...values) { 316 super.beanFiltersReplace(values); 317 return this; 318 } 319 320 @Override /* BeanContextBuilder */ 321 public ParserBuilder beanFiltersRemove(Class<?>...values) { 322 super.beanFiltersRemove(values); 323 return this; 324 } 325 326 @Override /* BeanContextBuilder */ 327 public ParserBuilder beanFiltersRemove(Object...values) { 328 super.beanFiltersRemove(values); 329 return this; 330 } 331 332 @Override /* BeanContextBuilder */ 333 public ParserBuilder beanMapPutReturnsOldValue(boolean value) { 334 super.beanMapPutReturnsOldValue(value); 335 return this; 336 } 337 338 @Override /* BeanContextBuilder */ 339 public ParserBuilder beanMapPutReturnsOldValue() { 340 super.beanMapPutReturnsOldValue(); 341 return this; 342 } 343 344 @Override /* BeanContextBuilder */ 345 public ParserBuilder beanMethodVisibility(Visibility value) { 346 super.beanMethodVisibility(value); 347 return this; 348 } 349 350 @Override /* BeanContextBuilder */ 351 public ParserBuilder beansRequireDefaultConstructor(boolean value) { 352 super.beansRequireDefaultConstructor(value); 353 return this; 354 } 355 356 @Override /* BeanContextBuilder */ 357 public ParserBuilder beansRequireDefaultConstructor() { 358 super.beansRequireDefaultConstructor(); 359 return this; 360 } 361 362 @Override /* BeanContextBuilder */ 363 public ParserBuilder beansRequireSerializable(boolean value) { 364 super.beansRequireSerializable(value); 365 return this; 366 } 367 368 @Override /* BeanContextBuilder */ 369 public ParserBuilder beansRequireSerializable() { 370 super.beansRequireSerializable(); 371 return this; 372 } 373 374 @Override /* BeanContextBuilder */ 375 public ParserBuilder beansRequireSettersForGetters(boolean value) { 376 super.beansRequireSettersForGetters(value); 377 return this; 378 } 379 380 @Override /* BeanContextBuilder */ 381 public ParserBuilder beansRequireSettersForGetters() { 382 super.beansRequireSettersForGetters(); 383 return this; 384 } 385 386 @Override /* BeanContextBuilder */ 387 public ParserBuilder beansRequireSomeProperties(boolean value) { 388 super.beansRequireSomeProperties(value); 389 return this; 390 } 391 392 @Override /* BeanContextBuilder */ 393 public ParserBuilder beanTypePropertyName(String value) { 394 super.beanTypePropertyName(value); 395 return this; 396 } 397 398 @Override /* BeanContextBuilder */ 399 public ParserBuilder bpi(Class<?> beanClass, String value) { 400 super.bpi(beanClass, value); 401 return this; 402 } 403 404 @Override /* BeanContextBuilder */ 405 public ParserBuilder bpi(Map<String,String> values) { 406 super.bpi(values); 407 return this; 408 } 409 410 @Override /* BeanContextBuilder */ 411 public ParserBuilder bpi(String beanClassName, String value) { 412 super.bpi(beanClassName, value); 413 return this; 414 } 415 416 @Override /* BeanContextBuilder */ 417 public ParserBuilder bpx(Class<?> beanClass, String properties) { 418 super.bpx(beanClass, properties); 419 return this; 420 } 421 422 @Override /* BeanContextBuilder */ 423 public ParserBuilder bpx(Map<String,String> values) { 424 super.bpx(values); 425 return this; 426 } 427 428 @Override /* BeanContextBuilder */ 429 public ParserBuilder bpx(String beanClassName, String value) { 430 super.bpx(beanClassName, value); 431 return this; 432 } 433 434 @Override /* BeanContextBuilder */ 435 public ParserBuilder bpro(Class<?> beanClass, String value) { 436 super.bpro(beanClass, value); 437 return this; 438 } 439 440 @Override /* BeanContextBuilder */ 441 public ParserBuilder bpro(Map<String,String> values) { 442 super.bpro(values); 443 return this; 444 } 445 446 @Override /* BeanContextBuilder */ 447 public ParserBuilder bpro(String beanClassName, String value) { 448 super.bpro(beanClassName, value); 449 return this; 450 } 451 452 @Override /* BeanContextBuilder */ 453 public ParserBuilder bpwo(Class<?> beanClass, String properties) { 454 super.bpwo(beanClass, properties); 455 return this; 456 } 457 458 @Override /* BeanContextBuilder */ 459 public ParserBuilder bpwo(Map<String,String> values) { 460 super.bpwo(values); 461 return this; 462 } 463 464 @Override /* BeanContextBuilder */ 465 public ParserBuilder bpwo(String beanClassName, String value) { 466 super.bpwo(beanClassName, value); 467 return this; 468 } 469 470 @Override /* BeanContextBuilder */ 471 public ParserBuilder debug() { 472 super.debug(); 473 return this; 474 } 475 476 @Override /* BeanContextBuilder */ 477 public ParserBuilder dictionary(Class<?>...values) { 478 super.dictionary(values); 479 return this; 480 } 481 482 @Override /* BeanContextBuilder */ 483 public ParserBuilder dictionary(Object...values) { 484 super.dictionary(values); 485 return this; 486 } 487 488 @Override /* BeanContextBuilder */ 489 public ParserBuilder dictionaryReplace(Class<?>...values) { 490 super.dictionaryReplace(values); 491 return this; 492 } 493 494 @Override /* BeanContextBuilder */ 495 public ParserBuilder dictionaryReplace(Object...values) { 496 super.dictionaryReplace(values); 497 return this; 498 } 499 500 @Override /* BeanContextBuilder */ 501 public ParserBuilder dictionaryRemove(Class<?>...values) { 502 super.dictionaryRemove(values); 503 return this; 504 } 505 506 @Override /* BeanContextBuilder */ 507 public ParserBuilder dictionaryRemove(Object...values) { 508 super.dictionaryRemove(values); 509 return this; 510 } 511 512 @Override /* BeanContextBuilder */ 513 public <T> ParserBuilder example(Class<T> c, T o) { 514 super.example(c, o); 515 return this; 516 } 517 518 @Override /* BeanContextBuilder */ 519 public <T> ParserBuilder exampleJson(Class<T> c, String value) { 520 super.exampleJson(c, value); 521 return this; 522 } 523 524 @Override /* BeanContextBuilder */ 525 public ParserBuilder ignoreInvocationExceptionsOnGetters(boolean value) { 526 super.ignoreInvocationExceptionsOnGetters(value); 527 return this; 528 } 529 530 @Override /* BeanContextBuilder */ 531 public ParserBuilder ignoreInvocationExceptionsOnGetters() { 532 super.ignoreInvocationExceptionsOnGetters(); 533 return this; 534 } 535 536 @Override /* BeanContextBuilder */ 537 public ParserBuilder ignoreInvocationExceptionsOnSetters(boolean value) { 538 super.ignoreInvocationExceptionsOnSetters(value); 539 return this; 540 } 541 542 @Override /* BeanContextBuilder */ 543 public ParserBuilder ignoreInvocationExceptionsOnSetters() { 544 super.ignoreInvocationExceptionsOnSetters(); 545 return this; 546 } 547 548 @Override /* BeanContextBuilder */ 549 public ParserBuilder ignorePropertiesWithoutSetters(boolean value) { 550 super.ignorePropertiesWithoutSetters(value); 551 return this; 552 } 553 554 @Override /* BeanContextBuilder */ 555 public ParserBuilder ignoreUnknownBeanProperties(boolean value) { 556 super.ignoreUnknownBeanProperties(value); 557 return this; 558 } 559 560 @Override /* BeanContextBuilder */ 561 public ParserBuilder ignoreUnknownBeanProperties() { 562 super.ignoreUnknownBeanProperties(); 563 return this; 564 } 565 566 @Override /* BeanContextBuilder */ 567 public ParserBuilder ignoreUnknownNullBeanProperties(boolean value) { 568 super.ignoreUnknownNullBeanProperties(value); 569 return this; 570 } 571 572 @Override /* BeanContextBuilder */ 573 public ParserBuilder implClass(Class<?> interfaceClass, Class<?> implClass) { 574 super.implClass(interfaceClass, implClass); 575 return this; 576 } 577 578 @Override /* BeanContextBuilder */ 579 public ParserBuilder implClasses(Map<String,Class<?>> values) { 580 super.implClasses(values); 581 return this; 582 } 583 584 @Override /* BeanContextBuilder */ 585 public ParserBuilder locale(Locale value) { 586 super.locale(value); 587 return this; 588 } 589 590 @Override /* BeanContextBuilder */ 591 public ParserBuilder mediaType(MediaType value) { 592 super.mediaType(value); 593 return this; 594 } 595 596 @Override /* BeanContextBuilder */ 597 public ParserBuilder notBeanClasses(Class<?>...values) { 598 super.notBeanClasses(values); 599 return this; 600 } 601 602 @Override /* BeanContextBuilder */ 603 public ParserBuilder notBeanClasses(Object...values) { 604 super.notBeanClasses(values); 605 return this; 606 } 607 608 @Override /* BeanContextBuilder */ 609 public ParserBuilder notBeanClassesReplace(Class<?>...values) { 610 super.notBeanClassesReplace(values); 611 return this; 612 } 613 614 @Override /* BeanContextBuilder */ 615 public ParserBuilder notBeanClassesReplace(Object...values) { 616 super.notBeanClassesReplace(values); 617 return this; 618 } 619 620 @Override /* BeanContextBuilder */ 621 public ParserBuilder notBeanClassesRemove(Class<?>...values) { 622 super.notBeanClassesRemove(values); 623 return this; 624 } 625 626 @Override /* BeanContextBuilder */ 627 public ParserBuilder notBeanClassesRemove(Object...values) { 628 super.notBeanClassesRemove(values); 629 return this; 630 } 631 632 @Override /* BeanContextBuilder */ 633 public ParserBuilder notBeanPackages(Object...values) { 634 super.notBeanPackages(values); 635 return this; 636 } 637 638 @Override /* BeanContextBuilder */ 639 public ParserBuilder notBeanPackages(String...values) { 640 super.notBeanPackages(values); 641 return this; 642 } 643 644 @Override /* BeanContextBuilder */ 645 public ParserBuilder notBeanPackagesReplace(String...values) { 646 super.notBeanPackagesReplace(values); 647 return this; 648 } 649 650 @Override /* BeanContextBuilder */ 651 public ParserBuilder notBeanPackagesReplace(Object...values) { 652 super.notBeanPackagesReplace(values); 653 return this; 654 } 655 656 @Override /* BeanContextBuilder */ 657 public ParserBuilder notBeanPackagesRemove(String...values) { 658 super.notBeanPackagesRemove(values); 659 return this; 660 } 661 662 @Override /* BeanContextBuilder */ 663 public ParserBuilder notBeanPackagesRemove(Object...values) { 664 super.notBeanPackagesRemove(values); 665 return this; 666 } 667 668 @Override /* BeanContextBuilder */ 669 public ParserBuilder pojoSwaps(Class<?>...values) { 670 super.pojoSwaps(values); 671 return this; 672 } 673 674 @Override /* BeanContextBuilder */ 675 public ParserBuilder pojoSwaps(Object...values) { 676 super.pojoSwaps(values); 677 return this; 678 } 679 680 @Override /* BeanContextBuilder */ 681 public ParserBuilder pojoSwapsReplace(Class<?>...values) { 682 super.pojoSwapsReplace(values); 683 return this; 684 } 685 686 @Override /* BeanContextBuilder */ 687 public ParserBuilder pojoSwapsReplace(Object...values) { 688 super.pojoSwapsReplace(values); 689 return this; 690 } 691 692 @Override /* BeanContextBuilder */ 693 public ParserBuilder pojoSwapsRemove(Class<?>...values) { 694 super.pojoSwapsRemove(values); 695 return this; 696 } 697 698 @Override /* BeanContextBuilder */ 699 public ParserBuilder pojoSwapsRemove(Object...values) { 700 super.pojoSwapsRemove(values); 701 return this; 702 } 703 704 @Override /* BeanContextBuilder */ 705 public ParserBuilder sortProperties(boolean value) { 706 super.sortProperties(value); 707 return this; 708 } 709 710 @Override /* BeanContextBuilder */ 711 public ParserBuilder sortProperties() { 712 super.sortProperties(); 713 return this; 714 } 715 716 @Override /* BeanContextBuilder */ 717 public ParserBuilder timeZone(TimeZone value) { 718 super.timeZone(value); 719 return this; 720 } 721 722 @Override /* BeanContextBuilder */ 723 public ParserBuilder useEnumNames(boolean value) { 724 super.useEnumNames(value); 725 return this; 726 } 727 728 @Override /* BeanContextBuilder */ 729 public ParserBuilder useEnumNames() { 730 super.useEnumNames(); 731 return this; 732 } 733 734 @Override /* BeanContextBuilder */ 735 public ParserBuilder useInterfaceProxies(boolean value) { 736 super.useInterfaceProxies(value); 737 return this; 738 } 739 740 @Override /* BeanContextBuilder */ 741 public ParserBuilder useJavaBeanIntrospector(boolean value) { 742 super.useJavaBeanIntrospector(value); 743 return this; 744 } 745 746 @Override /* BeanContextBuilder */ 747 public ParserBuilder useJavaBeanIntrospector() { 748 super.useJavaBeanIntrospector(); 749 return this; 750 } 751 752 @Override /* ContextBuilder */ 753 public ParserBuilder set(String name, Object value) { 754 super.set(name, value); 755 return this; 756 } 757 758 @Override /* ContextBuilder */ 759 public ParserBuilder set(Map<String,Object> properties) { 760 super.set(properties); 761 return this; 762 } 763 764 @Override /* ContextBuilder */ 765 public ParserBuilder add(Map<String,Object> properties) { 766 super.add(properties); 767 return this; 768 } 769 770 @Override /* ContextBuilder */ 771 public ParserBuilder addTo(String name, Object value) { 772 super.addTo(name, value); 773 return this; 774 } 775 776 @Override /* ContextBuilder */ 777 public ParserBuilder addTo(String name, String key, Object value) { 778 super.addTo(name, key, value); 779 return this; 780 } 781 782 @Override /* ContextBuilder */ 783 public ParserBuilder removeFrom(String name, Object value) { 784 super.removeFrom(name, value); 785 return this; 786 } 787 788 @Override /* ContextBuilder */ 789 public ParserBuilder apply(PropertyStore copyFrom) { 790 super.apply(copyFrom); 791 return this; 792 } 793 794 @Override /* ContextBuilder */ 795 public ParserBuilder applyAnnotations(AnnotationList al, VarResolverSession vrs) { 796 super.applyAnnotations(al, vrs); 797 return this; 798 } 799 800 @Override /* ContextBuilder */ 801 public ParserBuilder applyAnnotations(Class<?>...fromClasses) { 802 super.applyAnnotations(fromClasses); 803 return this; 804 } 805 806 @Override /* ContextBuilder */ 807 public ParserBuilder applyAnnotations(Method...fromMethods) { 808 super.applyAnnotations(fromMethods); 809 return this; 810 } 811 812 @Override /* Context */ 813 public Parser build() { 814 return null; 815 } 816}