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><></c> or <c><#></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>=></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}