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.html.*; 023import org.apache.juneau.http.*; 024import org.apache.juneau.internal.*; 025import org.apache.juneau.json.*; 026import org.apache.juneau.msgpack.*; 027import org.apache.juneau.reflect.*; 028import org.apache.juneau.svl.*; 029import org.apache.juneau.uon.*; 030import org.apache.juneau.xml.*; 031 032/** 033 * Builder class for building instances of parsers. 034 */ 035public class ParserBuilder extends BeanContextBuilder { 036 037 /** 038 * Constructor, default settings. 039 */ 040 public ParserBuilder() { 041 super(); 042 } 043 044 /** 045 * Constructor. 046 * 047 * @param ps The initial configuration settings for this builder. 048 */ 049 public ParserBuilder(PropertyStore ps) { 050 super(ps); 051 } 052 053 //----------------------------------------------------------------------------------------------------------------- 054 // Properties 055 //----------------------------------------------------------------------------------------------------------------- 056 057 /** 058 * <i><l>Parser</l> configuration property: </i> Auto-close streams. 059 * 060 * <div class='warn'> 061 * <b>Deprecated</b> - Use {@link #autoCloseStreams()} 062 * </div> 063 */ 064 @SuppressWarnings("javadoc") 065 @Deprecated 066 @FluentSetter 067 public ParserBuilder autoCloseStreams(boolean value) { 068 return set(PARSER_autoCloseStreams, value); 069 } 070 071 /** 072 * <i><l>Parser</l> configuration property: </i> Auto-close streams. 073 * 074 * <p> 075 * When enabled, <l>InputStreams</l> and <l>Readers</l> passed into parsers will be closed 076 * after parsing is complete. 077 * 078 * <h5 class='section'>Example:</h5> 079 * <p class='bcode w800'> 080 * <jc>// Create a parser using strict mode.</jc> 081 * ReaderParser p = JsonParser 082 * .<jsm>create</jsm>() 083 * .autoCloseStreams() 084 * .build(); 085 * 086 * Reader r = <jk>new</jk> FileReader(<js>"/tmp/myfile.json"</js>); 087 * MyBean myBean = p.parse(r, MyBean.<jk>class</jk>); 088 * 089 * <jsm>assertTrue</jsm>(r.isClosed()); 090 * </p> 091 * 092 * <ul class='seealso'> 093 * <li class='jf'>{@link Parser#PARSER_autoCloseStreams} 094 * </ul> 095 * 096 * @return This object (for method chaining). 097 */ 098 @FluentSetter 099 public ParserBuilder autoCloseStreams() { 100 return set(PARSER_autoCloseStreams, true); 101 } 102 103 /** 104 * <i><l>Parser</l> configuration property: </i> Debug output lines. 105 * 106 * <p> 107 * When parse errors occur, this specifies the number of lines of input before and after the 108 * error location to be printed as part of the exception message. 109 * 110 * <h5 class='section'>Example:</h5> 111 * <p class='bcode w800'> 112 * <jc>// Create a parser whose exceptions print out 100 lines before and after the parse error location.</jc> 113 * ReaderParser p = JsonParser 114 * .<jsm>create</jsm>() 115 * .debug() <jc>// Enable debug mode to capture Reader contents as strings.</jc> 116 * .debugOuputLines(100) 117 * .build(); 118 * 119 * Reader r = <jk>new</jk> FileReader(<js>"/tmp/mybadfile.json"</js>); 120 * <jk>try</jk> { 121 * p.parse(r, Object.<jk>class</jk>); 122 * } <jk>catch</jk> (ParseException e) { 123 * System.<jsf>err</jsf>.println(e.getMessage()); <jc>// Will display 200 lines of the output.</jc> 124 * } 125 * </p> 126 * 127 * <ul class='seealso'> 128 * <li class='jf'>{@link Parser#PARSER_debugOutputLines} 129 * </ul> 130 * 131 * @param value 132 * The new value for this property. 133 * <br>The default value is <c>5</c>. 134 * @return This object (for method chaining). 135 */ 136 @FluentSetter 137 public ParserBuilder debugOutputLines(int value) { 138 return set(PARSER_debugOutputLines, value); 139 } 140 141 /** 142 * <i><l>Parser</l> configuration property: </i> Parser listener. 143 * 144 * <p> 145 * Class used to listen for errors and warnings that occur during parsing. 146 * 147 * <h5 class='section'>Example:</h5> 148 * <p class='bcode w800'> 149 * <jc>// Define our parser listener.</jc> 150 * <jc>// Simply captures all unknown bean property events.</jc> 151 * <jk>public class</jk> MyParserListener <jk>extends</jk> ParserListener { 152 * 153 * <jc>// A simple property to store our events.</jc> 154 * <jk>public</jk> List<String> <jf>events</jf> = <jk>new</jk> LinkedList<>(); 155 * 156 * <ja>@Override</ja> 157 * <jk>public</jk> <T> <jk>void</jk> onUnknownBeanProperty(ParserSession session, ParserPipe pipe, String propertyName, Class<T> beanClass, T bean, <jk>int</jk> line, <jk>int</jk> col) { 158 * <jf>events</jf>.add(propertyName + <js>","</js> + line + <js>","</js> + col); 159 * } 160 * } 161 * 162 * <jc>// Create a parser using our listener.</jc> 163 * ReaderParser p = JsonParser 164 * .<jsm>create</jsm>() 165 * .listener(MyParserListener.<jk>class</jk>) 166 * .build(); 167 * 168 * <jc>// Create a session object.</jc> 169 * <jc>// Needed because listeners are created per-session.</jc> 170 * <jk>try</jk> (ReaderParserSession s = p.createSession()) { 171 * 172 * <jc>// Parse some JSON object.</jc> 173 * MyBean myBean = s.parse(<js>"{...}"</js>, MyBean.<jk>class</jk>); 174 * 175 * <jc>// Get the listener.</jc> 176 * MyParserListener l = s.getListener(MyParserListener.<jk>class</jk>); 177 * 178 * <jc>// Dump the results to the console.</jc> 179 * SimpleJsonSerializer.<jsf>DEFAULT</jsf>.println(l.<jf>events</jf>); 180 * } 181 * </p> 182 * 183 * <ul class='seealso'> 184 * <li class='jf'>{@link Parser#PARSER_listener} 185 * </ul> 186 * 187 * @param value The new value for this property. 188 * @return This object (for method chaining). 189 */ 190 @FluentSetter 191 public ParserBuilder listener(Class<? extends ParserListener> value) { 192 return set(PARSER_listener, value); 193 } 194 195 /** 196 * <i><l>Parser</l> configuration property: </i> Strict mode. 197 * 198 * <div class='warn'> 199 * <b>Deprecated</b> - Use {@link #strict()} 200 * </div> 201 */ 202 @SuppressWarnings("javadoc") 203 @Deprecated 204 @FluentSetter 205 public ParserBuilder strict(boolean value) { 206 return set(PARSER_strict, value); 207 } 208 209 /** 210 * <i><l>Parser</l> configuration property: </i> Strict mode. 211 * 212 * <p> 213 * When enabled, strict mode for the parser is enabled. 214 * 215 * <p> 216 * Strict mode can mean different things for different parsers. 217 * 218 * <table class='styled'> 219 * <tr><th>Parser class</th><th>Strict behavior</th></tr> 220 * <tr> 221 * <td>All reader-based parsers</td> 222 * <td> 223 * When enabled, throws {@link ParseException ParseExceptions} on malformed charset input. 224 * Otherwise, malformed input is ignored. 225 * </td> 226 * </tr> 227 * <tr> 228 * <td>{@link JsonParser}</td> 229 * <td> 230 * When enabled, throws exceptions on the following invalid JSON syntax: 231 * <ul> 232 * <li>Unquoted attributes. 233 * <li>Missing attribute values. 234 * <li>Concatenated strings. 235 * <li>Javascript comments. 236 * <li>Numbers and booleans when Strings are expected. 237 * <li>Numbers valid in Java but not JSON (e.g. octal notation, etc...) 238 * </ul> 239 * </td> 240 * </tr> 241 * </table> 242 * 243 * <h5 class='section'>Example:</h5> 244 * <p class='bcode w800'> 245 * <jc>// Create a parser using strict mode.</jc> 246 * ReaderParser p = JsonParser 247 * .<jsm>create</jsm>() 248 * .strict() 249 * .build(); 250 * 251 * <jc>// Use it.</jc> 252 * <jk>try</jk> { 253 * String json = <js>"{unquotedAttr:'value'}"</js>; 254 * MyBean myBean = p.parse(json, MyBean.<jk>class</jk>); 255 * } <jk>catch</jk> (ParseException e) { 256 * <jsm>assertTrue</jsm>(e.getMessage().contains(<js>"Unquoted attribute detected."</js>); 257 * } 258 * </p> 259 * 260 * <ul class='seealso'> 261 * <li class='jf'>{@link Parser#PARSER_strict} 262 * </ul> 263 * 264 * @return This object (for method chaining). 265 */ 266 @FluentSetter 267 public ParserBuilder strict() { 268 return set(PARSER_strict, true); 269 } 270 271 /** 272 * <i><l>Parser</l> configuration property: </i> Trim parsed strings. 273 * 274 * <div class='warn'> 275 * <b>Deprecated</b> - Use {@link #trimStrings()} 276 * </div> 277 */ 278 @SuppressWarnings("javadoc") 279 @Deprecated 280 @FluentSetter 281 public ParserBuilder trimStrings(boolean value) { 282 return set(PARSER_trimStrings, value); 283 } 284 285 /** 286 * <i><l>Parser</l> configuration property: </i> Trim parsed strings. 287 * 288 * <p> 289 * When enabled, string values will be trimmed of whitespace using {@link String#trim()} before being added to 290 * the POJO. 291 * 292 * <h5 class='section'>Example:</h5> 293 * <p class='bcode w800'> 294 * <jc>// Create a parser with trim-strings enabled.</jc> 295 * ReaderParser p = JsonParser 296 * .<jsm>create</jsm>() 297 * .trimStrings() 298 * .build(); 299 * 300 * <jc>// Use it.</jc> 301 * String json = <js>"{' foo ':' bar '}"</js>; 302 * Map<String,String> map = p.parse(json, HashMap.<jk>class</jk>, String.<jk>class</jk>, String.<jk>class</jk>); 303 * 304 * <jc>// Make sure strings are parsed.</jc> 305 * <jsm>assertEquals</jsm>(<js>"bar"</js>, map.get(<js>"foo"</js>)); 306 * </p> 307 * 308 * <ul class='seealso'> 309 * <li class='jf'>{@link Parser#PARSER_trimStrings} 310 * </ul> 311 * 312 * @return This object (for method chaining). 313 */ 314 @FluentSetter 315 public ParserBuilder trimStrings() { 316 return set(PARSER_trimStrings, true); 317 } 318 319 /** 320 * <i><l>Parser</l> configuration property: </i> Unbuffered. 321 * 322 * <div class='warn'> 323 * <b>Deprecated</b> - Use {@link #unbuffered()} 324 * </div> 325 */ 326 @SuppressWarnings("javadoc") 327 @Deprecated 328 @FluentSetter 329 public ParserBuilder unbuffered(boolean value) { 330 return set(PARSER_unbuffered, value); 331 } 332 333 /** 334 * <i><l>Parser</l> configuration property: </i> Unbuffered. 335 * 336 * <p> 337 * When enabled, don't use internal buffering during parsing. 338 * 339 * <p> 340 * This is useful in cases when you want to parse the same input stream or reader multiple times 341 * because it may contain multiple independent POJOs to parse. 342 * <br>Buffering would cause the parser to read past the current POJO in the stream. 343 * 344 * <h5 class='section'>Example:</h5> 345 * <p class='bcode w800'> 346 * <jc>// Create a parser using strict mode.</jc> 347 * ReaderParser p = JsonParser. 348 * .<jsm>create</jsm>() 349 * .unbuffered(<jk>true</jk>) 350 * .build(); 351 * 352 * <jc>// If you're calling parse on the same input multiple times, use a session instead of the parser directly.</jc> 353 * <jc>// It's more efficient because we don't need to recalc the session settings again. </jc> 354 * ReaderParserSession s = p.createSession(); 355 * 356 * <jc>// Read input with multiple POJOs</jc> 357 * Reader json = <jk>new</jk> StringReader(<js>"{foo:'bar'}{foo:'baz'}"</js>); 358 * MyBean myBean1 = s.parse(json, MyBean.<jk>class</jk>); 359 * MyBean myBean2 = s.parse(json, MyBean.<jk>class</jk>); 360 * </p> 361 * 362 * <ul class='notes'> 363 * <li> 364 * This only allows for multi-input streams for the following parsers: 365 * <ul> 366 * <li class='jc'>{@link JsonParser} 367 * <li class='jc'>{@link UonParser} 368 * </ul> 369 * It has no effect on the following parsers: 370 * <ul> 371 * <li class='jc'>{@link MsgPackParser} - It already doesn't use buffering. 372 * <li class='jc'>{@link XmlParser}, {@link HtmlParser} - These use StAX which doesn't allow for more than one root element anyway. 373 * <li>RDF parsers - These read everything into an internal model before any parsing begins. 374 * </ul> 375 * </ul> 376 * 377 * <ul class='seealso'> 378 * <li class='jf'>{@link Parser#PARSER_unbuffered} 379 * </ul> 380 * 381 * @return This object (for method chaining). 382 */ 383 @FluentSetter 384 public ParserBuilder unbuffered() { 385 return set(PARSER_unbuffered, true); 386 } 387 388 // <FluentSetters> 389 390 @Override /* GENERATED - ContextBuilder */ 391 public ParserBuilder add(Map<String,Object> properties) { 392 super.add(properties); 393 return this; 394 } 395 396 @Override /* GENERATED - ContextBuilder */ 397 public ParserBuilder addTo(String name, Object value) { 398 super.addTo(name, value); 399 return this; 400 } 401 402 @Override /* GENERATED - ContextBuilder */ 403 public ParserBuilder appendTo(String name, Object value) { 404 super.appendTo(name, value); 405 return this; 406 } 407 408 @Override /* GENERATED - ContextBuilder */ 409 public ParserBuilder apply(PropertyStore copyFrom) { 410 super.apply(copyFrom); 411 return this; 412 } 413 414 @Override /* GENERATED - ContextBuilder */ 415 public ParserBuilder applyAnnotations(java.lang.Class<?>...fromClasses) { 416 super.applyAnnotations(fromClasses); 417 return this; 418 } 419 420 @Override /* GENERATED - ContextBuilder */ 421 public ParserBuilder applyAnnotations(Method...fromMethods) { 422 super.applyAnnotations(fromMethods); 423 return this; 424 } 425 426 @Override /* GENERATED - ContextBuilder */ 427 public ParserBuilder applyAnnotations(AnnotationList al, VarResolverSession r) { 428 super.applyAnnotations(al, r); 429 return this; 430 } 431 432 @Override /* GENERATED - ContextBuilder */ 433 public ParserBuilder debug() { 434 super.debug(); 435 return this; 436 } 437 438 @Override /* GENERATED - ContextBuilder */ 439 public ParserBuilder locale(Locale value) { 440 super.locale(value); 441 return this; 442 } 443 444 @Override /* GENERATED - ContextBuilder */ 445 public ParserBuilder mediaType(MediaType value) { 446 super.mediaType(value); 447 return this; 448 } 449 450 @Override /* GENERATED - ContextBuilder */ 451 public ParserBuilder prependTo(String name, Object value) { 452 super.prependTo(name, value); 453 return this; 454 } 455 456 @Override /* GENERATED - ContextBuilder */ 457 public ParserBuilder putAllTo(String name, Object value) { 458 super.putAllTo(name, value); 459 return this; 460 } 461 462 @Override /* GENERATED - ContextBuilder */ 463 public ParserBuilder putTo(String name, String key, Object value) { 464 super.putTo(name, key, value); 465 return this; 466 } 467 468 @Override /* GENERATED - ContextBuilder */ 469 public ParserBuilder removeFrom(String name, Object value) { 470 super.removeFrom(name, value); 471 return this; 472 } 473 474 @Override /* GENERATED - ContextBuilder */ 475 public ParserBuilder set(Map<String,Object> properties) { 476 super.set(properties); 477 return this; 478 } 479 480 @Override /* GENERATED - ContextBuilder */ 481 public ParserBuilder set(String name, Object value) { 482 super.set(name, value); 483 return this; 484 } 485 486 @Override /* GENERATED - ContextBuilder */ 487 public ParserBuilder timeZone(TimeZone value) { 488 super.timeZone(value); 489 return this; 490 } 491 492 @Override /* GENERATED - BeanContextBuilder */ 493 public ParserBuilder annotations(Annotation...values) { 494 super.annotations(values); 495 return this; 496 } 497 498 @Override /* GENERATED - BeanContextBuilder */ 499 public ParserBuilder beanClassVisibility(Visibility value) { 500 super.beanClassVisibility(value); 501 return this; 502 } 503 504 @Override /* GENERATED - BeanContextBuilder */ 505 public ParserBuilder beanConstructorVisibility(Visibility value) { 506 super.beanConstructorVisibility(value); 507 return this; 508 } 509 510 @Override /* GENERATED - BeanContextBuilder */ 511 public ParserBuilder beanFieldVisibility(Visibility value) { 512 super.beanFieldVisibility(value); 513 return this; 514 } 515 516 @Override /* GENERATED - BeanContextBuilder */ 517 public ParserBuilder beanInterceptor(Class<?> on, Class<? extends org.apache.juneau.transform.BeanInterceptor<?>> value) { 518 super.beanInterceptor(on, value); 519 return this; 520 } 521 522 @Override /* GENERATED - BeanContextBuilder */ 523 public ParserBuilder beanMapPutReturnsOldValue() { 524 super.beanMapPutReturnsOldValue(); 525 return this; 526 } 527 528 @Override /* GENERATED - BeanContextBuilder */ 529 public ParserBuilder beanMethodVisibility(Visibility value) { 530 super.beanMethodVisibility(value); 531 return this; 532 } 533 534 @Override /* GENERATED - BeanContextBuilder */ 535 public ParserBuilder beansDontRequireSomeProperties() { 536 super.beansDontRequireSomeProperties(); 537 return this; 538 } 539 540 @Override /* GENERATED - BeanContextBuilder */ 541 public ParserBuilder beansRequireDefaultConstructor() { 542 super.beansRequireDefaultConstructor(); 543 return this; 544 } 545 546 @Override /* GENERATED - BeanContextBuilder */ 547 public ParserBuilder beansRequireSerializable() { 548 super.beansRequireSerializable(); 549 return this; 550 } 551 552 @Override /* GENERATED - BeanContextBuilder */ 553 public ParserBuilder beansRequireSettersForGetters() { 554 super.beansRequireSettersForGetters(); 555 return this; 556 } 557 558 @Override /* GENERATED - BeanContextBuilder */ 559 public ParserBuilder bpi(Map<String,Object> values) { 560 super.bpi(values); 561 return this; 562 } 563 564 @Override /* GENERATED - BeanContextBuilder */ 565 public ParserBuilder bpi(Class<?> beanClass, String properties) { 566 super.bpi(beanClass, properties); 567 return this; 568 } 569 570 @Override /* GENERATED - BeanContextBuilder */ 571 public ParserBuilder bpi(String beanClassName, String properties) { 572 super.bpi(beanClassName, properties); 573 return this; 574 } 575 576 @Override /* GENERATED - BeanContextBuilder */ 577 public ParserBuilder bpro(Map<String,Object> values) { 578 super.bpro(values); 579 return this; 580 } 581 582 @Override /* GENERATED - BeanContextBuilder */ 583 public ParserBuilder bpro(Class<?> beanClass, String properties) { 584 super.bpro(beanClass, properties); 585 return this; 586 } 587 588 @Override /* GENERATED - BeanContextBuilder */ 589 public ParserBuilder bpro(String beanClassName, String properties) { 590 super.bpro(beanClassName, properties); 591 return this; 592 } 593 594 @Override /* GENERATED - BeanContextBuilder */ 595 public ParserBuilder bpwo(Map<String,Object> values) { 596 super.bpwo(values); 597 return this; 598 } 599 600 @Override /* GENERATED - BeanContextBuilder */ 601 public ParserBuilder bpwo(Class<?> beanClass, String properties) { 602 super.bpwo(beanClass, properties); 603 return this; 604 } 605 606 @Override /* GENERATED - BeanContextBuilder */ 607 public ParserBuilder bpwo(String beanClassName, String properties) { 608 super.bpwo(beanClassName, properties); 609 return this; 610 } 611 612 @Override /* GENERATED - BeanContextBuilder */ 613 public ParserBuilder bpx(Map<String,Object> values) { 614 super.bpx(values); 615 return this; 616 } 617 618 @Override /* GENERATED - BeanContextBuilder */ 619 public ParserBuilder bpx(Class<?> beanClass, String properties) { 620 super.bpx(beanClass, properties); 621 return this; 622 } 623 624 @Override /* GENERATED - BeanContextBuilder */ 625 public ParserBuilder bpx(String beanClassName, String properties) { 626 super.bpx(beanClassName, properties); 627 return this; 628 } 629 630 @Override /* GENERATED - BeanContextBuilder */ 631 public ParserBuilder dictionary(Object...values) { 632 super.dictionary(values); 633 return this; 634 } 635 636 @Override /* GENERATED - BeanContextBuilder */ 637 public ParserBuilder dictionaryOn(Class<?> on, java.lang.Class<?>...values) { 638 super.dictionaryOn(on, values); 639 return this; 640 } 641 642 @Override /* GENERATED - BeanContextBuilder */ 643 public ParserBuilder dontIgnorePropertiesWithoutSetters() { 644 super.dontIgnorePropertiesWithoutSetters(); 645 return this; 646 } 647 648 @Override /* GENERATED - BeanContextBuilder */ 649 public ParserBuilder dontIgnoreTransientFields() { 650 super.dontIgnoreTransientFields(); 651 return this; 652 } 653 654 @Override /* GENERATED - BeanContextBuilder */ 655 public ParserBuilder dontIgnoreUnknownNullBeanProperties() { 656 super.dontIgnoreUnknownNullBeanProperties(); 657 return this; 658 } 659 660 @Override /* GENERATED - BeanContextBuilder */ 661 public ParserBuilder dontUseInterfaceProxies() { 662 super.dontUseInterfaceProxies(); 663 return this; 664 } 665 666 @Override /* GENERATED - BeanContextBuilder */ 667 public <T> ParserBuilder example(Class<T> pojoClass, T o) { 668 super.example(pojoClass, o); 669 return this; 670 } 671 672 @Override /* GENERATED - BeanContextBuilder */ 673 public <T> ParserBuilder exampleJson(Class<T> pojoClass, String json) { 674 super.exampleJson(pojoClass, json); 675 return this; 676 } 677 678 @Override /* GENERATED - BeanContextBuilder */ 679 public ParserBuilder fluentSetters() { 680 super.fluentSetters(); 681 return this; 682 } 683 684 @Override /* GENERATED - BeanContextBuilder */ 685 public ParserBuilder fluentSetters(Class<?> on) { 686 super.fluentSetters(on); 687 return this; 688 } 689 690 @Override /* GENERATED - BeanContextBuilder */ 691 public ParserBuilder ignoreInvocationExceptionsOnGetters() { 692 super.ignoreInvocationExceptionsOnGetters(); 693 return this; 694 } 695 696 @Override /* GENERATED - BeanContextBuilder */ 697 public ParserBuilder ignoreInvocationExceptionsOnSetters() { 698 super.ignoreInvocationExceptionsOnSetters(); 699 return this; 700 } 701 702 @Override /* GENERATED - BeanContextBuilder */ 703 public ParserBuilder ignoreUnknownBeanProperties() { 704 super.ignoreUnknownBeanProperties(); 705 return this; 706 } 707 708 @Override /* GENERATED - BeanContextBuilder */ 709 public ParserBuilder implClass(Class<?> interfaceClass, Class<?> implClass) { 710 super.implClass(interfaceClass, implClass); 711 return this; 712 } 713 714 @Override /* GENERATED - BeanContextBuilder */ 715 public ParserBuilder implClasses(Map<Class<?>,Class<?>> values) { 716 super.implClasses(values); 717 return this; 718 } 719 720 @Override /* GENERATED - BeanContextBuilder */ 721 public ParserBuilder interfaceClass(Class<?> on, Class<?> value) { 722 super.interfaceClass(on, value); 723 return this; 724 } 725 726 @Override /* GENERATED - BeanContextBuilder */ 727 public ParserBuilder interfaces(java.lang.Class<?>...value) { 728 super.interfaces(value); 729 return this; 730 } 731 732 @Override /* GENERATED - BeanContextBuilder */ 733 public ParserBuilder notBeanClasses(Object...values) { 734 super.notBeanClasses(values); 735 return this; 736 } 737 738 @Override /* GENERATED - BeanContextBuilder */ 739 public ParserBuilder notBeanPackages(Object...values) { 740 super.notBeanPackages(values); 741 return this; 742 } 743 744 @Override /* GENERATED - BeanContextBuilder */ 745 public ParserBuilder propertyNamer(Class<? extends org.apache.juneau.PropertyNamer> value) { 746 super.propertyNamer(value); 747 return this; 748 } 749 750 @Override /* GENERATED - BeanContextBuilder */ 751 public ParserBuilder propertyNamer(Class<?> on, Class<? extends org.apache.juneau.PropertyNamer> value) { 752 super.propertyNamer(on, value); 753 return this; 754 } 755 756 @Override /* GENERATED - BeanContextBuilder */ 757 public ParserBuilder sortProperties() { 758 super.sortProperties(); 759 return this; 760 } 761 762 @Override /* GENERATED - BeanContextBuilder */ 763 public ParserBuilder sortProperties(java.lang.Class<?>...on) { 764 super.sortProperties(on); 765 return this; 766 } 767 768 @Override /* GENERATED - BeanContextBuilder */ 769 public ParserBuilder stopClass(Class<?> on, Class<?> value) { 770 super.stopClass(on, value); 771 return this; 772 } 773 774 @Override /* GENERATED - BeanContextBuilder */ 775 public ParserBuilder swaps(Object...values) { 776 super.swaps(values); 777 return this; 778 } 779 780 @Override /* GENERATED - BeanContextBuilder */ 781 public ParserBuilder typeName(Class<?> on, String value) { 782 super.typeName(on, value); 783 return this; 784 } 785 786 @Override /* GENERATED - BeanContextBuilder */ 787 public ParserBuilder typePropertyName(String value) { 788 super.typePropertyName(value); 789 return this; 790 } 791 792 @Override /* GENERATED - BeanContextBuilder */ 793 public ParserBuilder typePropertyName(Class<?> on, String value) { 794 super.typePropertyName(on, value); 795 return this; 796 } 797 798 @Override /* GENERATED - BeanContextBuilder */ 799 public ParserBuilder useEnumNames() { 800 super.useEnumNames(); 801 return this; 802 } 803 804 @Override /* GENERATED - BeanContextBuilder */ 805 public ParserBuilder useJavaBeanIntrospector() { 806 super.useJavaBeanIntrospector(); 807 return this; 808 } 809 810 // </FluentSetters> 811 812 @Override /* Context */ 813 public Parser build() { 814 return null; 815 } 816}