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.util.*; 019 020import org.apache.juneau.*; 021import org.apache.juneau.http.*; 022import org.apache.juneau.jena.annotation.*; 023import org.apache.juneau.parser.*; 024import org.apache.juneau.xml.*; 025import org.apache.juneau.xml.annotation.*; 026 027/** 028 * Builder class for building instances of RDF parsers. 029 */ 030public class RdfParserBuilder extends ReaderParserBuilder { 031 032 /** 033 * Constructor, default settings. 034 */ 035 public RdfParserBuilder() { 036 super(); 037 } 038 039 /** 040 * Constructor. 041 * 042 * @param ps The initial configuration settings for this builder. 043 */ 044 public RdfParserBuilder(PropertyStore ps) { 045 super(ps); 046 } 047 048 @Override /* ContextBuilder */ 049 public RdfParser build() { 050 return build(RdfParser.class); 051 } 052 053 054 //----------------------------------------------------------------------------------------------------------------- 055 // Properties 056 //----------------------------------------------------------------------------------------------------------------- 057 058 /** 059 * Configuration property: RDF format for representing collections and arrays. 060 * 061 * <p> 062 * Possible values: 063 * <ul class='spaced-list'> 064 * <li> 065 * <js>"DEFAULT"</js> - Default format. The default is an RDF Sequence container. 066 * <li> 067 * <js>"SEQ"</js> - RDF Sequence container. 068 * <li> 069 * <js>"BAG"</js> - RDF Bag container. 070 * <li> 071 * <js>"LIST"</js> - RDF List container. 072 * <li> 073 * <js>"MULTI_VALUED"</js> - Multi-valued properties. 074 * </ul> 075 * 076 * <h5 class='section'>See Also:</h5> 077 * <ul> 078 * <li class='jf'>{@link RdfParser#RDF_collectionFormat} 079 * </ul> 080 * 081 * @param value The new value for this property. 082 * @return This object (for method chaining). 083 */ 084 public RdfParserBuilder collectionFormat(RdfCollectionFormat value) { 085 return set(RDF_collectionFormat, value); 086 } 087 088 /** 089 * Configuration property: Default XML namespace for bean properties. 090 * 091 * <h5 class='section'>See Also:</h5> 092 * <ul> 093 * <li class='jf'>{@link RdfParser#RDF_juneauBpNs} 094 * </ul> 095 * 096 * @param value 097 * The new value for this property. 098 * <br>The default is <code>{j:<js>'http://www.apache.org/juneaubp/'</js>}</code>. 099 * @return This object (for method chaining). 100 */ 101 public RdfParserBuilder juneauBpNs(Namespace value) { 102 return set(RDF_juneauBpNs, value); 103 } 104 105 /** 106 * Configuration property: XML namespace for Juneau properties. 107 * 108 * <h5 class='section'>See Also:</h5> 109 * <ul> 110 * <li class='jf'>{@link RdfParser#RDF_juneauNs} 111 * </ul> 112 * 113 * @param value 114 * The new value for this property. 115 * <br>The default is <code>{j:<js>'http://www.apache.org/juneau/'</js>}</code>. 116 * @return This object (for method chaining). 117 */ 118 public RdfParserBuilder juneauNs(Namespace value) { 119 return set(RDF_juneauNs, value); 120 } 121 122 /** 123 * Configuration property: RDF language. 124 * 125 * <p> 126 * Can be any of the following: 127 * <ul class='spaced-list'> 128 * <li> 129 * <js>"RDF/XML"</js> 130 * <li> 131 * <js>"RDF/XML-ABBREV"</js> (default) 132 * <li> 133 * <js>"N-TRIPLE"</js> 134 * <li> 135 * <js>"N3"</js> - General name for the N3 writer. 136 * Will make a decision on exactly which writer to use (pretty writer, plain writer or simple writer) when 137 * created. 138 * Default is the pretty writer but can be overridden with system property 139 * <code>com.hp.hpl.jena.n3.N3JenaWriter.writer</code>. 140 * <li> 141 * <js>"N3-PP"</js> - Name of the N3 pretty writer. 142 * The pretty writer uses a frame-like layout, with prefixing, clustering like properties and embedding 143 * one-referenced bNodes. 144 * <li> 145 * <js>"N3-PLAIN"</js> - Name of the N3 plain writer. 146 * The plain writer writes records by subject. 147 * <li> 148 * <js>"N3-TRIPLES"</js> - Name of the N3 triples writer. 149 * This writer writes one line per statement, like N-Triples, but does N3-style prefixing. 150 * <li> 151 * <js>"TURTLE"</js> - Turtle writer. 152 * http://www.dajobe.org/2004/01/turtle/ 153 * </ul> 154 * 155 * <h5 class='section'>See Also:</h5> 156 * <ul> 157 * <li class='jf'>{@link RdfParser#RDF_language} 158 * </ul> 159 * 160 * @param value The new value for this property. 161 * @return This object (for method chaining). 162 */ 163 public RdfParserBuilder language(String value) { 164 return set(RDF_language, value); 165 } 166 167 /** 168 * Configuration property: Collections should be serialized and parsed as loose collections. 169 * 170 * <p> 171 * When specified, collections of resources are handled as loose collections of resources in RDF instead of 172 * resources that are children of an RDF collection (e.g. Sequence, Bag). 173 * 174 * <h5 class='section'>See Also:</h5> 175 * <ul> 176 * <li class='jf'>{@link RdfParser#RDF_looseCollections} 177 * </ul> 178 * 179 * @param value 180 * The new value for this property. 181 * <br>The default is <jk>false</jk>. 182 * @return This object (for method chaining). 183 */ 184 public RdfParserBuilder looseCollections(boolean value) { 185 return set(RDF_looseCollections, value); 186 } 187 188 /** 189 * Configuration property: Collections should be serialized and parsed as loose collections. 190 * 191 * <p> 192 * Shortcut for calling <code>looseCollection(<jk>true</jk>)</code>. 193 * 194 * <h5 class='section'>See Also:</h5> 195 * <ul> 196 * <li class='jf'>{@link RdfParser#RDF_looseCollections} 197 * </ul> 198 * 199 * @return This object (for method chaining). 200 */ 201 public RdfParserBuilder looseCollections() { 202 return set(RDF_looseCollections, true); 203 } 204 205 /** 206 * Configuration property: RDF language. 207 * 208 * <p> 209 * Shortcut for calling <code>language(<jsf>LANG_N3</jsf>)</code>. 210 * 211 * <h5 class='section'>See Also:</h5> 212 * <ul> 213 * <li class='jf'>{@link RdfParser#RDF_language} 214 * </ul> 215 * 216 * @return This object (for method chaining). 217 */ 218 public RdfParserBuilder n3() { 219 return language(Constants.LANG_N3); 220 } 221 222 /** 223 * Configuration property: RDF language. 224 * 225 * <p> 226 * Shortcut for calling <code>language(<jsf>LANG_NTRIPLE</jsf>)</code>. 227 * 228 * <h5 class='section'>See Also:</h5> 229 * <ul> 230 * <li class='jf'>{@link RdfParser#RDF_language} 231 * </ul> 232 * 233 * @return This object (for method chaining). 234 */ 235 public RdfParserBuilder ntriple() { 236 return language(Constants.LANG_NTRIPLE); 237 } 238 239 /** 240 * Configuration property: Trim whitespace from text elements. 241 * 242 * <p> 243 * If <jk>true</jk>, whitespace in text elements will be automatically trimmed. 244 * 245 * <h5 class='section'>See Also:</h5> 246 * <ul> 247 * <li class='jf'>{@link RdfParser#RDF_trimWhitespace} 248 * </ul> 249 * 250 * @param value 251 * The new value for this property. 252 * <br>The default is <jk>false</jk>. 253 * @return This object (for method chaining). 254 */ 255 public RdfParserBuilder trimWhitespace(boolean value) { 256 return set(RDF_trimWhitespace, value); 257 } 258 259 /** 260 * Configuration property: Trim whitespace from text elements. 261 * 262 * <p> 263 * Shortcut for calling <code>trimWhitespace(<jk>true</jk>)</code>. 264 * 265 * <h5 class='section'>See Also:</h5> 266 * <ul> 267 * <li class='jf'>{@link RdfParser#RDF_trimWhitespace} 268 * </ul> 269 * 270 * @return This object (for method chaining). 271 */ 272 public RdfParserBuilder trimWhitespace() { 273 return set(RDF_trimWhitespace, true); 274 } 275 276 /** 277 * Shortcut for calling <code>language(<jsf>LANG_TURTLE</jsf>)</code>. 278 * 279 * <h5 class='section'>See Also:</h5> 280 * <ul> 281 * <li class='jf'>{@link RdfParser#RDF_language} 282 * </ul> 283 * 284 * @return This object (for method chaining). 285 */ 286 public RdfParserBuilder turtle() { 287 return language(Constants.LANG_TURTLE); 288 } 289 290 /** 291 * Configuration property: Reuse XML namespaces when RDF namespaces not specified. 292 * 293 * <p> 294 * When specified, namespaces defined using {@link XmlNs @XmlNs} and {@link org.apache.juneau.xml.annotation.Xml @Xml} will be 295 * inherited by the RDF parsers. 296 * Otherwise, namespaces will be defined using {@link RdfNs @RdfNs} and {@link Rdf @Rdf}. 297 * 298 * <h5 class='section'>See Also:</h5> 299 * <ul> 300 * <li class='jf'>{@link RdfParser#RDF_useXmlNamespaces} 301 * </ul> 302 * 303 * @param value 304 * The new value for this property. 305 * <br>The default is <jk>true</jk>. 306 * @return This object (for method chaining). 307 */ 308 public RdfParserBuilder useXmlNamespaces(boolean value) { 309 return set(RDF_useXmlNamespaces, value); 310 } 311 312 /** 313 * Shortcut for calling <code>language(<jsf>LANG_RDF_XML</jsf>)</code>. 314 * 315 * <h5 class='section'>See Also:</h5> 316 * <ul> 317 * <li class='jf'>{@link RdfParser#RDF_language} 318 * </ul> 319 * 320 * @return This object (for method chaining). 321 */ 322 public RdfParserBuilder xml() { 323 return language(Constants.LANG_RDF_XML); 324 } 325 326 /** 327 * Shortcut for calling <code>language(<jsf>LANG_RDF_XML_ABBREV</jsf>)</code>. 328 * 329 * <h5 class='section'>See Also:</h5> 330 * <ul> 331 * <li class='jf'>{@link RdfParser#RDF_language} 332 * </ul> 333 * 334 * @return This object (for method chaining). 335 */ 336 public RdfParserBuilder xmlabbrev() { 337 return language(Constants.LANG_RDF_XML_ABBREV); 338 } 339 340 @Override /* ReaderParserBuilder */ 341 public RdfParserBuilder fileCharset(String value) { 342 super.fileCharset(value); 343 return this; 344 } 345 346 @Override /* ReaderParserBuilder */ 347 public RdfParserBuilder inputStreamCharset(String value) { 348 super.inputStreamCharset(value); 349 return this; 350 } 351 352 @Override /* ParserBuilder */ 353 public RdfParserBuilder autoCloseStreams(boolean value) { 354 super.autoCloseStreams(value); 355 return this; 356 } 357 358 @Override /* ParserBuilder */ 359 public RdfParserBuilder autoCloseStreams() { 360 super.autoCloseStreams(); 361 return this; 362 } 363 364 @Override /* ParserBuilder */ 365 public RdfParserBuilder debugOutputLines(int value) { 366 super.debugOutputLines(value); 367 return this; 368 } 369 370 @Override /* ParserBuilder */ 371 public RdfParserBuilder listener(Class<? extends ParserListener> value) { 372 super.listener(value); 373 return this; 374 } 375 376 @Override /* ParserBuilder */ 377 public RdfParserBuilder strict(boolean value) { 378 super.strict(value); 379 return this; 380 } 381 382 @Override /* ParserBuilder */ 383 public RdfParserBuilder strict() { 384 super.strict(); 385 return this; 386 } 387 388 @Override /* ParserBuilder */ 389 public RdfParserBuilder trimStrings(boolean value) { 390 super.trimStrings(value); 391 return this; 392 } 393 394 @Override /* ParserBuilder */ 395 public RdfParserBuilder trimStrings() { 396 super.trimStrings(); 397 return this; 398 } 399 400 @Override /* ParserBuilder */ 401 public RdfParserBuilder unbuffered(boolean value) { 402 super.unbuffered(value); 403 return this; 404 } 405 406 @Override /* ParserBuilder */ 407 public RdfParserBuilder unbuffered() { 408 super.unbuffered(); 409 return this; 410 } 411 412 @Override /* BeanContextBuilder */ 413 public RdfParserBuilder beanClassVisibility(Visibility value) { 414 super.beanClassVisibility(value); 415 return this; 416 } 417 418 @Override /* BeanContextBuilder */ 419 public RdfParserBuilder beanConstructorVisibility(Visibility value) { 420 super.beanConstructorVisibility(value); 421 return this; 422 } 423 424 @Override /* BeanContextBuilder */ 425 public RdfParserBuilder beanDictionary(boolean append, Object...values) { 426 super.beanDictionary(append, values); 427 return this; 428 } 429 430 @Override /* BeanContextBuilder */ 431 public RdfParserBuilder beanDictionary(Class<?>...values) { 432 super.beanDictionary(values); 433 return this; 434 } 435 436 @Override /* BeanContextBuilder */ 437 public RdfParserBuilder beanDictionary(Object...values) { 438 super.beanDictionary(values); 439 return this; 440 } 441 442 @Override /* BeanContextBuilder */ 443 public RdfParserBuilder beanDictionaryRemove(Object...values) { 444 super.beanDictionaryRemove(values); 445 return this; 446 } 447 448 @Override /* BeanContextBuilder */ 449 public RdfParserBuilder beanFieldVisibility(Visibility value) { 450 super.beanFieldVisibility(value); 451 return this; 452 } 453 454 @Override /* BeanContextBuilder */ 455 public RdfParserBuilder beanFilters(boolean append, Object...values) { 456 super.beanFilters(append, values); 457 return this; 458 } 459 460 @Override /* BeanContextBuilder */ 461 public RdfParserBuilder beanFilters(Class<?>...values) { 462 super.beanFilters(values); 463 return this; 464 } 465 466 @Override /* BeanContextBuilder */ 467 public RdfParserBuilder beanFilters(Object...values) { 468 super.beanFilters(values); 469 return this; 470 } 471 472 @Override /* BeanContextBuilder */ 473 public RdfParserBuilder beanFiltersRemove(Object...values) { 474 super.beanFiltersRemove(values); 475 return this; 476 } 477 478 @Override /* BeanContextBuilder */ 479 public RdfParserBuilder beanMapPutReturnsOldValue(boolean value) { 480 super.beanMapPutReturnsOldValue(value); 481 return this; 482 } 483 484 @Override /* BeanContextBuilder */ 485 public RdfParserBuilder beanMapPutReturnsOldValue() { 486 super.beanMapPutReturnsOldValue(); 487 return this; 488 } 489 490 @Override /* BeanContextBuilder */ 491 public RdfParserBuilder beanMethodVisibility(Visibility value) { 492 super.beanMethodVisibility(value); 493 return this; 494 } 495 496 @Override /* BeanContextBuilder */ 497 public RdfParserBuilder beansRequireDefaultConstructor(boolean value) { 498 super.beansRequireDefaultConstructor(value); 499 return this; 500 } 501 502 @Override /* BeanContextBuilder */ 503 public RdfParserBuilder beansRequireDefaultConstructor() { 504 super.beansRequireDefaultConstructor(); 505 return this; 506 } 507 508 @Override /* BeanContextBuilder */ 509 public RdfParserBuilder beansRequireSerializable(boolean value) { 510 super.beansRequireSerializable(value); 511 return this; 512 } 513 514 @Override /* BeanContextBuilder */ 515 public RdfParserBuilder beansRequireSerializable() { 516 super.beansRequireSerializable(); 517 return this; 518 } 519 520 @Override /* BeanContextBuilder */ 521 public RdfParserBuilder beansRequireSettersForGetters(boolean value) { 522 super.beansRequireSettersForGetters(value); 523 return this; 524 } 525 526 @Override /* BeanContextBuilder */ 527 public RdfParserBuilder beansRequireSettersForGetters() { 528 super.beansRequireSettersForGetters(); 529 return this; 530 } 531 532 @Override /* BeanContextBuilder */ 533 public RdfParserBuilder beansRequireSomeProperties(boolean value) { 534 super.beansRequireSomeProperties(value); 535 return this; 536 } 537 538 @Override /* BeanContextBuilder */ 539 public RdfParserBuilder beanTypePropertyName(String value) { 540 super.beanTypePropertyName(value); 541 return this; 542 } 543 544 @Override /* BeanContextBuilder */ 545 public RdfParserBuilder debug() { 546 super.debug(); 547 return this; 548 } 549 550 @Override /* BeanContextBuilder */ 551 public <T> RdfParserBuilder example(Class<T> c, T o) { 552 super.example(c, o); 553 return this; 554 } 555 556 @Override /* BeanContextBuilder */ 557 public RdfParserBuilder ignoreInvocationExceptionsOnGetters(boolean value) { 558 super.ignoreInvocationExceptionsOnGetters(value); 559 return this; 560 } 561 562 @Override /* BeanContextBuilder */ 563 public RdfParserBuilder ignoreInvocationExceptionsOnGetters() { 564 super.ignoreInvocationExceptionsOnGetters(); 565 return this; 566 } 567 568 @Override /* BeanContextBuilder */ 569 public RdfParserBuilder ignoreInvocationExceptionsOnSetters(boolean value) { 570 super.ignoreInvocationExceptionsOnSetters(value); 571 return this; 572 } 573 574 @Override /* BeanContextBuilder */ 575 public RdfParserBuilder ignoreInvocationExceptionsOnSetters() { 576 super.ignoreInvocationExceptionsOnSetters(); 577 return this; 578 } 579 580 @Override /* BeanContextBuilder */ 581 public RdfParserBuilder ignorePropertiesWithoutSetters(boolean value) { 582 super.ignorePropertiesWithoutSetters(value); 583 return this; 584 } 585 586 @Override /* BeanContextBuilder */ 587 public RdfParserBuilder ignoreUnknownBeanProperties(boolean value) { 588 super.ignoreUnknownBeanProperties(value); 589 return this; 590 } 591 592 @Override /* BeanContextBuilder */ 593 public RdfParserBuilder ignoreUnknownBeanProperties() { 594 super.ignoreUnknownBeanProperties(); 595 return this; 596 } 597 598 @Override /* BeanContextBuilder */ 599 public RdfParserBuilder ignoreUnknownNullBeanProperties(boolean value) { 600 super.ignoreUnknownNullBeanProperties(value); 601 return this; 602 } 603 604 @Override /* BeanContextBuilder */ 605 public <T> RdfParserBuilder implClass(Class<T> interfaceClass, Class<? extends T> implClass) { 606 super.implClass(interfaceClass, implClass); 607 return this; 608 } 609 610 @Override /* BeanContextBuilder */ 611 public RdfParserBuilder implClasses(Map<String,Class<?>> values) { 612 super.implClasses(values); 613 return this; 614 } 615 616 @Override /* BeanContextBuilder */ 617 public RdfParserBuilder locale(Locale value) { 618 super.locale(value); 619 return this; 620 } 621 622 @Override /* BeanContextBuilder */ 623 public RdfParserBuilder mediaType(MediaType value) { 624 super.mediaType(value); 625 return this; 626 } 627 628 @Override /* BeanContextBuilder */ 629 public RdfParserBuilder notBeanClasses(boolean append, Object...values) { 630 super.notBeanClasses(append, values); 631 return this; 632 } 633 634 @Override /* BeanContextBuilder */ 635 public RdfParserBuilder notBeanClasses(Class<?>...values) { 636 super.notBeanClasses(values); 637 return this; 638 } 639 640 @Override /* BeanContextBuilder */ 641 public RdfParserBuilder notBeanClasses(Object...values) { 642 super.notBeanClasses(values); 643 return this; 644 } 645 646 @Override /* BeanContextBuilder */ 647 public RdfParserBuilder notBeanClassesRemove(Object...values) { 648 super.notBeanClassesRemove(values); 649 return this; 650 } 651 652 @Override /* BeanContextBuilder */ 653 public RdfParserBuilder notBeanPackages(boolean append, Object...values) { 654 super.notBeanPackages(append, values); 655 return this; 656 } 657 658 @Override /* BeanContextBuilder */ 659 public RdfParserBuilder notBeanPackages(Object...values) { 660 super.notBeanPackages(values); 661 return this; 662 } 663 664 @Override /* BeanContextBuilder */ 665 public RdfParserBuilder notBeanPackages(String...values) { 666 super.notBeanPackages(values); 667 return this; 668 } 669 670 @Override /* BeanContextBuilder */ 671 public RdfParserBuilder notBeanPackagesRemove(Object...values) { 672 super.notBeanPackagesRemove(values); 673 return this; 674 } 675 676 @Override /* BeanContextBuilder */ 677 public RdfParserBuilder pojoSwaps(boolean append, Object...values) { 678 super.pojoSwaps(append, values); 679 return this; 680 } 681 682 @Override /* BeanContextBuilder */ 683 public RdfParserBuilder pojoSwaps(Class<?>...values) { 684 super.pojoSwaps(values); 685 return this; 686 } 687 688 @Override /* BeanContextBuilder */ 689 public RdfParserBuilder pojoSwaps(Object...values) { 690 super.pojoSwaps(values); 691 return this; 692 } 693 694 @Override /* BeanContextBuilder */ 695 public RdfParserBuilder pojoSwapsRemove(Object...values) { 696 super.pojoSwapsRemove(values); 697 return this; 698 } 699 700 @Override /* BeanContextBuilder */ 701 public RdfParserBuilder sortProperties(boolean value) { 702 super.sortProperties(value); 703 return this; 704 } 705 706 @Override /* BeanContextBuilder */ 707 public RdfParserBuilder sortProperties() { 708 super.sortProperties(); 709 return this; 710 } 711 712 @Override /* BeanContextBuilder */ 713 public RdfParserBuilder timeZone(TimeZone value) { 714 super.timeZone(value); 715 return this; 716 } 717 718 @Override /* BeanContextBuilder */ 719 public RdfParserBuilder useEnumNames() { 720 super.useEnumNames(); 721 return this; 722 } 723 724 @Override /* BeanContextBuilder */ 725 public RdfParserBuilder useInterfaceProxies(boolean value) { 726 super.useInterfaceProxies(value); 727 return this; 728 } 729 730 @Override /* BeanContextBuilder */ 731 public RdfParserBuilder useJavaBeanIntrospector(boolean value) { 732 super.useJavaBeanIntrospector(value); 733 return this; 734 } 735 736 @Override /* BeanContextBuilder */ 737 public RdfParserBuilder useJavaBeanIntrospector() { 738 super.useJavaBeanIntrospector(); 739 return this; 740 } 741 742 @Override /* ContextBuilder */ 743 public RdfParserBuilder set(String name, Object value) { 744 super.set(name, value); 745 return this; 746 } 747 748 @Override /* ContextBuilder */ 749 public RdfParserBuilder set(boolean append, String name, Object value) { 750 super.set(append, name, value); 751 return this; 752 } 753 754 @Override /* ContextBuilder */ 755 public RdfParserBuilder set(Map<String,Object> properties) { 756 super.set(properties); 757 return this; 758 } 759 760 @Override /* ContextBuilder */ 761 public RdfParserBuilder add(Map<String,Object> properties) { 762 super.add(properties); 763 return this; 764 } 765 766 @Override /* ContextBuilder */ 767 public RdfParserBuilder addTo(String name, Object value) { 768 super.addTo(name, value); 769 return this; 770 } 771 772 @Override /* ContextBuilder */ 773 public RdfParserBuilder addTo(String name, String key, Object value) { 774 super.addTo(name, key, value); 775 return this; 776 } 777 778 @Override /* ContextBuilder */ 779 public RdfParserBuilder removeFrom(String name, Object value) { 780 super.removeFrom(name, value); 781 return this; 782 } 783 784 @Override /* ContextBuilder */ 785 public RdfParserBuilder apply(PropertyStore copyFrom) { 786 super.apply(copyFrom); 787 return this; 788 } 789}