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