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