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:&emsp;</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:&emsp;</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:&emsp;</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:&emsp;</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&lt;String&gt; <jf>events</jf> = <jk>new</jk> LinkedList&lt;&gt;();
155    *
156    *       <ja>@Override</ja>
157    *       <jk>public</jk> &lt;T&gt; <jk>void</jk> onUnknownBeanProperty(ParserSession session, ParserPipe pipe, String propertyName, Class&lt;T&gt; 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:&emsp;</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:&emsp;</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:&emsp;</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:&emsp;</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&lt;String,String&gt; 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:&emsp;</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:&emsp;</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}