001/* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017package org.apache.juneau.html; 018 019import java.lang.annotation.*; 020import java.nio.charset.*; 021import java.util.*; 022 023import org.apache.juneau.*; 024import org.apache.juneau.annotation.*; 025import org.apache.juneau.commons.collections.*; 026import org.apache.juneau.commons.function.*; 027import org.apache.juneau.commons.reflect.*; 028import org.apache.juneau.json.*; 029import org.apache.juneau.jsonschema.*; 030import org.apache.juneau.xml.*; 031 032/** 033 * Serializes POJO metamodels to HTML. 034 * 035 * <h5 class='topic'>Media types</h5> 036 * 037 * Handles <c>Accept</c> types: <bc>text/html+schema</bc> 038 * <p> 039 * Produces <c>Content-Type</c> types: <bc>text/html</bc> 040 * 041 * <h5 class='topic'>Description</h5> 042 * 043 * Essentially the same as {@link HtmlDocSerializer}, except serializes the POJO metamodel instead of the model itself. 044 * 045 * <p> 046 * Produces output that describes the POJO metamodel similar to an XML schema document. 047 * 048 * <p> 049 * The easiest way to create instances of this class is through the {@link HtmlSerializer#getSchemaSerializer()}, 050 * which will create a schema serializer with the same settings as the originating serializer. 051 * 052 * <h5 class='section'>Notes:</h5><ul> 053 * <li class='note'>This class is thread safe and reusable. 054 * </ul> 055 * 056 * <h5 class='section'>See Also:</h5><ul> 057 * <li class='link'><a class="doclink" href="https://juneau.apache.org/docs/topics/HtmlBasics">HTML Basics</a> 058 059 * </ul> 060 */ 061public class HtmlSchemaDocSerializer extends HtmlDocSerializer { 062 /** 063 * Builder class. 064 */ 065 public static class Builder extends HtmlDocSerializer.Builder { 066 067 JsonSchemaGenerator.Builder generatorBuilder; 068 069 /** 070 * Constructor, default settings. 071 */ 072 protected Builder() { 073 produces("text/html"); 074 accept("text/html+schema"); 075 generatorBuilder = JsonSchemaGenerator.create().beanContext(beanContext()); 076 } 077 078 /** 079 * Copy constructor. 080 * 081 * @param copyFrom The builder to copy from. 082 */ 083 protected Builder(Builder copyFrom) { 084 super(copyFrom); 085 generatorBuilder = copyFrom.generatorBuilder.copy().beanContext(beanContext()); 086 } 087 088 /** 089 * Copy constructor. 090 * 091 * @param copyFrom The bean to copy from. 092 */ 093 protected Builder(HtmlSchemaDocSerializer copyFrom) { 094 super(copyFrom); 095 generatorBuilder = copyFrom.generator.copy().beanContext(beanContext()); 096 } 097 098 @Override /* Overridden from Builder */ 099 public Builder accept(String value) { 100 super.accept(value); 101 return this; 102 } 103 104 @Override /* Overridden from Builder */ 105 public Builder addBeanTypes() { 106 super.addBeanTypes(); 107 return this; 108 } 109 110 @Override /* Overridden from Builder */ 111 public Builder addBeanTypes(boolean value) { 112 super.addBeanTypes(value); 113 return this; 114 } 115 116 @Override /* Overridden from Builder */ 117 public Builder addBeanTypesHtml() { 118 super.addBeanTypesHtml(); 119 return this; 120 } 121 122 @Override /* Overridden from Builder */ 123 public Builder addBeanTypesHtml(boolean value) { 124 super.addBeanTypesHtml(value); 125 return this; 126 } 127 128 @Override /* Overridden from Builder */ 129 public Builder addBeanTypesXml() { 130 super.addBeanTypesXml(); 131 return this; 132 } 133 134 @Override /* Overridden from Builder */ 135 public Builder addBeanTypesXml(boolean value) { 136 super.addBeanTypesXml(value); 137 return this; 138 } 139 140 /** 141 * <i><l>HtmlSchemaSerializer</l> configuration property: </i> Add descriptions. 142 * 143 * <p> 144 * Identifies which categories of types that descriptions should be automatically added to generated schemas. 145 * <p> 146 * The description is the result of calling {@link ClassMeta#getName()}. 147 * 148 * <h5 class='section'>See Also:</h5><ul> 149 * <li class='jm'>{@link org.apache.juneau.jsonschema.JsonSchemaGenerator.Builder#addDescriptionsTo(TypeCategory...)} 150 * </ul> 151 * 152 * @param values 153 * The values to add to this setting. 154 * <br>The default is an empty string. 155 * @return This object. 156 */ 157 public Builder addDescriptionsTo(TypeCategory...values) { 158 generatorBuilder.addDescriptionsTo(values); 159 return this; 160 } 161 162 /** 163 * <i><l>HtmlSchemaSerializer</l> configuration property: </i> Add examples. 164 * 165 * <p> 166 * Identifies which categories of types that examples should be automatically added to generated schemas. 167 * <p> 168 * The examples come from calling {@link ClassMeta#getExample(BeanSession,JsonParserSession)} which in turn gets examples 169 * from the following: 170 * <ul class='javatree'> 171 * <li class='ja'>{@link Example} 172 * <li class='ja'>{@link Marshalled#example() Marshalled(example)} 173 * </ul> 174 * 175 * <h5 class='section'>See Also:</h5><ul> 176 * <li class='jm'>{@link org.apache.juneau.jsonschema.JsonSchemaGenerator.Builder#addExamplesTo(TypeCategory...)} 177 * </ul> 178 * 179 * @param values 180 * The values to add to this setting. 181 * <br>The default is an empty string. 182 * @return This object. 183 */ 184 public Builder addExamplesTo(TypeCategory...values) { 185 generatorBuilder.addExamplesTo(values); 186 return this; 187 } 188 189 @Override /* Overridden from Builder */ 190 public Builder addKeyValueTableHeaders() { 191 super.addKeyValueTableHeaders(); 192 return this; 193 } 194 195 @Override /* Overridden from Builder */ 196 public Builder addKeyValueTableHeaders(boolean value) { 197 super.addKeyValueTableHeaders(value); 198 return this; 199 } 200 201 @Override /* Overridden from Builder */ 202 public Builder addNamespaceUrisToRoot() { 203 super.addNamespaceUrisToRoot(); 204 return this; 205 } 206 207 @Override /* Overridden from Builder */ 208 public Builder addNamespaceUrisToRoot(boolean value) { 209 super.addNamespaceUrisToRoot(value); 210 return this; 211 } 212 213 @Override /* Overridden from Builder */ 214 public Builder addRootType() { 215 super.addRootType(); 216 return this; 217 } 218 219 @Override /* Overridden from Builder */ 220 public Builder addRootType(boolean value) { 221 super.addRootType(value); 222 return this; 223 } 224 225 /** 226 * <i><l>HtmlSchemaSerializer</l> configuration property: </i> Allow nested descriptions. 227 * 228 * <p> 229 * Identifies whether nested descriptions are allowed in schema definitions. 230 * 231 * <h5 class='section'>See Also:</h5><ul> 232 * <li class='jm'>{@link org.apache.juneau.jsonschema.JsonSchemaGenerator.Builder#allowNestedDescriptions()} 233 * </ul> 234 * 235 * @return This object. 236 */ 237 public Builder allowNestedDescriptions() { 238 generatorBuilder.allowNestedDescriptions(); 239 return this; 240 } 241 242 /** 243 * <i><l>HtmlSchemaSerializer</l> configuration property: </i> Allow nested examples. 244 * 245 * <p> 246 * Identifies whether nested examples are allowed in schema definitions. 247 * 248 * <h5 class='section'>See Also:</h5><ul> 249 * <li class='jm'>{@link org.apache.juneau.jsonschema.JsonSchemaGenerator.Builder#allowNestedExamples()} 250 * </ul> 251 * 252 * @return This object. 253 */ 254 public Builder allowNestedExamples() { 255 generatorBuilder.allowNestedExamples(); 256 return this; 257 } 258 259 @Override /* Overridden from Builder */ 260 public Builder annotations(Annotation...values) { 261 super.annotations(values); 262 return this; 263 } 264 265 @Override /* Overridden from Builder */ 266 public Builder apply(AnnotationWorkList work) { 267 super.apply(work); 268 return this; 269 } 270 271 @Override /* Overridden from Builder */ 272 public Builder applyAnnotations(Class<?>...from) { 273 super.applyAnnotations(from); 274 return this; 275 } 276 277 @Override /* Overridden from Builder */ 278 public Builder applyAnnotations(Object...from) { 279 super.applyAnnotations(from); 280 return this; 281 } 282 283 @Override /* Overridden from Builder */ 284 public Builder aside(String...value) { 285 super.aside(value); 286 return this; 287 } 288 289 @Override /* Overridden from Builder */ 290 public Builder asideFloat(AsideFloat value) { 291 super.asideFloat(value); 292 return this; 293 } 294 295 @Override /* Overridden from Builder */ 296 public Builder beanClassVisibility(Visibility value) { 297 super.beanClassVisibility(value); 298 return this; 299 } 300 301 @Override /* Overridden from Builder */ 302 public Builder beanConstructorVisibility(Visibility value) { 303 super.beanConstructorVisibility(value); 304 return this; 305 } 306 307 @Override /* Overridden from Builder */ 308 public Builder beanContext(BeanContext value) { 309 super.beanContext(value); 310 return this; 311 } 312 313 @Override /* Overridden from Builder */ 314 public Builder beanContext(BeanContext.Builder value) { 315 super.beanContext(value); 316 return this; 317 } 318 319 /** 320 * <i><l>HtmlSchemaSerializer</l> configuration property: </i> Schema definition mapper. 321 * 322 * <p> 323 * Interface to use for converting Bean classes to definition IDs and URIs. 324 * <p> 325 * Used primarily for defining common definition sections for beans in Swagger JSON. 326 * <p> 327 * This setting is ignored if {@link org.apache.juneau.jsonschema.JsonSchemaGenerator.Builder#useBeanDefs()} is not enabled. 328 * 329 * <h5 class='section'>See Also:</h5><ul> 330 * <li class='jm'>{@link org.apache.juneau.jsonschema.JsonSchemaGenerator.Builder#beanDefMapper(Class)} 331 * </ul> 332 * 333 * @param value 334 * The new value for this property. 335 * <br>The default is {@link org.apache.juneau.jsonschema.BasicBeanDefMapper}. 336 * @return This object. 337 */ 338 public Builder beanDefMapper(Class<? extends BeanDefMapper> value) { 339 generatorBuilder.beanDefMapper(value); 340 return this; 341 } 342 343 @Override /* Overridden from Builder */ 344 public Builder beanDictionary(java.lang.Class<?>...values) { 345 super.beanDictionary(values); 346 return this; 347 } 348 349 @Override /* Overridden from Builder */ 350 public Builder beanFieldVisibility(Visibility value) { 351 super.beanFieldVisibility(value); 352 return this; 353 } 354 355 @Override /* Overridden from Builder */ 356 public Builder beanInterceptor(Class<?> on, Class<? extends org.apache.juneau.swap.BeanInterceptor<?>> value) { 357 super.beanInterceptor(on, value); 358 return this; 359 } 360 361 @Override /* Overridden from Builder */ 362 public Builder beanMapPutReturnsOldValue() { 363 super.beanMapPutReturnsOldValue(); 364 return this; 365 } 366 367 @Override /* Overridden from Builder */ 368 public Builder beanMethodVisibility(Visibility value) { 369 super.beanMethodVisibility(value); 370 return this; 371 } 372 373 @Override /* Overridden from Builder */ 374 public Builder beanProperties(Class<?> beanClass, String properties) { 375 super.beanProperties(beanClass, properties); 376 return this; 377 } 378 379 @Override /* Overridden from Builder */ 380 public Builder beanProperties(Map<String,Object> values) { 381 super.beanProperties(values); 382 return this; 383 } 384 385 @Override /* Overridden from Builder */ 386 public Builder beanProperties(String beanClassName, String properties) { 387 super.beanProperties(beanClassName, properties); 388 return this; 389 } 390 391 @Override /* Overridden from Builder */ 392 public Builder beanPropertiesExcludes(Class<?> beanClass, String properties) { 393 super.beanPropertiesExcludes(beanClass, properties); 394 return this; 395 } 396 397 @Override /* Overridden from Builder */ 398 public Builder beanPropertiesExcludes(Map<String,Object> values) { 399 super.beanPropertiesExcludes(values); 400 return this; 401 } 402 403 @Override /* Overridden from Builder */ 404 public Builder beanPropertiesExcludes(String beanClassName, String properties) { 405 super.beanPropertiesExcludes(beanClassName, properties); 406 return this; 407 } 408 409 @Override /* Overridden from Builder */ 410 public Builder beanPropertiesReadOnly(Class<?> beanClass, String properties) { 411 super.beanPropertiesReadOnly(beanClass, properties); 412 return this; 413 } 414 415 @Override /* Overridden from Builder */ 416 public Builder beanPropertiesReadOnly(Map<String,Object> values) { 417 super.beanPropertiesReadOnly(values); 418 return this; 419 } 420 421 @Override /* Overridden from Builder */ 422 public Builder beanPropertiesReadOnly(String beanClassName, String properties) { 423 super.beanPropertiesReadOnly(beanClassName, properties); 424 return this; 425 } 426 427 @Override /* Overridden from Builder */ 428 public Builder beanPropertiesWriteOnly(Class<?> beanClass, String properties) { 429 super.beanPropertiesWriteOnly(beanClass, properties); 430 return this; 431 } 432 433 @Override /* Overridden from Builder */ 434 public Builder beanPropertiesWriteOnly(Map<String,Object> values) { 435 super.beanPropertiesWriteOnly(values); 436 return this; 437 } 438 439 @Override /* Overridden from Builder */ 440 public Builder beanPropertiesWriteOnly(String beanClassName, String properties) { 441 super.beanPropertiesWriteOnly(beanClassName, properties); 442 return this; 443 } 444 445 @Override /* Overridden from Builder */ 446 public Builder beansRequireDefaultConstructor() { 447 super.beansRequireDefaultConstructor(); 448 return this; 449 } 450 451 @Override /* Overridden from Builder */ 452 public Builder beansRequireSerializable() { 453 super.beansRequireSerializable(); 454 return this; 455 } 456 457 @Override /* Overridden from Builder */ 458 public Builder beansRequireSettersForGetters() { 459 super.beansRequireSettersForGetters(); 460 return this; 461 } 462 463 @Override /* Overridden from Context.Builder */ 464 public HtmlSchemaDocSerializer build() { 465 return build(HtmlSchemaDocSerializer.class); 466 } 467 468 @Override /* Overridden from Builder */ 469 public Builder cache(Cache<HashKey,? extends org.apache.juneau.Context> value) { 470 super.cache(value); 471 return this; 472 } 473 474 @Override /* Overridden from Context.Builder */ 475 public Builder copy() { 476 return new Builder(this); 477 } 478 479 @Override /* Overridden from Builder */ 480 public Builder debug() { 481 super.debug(); 482 return this; 483 } 484 485 @Override /* Overridden from Builder */ 486 public Builder debug(boolean value) { 487 super.debug(value); 488 return this; 489 } 490 491 @Override /* Overridden from Builder */ 492 public Builder defaultNamespace(Namespace value) { 493 super.defaultNamespace(value); 494 return this; 495 } 496 497 @Override /* Overridden from Builder */ 498 public Builder detectRecursions() { 499 super.detectRecursions(); 500 return this; 501 } 502 503 @Override /* Overridden from Builder */ 504 public Builder detectRecursions(boolean value) { 505 super.detectRecursions(value); 506 return this; 507 } 508 509 @Override /* Overridden from Builder */ 510 public Builder dictionaryOn(Class<?> on, java.lang.Class<?>...values) { 511 super.dictionaryOn(on, values); 512 return this; 513 } 514 515 @Override /* Overridden from Builder */ 516 public Builder disableAutoDetectNamespaces() { 517 super.disableAutoDetectNamespaces(); 518 return this; 519 } 520 521 @Override /* Overridden from Builder */ 522 public Builder disableAutoDetectNamespaces(boolean value) { 523 super.disableAutoDetectNamespaces(value); 524 return this; 525 } 526 527 @Override /* Overridden from Builder */ 528 public Builder disableBeansRequireSomeProperties() { 529 super.disableBeansRequireSomeProperties(); 530 return this; 531 } 532 533 @Override /* Overridden from Builder */ 534 public Builder disableDetectLabelParameters() { 535 super.disableDetectLabelParameters(); 536 return this; 537 } 538 539 @Override /* Overridden from Builder */ 540 public Builder disableDetectLabelParameters(boolean value) { 541 super.disableDetectLabelParameters(value); 542 return this; 543 } 544 545 @Override /* Overridden from Builder */ 546 public Builder disableDetectLinksInStrings() { 547 super.disableDetectLinksInStrings(); 548 return this; 549 } 550 551 @Override /* Overridden from Builder */ 552 public Builder disableDetectLinksInStrings(boolean value) { 553 super.disableDetectLinksInStrings(value); 554 return this; 555 } 556 557 @Override /* Overridden from Builder */ 558 public Builder disableIgnoreMissingSetters() { 559 super.disableIgnoreMissingSetters(); 560 return this; 561 } 562 563 @Override /* Overridden from Builder */ 564 public Builder disableIgnoreTransientFields() { 565 super.disableIgnoreTransientFields(); 566 return this; 567 } 568 569 @Override /* Overridden from Builder */ 570 public Builder disableIgnoreUnknownNullBeanProperties() { 571 super.disableIgnoreUnknownNullBeanProperties(); 572 return this; 573 } 574 575 @Override /* Overridden from Builder */ 576 public Builder disableInterfaceProxies() { 577 super.disableInterfaceProxies(); 578 return this; 579 } 580 581 @Override /* Overridden from Builder */ 582 public Builder enableNamespaces() { 583 super.enableNamespaces(); 584 return this; 585 } 586 587 @Override /* Overridden from Builder */ 588 public Builder enableNamespaces(boolean value) { 589 super.enableNamespaces(value); 590 return this; 591 } 592 593 @Override /* Overridden from Builder */ 594 public <T> Builder example(Class<T> pojoClass, String json) { 595 super.example(pojoClass, json); 596 return this; 597 } 598 599 @Override /* Overridden from Builder */ 600 public <T> Builder example(Class<T> pojoClass, T o) { 601 super.example(pojoClass, o); 602 return this; 603 } 604 605 @Override /* Overridden from Builder */ 606 public Builder fileCharset(Charset value) { 607 super.fileCharset(value); 608 return this; 609 } 610 611 @Override /* Overridden from Builder */ 612 public Builder findFluentSetters() { 613 super.findFluentSetters(); 614 return this; 615 } 616 617 @Override /* Overridden from Builder */ 618 public Builder findFluentSetters(Class<?> on) { 619 super.findFluentSetters(on); 620 return this; 621 } 622 623 @Override /* Overridden from Builder */ 624 public Builder footer(String...value) { 625 super.footer(value); 626 return this; 627 } 628 629 @Override /* Overridden from Builder */ 630 public Builder head(String...value) { 631 super.head(value); 632 return this; 633 } 634 635 @Override /* Overridden from Builder */ 636 public Builder header(String...value) { 637 super.header(value); 638 return this; 639 } 640 641 @Override /* Overridden from Builder */ 642 public Builder ignoreInvocationExceptionsOnGetters() { 643 super.ignoreInvocationExceptionsOnGetters(); 644 return this; 645 } 646 647 @Override /* Overridden from Builder */ 648 public Builder ignoreInvocationExceptionsOnSetters() { 649 super.ignoreInvocationExceptionsOnSetters(); 650 return this; 651 } 652 653 @Override /* Overridden from Builder */ 654 public Builder ignoreRecursions() { 655 super.ignoreRecursions(); 656 return this; 657 } 658 659 @Override /* Overridden from Builder */ 660 public Builder ignoreRecursions(boolean value) { 661 super.ignoreRecursions(value); 662 return this; 663 } 664 665 @Override /* Overridden from Builder */ 666 public Builder ignoreUnknownBeanProperties() { 667 super.ignoreUnknownBeanProperties(); 668 return this; 669 } 670 671 @Override /* Overridden from Builder */ 672 public Builder ignoreUnknownEnumValues() { 673 super.ignoreUnknownEnumValues(); 674 return this; 675 } 676 677 @Override /* Overridden from Builder */ 678 public Builder impl(Context value) { 679 super.impl(value); 680 return this; 681 } 682 683 @Override /* Overridden from Builder */ 684 public Builder implClass(Class<?> interfaceClass, Class<?> implClass) { 685 super.implClass(interfaceClass, implClass); 686 return this; 687 } 688 689 @Override /* Overridden from Builder */ 690 public Builder implClasses(Map<Class<?>,Class<?>> values) { 691 super.implClasses(values); 692 return this; 693 } 694 695 @Override /* Overridden from Builder */ 696 public Builder initialDepth(int value) { 697 super.initialDepth(value); 698 return this; 699 } 700 701 @Override /* Overridden from Builder */ 702 public Builder interfaceClass(Class<?> on, Class<?> value) { 703 super.interfaceClass(on, value); 704 return this; 705 } 706 707 @Override /* Overridden from Builder */ 708 public Builder interfaces(java.lang.Class<?>...value) { 709 super.interfaces(value); 710 return this; 711 } 712 713 @Override /* Overridden from Builder */ 714 public Builder keepNullProperties() { 715 super.keepNullProperties(); 716 return this; 717 } 718 719 @Override /* Overridden from Builder */ 720 public Builder keepNullProperties(boolean value) { 721 super.keepNullProperties(value); 722 return this; 723 } 724 725 @Override /* Overridden from Builder */ 726 public Builder labelParameter(String value) { 727 super.labelParameter(value); 728 return this; 729 } 730 731 @Override /* Overridden from Builder */ 732 public Builder listener(Class<? extends org.apache.juneau.serializer.SerializerListener> value) { 733 super.listener(value); 734 return this; 735 } 736 737 @Override /* Overridden from Builder */ 738 public Builder locale(Locale value) { 739 super.locale(value); 740 return this; 741 } 742 743 @Override /* Overridden from Builder */ 744 public Builder maxDepth(int value) { 745 super.maxDepth(value); 746 return this; 747 } 748 749 @Override /* Overridden from Builder */ 750 public Builder maxIndent(int value) { 751 super.maxIndent(value); 752 return this; 753 } 754 755 @Override /* Overridden from Builder */ 756 public Builder mediaType(MediaType value) { 757 super.mediaType(value); 758 return this; 759 } 760 761 @Override /* Overridden from Builder */ 762 public Builder namespaces(Namespace...values) { 763 super.namespaces(values); 764 return this; 765 } 766 767 @Override /* Overridden from Builder */ 768 public Builder nav(String...value) { 769 super.nav(value); 770 return this; 771 } 772 773 @Override /* Overridden from Builder */ 774 public Builder navlinks(String...value) { 775 super.navlinks(value); 776 return this; 777 } 778 779 @Override /* Overridden from Builder */ 780 public Builder noResultsMessage(String value) { 781 super.noResultsMessage(value); 782 return this; 783 } 784 785 @Override /* Overridden from Builder */ 786 public Builder notBeanClasses(java.lang.Class<?>...values) { 787 super.notBeanClasses(values); 788 return this; 789 } 790 791 @Override /* Overridden from Builder */ 792 public Builder notBeanPackages(String...values) { 793 super.notBeanPackages(values); 794 return this; 795 } 796 797 @Override /* Overridden from Builder */ 798 public Builder nowrap() { 799 super.nowrap(); 800 return this; 801 } 802 803 @Override /* Overridden from Builder */ 804 public Builder nowrap(boolean value) { 805 super.nowrap(value); 806 return this; 807 } 808 809 @Override /* Overridden from Builder */ 810 public Builder ns() { 811 super.ns(); 812 return this; 813 } 814 815 @Override /* Overridden from Builder */ 816 public Builder produces(String value) { 817 super.produces(value); 818 return this; 819 } 820 821 @Override /* Overridden from Builder */ 822 public Builder propertyNamer(Class<?> on, Class<? extends org.apache.juneau.PropertyNamer> value) { 823 super.propertyNamer(on, value); 824 return this; 825 } 826 827 @Override /* Overridden from Builder */ 828 public Builder propertyNamer(Class<? extends org.apache.juneau.PropertyNamer> value) { 829 super.propertyNamer(value); 830 return this; 831 } 832 833 @Override /* Overridden from Builder */ 834 public Builder quoteChar(char value) { 835 super.quoteChar(value); 836 return this; 837 } 838 839 @Override /* Overridden from Builder */ 840 public Builder quoteCharOverride(char value) { 841 super.quoteCharOverride(value); 842 return this; 843 } 844 845 @Override /* Overridden from Builder */ 846 public Builder script(String...value) { 847 super.script(value); 848 return this; 849 } 850 851 @Override /* Overridden from Builder */ 852 public Builder sortCollections() { 853 super.sortCollections(); 854 return this; 855 } 856 857 @Override /* Overridden from Builder */ 858 public Builder sortCollections(boolean value) { 859 super.sortCollections(value); 860 return this; 861 } 862 863 @Override /* Overridden from Builder */ 864 public Builder sortMaps() { 865 super.sortMaps(); 866 return this; 867 } 868 869 @Override /* Overridden from Builder */ 870 public Builder sortMaps(boolean value) { 871 super.sortMaps(value); 872 return this; 873 } 874 875 @Override /* Overridden from Builder */ 876 public Builder sortProperties() { 877 super.sortProperties(); 878 return this; 879 } 880 881 @Override /* Overridden from Builder */ 882 public Builder sortProperties(java.lang.Class<?>...on) { 883 super.sortProperties(on); 884 return this; 885 } 886 887 @Override /* Overridden from Builder */ 888 public Builder sq() { 889 super.sq(); 890 return this; 891 } 892 893 @Override /* Overridden from Builder */ 894 public Builder stopClass(Class<?> on, Class<?> value) { 895 super.stopClass(on, value); 896 return this; 897 } 898 899 @Override /* Overridden from Builder */ 900 public Builder streamCharset(Charset value) { 901 super.streamCharset(value); 902 return this; 903 } 904 905 @Override /* Overridden from Builder */ 906 public Builder style(String...value) { 907 super.style(value); 908 return this; 909 } 910 911 @Override /* Overridden from Builder */ 912 public Builder stylesheet(String...value) { 913 super.stylesheet(value); 914 return this; 915 } 916 917 @Override /* Overridden from Builder */ 918 public <T,S> Builder swap(Class<T> normalClass, Class<S> swappedClass, ThrowingFunction<T,S> swapFunction) { 919 super.swap(normalClass, swappedClass, swapFunction); 920 return this; 921 } 922 923 @Override /* Overridden from Builder */ 924 public <T,S> Builder swap(Class<T> normalClass, Class<S> swappedClass, ThrowingFunction<T,S> swapFunction, ThrowingFunction<S,T> unswapFunction) { 925 super.swap(normalClass, swappedClass, swapFunction, unswapFunction); 926 return this; 927 } 928 929 @Override /* Overridden from Builder */ 930 public Builder swaps(Class<?>...values) { 931 super.swaps(values); 932 return this; 933 } 934 935 @Override /* Overridden from Builder */ 936 public Builder swaps(Object...values) { 937 super.swaps(values); 938 return this; 939 } 940 941 @Override /* Overridden from Builder */ 942 public Builder template(Class<? extends org.apache.juneau.html.HtmlDocTemplate> value) { 943 super.template(value); 944 return this; 945 } 946 947 @Override /* Overridden from Builder */ 948 public Builder timeZone(TimeZone value) { 949 super.timeZone(value); 950 return this; 951 } 952 953 @Override /* Overridden from Builder */ 954 public Builder trimEmptyCollections() { 955 super.trimEmptyCollections(); 956 return this; 957 } 958 959 @Override /* Overridden from Builder */ 960 public Builder trimEmptyCollections(boolean value) { 961 super.trimEmptyCollections(value); 962 return this; 963 } 964 965 @Override /* Overridden from Builder */ 966 public Builder trimEmptyMaps() { 967 super.trimEmptyMaps(); 968 return this; 969 } 970 971 @Override /* Overridden from Builder */ 972 public Builder trimEmptyMaps(boolean value) { 973 super.trimEmptyMaps(value); 974 return this; 975 } 976 977 @Override /* Overridden from Builder */ 978 public Builder trimStrings() { 979 super.trimStrings(); 980 return this; 981 } 982 983 @Override /* Overridden from Builder */ 984 public Builder trimStrings(boolean value) { 985 super.trimStrings(value); 986 return this; 987 } 988 989 @Override /* Overridden from Builder */ 990 public Builder type(Class<? extends org.apache.juneau.Context> value) { 991 super.type(value); 992 return this; 993 } 994 995 @Override /* Overridden from Builder */ 996 public Builder typeName(Class<?> on, String value) { 997 super.typeName(on, value); 998 return this; 999 } 1000 1001 @Override /* Overridden from Builder */ 1002 public Builder typePropertyName(Class<?> on, String value) { 1003 super.typePropertyName(on, value); 1004 return this; 1005 } 1006 1007 @Override /* Overridden from Builder */ 1008 public Builder typePropertyName(String value) { 1009 super.typePropertyName(value); 1010 return this; 1011 } 1012 1013 @Override /* Overridden from Builder */ 1014 public Builder uriAnchorText(AnchorText value) { 1015 super.uriAnchorText(value); 1016 return this; 1017 } 1018 1019 @Override /* Overridden from Builder */ 1020 public Builder uriContext(UriContext value) { 1021 super.uriContext(value); 1022 return this; 1023 } 1024 1025 @Override /* Overridden from Builder */ 1026 public Builder uriRelativity(UriRelativity value) { 1027 super.uriRelativity(value); 1028 return this; 1029 } 1030 1031 @Override /* Overridden from Builder */ 1032 public Builder uriResolution(UriResolution value) { 1033 super.uriResolution(value); 1034 return this; 1035 } 1036 1037 /** 1038 * <i><l>HtmlSchemaSerializer</l> configuration property: </i> Use bean definitions. 1039 * 1040 * <p> 1041 * When enabled, schemas on beans will be serialized as the following: 1042 * <p class='bjson'> 1043 * { 1044 * type: <js>'object'</js>, 1045 * <js>'$ref'</js>: <js>'#/definitions/TypeId'</js> 1046 * } 1047 * </p> 1048 * 1049 * @return This object. 1050 */ 1051 public Builder useBeanDefs() { 1052 generatorBuilder.useBeanDefs(); 1053 return this; 1054 } 1055 1056 @Override /* Overridden from Builder */ 1057 public Builder useEnumNames() { 1058 super.useEnumNames(); 1059 return this; 1060 } 1061 1062 @Override /* Overridden from Builder */ 1063 public Builder useJavaBeanIntrospector() { 1064 super.useJavaBeanIntrospector(); 1065 return this; 1066 } 1067 1068 @Override /* Overridden from Builder */ 1069 public Builder useWhitespace() { 1070 super.useWhitespace(); 1071 return this; 1072 } 1073 1074 @Override /* Overridden from Builder */ 1075 public Builder useWhitespace(boolean value) { 1076 super.useWhitespace(value); 1077 return this; 1078 } 1079 1080 @Override /* Overridden from Builder */ 1081 @SuppressWarnings("unchecked") 1082 public Builder widgets(java.lang.Class<? extends org.apache.juneau.html.HtmlWidget>...values) { 1083 super.widgets(values); 1084 return this; 1085 } 1086 1087 @Override /* Overridden from Builder */ 1088 public Builder ws() { 1089 super.ws(); 1090 return this; 1091 } 1092 } 1093 1094 /** 1095 * Creates a new builder for this object. 1096 * 1097 * @return A new builder. 1098 */ 1099 public static Builder create() { 1100 return new Builder(); 1101 } 1102 1103 final JsonSchemaGenerator generator; 1104 1105 /** 1106 * Constructor. 1107 * 1108 * @param builder 1109 * The builder for this object. 1110 */ 1111 public HtmlSchemaDocSerializer(HtmlDocSerializer.Builder builder) { 1112 super(builder.detectRecursions().ignoreRecursions()); 1113 1114 generator = JsonSchemaGenerator.create().beanContext(getBeanContext()).build(); 1115 } 1116 1117 @Override /* Overridden from Context */ 1118 public Builder copy() { 1119 return new Builder(this); 1120 } 1121 1122 @Override /* Overridden from Context */ 1123 public HtmlSchemaDocSerializerSession.Builder createSession() { 1124 return HtmlSchemaDocSerializerSession.create(this); 1125 } 1126 1127 @Override /* Overridden from Context */ 1128 public HtmlSchemaDocSerializerSession getSession() { return createSession().build(); } 1129 1130 JsonSchemaGenerator getGenerator() { return generator; } 1131}