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