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.RdfSerializer.*;
017
018import java.util.*;
019
020import org.apache.juneau.*;
021import org.apache.juneau.http.*;
022import org.apache.juneau.jena.annotation.*;
023import org.apache.juneau.serializer.*;
024import org.apache.juneau.xml.*;
025import org.apache.juneau.xml.annotation.*;
026
027/**
028 * Builder class for building instances of RDF serializers.
029 */
030public class RdfSerializerBuilder extends WriterSerializerBuilder {
031
032   /**
033    * Constructor, default settings.
034    */
035   public RdfSerializerBuilder() {
036      super();
037   }
038
039   /**
040    * Constructor.
041    *
042    * @param ps The initial configuration settings for this builder.
043    */
044   public RdfSerializerBuilder(PropertyStore ps) {
045      super(ps);
046   }
047
048   @Override /* ContextBuilder */
049   public RdfSerializer build() {
050      return build(RdfSerializer.class);
051   }
052
053
054   //-----------------------------------------------------------------------------------------------------------------
055   // Properties
056   //-----------------------------------------------------------------------------------------------------------------
057
058   /**
059    * Configuration property:  Add XSI data types to non-<code>String</code> literals.
060    *
061    * <h5 class='section'>See Also:</h5>
062    * <ul>
063    *    <li class='jf'>{@link RdfSerializer#RDF_addLiteralTypes}
064    * </ul>
065    *
066    * @param value
067    *    The new value for this property.
068    *    <br>The default is <jk>false</jk>.
069    * @return This object (for method chaining).
070    */
071   public RdfSerializerBuilder addLiteralTypes(boolean value) {
072      return set(RDF_addLiteralTypes, value);
073   }
074
075   /**
076    * Configuration property:  Add XSI data types to non-<code>String</code> literals.
077    *
078    * <p>
079    * Shortcut for calling <code>addLiteralTypes(<jk>true</jk>)</code>.
080    *
081    * @return This object (for method chaining).
082    */
083   public RdfSerializerBuilder addLiteralTypes() {
084      return set(RDF_addLiteralTypes, true);
085   }
086
087   /**
088    * Configuration property:  Add RDF root identifier property to root node.
089    *
090    * <p>
091    * When enabled an RDF property <code>http://www.apache.org/juneau/root</code> is added with a value of <js>"true"</js>
092    * to identify the root node in the graph.
093    * This helps locate the root node during parsing.
094    *
095    * <p>
096    * If disabled, the parser has to search through the model to find any resources without incoming predicates to
097    * identify root notes, which can introduce a considerable performance degradation.
098    *
099    * <h5 class='section'>See Also:</h5>
100    * <ul>
101    *    <li class='jf'>{@link RdfSerializer#RDF_addRootProperty}
102    * </ul>
103    *
104    * @param value
105    *    The new value for this property.
106    *    <br>The default is <jk>false</jk>.
107    * @return This object (for method chaining).
108    */
109   public RdfSerializerBuilder addRootProperty(boolean value) {
110      return set(RDF_addRootProperty, value);
111   }
112
113   /**
114    * Configuration property:  Add RDF root identifier property to root node.
115    *
116    * <p>
117    * Shortcut for calling <code>addRootProperty(<jk>true</jk>)</code>.
118    *
119    * <h5 class='section'>See Also:</h5>
120    * <ul>
121    *    <li class='jf'>{@link RdfSerializer#RDF_addRootProperty}
122    * </ul>
123    *
124    * @return This object (for method chaining).
125    */
126   public RdfSerializerBuilder addRootProperty() {
127      return set(RDF_addRootProperty, true);
128   }
129
130   /**
131    * Configuration property:  Auto-detect namespace usage.
132    *
133    * <p>
134    * Detect namespace usage before serialization.
135    *
136    * <h5 class='section'>See Also:</h5>
137    * <ul>
138    *    <li class='jf'>{@link RdfSerializer#RDF_autoDetectNamespaces}
139    * </ul>
140    *
141    * @param value
142    *    The new value for this property.
143    *    <br>The default is <jk>true</jk>.
144    * @return This object (for method chaining).
145    */
146   public RdfSerializerBuilder autoDetectNamespaces(boolean value) {
147      return set(RDF_autoDetectNamespaces, value);
148   }
149
150   /**
151    * Configuration property:  RDF format for representing collections and arrays.
152    *
153    * <p>
154    *
155    * <h5 class='section'>Notes:</h5>
156    * <ul class='spaced-list'>
157    *    <li>
158    *       If you use <js>"BAG"</js> or <js>"MULTI_VALUED"</js>, the order of the elements in the collection will get
159    *       lost.
160    * </ul>
161    *
162    * <h5 class='section'>See Also:</h5>
163    * <ul>
164    *    <li class='jf'>{@link RdfSerializer#RDF_collectionFormat}
165    * </ul>
166    *
167    * @param value
168    *    The new value for this property.
169    *    <br>Possible values:
170    *    <ul>
171    *       <li><js>"DEFAULT"</js> - Default format.  The default is an RDF Sequence container.
172    *       <li><js>"SEQ"</js> - RDF Sequence container.
173    *       <li><js>"BAG"</js> - RDF Bag container.
174    *       <li><js>"LIST"</js> - RDF List container.
175    *       <li><js>"MULTI_VALUED"</js> - Multi-valued properties.
176    *    </ul>
177    * @return This object (for method chaining).
178    */
179   public RdfSerializerBuilder collectionFormat(RdfCollectionFormat value) {
180      return set(RDF_collectionFormat, value);
181   }
182
183   /**
184    * Configuration property:  Default XML namespace for bean properties.
185    *
186    * <h5 class='section'>See Also:</h5>
187    * <ul>
188    *    <li class='jf'>{@link RdfSerializer#RDF_juneauBpNs}
189    * </ul>
190    *
191    * @param value
192    *    The new value for this property.
193    *    <br>The default is <code>{j:<js>'http://www.apache.org/juneaubp/'</js>}</code>.
194    * @return This object (for method chaining).
195    */
196   public RdfSerializerBuilder juneauBpNs(Namespace value) {
197      return set(RDF_juneauBpNs, value);
198   }
199
200   /**
201    * Configuration property:  XML namespace for Juneau properties.
202    *
203    * <h5 class='section'>See Also:</h5>
204    * <ul>
205    *    <li class='jf'>{@link RdfSerializer#RDF_juneauNs}
206    * </ul>
207    *
208    * @param value
209    *    The new value for this property.
210    *    <br>The default is <code>{j:<js>'http://www.apache.org/juneau/'</js>}</code>.
211    * @return This object (for method chaining).
212    */
213   public RdfSerializerBuilder juneauNs(Namespace value) {
214      return set(RDF_juneauNs, value);
215   }
216
217   /**
218    * Configuration property:  RDF language.
219    *
220    * <p>
221    * Can be any of the following:
222    * <ul class='spaced-list'>
223    *    <li>
224    *       <js>"RDF/XML"</js>
225    *    <li>
226    *       <js>"RDF/XML-ABBREV"</js> (default)
227    *    <li>
228    *       <js>"N-TRIPLE"</js>
229    *    <li>
230    *       <js>"N3"</js> - General name for the N3 writer.
231    *       Will make a decision on exactly which writer to use (pretty writer, plain writer or simple writer) when
232    *       created.
233    *       Default is the pretty writer but can be overridden with system property
234    *       <code>com.hp.hpl.jena.n3.N3JenaWriter.writer</code>.
235    *    <li>
236    *       <js>"N3-PP"</js> - Name of the N3 pretty writer.
237    *       The pretty writer uses a frame-like layout, with prefixing, clustering like properties and embedding
238    *       one-referenced bNodes.
239    *    <li>
240    *       <js>"N3-PLAIN"</js> - Name of the N3 plain writer.
241    *       The plain writer writes records by subject.
242    *    <li>
243    *       <js>"N3-TRIPLES"</js> - Name of the N3 triples writer.
244    *       This writer writes one line per statement, like N-Triples, but does N3-style prefixing.
245    *    <li>
246    *       <js>"TURTLE"</js> -  Turtle writer.
247    *       http://www.dajobe.org/2004/01/turtle/
248    * </ul>
249    *
250    * <h5 class='section'>See Also:</h5>
251    * <ul>
252    *    <li class='jf'>{@link RdfSerializer#RDF_language}
253    * </ul>
254    *
255    * @param value
256    *    The new value for this property.
257    * @return This object (for method chaining).
258    */
259   public RdfSerializerBuilder language(String value) {
260      return set(RDF_language, value);
261   }
262
263   /**
264    * Configuration property:  Collections should be serialized and parsed as loose collections.
265    *
266    * <p>
267    * When specified, collections of resources are handled as loose collections of resources in RDF instead of
268    * resources that are children of an RDF collection (e.g. Sequence, Bag).
269    *
270    * <h5 class='section'>See Also:</h5>
271    * <ul>
272    *    <li class='jf'>{@link RdfSerializer#RDF_looseCollections}
273    * </ul>
274    *
275    * @param value
276    *    The new value for this property.
277    *    <br>The default is <jk>false</jk>.
278    * @return This object (for method chaining).
279    */
280   public RdfSerializerBuilder looseCollections(boolean value) {
281      return set(RDF_looseCollections, value);
282   }
283
284   /**
285    * Configuration property:  Collections should be serialized and parsed as loose collections.
286    *
287    * <p>
288    * Shortcut for <code>looseCollections(<jk>true</jk>)</code>.
289    *
290    * <h5 class='section'>See Also:</h5>
291    * <ul>
292    *    <li class='jf'>{@link RdfSerializer#RDF_looseCollections}
293    * </ul>
294    *
295    * @return This object (for method chaining).
296    */
297   public RdfSerializerBuilder looseCollections() {
298      return set(RDF_looseCollections, true);
299   }
300
301   /**
302    * Configuration property:  RDF language.
303    *
304    * <p>
305    * Shortcut for calling <code>language(<jsf>LANG_N3</jsf>)</code>
306    *
307    * <h5 class='section'>See Also:</h5>
308    * <ul>
309    *    <li class='jf'>{@link RdfSerializer#RDF_language}
310    * </ul>
311    *
312    * @return This object (for method chaining).
313    */
314   public RdfSerializerBuilder n3() {
315      return language(Constants.LANG_N3);
316   }
317
318   /**
319    * Configuration property:  Default namespaces.
320    *
321    * <p>
322    * The default list of namespaces associated with this serializer.
323    *
324    * <h5 class='section'>See Also:</h5>
325    * <ul>
326    *    <li class='jf'>{@link RdfSerializer#RDF_namespaces}
327    * </ul>
328    *
329    * @param values The new value for this property.
330    * @return This object (for method chaining).
331    */
332   public RdfSerializerBuilder namespaces(Namespace...values) {
333      return set(RDF_namespaces, values);
334   }
335
336   /**
337    * Configuration property:  RDF language.
338    *
339    * <p>
340    * Shortcut for calling <code>language(<jsf>LANG_NTRIPLE</jsf>)</code>
341    *
342    * <h5 class='section'>See Also:</h5>
343    * <ul>
344    *    <li class='jf'>{@link RdfSerializer#RDF_language}
345    * </ul>
346    *
347    * @return This object (for method chaining).
348    */
349   public RdfSerializerBuilder ntriple() {
350      return language(Constants.LANG_NTRIPLE);
351   }
352
353   /**
354    * Configuration property:  RDF language.
355    *
356    * <p>
357    * Shortcut for calling <code>language(<jsf>LANG_TURTLE</jsf>)</code>
358    *
359    * <h5 class='section'>See Also:</h5>
360    * <ul>
361    *    <li class='jf'>{@link RdfSerializer#RDF_language}
362    * </ul>
363    *
364    * @return This object (for method chaining).
365    */
366   public RdfSerializerBuilder turtle() {
367      return language(Constants.LANG_TURTLE);
368   }
369
370   /**
371    * Configuration property:  Reuse XML namespaces when RDF namespaces not specified.
372    *
373    * <p>
374    * When specified, namespaces defined using {@link XmlNs @XmlNs} and {@link org.apache.juneau.xml.annotation.Xml Xml} will be
375    * inherited by the RDF serializers.
376    * Otherwise, namespaces will be defined using {@link RdfNs @RdfNs} and {@link Rdf @Rdf}.
377    *
378    * <h5 class='section'>See Also:</h5>
379    * <ul>
380    *    <li class='jf'>{@link RdfSerializer#RDF_useXmlNamespaces}
381    * </ul>
382    *
383    * @param value
384    *    The new value for this property.
385    *    <br>The default is <jk>true</jk>.
386    * @return This object (for method chaining).
387    */
388   public RdfSerializerBuilder useXmlNamespaces(boolean value) {
389      return set(RDF_useXmlNamespaces, value);
390   }
391
392   /**
393    * Configuration property:  RDF language.
394    *
395    * <p>
396    * Shortcut for calling <code>language(<jsf>LANG_RDF_XML</jsf>)</code>
397    *
398    * <h5 class='section'>See Also:</h5>
399    * <ul>
400    *    <li class='jf'>{@link RdfSerializer#RDF_language}
401    * </ul>
402    *
403    * @return This object (for method chaining).
404    */
405   public RdfSerializerBuilder xml() {
406      return language(Constants.LANG_RDF_XML);
407   }
408
409   /**
410    * Configuration property:  RDF language.
411    *
412    * <p>
413    * Shortcut for calling <code>language(<jsf>LANG_RDF_XML_ABBREV</jsf>)</code>
414    *
415    * <h5 class='section'>See Also:</h5>
416    * <ul>
417    *    <li class='jf'>{@link RdfSerializer#RDF_language}
418    * </ul>
419    *
420    * @return This object (for method chaining).
421    */
422   public RdfSerializerBuilder xmlabbrev() {
423      return language(Constants.LANG_RDF_XML_ABBREV);
424   }
425
426   @Override /* WriterSerializerBuilder */
427   public RdfSerializerBuilder maxIndent(int value) {
428      super.maxIndent(value);
429      return this;
430   }
431
432   @Override /* WriterSerializerBuilder */
433   public RdfSerializerBuilder quoteChar(char value) {
434      super.quoteChar(value);
435      return this;
436   }
437
438   @Override /* WriterSerializerBuilder */
439   public RdfSerializerBuilder sq() {
440      super.sq();
441      return this;
442   }
443
444   @Override /* WriterSerializerBuilder */
445   public RdfSerializerBuilder useWhitespace(boolean value) {
446      super.useWhitespace(value);
447      return this;
448   }
449
450   @Override /* WriterSerializerBuilder */
451   public RdfSerializerBuilder useWhitespace() {
452      super.useWhitespace();
453      return this;
454   }
455
456   @Override /* WriterSerializerBuilder */
457   public RdfSerializerBuilder ws() {
458      super.ws();
459      return this;
460   }
461
462   @Override /* SerializerBuilder */
463   public RdfSerializerBuilder addBeanTypes(boolean value) {
464      super.addBeanTypes(value);
465      return this;
466   }
467
468   @Override /* SerializerBuilder */
469   public RdfSerializerBuilder addBeanTypes() {
470      super.addBeanTypes();
471      return this;
472   }
473
474   @Override /* SerializerBuilder */
475   public RdfSerializerBuilder addRootType(boolean value) {
476      super.addRootType(value);
477      return this;
478   }
479
480   @Override /* SerializerBuilder */
481   public RdfSerializerBuilder addRootType() {
482      super.addRootType();
483      return this;
484   }
485
486   @Override /* SerializerBuilder */
487   public RdfSerializerBuilder detectRecursions(boolean value) {
488      super.detectRecursions(value);
489      return this;
490   }
491
492   @Override /* SerializerBuilder */
493   public RdfSerializerBuilder detectRecursions() {
494      super.detectRecursions();
495      return this;
496   }
497
498   @Override /* SerializerBuilder */
499   public RdfSerializerBuilder ignoreRecursions(boolean value) {
500      super.ignoreRecursions(value);
501      return this;
502   }
503
504   @Override /* SerializerBuilder */
505   public RdfSerializerBuilder ignoreRecursions() {
506      super.ignoreRecursions();
507      return this;
508   }
509   @Override /* SerializerBuilder */
510   public RdfSerializerBuilder initialDepth(int value) {
511      super.initialDepth(value);
512      return this;
513   }
514
515   @Override /* SerializerBuilder */
516   public RdfSerializerBuilder listener(Class<? extends SerializerListener> value) {
517      super.listener(value);
518      return this;
519   }
520
521   @Override /* SerializerBuilder */
522   public RdfSerializerBuilder maxDepth(int value) {
523      super.maxDepth(value);
524      return this;
525   }
526
527   @Override /* SerializerBuilder */
528   public RdfSerializerBuilder sortCollections(boolean value) {
529      super.sortCollections(value);
530      return this;
531   }
532
533   @Override /* SerializerBuilder */
534   public RdfSerializerBuilder sortCollections() {
535      super.sortCollections();
536      return this;
537   }
538
539   @Override /* SerializerBuilder */
540   public RdfSerializerBuilder sortMaps(boolean value) {
541      super.sortMaps(value);
542      return this;
543   }
544
545   @Override /* SerializerBuilder */
546   public RdfSerializerBuilder sortMaps() {
547      super.sortMaps();
548      return this;
549   }
550
551   @Override /* SerializerBuilder */
552   public RdfSerializerBuilder trimEmptyCollections(boolean value) {
553      super.trimEmptyCollections(value);
554      return this;
555   }
556
557   @Override /* SerializerBuilder */
558   public RdfSerializerBuilder trimEmptyCollections() {
559      super.trimEmptyCollections();
560      return this;
561   }
562
563   @Override /* SerializerBuilder */
564   public RdfSerializerBuilder trimEmptyMaps(boolean value) {
565      super.trimEmptyMaps(value);
566      return this;
567   }
568
569   @Override /* SerializerBuilder */
570   public RdfSerializerBuilder trimEmptyMaps() {
571      super.trimEmptyMaps();
572      return this;
573   }
574
575   @Override /* SerializerBuilder */
576   public RdfSerializerBuilder trimNullProperties(boolean value) {
577      super.trimNullProperties(value);
578      return this;
579   }
580
581   @Override /* SerializerBuilder */
582   public RdfSerializerBuilder trimStrings(boolean value) {
583      super.trimStrings(value);
584      return this;
585   }
586
587   @Override /* SerializerBuilder */
588   public RdfSerializerBuilder trimStrings() {
589      super.trimStrings();
590      return this;
591   }
592
593   @Override /* SerializerBuilder */
594   public RdfSerializerBuilder uriContext(UriContext value) {
595      super.uriContext(value);
596      return this;
597   }
598
599   @Override /* SerializerBuilder */
600   public RdfSerializerBuilder uriRelativity(UriRelativity value) {
601      super.uriRelativity(value);
602      return this;
603   }
604
605   @Override /* SerializerBuilder */
606   public RdfSerializerBuilder uriResolution(UriResolution value) {
607      super.uriResolution(value);
608      return this;
609   }
610
611   @Override /* BeanContextBuilder */
612   public RdfSerializerBuilder beanClassVisibility(Visibility value) {
613      super.beanClassVisibility(value);
614      return this;
615   }
616
617   @Override /* BeanContextBuilder */
618   public RdfSerializerBuilder beanConstructorVisibility(Visibility value) {
619      super.beanConstructorVisibility(value);
620      return this;
621   }
622
623   @Override /* BeanContextBuilder */
624   public RdfSerializerBuilder beanDictionary(boolean append, Object...values) {
625      super.beanDictionary(append, values);
626      return this;
627   }
628
629   @Override /* BeanContextBuilder */
630   public RdfSerializerBuilder beanDictionary(Class<?>...values) {
631      super.beanDictionary(values);
632      return this;
633   }
634
635   @Override /* BeanContextBuilder */
636   public RdfSerializerBuilder beanDictionary(Object...values) {
637      super.beanDictionary(values);
638      return this;
639   }
640
641   @Override /* BeanContextBuilder */
642   public RdfSerializerBuilder beanDictionaryRemove(Object...values) {
643      super.beanDictionaryRemove(values);
644      return this;
645   }
646
647   @Override /* BeanContextBuilder */
648   public RdfSerializerBuilder beanFieldVisibility(Visibility value) {
649      super.beanFieldVisibility(value);
650      return this;
651   }
652
653   @Override /* BeanContextBuilder */
654   public RdfSerializerBuilder beanFilters(boolean append, Object...values) {
655      super.beanFilters(append, values);
656      return this;
657   }
658
659   @Override /* BeanContextBuilder */
660   public RdfSerializerBuilder beanFilters(Class<?>...values) {
661      super.beanFilters(values);
662      return this;
663   }
664
665   @Override /* BeanContextBuilder */
666   public RdfSerializerBuilder beanFilters(Object...values) {
667      super.beanFilters(values);
668      return this;
669   }
670
671   @Override /* BeanContextBuilder */
672   public RdfSerializerBuilder beanFiltersRemove(Object...values) {
673      super.beanFiltersRemove(values);
674      return this;
675   }
676
677   @Override /* BeanContextBuilder */
678   public RdfSerializerBuilder beanMapPutReturnsOldValue(boolean value) {
679      super.beanMapPutReturnsOldValue(value);
680      return this;
681   }
682
683   @Override /* BeanContextBuilder */
684   public RdfSerializerBuilder beanMapPutReturnsOldValue() {
685      super.beanMapPutReturnsOldValue();
686      return this;
687   }
688
689   @Override /* BeanContextBuilder */
690   public RdfSerializerBuilder beanMethodVisibility(Visibility value) {
691      super.beanMethodVisibility(value);
692      return this;
693   }
694
695   @Override /* BeanContextBuilder */
696   public RdfSerializerBuilder beansRequireDefaultConstructor(boolean value) {
697      super.beansRequireDefaultConstructor(value);
698      return this;
699   }
700
701   @Override /* BeanContextBuilder */
702   public RdfSerializerBuilder beansRequireDefaultConstructor() {
703      super.beansRequireDefaultConstructor();
704      return this;
705   }
706
707   @Override /* BeanContextBuilder */
708   public RdfSerializerBuilder beansRequireSerializable(boolean value) {
709      super.beansRequireSerializable(value);
710      return this;
711   }
712
713   @Override /* BeanContextBuilder */
714   public RdfSerializerBuilder beansRequireSerializable() {
715      super.beansRequireSerializable();
716      return this;
717   }
718
719   @Override /* BeanContextBuilder */
720   public RdfSerializerBuilder beansRequireSettersForGetters(boolean value) {
721      super.beansRequireSettersForGetters(value);
722      return this;
723   }
724
725   @Override /* BeanContextBuilder */
726   public RdfSerializerBuilder beansRequireSettersForGetters() {
727      super.beansRequireSettersForGetters();
728      return this;
729   }
730
731   @Override /* BeanContextBuilder */
732   public RdfSerializerBuilder beansRequireSomeProperties(boolean value) {
733      super.beansRequireSomeProperties(value);
734      return this;
735   }
736
737   @Override /* BeanContextBuilder */
738   public RdfSerializerBuilder beanTypePropertyName(String value) {
739      super.beanTypePropertyName(value);
740      return this;
741   }
742
743   @Override /* BeanContextBuilder */
744   public RdfSerializerBuilder debug() {
745      super.debug();
746      return this;
747   }
748
749   @Override /* BeanContextBuilder */
750   public <T> RdfSerializerBuilder example(Class<T> c, T o) {
751      super.example(c, o);
752      return this;
753   }
754
755   @Override /* BeanContextBuilder */
756   public RdfSerializerBuilder ignoreInvocationExceptionsOnGetters(boolean value) {
757      super.ignoreInvocationExceptionsOnGetters(value);
758      return this;
759   }
760
761   @Override /* BeanContextBuilder */
762   public RdfSerializerBuilder ignoreInvocationExceptionsOnGetters() {
763      super.ignoreInvocationExceptionsOnGetters();
764      return this;
765   }
766
767   @Override /* BeanContextBuilder */
768   public RdfSerializerBuilder ignoreInvocationExceptionsOnSetters(boolean value) {
769      super.ignoreInvocationExceptionsOnSetters(value);
770      return this;
771   }
772
773   @Override /* BeanContextBuilder */
774   public RdfSerializerBuilder ignoreInvocationExceptionsOnSetters() {
775      super.ignoreInvocationExceptionsOnSetters();
776      return this;
777   }
778
779   @Override /* BeanContextBuilder */
780   public RdfSerializerBuilder ignorePropertiesWithoutSetters(boolean value) {
781      super.ignorePropertiesWithoutSetters(value);
782      return this;
783   }
784
785   @Override /* BeanContextBuilder */
786   public RdfSerializerBuilder ignoreUnknownBeanProperties(boolean value) {
787      super.ignoreUnknownBeanProperties(value);
788      return this;
789   }
790
791   @Override /* BeanContextBuilder */
792   public RdfSerializerBuilder ignoreUnknownBeanProperties() {
793      super.ignoreUnknownBeanProperties();
794      return this;
795   }
796
797   @Override /* BeanContextBuilder */
798   public RdfSerializerBuilder ignoreUnknownNullBeanProperties(boolean value) {
799      super.ignoreUnknownNullBeanProperties(value);
800      return this;
801   }
802
803   @Override /* BeanContextBuilder */
804   public <T> RdfSerializerBuilder implClass(Class<T> interfaceClass, Class<? extends T> implClass) {
805      super.implClass(interfaceClass, implClass);
806      return this;
807   }
808
809   @Override /* BeanContextBuilder */
810   public RdfSerializerBuilder implClasses(Map<String,Class<?>> values) {
811      super.implClasses(values);
812      return this;
813   }
814
815   @Override /* BeanContextBuilder */
816   public RdfSerializerBuilder locale(Locale value) {
817      super.locale(value);
818      return this;
819   }
820
821   @Override /* BeanContextBuilder */
822   public RdfSerializerBuilder mediaType(MediaType value) {
823      super.mediaType(value);
824      return this;
825   }
826
827   @Override /* BeanContextBuilder */
828   public RdfSerializerBuilder notBeanClasses(boolean append, Object...values) {
829      super.notBeanClasses(append, values);
830      return this;
831   }
832
833   @Override /* BeanContextBuilder */
834   public RdfSerializerBuilder notBeanClasses(Class<?>...values) {
835      super.notBeanClasses(values);
836      return this;
837   }
838
839   @Override /* BeanContextBuilder */
840   public RdfSerializerBuilder notBeanClasses(Object...values) {
841      super.notBeanClasses(values);
842      return this;
843   }
844
845   @Override /* BeanContextBuilder */
846   public RdfSerializerBuilder notBeanClassesRemove(Object...values) {
847      super.notBeanClassesRemove(values);
848      return this;
849   }
850
851   @Override /* BeanContextBuilder */
852   public RdfSerializerBuilder notBeanPackages(boolean append, Object...values) {
853      super.notBeanPackages(append, values);
854      return this;
855   }
856
857   @Override /* BeanContextBuilder */
858   public RdfSerializerBuilder notBeanPackages(Object...values) {
859      super.notBeanPackages(values);
860      return this;
861   }
862
863   @Override /* BeanContextBuilder */
864   public RdfSerializerBuilder notBeanPackages(String...values) {
865      super.notBeanPackages(values);
866      return this;
867   }
868
869   @Override /* BeanContextBuilder */
870   public RdfSerializerBuilder notBeanPackagesRemove(Object...values) {
871      super.notBeanPackagesRemove(values);
872      return this;
873   }
874
875   @Override /* BeanContextBuilder */
876   public RdfSerializerBuilder pojoSwaps(boolean append, Object...values) {
877      super.pojoSwaps(append, values);
878      return this;
879   }
880
881   @Override /* BeanContextBuilder */
882   public RdfSerializerBuilder pojoSwaps(Class<?>...values) {
883      super.pojoSwaps(values);
884      return this;
885   }
886
887   @Override /* BeanContextBuilder */
888   public RdfSerializerBuilder pojoSwaps(Object...values) {
889      super.pojoSwaps(values);
890      return this;
891   }
892
893   @Override /* BeanContextBuilder */
894   public RdfSerializerBuilder pojoSwapsRemove(Object...values) {
895      super.pojoSwapsRemove(values);
896      return this;
897   }
898
899   @Override /* BeanContextBuilder */
900   public RdfSerializerBuilder sortProperties(boolean value) {
901      super.sortProperties(value);
902      return this;
903   }
904
905   @Override /* BeanContextBuilder */
906   public RdfSerializerBuilder sortProperties() {
907      super.sortProperties();
908      return this;
909   }
910
911   @Override /* BeanContextBuilder */
912   public RdfSerializerBuilder timeZone(TimeZone value) {
913      super.timeZone(value);
914      return this;
915   }
916
917   @Override /* BeanContextBuilder */
918   public RdfSerializerBuilder useEnumNames() {
919      super.useEnumNames();
920      return this;
921   }
922
923   @Override /* BeanContextBuilder */
924   public RdfSerializerBuilder useInterfaceProxies(boolean value) {
925      super.useInterfaceProxies(value);
926      return this;
927   }
928
929   @Override /* BeanContextBuilder */
930   public RdfSerializerBuilder useJavaBeanIntrospector(boolean value) {
931      super.useJavaBeanIntrospector(value);
932      return this;
933   }
934
935   @Override /* BeanContextBuilder */
936   public RdfSerializerBuilder useJavaBeanIntrospector() {
937      super.useJavaBeanIntrospector();
938      return this;
939   }
940
941   @Override /* ContextBuilder */
942   public RdfSerializerBuilder set(String name, Object value) {
943      super.set(name, value);
944      return this;
945   }
946
947   @Override /* ContextBuilder */
948   public RdfSerializerBuilder set(boolean append, String name, Object value) {
949      super.set(append, name, value);
950      return this;
951   }
952
953   @Override /* ContextBuilder */
954   public RdfSerializerBuilder set(Map<String,Object> properties) {
955      super.set(properties);
956      return this;
957   }
958
959   @Override /* ContextBuilder */
960   public RdfSerializerBuilder add(Map<String,Object> properties) {
961      super.add(properties);
962      return this;
963   }
964
965   @Override /* ContextBuilder */
966   public RdfSerializerBuilder addTo(String name, Object value) {
967      super.addTo(name, value);
968      return this;
969   }
970
971   @Override /* ContextBuilder */
972   public RdfSerializerBuilder addTo(String name, String key, Object value) {
973      super.addTo(name, key, value);
974      return this;
975   }
976
977   @Override /* ContextBuilder */
978   public RdfSerializerBuilder removeFrom(String name, Object value) {
979      super.removeFrom(name, value);
980      return this;
981   }
982
983   @Override /* ContextBuilder */
984   public RdfSerializerBuilder apply(PropertyStore copyFrom) {
985      super.apply(copyFrom);
986      return this;
987   }
988}