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