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.jena;
014
015import static org.apache.juneau.jena.RdfCommon.*;
016import static org.apache.juneau.jena.RdfParser.*;
017
018import java.nio.charset.*;
019import java.util.*;
020
021import org.apache.juneau.*;
022import org.apache.juneau.http.*;
023import org.apache.juneau.parser.*;
024import org.apache.juneau.reflect.*;
025import org.apache.juneau.svl.*;
026import org.apache.juneau.xml.*;
027
028/**
029 * Builder class for building instances of RDF parsers.
030 */
031public class RdfParserBuilder extends ReaderParserBuilder {
032
033   /**
034    * Constructor, default settings.
035    */
036   public RdfParserBuilder() {
037      super();
038   }
039
040   /**
041    * Constructor.
042    *
043    * @param ps The initial configuration settings for this builder.
044    */
045   public RdfParserBuilder(PropertyStore ps) {
046      super(ps);
047   }
048
049   @Override /* ContextBuilder */
050   public RdfParser build() {
051      return build(RdfParser.class);
052   }
053
054   //-----------------------------------------------------------------------------------------------------------------
055   // Properties
056   //-----------------------------------------------------------------------------------------------------------------
057
058   /**
059    * Configuration property:  XML namespace for Juneau properties.
060    *
061    * @param value
062    *    The new value for this property.
063    * @return This object (for method chaining).
064    */
065   public RdfParserBuilder juneauNs(String value) {
066      return set(RDF_juneauNs, value);
067   }
068
069   /**
070    * Configuration property:  Default XML namespace for bean properties.
071    *
072    * @param value
073    *    The new value for this property.
074    * @return This object (for method chaining).
075    */
076   public RdfParserBuilder juneauBpNs(String value) {
077      return set(RDF_juneauBpNs, value);
078   }
079
080   /**
081    * Configuration property:  RDF/XML property: <c>iri_rules</c>.
082    *
083    * <p>
084    * Set the engine for checking and resolving.
085    *
086    * <p>
087    * Possible values:
088    * <ul class='spaced-list'>
089    *    <li>
090    *       <js>"lax"</js> - The rules for RDF URI references only, which does permit spaces although the use of spaces
091    *       is not good practice.
092    *    <li>
093    *       <js>"strict"</js> - Sets the IRI engine with rules for valid IRIs, XLink and RDF; it does not permit spaces
094    *       in IRIs.
095    *    <li>
096    *       <js>"iri"</js> - Sets the IRI engine to IRI
097    *       ({@doc http://www.ietf.org/rfc/rfc3986.txt RFC 3986},
098    *       {@doc http://www.ietf.org/rfc/rfc3987.txt RFC 3987}).
099    *
100    * </ul>
101    *
102    * @param value
103    *    The new value for this property.
104    * @return This object (for method chaining).
105    */
106   public RdfParserBuilder arp_iriRules(String value) {
107      return set(RDF_arp_iriRules, value);
108   }
109
110   /**
111    * Configuration property:  RDF/XML ARP property: <c>error-mode</c>.
112    *
113    * <p>
114    * This allows a coarse-grained approach to control of error handling.
115    *
116    * <p>
117    * Possible values:
118    * <ul>
119    *    <li><js>"default"</js>
120    *    <li><js>"lax"</js>
121    *    <li><js>"strict"</js>
122    *    <li><js>"strict-ignore"</js>
123    *    <li><js>"strict-warning"</js>
124    *    <li><js>"strict-error"</js>
125    *    <li><js>"strict-fatal"</js>
126    * </ul>
127    *
128    * @param value
129    *    The new value for this property.
130    * @return This object (for method chaining).
131    */
132   public RdfParserBuilder arp_errorMode(String value) {
133      return set(RDF_arp_errorMode, value);
134   }
135
136   /**
137    * Configuration property:  RDF/XML ARP property: <c>error-mode</c>.
138    *
139    * <p>
140    * Sets ARP to look for RDF embedded within an enclosing XML document.
141    *
142    * @param value
143    *    The new value for this property.
144    * @return This object (for method chaining).
145    */
146   public RdfParserBuilder arp_embedding(boolean value) {
147      return set(RDF_arp_embedding, value);
148   }
149
150   /**
151    * Configuration property:  RDF/XML property: <c>xmlbase</c>.
152    *
153    * <p>
154    * The value to be included for an <xa>xml:base</xa> attribute on the root element in the file.
155    *
156    * @param value
157    *    The new value for this property.
158    * @return This object (for method chaining).
159    */
160   public RdfParserBuilder rdfxml_xmlBase(String value) {
161      return set(RDF_rdfxml_xmlBase, value);
162   }
163
164   /**
165    * Configuration property:  RDF/XML property: <c>longId</c>.
166    *
167    * <p>
168    * Whether to use long ID's for anon resources.
169    * Short ID's are easier to read, but can run out of memory on very large models.
170    *
171    * @param value
172    *    The new value for this property.
173    * @return This object (for method chaining).
174    */
175   public RdfParserBuilder rdfxml_longId(boolean value) {
176      return set(RDF_rdfxml_longId, value);
177   }
178
179   /**
180    * Configuration property:  RDF/XML property: <c>allowBadURIs</c>.
181    *
182    * <p>
183    * URIs in the graph are, by default, checked prior to serialization.
184    *
185    * @param value
186    *    The new value for this property.
187    * @return This object (for method chaining).
188    */
189   public RdfParserBuilder rdfxml_allowBadUris(boolean value) {
190      return set(RDF_rdfxml_allowBadUris, value);
191   }
192
193   /**
194    * Configuration property:  RDF/XML property: <c>relativeURIs</c>.
195    *
196    * <p>
197    * What sort of relative URIs should be used.
198    *
199    * <p>
200    * A comma separate list of options:
201    * <ul class='spaced-list'>
202    *    <li>
203    *       <js>"same-document"</js> - Same-document references (e.g. <js>""</js> or <js>"#foo"</js>)
204    *    <li>
205    *       <js>"network"</js>  - Network paths (e.g. <js>"//example.org/foo"</js> omitting the URI scheme)
206    *    <li>
207    *       <js>"absolute"</js> - Absolute paths (e.g. <js>"/foo"</js> omitting the scheme and authority)
208    *    <li>
209    *       <js>"relative"</js> - Relative path not beginning in <js>"../"</js>
210    *    <li>
211    *       <js>"parent"</js> - Relative path beginning in <js>"../"</js>
212    *    <li>
213    *       <js>"grandparent"</js> - Relative path beginning in <js>"../../"</js>
214    * </ul>
215    *
216    * <p>
217    * The default value is <js>"same-document, absolute, relative, parent"</js>.
218    * To switch off relative URIs use the value <js>""</js>.
219    * Relative URIs of any of these types are output where possible if and only if the option has been specified.
220    *
221    * @param value
222    *    The new value for this property.
223    * @return This object (for method chaining).
224    */
225   public RdfParserBuilder rdfxml_relativeUris(String value) {
226      return set(RDF_rdfxml_relativeUris, value);
227   }
228
229   /**
230    * Configuration property:  RDF/XML property: <c>showXmlDeclaration</c>.
231    *
232    * <p>
233    * Possible values:
234    * <ul class='spaced-list'>
235    *    <li>
236    *       <js>"true"</js> - Add XML Declaration to the output.
237    *    <li>
238    *       <js>"false"</js> - Don't add XML Declaration to the output.
239    *    <li>
240    *       <js>"default"</js> - Only add an XML Declaration when asked to write to an <c>OutputStreamWriter</c>
241    *       that uses some encoding other than <c>UTF-8</c> or <c>UTF-16</c>.
242    *       In this case the encoding is shown in the XML declaration.
243    * </ul>
244    *
245    * @param value
246    *    The new value for this property.
247    * @return This object (for method chaining).
248    */
249   public RdfParserBuilder rdfxml_showXmlDeclaration(String value) {
250      return set(RDF_rdfxml_showXmlDeclaration, value);
251   }
252
253   /**
254    * Configuration property:  RDF/XML property: <c>showDoctypeDeclaration</c>.
255    *
256    * <p>
257    * If true, an XML doctype declaration is included in the output.
258    * This declaration includes a <c>!ENTITY</c> declaration for each prefix mapping in the model, and any
259    * attribute value that starts with the URI of that mapping is written as starting with the corresponding entity
260    * invocation.
261    *
262    * @param value
263    *    The new value for this property.
264    * @return This object (for method chaining).
265    */
266   public RdfParserBuilder rdfxml_showDoctypeDeclaration(boolean value) {
267      return set(RDF_rdfxml_showDoctypeDeclaration, value);
268   }
269
270   /**
271    * Configuration property:  RDF/XML property: <c>tab</c>.
272    *
273    * <p>
274    * The number of spaces with which to indent XML child elements.
275    *
276    * @param value
277    *    The new value for this property.
278    * @return This object (for method chaining).
279    */
280   public RdfParserBuilder rdfxml_tab(int value) {
281      return set(RDF_rdfxml_tab, value);
282   }
283
284   /**
285    * Configuration property:  RDF/XML property: <c>attributeQuoteChar</c>.
286    *
287    * <p>
288    * The XML attribute quote character.
289    *
290    * @param value
291    *    The new value for this property.
292    * @return This object (for method chaining).
293    */
294   public RdfParserBuilder rdfxml_attributeQuoteChar(String value) {
295      return set(RDF_rdfxml_attributeQuoteChar, value);
296   }
297
298   /**
299    * Configuration property:  RDF/XML property: <c>blockRules</c>.
300    *
301    * <p>
302    * A list of <c>Resource</c> or a <c>String</c> being a comma separated list of fragment IDs from
303    * {@doc http://www.w3.org/TR/rdf-syntax-grammar RDF Syntax Grammar} indicating grammar
304    * rules that will not be used.
305    *
306    * @param value
307    *    The new value for this property.
308    * @return This object (for method chaining).
309    */
310   public RdfParserBuilder rdfxml_blockRules(String value) {
311      return set(RDF_rdfxml_blockRules, value);
312   }
313
314   /**
315    * Configuration property:  N3/Turtle property: <c>minGap</c>.
316    *
317    * <p>
318    * Minimum gap between items on a line.
319    *
320    * @param value
321    *    The new value for this property.
322    * @return This object (for method chaining).
323    */
324   public RdfParserBuilder n3_minGap(int value) {
325      return set(RDF_n3_minGap, value);
326   }
327
328   /**
329    * Configuration property:  N3/Turtle property: <c>objectLists</c>.
330    *
331    * <p>
332    * Print object lists as comma separated lists.
333    *
334    * @param value
335    *    The new value for this property.
336    * @return This object (for method chaining).
337    */
338   public RdfParserBuilder n3_objectLists(boolean value) {
339      return set(RDF_n3_objectLists, value);
340   }
341
342   /**
343    * Configuration property:  N3/Turtle property: <c>subjectColumn</c>.
344    *
345    * <p>
346    * If the subject is shorter than this value, the first property may go on the same line.
347    *
348    * @param value
349    *    The new value for this property.
350    * @return This object (for method chaining).
351    */
352   public RdfParserBuilder n3_subjectColumn(int value) {
353      return set(RDF_n3_subjectColumn, value);
354   }
355
356   /**
357    * Configuration property:  N3/Turtle property: <c>propertyColumn</c>.
358    *
359    * <p>
360    * Width of the property column.
361    *
362    * @param value
363    *    The new value for this property.
364    * @return This object (for method chaining).
365    */
366   public RdfParserBuilder n3_propertyColumn(int value) {
367      return set(RDF_n3_propertyColumn, value);
368   }
369
370   /**
371    * Configuration property:  N3/Turtle property: <c>indentProperty</c>.
372    *
373    * <p>
374    * Width to indent properties.
375    *
376    * @param value
377    *    The new value for this property.
378    * @return This object (for method chaining).
379    */
380   public RdfParserBuilder n3_indentProperty(int value) {
381      return set(RDF_n3_indentProperty, value);
382   }
383
384   /**
385    * Configuration property:  N3/Turtle property: <c>widePropertyLen</c>.
386    *
387    * <p>
388    * Width of the property column.
389    * Must be longer than <c>propertyColumn</c>.
390    *
391    * @param value
392    *    The new value for this property.
393    * @return This object (for method chaining).
394    */
395   public RdfParserBuilder n3_widePropertyLen(int value) {
396      return set(RDF_n3_widePropertyLen, value);
397   }
398
399   /**
400    * Configuration property:  N3/Turtle property: <c>abbrevBaseURI</c>.
401    *
402    * <p>
403    * Control whether to use abbreviations <c>&lt;&gt;</c> or <c>&lt;#&gt;</c>.
404    *
405    * @param value
406    *    The new value for this property.
407    * @return This object (for method chaining).
408    */
409   public RdfParserBuilder n3_abbrevBaseUri(boolean value) {
410      return set(RDF_n3_abbrevBaseUri, value);
411   }
412
413   /**
414    * Configuration property:  N3/Turtle property: <c>usePropertySymbols</c>.
415    *
416    * <p>
417    * Control whether to use <c>a</c>, <c>=</c> and <c>=&gt;</c> in output
418    *
419    * @param value
420    *    The new value for this property.
421    * @return This object (for method chaining).
422    */
423   public RdfParserBuilder n3_usePropertySymbols(boolean value) {
424      return set(RDF_n3_usePropertySymbols, value);
425   }
426
427   /**
428    * Configuration property:  N3/Turtle property: <c>useTripleQuotedStrings</c>.
429    *
430    * <p>
431    * Allow the use of <c>"""</c> to delimit long strings.
432    *
433    * @param value
434    *    The new value for this property.
435    * @return This object (for method chaining).
436    */
437   public RdfParserBuilder n3_useTripleQuotedStrings(boolean value) {
438      return set(RDF_n3_useTripleQuotedStrings, value);
439   }
440
441   /**
442    * Configuration property:  N3/Turtle property: <c>useDoubles</c>.
443    *
444    * <p>
445    * Allow the use doubles as <c>123.456</c>.
446    *
447    * @param value
448    *    The new value for this property.
449    * @return This object (for method chaining).
450    */
451   public RdfParserBuilder n3_useDoubles(boolean value) {
452      return set(RDF_n3_useDoubles, value);
453   }
454
455   /**
456    * Configuration property:  RDF format for representing collections and arrays.
457    *
458    * <p>
459    * Possible values:
460    * <ul class='spaced-list'>
461    *    <li>
462    *       <js>"DEFAULT"</js> - Default format.  The default is an RDF Sequence container.
463    *    <li>
464    *       <js>"SEQ"</js> - RDF Sequence container.
465    *    <li>
466    *       <js>"BAG"</js> - RDF Bag container.
467    *    <li>
468    *       <js>"LIST"</js> - RDF List container.
469    *    <li>
470    *       <js>"MULTI_VALUED"</js> - Multi-valued properties.
471    * </ul>
472    *
473    * <ul class='notes'>
474    *    <li>
475    *       If you use <js>"BAG"</js> or <js>"MULTI_VALUED"</js>, the order of the elements in the collection will get
476    *       lost.
477    * </ul>
478    *
479    * @param value
480    *    The new value for this property.
481    * @return This object (for method chaining).
482    */
483   public RdfParserBuilder collectionFormat(String value) {
484      return set(RDF_collectionFormat, value);
485   }
486
487   /**
488    * Configuration property:  RDF format for representing collections and arrays.
489    *
490    * <p>
491    * Possible values:
492    * <ul class='spaced-list'>
493    *    <li>
494    *       <js>"DEFAULT"</js> - Default format.  The default is an RDF Sequence container.
495    *    <li>
496    *       <js>"SEQ"</js> - RDF Sequence container.
497    *    <li>
498    *       <js>"BAG"</js> - RDF Bag container.
499    *    <li>
500    *       <js>"LIST"</js> - RDF List container.
501    *    <li>
502    *       <js>"MULTI_VALUED"</js> - Multi-valued properties.
503    * </ul>
504    *
505    * <ul class='seealso'>
506    *    <li class='jf'>{@link RdfParser#RDF_collectionFormat}
507    * </ul>
508    *
509    * @param value The new value for this property.
510    * @return This object (for method chaining).
511    */
512   public RdfParserBuilder collectionFormat(RdfCollectionFormat value) {
513      return set(RDF_collectionFormat, value);
514   }
515
516   /**
517    * Configuration property:  Default XML namespace for bean properties.
518    *
519    * <ul class='seealso'>
520    *    <li class='jf'>{@link RdfParser#RDF_juneauBpNs}
521    * </ul>
522    *
523    * @param value
524    *    The new value for this property.
525    *    <br>The default is <code>{j:<js>'http://www.apache.org/juneaubp/'</js>}</code>.
526    * @return This object (for method chaining).
527    */
528   public RdfParserBuilder juneauBpNs(Namespace value) {
529      return set(RDF_juneauBpNs, value);
530   }
531
532   /**
533    * Configuration property:  XML namespace for Juneau properties.
534    *
535    * <ul class='seealso'>
536    *    <li class='jf'>{@link RdfParser#RDF_juneauNs}
537    * </ul>
538    *
539    * @param value
540    *    The new value for this property.
541    *    <br>The default is <code>{j:<js>'http://www.apache.org/juneau/'</js>}</code>.
542    * @return This object (for method chaining).
543    */
544   public RdfParserBuilder juneauNs(Namespace value) {
545      return set(RDF_juneauNs, value);
546   }
547
548   /**
549    * Configuration property:  RDF language.
550    *
551    * <p>
552    * Can be any of the following:
553    * <ul class='spaced-list'>
554    *    <li>
555    *       <js>"RDF/XML"</js>
556    *    <li>
557    *       <js>"RDF/XML-ABBREV"</js> (default)
558    *    <li>
559    *       <js>"N-TRIPLE"</js>
560    *    <li>
561    *       <js>"N3"</js> - General name for the N3 writer.
562    *       Will make a decision on exactly which writer to use (pretty writer, plain writer or simple writer) when
563    *       created.
564    *       Default is the pretty writer but can be overridden with system property
565    *       <c>org.apache.jena.n3.N3JenaWriter.writer</c>.
566    *    <li>
567    *       <js>"N3-PP"</js> - Name of the N3 pretty writer.
568    *       The pretty writer uses a frame-like layout, with prefixing, clustering like properties and embedding
569    *       one-referenced bNodes.
570    *    <li>
571    *       <js>"N3-PLAIN"</js> - Name of the N3 plain writer.
572    *       The plain writer writes records by subject.
573    *    <li>
574    *       <js>"N3-TRIPLES"</js> - Name of the N3 triples writer.
575    *       This writer writes one line per statement, like N-Triples, but does N3-style prefixing.
576    *    <li>
577    *       <js>"TURTLE"</js> -  Turtle writer.
578    *       http://www.dajobe.org/2004/01/turtle/
579    * </ul>
580    *
581    * <ul class='seealso'>
582    *    <li class='jf'>{@link RdfParser#RDF_language}
583    * </ul>
584    *
585    * @param value The new value for this property.
586    * @return This object (for method chaining).
587    */
588   public RdfParserBuilder language(String value) {
589      return set(RDF_language, value);
590   }
591
592   /**
593    * Configuration property:  Collections should be serialized and parsed as loose collections.
594    *
595    * <p>
596    * When specified, collections of resources are handled as loose collections of resources in RDF instead of
597    * resources that are children of an RDF collection (e.g. Sequence, Bag).
598    *
599    * <ul class='seealso'>
600    *    <li class='jf'>{@link RdfParser#RDF_looseCollections}
601    * </ul>
602    *
603    * @param value
604    *    The new value for this property.
605    *    <br>The default is <jk>false</jk>.
606    * @return This object (for method chaining).
607    */
608   public RdfParserBuilder looseCollections(boolean value) {
609      return set(RDF_looseCollections, value);
610   }
611
612   /**
613    * Configuration property:  Collections should be serialized and parsed as loose collections.
614    *
615    * <p>
616    * Shortcut for calling <code>looseCollection(<jk>true</jk>)</code>.
617    *
618    * <ul class='seealso'>
619    *    <li class='jf'>{@link RdfParser#RDF_looseCollections}
620    * </ul>
621    *
622    * @return This object (for method chaining).
623    */
624   public RdfParserBuilder looseCollections() {
625      return set(RDF_looseCollections, true);
626   }
627
628   /**
629    * Configuration property:  RDF language.
630    *
631    * <p>
632    * Shortcut for calling <code>language(<jsf>LANG_N3</jsf>)</code>.
633    *
634    * <ul class='seealso'>
635    *    <li class='jf'>{@link RdfParser#RDF_language}
636    * </ul>
637    *
638    * @return This object (for method chaining).
639    */
640   public RdfParserBuilder n3() {
641      return language(Constants.LANG_N3);
642   }
643
644   /**
645    * Configuration property:  RDF language.
646    *
647    * <p>
648    * Shortcut for calling <code>language(<jsf>LANG_NTRIPLE</jsf>)</code>.
649    *
650    * <ul class='seealso'>
651    *    <li class='jf'>{@link RdfParser#RDF_language}
652    * </ul>
653    *
654    * @return This object (for method chaining).
655    */
656   public RdfParserBuilder ntriple() {
657      return language(Constants.LANG_NTRIPLE);
658   }
659
660   /**
661    * Configuration property:  Trim whitespace from text elements.
662    *
663    * <p>
664    * If <jk>true</jk>, whitespace in text elements will be automatically trimmed.
665    *
666    * <ul class='seealso'>
667    *    <li class='jf'>{@link RdfParser#RDF_trimWhitespace}
668    * </ul>
669    *
670    * @param value
671    *    The new value for this property.
672    *    <br>The default is <jk>false</jk>.
673    * @return This object (for method chaining).
674    */
675   public RdfParserBuilder trimWhitespace(boolean value) {
676      return set(RDF_trimWhitespace, value);
677   }
678
679   /**
680    * Configuration property:  Trim whitespace from text elements.
681    *
682    * <p>
683    * Shortcut for calling <code>trimWhitespace(<jk>true</jk>)</code>.
684    *
685    * <ul class='seealso'>
686    *    <li class='jf'>{@link RdfParser#RDF_trimWhitespace}
687    * </ul>
688    *
689    * @return This object (for method chaining).
690    */
691   public RdfParserBuilder trimWhitespace() {
692      return set(RDF_trimWhitespace, true);
693   }
694
695   /**
696    * Shortcut for calling <code>language(<jsf>LANG_TURTLE</jsf>)</code>.
697    *
698    * <ul class='seealso'>
699    *    <li class='jf'>{@link RdfParser#RDF_language}
700    * </ul>
701    *
702    * @return This object (for method chaining).
703    */
704   public RdfParserBuilder turtle() {
705      return language(Constants.LANG_TURTLE);
706   }
707
708   /**
709    * Shortcut for calling <code>language(<jsf>LANG_RDF_XML</jsf>)</code>.
710    *
711    * <ul class='seealso'>
712    *    <li class='jf'>{@link RdfParser#RDF_language}
713    * </ul>
714    *
715    * @return This object (for method chaining).
716    */
717   public RdfParserBuilder xml() {
718      return language(Constants.LANG_RDF_XML);
719   }
720
721   /**
722    * Shortcut for calling <code>language(<jsf>LANG_RDF_XML_ABBREV</jsf>)</code>.
723    *
724    * <ul class='seealso'>
725    *    <li class='jf'>{@link RdfParser#RDF_language}
726    * </ul>
727    *
728    * @return This object (for method chaining).
729    */
730   public RdfParserBuilder xmlabbrev() {
731      return language(Constants.LANG_RDF_XML_ABBREV);
732   }
733
734   @Override /* ReaderParserBuilder */
735   public RdfParserBuilder fileCharset(Charset value) {
736      super.fileCharset(value);
737      return this;
738   }
739
740   @Override /* ReaderParserBuilder */
741   public RdfParserBuilder streamCharset(Charset value) {
742      super.streamCharset(value);
743      return this;
744   }
745
746   @Override /* ParserBuilder */
747   public RdfParserBuilder autoCloseStreams(boolean value) {
748      super.autoCloseStreams(value);
749      return this;
750   }
751
752   @Override /* ParserBuilder */
753   public RdfParserBuilder autoCloseStreams() {
754      super.autoCloseStreams();
755      return this;
756   }
757
758   @Override /* ParserBuilder */
759   public RdfParserBuilder debugOutputLines(int value) {
760      super.debugOutputLines(value);
761      return this;
762   }
763
764   @Override /* ParserBuilder */
765   public RdfParserBuilder listener(Class<? extends ParserListener> value) {
766      super.listener(value);
767      return this;
768   }
769
770   @Override /* ParserBuilder */
771   public RdfParserBuilder strict(boolean value) {
772      super.strict(value);
773      return this;
774   }
775
776   @Override /* ParserBuilder */
777   public RdfParserBuilder strict() {
778      super.strict();
779      return this;
780   }
781
782   @Override /* ParserBuilder */
783   public RdfParserBuilder trimStrings(boolean value) {
784      super.trimStrings(value);
785      return this;
786   }
787
788   @Override /* ParserBuilder */
789   public RdfParserBuilder trimStrings() {
790      super.trimStrings();
791      return this;
792   }
793
794   @Override /* ParserBuilder */
795   public RdfParserBuilder unbuffered(boolean value) {
796      super.unbuffered(value);
797      return this;
798   }
799
800   @Override /* ParserBuilder */
801   public RdfParserBuilder unbuffered() {
802      super.unbuffered();
803      return this;
804   }
805
806   @Override /* BeanContextBuilder */
807   public RdfParserBuilder beanClassVisibility(Visibility value) {
808      super.beanClassVisibility(value);
809      return this;
810   }
811
812   @Override /* BeanContextBuilder */
813   public RdfParserBuilder beanConstructorVisibility(Visibility value) {
814      super.beanConstructorVisibility(value);
815      return this;
816   }
817
818   @Override /* BeanContextBuilder */
819   public RdfParserBuilder beanDictionary(Class<?>...values) {
820      super.beanDictionary(values);
821      return this;
822   }
823
824   @Override /* BeanContextBuilder */
825   public RdfParserBuilder beanDictionary(Object...values) {
826      super.beanDictionary(values);
827      return this;
828   }
829
830   @Override /* BeanContextBuilder */
831   public RdfParserBuilder beanDictionaryReplace(Class<?>...values) {
832      super.beanDictionaryReplace(values);
833      return this;
834   }
835
836   @Override /* BeanContextBuilder */
837   public RdfParserBuilder beanDictionaryReplace(Object...values) {
838      super.beanDictionaryReplace(values);
839      return this;
840   }
841
842   @Override /* BeanContextBuilder */
843   public RdfParserBuilder beanDictionaryRemove(Class<?>...values) {
844      super.beanDictionaryRemove(values);
845      return this;
846   }
847
848   @Override /* BeanContextBuilder */
849   public RdfParserBuilder beanDictionaryRemove(Object...values) {
850      super.beanDictionaryRemove(values);
851      return this;
852   }
853
854   @Override /* BeanContextBuilder */
855   public RdfParserBuilder beanFieldVisibility(Visibility value) {
856      super.beanFieldVisibility(value);
857      return this;
858   }
859
860   @Override /* BeanContextBuilder */
861   public RdfParserBuilder beanFilters(Class<?>...values) {
862      super.beanFilters(values);
863      return this;
864   }
865
866   @Override /* BeanContextBuilder */
867   public RdfParserBuilder beanFilters(Object...values) {
868      super.beanFilters(values);
869      return this;
870   }
871
872   @Override /* BeanContextBuilder */
873   public RdfParserBuilder beanFiltersReplace(Class<?>...values) {
874      super.beanFiltersReplace(values);
875      return this;
876   }
877
878   @Override /* BeanContextBuilder */
879   public RdfParserBuilder beanFiltersReplace(Object...values) {
880      super.beanFiltersReplace(values);
881      return this;
882   }
883
884   @Override /* BeanContextBuilder */
885   public RdfParserBuilder beanFiltersRemove(Class<?>...values) {
886      super.beanFiltersRemove(values);
887      return this;
888   }
889
890   @Override /* BeanContextBuilder */
891   public RdfParserBuilder beanFiltersRemove(Object...values) {
892      super.beanFiltersRemove(values);
893      return this;
894   }
895
896   @Override /* BeanContextBuilder */
897   public RdfParserBuilder beanMapPutReturnsOldValue(boolean value) {
898      super.beanMapPutReturnsOldValue(value);
899      return this;
900   }
901
902   @Override /* BeanContextBuilder */
903   public RdfParserBuilder beanMapPutReturnsOldValue() {
904      super.beanMapPutReturnsOldValue();
905      return this;
906   }
907
908   @Override /* BeanContextBuilder */
909   public RdfParserBuilder beanMethodVisibility(Visibility value) {
910      super.beanMethodVisibility(value);
911      return this;
912   }
913
914   @Override /* BeanContextBuilder */
915   public RdfParserBuilder beansRequireDefaultConstructor(boolean value) {
916      super.beansRequireDefaultConstructor(value);
917      return this;
918   }
919
920   @Override /* BeanContextBuilder */
921   public RdfParserBuilder beansRequireDefaultConstructor() {
922      super.beansRequireDefaultConstructor();
923      return this;
924   }
925
926   @Override /* BeanContextBuilder */
927   public RdfParserBuilder beansRequireSerializable(boolean value) {
928      super.beansRequireSerializable(value);
929      return this;
930   }
931
932   @Override /* BeanContextBuilder */
933   public RdfParserBuilder beansRequireSerializable() {
934      super.beansRequireSerializable();
935      return this;
936   }
937
938   @Override /* BeanContextBuilder */
939   public RdfParserBuilder beansRequireSettersForGetters(boolean value) {
940      super.beansRequireSettersForGetters(value);
941      return this;
942   }
943
944   @Override /* BeanContextBuilder */
945   public RdfParserBuilder beansRequireSettersForGetters() {
946      super.beansRequireSettersForGetters();
947      return this;
948   }
949
950   @Override /* BeanContextBuilder */
951   public RdfParserBuilder beansRequireSomeProperties(boolean value) {
952      super.beansRequireSomeProperties(value);
953      return this;
954   }
955
956   @Override /* BeanContextBuilder */
957   public RdfParserBuilder beanTypePropertyName(String value) {
958      super.beanTypePropertyName(value);
959      return this;
960   }
961
962   @Override /* BeanContextBuilder */
963   public RdfParserBuilder debug() {
964      super.debug();
965      return this;
966   }
967
968   @Override /* BeanContextBuilder */
969   public <T> RdfParserBuilder example(Class<T> c, T o) {
970      super.example(c, o);
971      return this;
972   }
973
974   @Override /* BeanContextBuilder */
975   public <T> RdfParserBuilder exampleJson(Class<T> c, String value) {
976      super.exampleJson(c, value);
977      return this;
978   }
979
980   @Override /* BeanContextBuilder */
981   public RdfParserBuilder ignoreInvocationExceptionsOnGetters(boolean value) {
982      super.ignoreInvocationExceptionsOnGetters(value);
983      return this;
984   }
985
986   @Override /* BeanContextBuilder */
987   public RdfParserBuilder ignoreInvocationExceptionsOnGetters() {
988      super.ignoreInvocationExceptionsOnGetters();
989      return this;
990   }
991
992   @Override /* BeanContextBuilder */
993   public RdfParserBuilder ignoreInvocationExceptionsOnSetters(boolean value) {
994      super.ignoreInvocationExceptionsOnSetters(value);
995      return this;
996   }
997
998   @Override /* BeanContextBuilder */
999   public RdfParserBuilder ignoreInvocationExceptionsOnSetters() {
1000      super.ignoreInvocationExceptionsOnSetters();
1001      return this;
1002   }
1003
1004   @Override /* BeanContextBuilder */
1005   public RdfParserBuilder ignorePropertiesWithoutSetters(boolean value) {
1006      super.ignorePropertiesWithoutSetters(value);
1007      return this;
1008   }
1009
1010   @Override /* BeanContextBuilder */
1011   public RdfParserBuilder ignoreUnknownBeanProperties(boolean value) {
1012      super.ignoreUnknownBeanProperties(value);
1013      return this;
1014   }
1015
1016   @Override /* BeanContextBuilder */
1017   public RdfParserBuilder ignoreUnknownBeanProperties() {
1018      super.ignoreUnknownBeanProperties();
1019      return this;
1020   }
1021
1022   @Override /* BeanContextBuilder */
1023   public RdfParserBuilder ignoreUnknownNullBeanProperties(boolean value) {
1024      super.ignoreUnknownNullBeanProperties(value);
1025      return this;
1026   }
1027
1028   @Override /* BeanContextBuilder */
1029   public RdfParserBuilder implClass(Class<?> interfaceClass, Class<?> implClass) {
1030      super.implClass(interfaceClass, implClass);
1031      return this;
1032   }
1033
1034   @Override /* BeanContextBuilder */
1035   public RdfParserBuilder implClasses(Map<String,Class<?>> values) {
1036      super.implClasses(values);
1037      return this;
1038   }
1039
1040   @Override /* BeanContextBuilder */
1041   public RdfParserBuilder locale(Locale value) {
1042      super.locale(value);
1043      return this;
1044   }
1045
1046   @Override /* BeanContextBuilder */
1047   public RdfParserBuilder mediaType(MediaType value) {
1048      super.mediaType(value);
1049      return this;
1050   }
1051
1052   @Override /* BeanContextBuilder */
1053   public RdfParserBuilder notBeanClasses(Class<?>...values) {
1054      super.notBeanClasses(values);
1055      return this;
1056   }
1057
1058   @Override /* BeanContextBuilder */
1059   public RdfParserBuilder notBeanClasses(Object...values) {
1060      super.notBeanClasses(values);
1061      return this;
1062   }
1063
1064   @Override /* BeanContextBuilder */
1065   public RdfParserBuilder notBeanClassesReplace(Class<?>...values) {
1066      super.notBeanClassesReplace(values);
1067      return this;
1068   }
1069
1070   @Override /* BeanContextBuilder */
1071   public RdfParserBuilder notBeanClassesReplace(Object...values) {
1072      super.notBeanClassesReplace(values);
1073      return this;
1074   }
1075
1076   @Override /* BeanContextBuilder */
1077   public RdfParserBuilder notBeanClassesRemove(Class<?>...values) {
1078      super.notBeanClassesRemove(values);
1079      return this;
1080   }
1081
1082   @Override /* BeanContextBuilder */
1083   public RdfParserBuilder notBeanClassesRemove(Object...values) {
1084      super.notBeanClassesRemove(values);
1085      return this;
1086   }
1087
1088   @Override /* BeanContextBuilder */
1089   public RdfParserBuilder notBeanPackages(Object...values) {
1090      super.notBeanPackages(values);
1091      return this;
1092   }
1093
1094   @Override /* BeanContextBuilder */
1095   public RdfParserBuilder notBeanPackages(String...values) {
1096      super.notBeanPackages(values);
1097      return this;
1098   }
1099
1100   @Override /* BeanContextBuilder */
1101   public RdfParserBuilder notBeanPackagesReplace(String...values) {
1102      super.notBeanPackagesReplace(values);
1103      return this;
1104   }
1105
1106   @Override /* BeanContextBuilder */
1107   public RdfParserBuilder notBeanPackagesReplace(Object...values) {
1108      super.notBeanPackagesReplace(values);
1109      return this;
1110   }
1111
1112   @Override /* BeanContextBuilder */
1113   public RdfParserBuilder notBeanPackagesRemove(String...values) {
1114      super.notBeanPackagesRemove(values);
1115      return this;
1116   }
1117
1118   @Override /* BeanContextBuilder */
1119   public RdfParserBuilder notBeanPackagesRemove(Object...values) {
1120      super.notBeanPackagesRemove(values);
1121      return this;
1122   }
1123
1124   @Override /* BeanContextBuilder */
1125   public RdfParserBuilder pojoSwaps(Class<?>...values) {
1126      super.pojoSwaps(values);
1127      return this;
1128   }
1129
1130   @Override /* BeanContextBuilder */
1131   public RdfParserBuilder pojoSwaps(Object...values) {
1132      super.pojoSwaps(values);
1133      return this;
1134   }
1135
1136   @Override /* BeanContextBuilder */
1137   public RdfParserBuilder pojoSwapsReplace(Class<?>...values) {
1138      super.pojoSwapsReplace(values);
1139      return this;
1140   }
1141
1142   @Override /* BeanContextBuilder */
1143   public RdfParserBuilder pojoSwapsReplace(Object...values) {
1144      super.pojoSwapsReplace(values);
1145      return this;
1146   }
1147
1148   @Override /* BeanContextBuilder */
1149   public RdfParserBuilder pojoSwapsRemove(Class<?>...values) {
1150      super.pojoSwapsRemove(values);
1151      return this;
1152   }
1153
1154   @Override /* BeanContextBuilder */
1155   public RdfParserBuilder pojoSwapsRemove(Object...values) {
1156      super.pojoSwapsRemove(values);
1157      return this;
1158   }
1159
1160   @Override /* BeanContextBuilder */
1161   public RdfParserBuilder sortProperties(boolean value) {
1162      super.sortProperties(value);
1163      return this;
1164   }
1165
1166   @Override /* BeanContextBuilder */
1167   public RdfParserBuilder sortProperties() {
1168      super.sortProperties();
1169      return this;
1170   }
1171
1172   @Override /* BeanContextBuilder */
1173   public RdfParserBuilder timeZone(TimeZone value) {
1174      super.timeZone(value);
1175      return this;
1176   }
1177
1178   @Override /* BeanContextBuilder */
1179   public RdfParserBuilder useEnumNames(boolean value) {
1180      super.useEnumNames(value);
1181      return this;
1182   }
1183
1184   @Override /* BeanContextBuilder */
1185   public RdfParserBuilder useEnumNames() {
1186      super.useEnumNames();
1187      return this;
1188   }
1189
1190   @Override /* BeanContextBuilder */
1191   public RdfParserBuilder useInterfaceProxies(boolean value) {
1192      super.useInterfaceProxies(value);
1193      return this;
1194   }
1195
1196   @Override /* BeanContextBuilder */
1197   public RdfParserBuilder useJavaBeanIntrospector(boolean value) {
1198      super.useJavaBeanIntrospector(value);
1199      return this;
1200   }
1201
1202   @Override /* BeanContextBuilder */
1203   public RdfParserBuilder useJavaBeanIntrospector() {
1204      super.useJavaBeanIntrospector();
1205      return this;
1206   }
1207
1208   @Override /* ContextBuilder */
1209   public RdfParserBuilder set(String name, Object value) {
1210      super.set(name, value);
1211      return this;
1212   }
1213
1214   @Override /* ContextBuilder */
1215   public RdfParserBuilder set(Map<String,Object> properties) {
1216      super.set(properties);
1217      return this;
1218   }
1219
1220   @Override /* ContextBuilder */
1221   public RdfParserBuilder add(Map<String,Object> properties) {
1222      super.add(properties);
1223      return this;
1224   }
1225
1226   @Override /* ContextBuilder */
1227   public RdfParserBuilder addTo(String name, Object value) {
1228      super.addTo(name, value);
1229      return this;
1230   }
1231
1232   @Override /* ContextBuilder */
1233   public RdfParserBuilder addTo(String name, String key, Object value) {
1234      super.addTo(name, key, value);
1235      return this;
1236   }
1237
1238   @Override /* ContextBuilder */
1239   public RdfParserBuilder removeFrom(String name, Object value) {
1240      super.removeFrom(name, value);
1241      return this;
1242   }
1243
1244   @Override /* ContextBuilder */
1245   public RdfParserBuilder apply(PropertyStore copyFrom) {
1246      super.apply(copyFrom);
1247      return this;
1248   }
1249
1250   @Override
1251   public RdfParserBuilder applyAnnotations(AnnotationList al, VarResolverSession vrs) {
1252      super.applyAnnotations(al, vrs);
1253      return this;
1254   }
1255}