001package org.apache.maven.doxia.sink.impl; 002 003/* 004 * Licensed to the Apache Software Foundation (ASF) under one 005 * or more contributor license agreements. See the NOTICE file 006 * distributed with this work for additional information 007 * regarding copyright ownership. The ASF licenses this file 008 * to you under the Apache License, Version 2.0 (the 009 * "License"); you may not use this file except in compliance 010 * with the License. You may obtain a copy of the License at 011 * 012 * http://www.apache.org/licenses/LICENSE-2.0 013 * 014 * Unless required by applicable law or agreed to in writing, 015 * software distributed under the License is distributed on an 016 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 017 * KIND, either express or implied. See the License for the 018 * specific language governing permissions and limitations 019 * under the License. 020 */ 021 022import java.io.ByteArrayOutputStream; 023import java.io.File; 024import java.io.FileOutputStream; 025import java.io.IOException; 026import java.io.OutputStream; 027import java.util.ArrayList; 028import java.util.List; 029 030import org.apache.maven.doxia.logging.Log; 031import org.apache.maven.doxia.sink.Sink; 032import org.apache.maven.doxia.sink.SinkEventAttributes; 033import org.apache.maven.doxia.sink.SinkFactory; 034 035/** 036 * The RandomAccessSink provides the ability to create a {@link Sink} with hooks. 037 * A page can be prepared by first creating its structure and specifying the positions of these hooks. 038 * After specifying the structure, the page can be filled with content from one or more models. 039 * These hooks can prevent you to have to loop over the model multiple times to build the page as desired. 040 * 041 * @author Robert Scholte 042 * @since 1.3 043 */ 044public class RandomAccessSink 045 implements Sink 046{ 047 private SinkFactory sinkFactory; 048 049 private String encoding; 050 051 private OutputStream coreOutputStream; 052 053 private Sink coreSink; 054 055 private List<Sink> sinks = new ArrayList<>(); 056 057 private List<ByteArrayOutputStream> outputStreams = new ArrayList<>(); 058 059 private Sink currentSink; 060 061 /** 062 * <p>Constructor for RandomAccessSink.</p> 063 * 064 * @param sinkFactory a {@link org.apache.maven.doxia.sink.SinkFactory} object. 065 * @param stream a {@link java.io.OutputStream} object. 066 * @throws java.io.IOException if any. 067 */ 068 public RandomAccessSink( SinkFactory sinkFactory, OutputStream stream ) 069 throws IOException 070 { 071 this.sinkFactory = sinkFactory; 072 this.coreOutputStream = stream; 073 this.currentSink = sinkFactory.createSink( stream ); 074 this.coreSink = this.currentSink; 075 } 076 077 /** 078 * <p>Constructor for RandomAccessSink.</p> 079 * 080 * @param sinkFactory a {@link org.apache.maven.doxia.sink.SinkFactory} object. 081 * @param stream a {@link java.io.OutputStream} object. 082 * @param encoding a {@link java.lang.String} object. 083 * @throws java.io.IOException if any. 084 */ 085 public RandomAccessSink( SinkFactory sinkFactory, OutputStream stream, String encoding ) 086 throws IOException 087 { 088 this.sinkFactory = sinkFactory; 089 this.coreOutputStream = stream; 090 this.encoding = encoding; 091 this.currentSink = sinkFactory.createSink( stream, encoding ); 092 this.coreSink = this.currentSink; 093 } 094 095 /** 096 * <p>Constructor for RandomAccessSink.</p> 097 * 098 * @param sinkFactory a {@link org.apache.maven.doxia.sink.SinkFactory} object. 099 * @param outputDirectory a {@link java.io.File} object. 100 * @param outputName a {@link java.lang.String} object. 101 * @throws java.io.IOException if any. 102 */ 103 public RandomAccessSink( SinkFactory sinkFactory, File outputDirectory, String outputName ) 104 throws IOException 105 { 106 this.sinkFactory = sinkFactory; 107 this.coreOutputStream = new FileOutputStream( new File( outputDirectory, outputName ) ); 108 this.currentSink = sinkFactory.createSink( coreOutputStream ); 109 this.coreSink = this.currentSink; 110 } 111 112 /** 113 * <p>Constructor for RandomAccessSink.</p> 114 * 115 * @param sinkFactory a {@link org.apache.maven.doxia.sink.SinkFactory} object. 116 * @param outputDirectory a {@link java.io.File} object. 117 * @param outputName a {@link java.lang.String} object. 118 * @param encoding a {@link java.lang.String} object. 119 * @throws java.io.IOException if any. 120 */ 121 public RandomAccessSink( SinkFactory sinkFactory, File outputDirectory, String outputName, String encoding ) 122 throws IOException 123 { 124 this.sinkFactory = sinkFactory; 125 this.coreOutputStream = new FileOutputStream( new File( outputDirectory, outputName ) ); 126 this.encoding = encoding; 127 this.currentSink = sinkFactory.createSink( coreOutputStream, encoding ); 128 this.coreSink = this.currentSink; 129 } 130 131 /** {@inheritDoc} */ 132 @Override 133 public void address() 134 { 135 currentSink.address(); 136 } 137 138 /** {@inheritDoc} */ 139 @Override 140 public void address( SinkEventAttributes attributes ) 141 { 142 currentSink.address( attributes ); 143 } 144 145 /** {@inheritDoc} */ 146 @Override 147 public void address_() 148 { 149 currentSink.address_(); 150 } 151 152 /** 153 * By calling this method a sink reference is added at the current position. You can write to both the new sink 154 * reference and the original sink. After flushing all sinks will be flushed in the right order. 155 * 156 * @return a subsink reference you can write to 157 */ 158 public Sink addSinkHook() 159 { 160 Sink subSink = null; 161 try 162 { 163 ByteArrayOutputStream subOut = new ByteArrayOutputStream(); 164 ByteArrayOutputStream newOut = new ByteArrayOutputStream(); 165 166 outputStreams.add( subOut ); 167 outputStreams.add( newOut ); 168 169 if ( encoding != null ) 170 { 171 subSink = sinkFactory.createSink( subOut, encoding ); 172 currentSink = sinkFactory.createSink( newOut, encoding ); 173 } 174 else 175 { 176 subSink = sinkFactory.createSink( subOut ); 177 currentSink = sinkFactory.createSink( newOut ); 178 } 179 sinks.add( subSink ); 180 sinks.add( currentSink ); 181 } 182 catch ( IOException e ) 183 { 184 // IOException can only be caused by our own ByteArrayOutputStream 185 } 186 return subSink; 187 } 188 189 /** {@inheritDoc} */ 190 @Override 191 public void anchor( String name ) 192 { 193 currentSink.anchor( name ); 194 } 195 196 /** {@inheritDoc} */ 197 @Override 198 public void anchor( String name, SinkEventAttributes attributes ) 199 { 200 currentSink.anchor( name, attributes ); 201 } 202 203 /** {@inheritDoc} */ 204 @Override 205 public void anchor_() 206 { 207 currentSink.anchor_(); 208 } 209 210 /** {@inheritDoc} */ 211 @Override 212 public void article() 213 { 214 currentSink.article(); 215 } 216 217 /** {@inheritDoc} */ 218 @Override 219 public void article( SinkEventAttributes attributes ) 220 { 221 currentSink.article( attributes ); 222 } 223 224 /** {@inheritDoc} */ 225 @Override 226 public void article_() 227 { 228 currentSink.article_(); 229 } 230 231 /** {@inheritDoc} */ 232 @Override 233 public void author() 234 { 235 currentSink.author(); 236 } 237 238 /** {@inheritDoc} */ 239 @Override 240 public void author( SinkEventAttributes attributes ) 241 { 242 currentSink.author( attributes ); 243 } 244 245 /** {@inheritDoc} */ 246 @Override 247 public void author_() 248 { 249 currentSink.author_(); 250 } 251 252 /** {@inheritDoc} */ 253 @Override 254 public void blockquote() 255 { 256 currentSink.blockquote(); 257 } 258 259 /** {@inheritDoc} */ 260 @Override 261 public void blockquote( SinkEventAttributes attributes ) 262 { 263 currentSink.blockquote( attributes ); 264 } 265 266 /** {@inheritDoc} */ 267 @Override 268 public void blockquote_() 269 { 270 currentSink.blockquote_(); 271 } 272 273 /** {@inheritDoc} */ 274 @Override 275 public void body() 276 { 277 currentSink.body(); 278 } 279 280 /** {@inheritDoc} */ 281 @Override 282 public void body( SinkEventAttributes attributes ) 283 { 284 currentSink.body( attributes ); 285 } 286 287 /** {@inheritDoc} */ 288 @Override 289 public void body_() 290 { 291 currentSink.body_(); 292 } 293 294 /** {@inheritDoc} */ 295 @Override 296 public void bold() 297 { 298 currentSink.bold(); 299 } 300 301 /** {@inheritDoc} */ 302 @Override 303 public void bold_() 304 { 305 currentSink.bold_(); 306 } 307 308 /** 309 * Close all sinks 310 */ 311 public void close() 312 { 313 for ( Sink sink : sinks ) 314 { 315 // sink is responsible for closing it's stream 316 sink.close(); 317 } 318 coreSink.close(); 319 } 320 321 /** {@inheritDoc} */ 322 @Override 323 public void comment( String comment ) 324 { 325 currentSink.comment( comment ); 326 } 327 328 /** {@inheritDoc} */ 329 @Override 330 public void content() 331 { 332 currentSink.content(); 333 } 334 335 /** {@inheritDoc} */ 336 @Override 337 public void content( SinkEventAttributes attributes ) 338 { 339 currentSink.content( attributes ); 340 } 341 342 /** {@inheritDoc} */ 343 @Override 344 public void content_() 345 { 346 currentSink.content_(); 347 } 348 349 /** {@inheritDoc} */ 350 @Override 351 public void data( String value ) 352 { 353 currentSink.data( value ); 354 } 355 356 /** {@inheritDoc} */ 357 @Override 358 public void data( String value, SinkEventAttributes attributes ) 359 { 360 currentSink.data( value, attributes ); 361 } 362 363 /** {@inheritDoc} */ 364 @Override 365 public void data_() 366 { 367 currentSink.data_(); 368 } 369 370 /** {@inheritDoc} */ 371 @Override 372 public void date() 373 { 374 currentSink.date(); 375 } 376 377 /** {@inheritDoc} */ 378 @Override 379 public void date( SinkEventAttributes attributes ) 380 { 381 currentSink.date( attributes ); 382 } 383 384 /** {@inheritDoc} */ 385 @Override 386 public void date_() 387 { 388 currentSink.date_(); 389 } 390 391 /** {@inheritDoc} */ 392 @Override 393 public void definedTerm() 394 { 395 currentSink.definedTerm(); 396 } 397 398 /** {@inheritDoc} */ 399 @Override 400 public void definedTerm( SinkEventAttributes attributes ) 401 { 402 currentSink.definedTerm( attributes ); 403 } 404 405 /** {@inheritDoc} */ 406 @Override 407 public void definedTerm_() 408 { 409 currentSink.definedTerm_(); 410 } 411 412 /** {@inheritDoc} */ 413 @Override 414 public void definition() 415 { 416 currentSink.definition(); 417 } 418 419 /** {@inheritDoc} */ 420 @Override 421 public void definition( SinkEventAttributes attributes ) 422 { 423 currentSink.definition( attributes ); 424 } 425 426 /** {@inheritDoc} */ 427 @Override 428 public void definitionList() 429 { 430 currentSink.definitionList(); 431 } 432 433 /** {@inheritDoc} */ 434 @Override 435 public void definitionList( SinkEventAttributes attributes ) 436 { 437 currentSink.definitionList( attributes ); 438 } 439 440 /** {@inheritDoc} */ 441 @Override 442 public void definitionListItem() 443 { 444 currentSink.definitionListItem(); 445 } 446 447 /** {@inheritDoc} */ 448 @Override 449 public void definitionListItem( SinkEventAttributes attributes ) 450 { 451 currentSink.definitionListItem( attributes ); 452 } 453 454 /** {@inheritDoc} */ 455 @Override 456 public void definitionListItem_() 457 { 458 currentSink.definitionListItem_(); 459 } 460 461 /** {@inheritDoc} */ 462 @Override 463 public void definitionList_() 464 { 465 currentSink.definitionList_(); 466 } 467 468 /** {@inheritDoc} */ 469 @Override 470 public void definition_() 471 { 472 currentSink.definition_(); 473 } 474 475 /** {@inheritDoc} */ 476 @Override 477 public void division() 478 { 479 currentSink.division(); 480 } 481 482 /** {@inheritDoc} */ 483 @Override 484 public void division( SinkEventAttributes attributes ) 485 { 486 currentSink.division( attributes ); 487 } 488 489 /** {@inheritDoc} */ 490 @Override 491 public void division_() 492 { 493 currentSink.division_(); 494 } 495 496 /** {@inheritDoc} */ 497 @Override 498 public void figure() 499 { 500 currentSink.figure(); 501 } 502 503 /** {@inheritDoc} */ 504 @Override 505 public void figure( SinkEventAttributes attributes ) 506 { 507 currentSink.figure( attributes ); 508 } 509 510 /** {@inheritDoc} */ 511 @Override 512 public void figureCaption() 513 { 514 currentSink.figureCaption(); 515 } 516 517 /** {@inheritDoc} */ 518 @Override 519 public void figureCaption( SinkEventAttributes attributes ) 520 { 521 currentSink.figureCaption( attributes ); 522 } 523 524 /** {@inheritDoc} */ 525 @Override 526 public void figureCaption_() 527 { 528 currentSink.figureCaption_(); 529 } 530 531 /** {@inheritDoc} */ 532 @Override 533 public void figureGraphics( String name ) 534 { 535 currentSink.figureGraphics( name ); 536 } 537 538 /** {@inheritDoc} */ 539 @Override 540 public void figureGraphics( String src, SinkEventAttributes attributes ) 541 { 542 currentSink.figureGraphics( src, attributes ); 543 } 544 545 /** {@inheritDoc} */ 546 @Override 547 public void figure_() 548 { 549 currentSink.figure_(); 550 } 551 552 /** 553 * Flush all sinks 554 */ 555 public void flush() 556 { 557 for ( int i = 0; i < sinks.size(); i++ ) 558 { 559 // first flush to get complete buffer 560 // sink is responsible for flushing it's stream 561 Sink sink = sinks.get( i ); 562 sink.flush(); 563 564 ByteArrayOutputStream stream = outputStreams.get( i ); 565 try 566 { 567 coreOutputStream.write( stream.toByteArray() ); 568 } 569 catch ( IOException e ) 570 { 571 // @todo 572 } 573 } 574 coreSink.flush(); 575 } 576 577 /** {@inheritDoc} */ 578 @Override 579 public void footer() 580 { 581 currentSink.footer(); 582 } 583 584 /** {@inheritDoc} */ 585 @Override 586 public void footer( SinkEventAttributes attributes ) 587 { 588 currentSink.footer( attributes ); 589 } 590 591 /** {@inheritDoc} */ 592 @Override 593 public void footer_() 594 { 595 currentSink.footer_(); 596 } 597 598 /** {@inheritDoc} */ 599 @Override 600 public void head() 601 { 602 currentSink.head(); 603 } 604 605 /** {@inheritDoc} */ 606 @Override 607 public void head( SinkEventAttributes attributes ) 608 { 609 currentSink.head( attributes ); 610 } 611 612 /** {@inheritDoc} */ 613 @Override 614 public void head_() 615 { 616 currentSink.head_(); 617 } 618 619 /** {@inheritDoc} */ 620 @Override 621 public void header() 622 { 623 currentSink.header(); 624 } 625 626 /** {@inheritDoc} */ 627 @Override 628 public void header( SinkEventAttributes attributes ) 629 { 630 currentSink.header( attributes ); 631 } 632 633 /** {@inheritDoc} */ 634 @Override 635 public void header_() 636 { 637 currentSink.header_(); 638 } 639 640 /** {@inheritDoc} */ 641 @Override 642 public void horizontalRule() 643 { 644 currentSink.horizontalRule(); 645 } 646 647 /** {@inheritDoc} */ 648 @Override 649 public void horizontalRule( SinkEventAttributes attributes ) 650 { 651 currentSink.horizontalRule( attributes ); 652 } 653 654 /** {@inheritDoc} */ 655 @Override 656 public void inline() 657 { 658 currentSink.inline(); 659 } 660 661 /** {@inheritDoc} */ 662 @Override 663 public void inline( SinkEventAttributes attributes ) 664 { 665 currentSink.inline( attributes ); 666 } 667 668 /** {@inheritDoc} */ 669 @Override 670 public void inline_() 671 { 672 currentSink.inline_(); 673 } 674 675 /** {@inheritDoc} */ 676 @Override 677 public void italic() 678 { 679 currentSink.italic(); 680 } 681 682 /** {@inheritDoc} */ 683 @Override 684 public void italic_() 685 { 686 currentSink.italic_(); 687 } 688 689 /** {@inheritDoc} */ 690 @Override 691 public void lineBreak() 692 { 693 currentSink.lineBreak(); 694 } 695 696 /** {@inheritDoc} */ 697 @Override 698 public void lineBreak( SinkEventAttributes attributes ) 699 { 700 currentSink.lineBreak( attributes ); 701 } 702 703 /** {@inheritDoc} */ 704 @Override 705 public void lineBreakOpportunity() 706 { 707 currentSink.lineBreakOpportunity(); 708 } 709 710 /** {@inheritDoc} */ 711 @Override 712 public void lineBreakOpportunity( SinkEventAttributes attributes ) 713 { 714 currentSink.lineBreakOpportunity( attributes ); 715 } 716 717 /** {@inheritDoc} */ 718 @Override 719 public void link( String name ) 720 { 721 currentSink.link( name ); 722 } 723 724 /** {@inheritDoc} */ 725 @Override 726 public void link( String name, SinkEventAttributes attributes ) 727 { 728 currentSink.link( name, attributes ); 729 } 730 731 /** {@inheritDoc} */ 732 @Override 733 public void link_() 734 { 735 currentSink.link_(); 736 } 737 738 /** {@inheritDoc} */ 739 @Override 740 public void list() 741 { 742 currentSink.list(); 743 } 744 745 /** {@inheritDoc} */ 746 @Override 747 public void list( SinkEventAttributes attributes ) 748 { 749 currentSink.list( attributes ); 750 } 751 752 /** {@inheritDoc} */ 753 @Override 754 public void listItem() 755 { 756 currentSink.listItem(); 757 } 758 759 /** {@inheritDoc} */ 760 @Override 761 public void listItem( SinkEventAttributes attributes ) 762 { 763 currentSink.listItem( attributes ); 764 } 765 766 /** {@inheritDoc} */ 767 @Override 768 public void listItem_() 769 { 770 currentSink.listItem_(); 771 } 772 773 /** {@inheritDoc} */ 774 @Override 775 public void list_() 776 { 777 currentSink.list_(); 778 } 779 780 /** {@inheritDoc} */ 781 @Override 782 public void monospaced() 783 { 784 currentSink.monospaced(); 785 } 786 787 /** {@inheritDoc} */ 788 @Override 789 public void monospaced_() 790 { 791 currentSink.monospaced_(); 792 } 793 794 /** {@inheritDoc} */ 795 @Override 796 public void navigation() 797 { 798 currentSink.navigation(); 799 } 800 801 /** {@inheritDoc} */ 802 @Override 803 public void navigation( SinkEventAttributes attributes ) 804 { 805 currentSink.navigation( attributes ); 806 } 807 808 /** {@inheritDoc} */ 809 @Override 810 public void navigation_() 811 { 812 currentSink.navigation_(); 813 } 814 815 /** {@inheritDoc} */ 816 @Override 817 public void nonBreakingSpace() 818 { 819 currentSink.nonBreakingSpace(); 820 } 821 822 /** {@inheritDoc} */ 823 @Override 824 public void numberedList( int numbering ) 825 { 826 currentSink.numberedList( numbering ); 827 } 828 829 /** {@inheritDoc} */ 830 @Override 831 public void numberedList( int numbering, SinkEventAttributes attributes ) 832 { 833 currentSink.numberedList( numbering, attributes ); 834 } 835 836 /** {@inheritDoc} */ 837 @Override 838 public void numberedListItem() 839 { 840 currentSink.numberedListItem(); 841 } 842 843 /** {@inheritDoc} */ 844 @Override 845 public void numberedListItem( SinkEventAttributes attributes ) 846 { 847 currentSink.numberedListItem( attributes ); 848 } 849 850 /** {@inheritDoc} */ 851 @Override 852 public void numberedListItem_() 853 { 854 currentSink.numberedListItem_(); 855 } 856 857 /** {@inheritDoc} */ 858 @Override 859 public void numberedList_() 860 { 861 currentSink.numberedList_(); 862 } 863 864 /** {@inheritDoc} */ 865 @Override 866 public void pageBreak() 867 { 868 currentSink.pageBreak(); 869 } 870 871 /** {@inheritDoc} */ 872 @Override 873 public void paragraph() 874 { 875 currentSink.paragraph(); 876 } 877 878 /** {@inheritDoc} */ 879 @Override 880 public void paragraph( SinkEventAttributes attributes ) 881 { 882 currentSink.paragraph( attributes ); 883 } 884 885 /** {@inheritDoc} */ 886 @Override 887 public void paragraph_() 888 { 889 currentSink.paragraph_(); 890 } 891 892 /** {@inheritDoc} */ 893 @Override 894 public void rawText( String text ) 895 { 896 currentSink.rawText( text ); 897 } 898 899 /** {@inheritDoc} */ 900 @Override 901 public void section( int level, SinkEventAttributes attributes ) 902 { 903 currentSink.section( level, attributes ); 904 } 905 906 /** {@inheritDoc} */ 907 @Override 908 public void section1() 909 { 910 currentSink.section1(); 911 } 912 913 /** {@inheritDoc} */ 914 @Override 915 public void section1_() 916 { 917 currentSink.section1_(); 918 } 919 920 /** {@inheritDoc} */ 921 @Override 922 public void section2() 923 { 924 currentSink.section2(); 925 } 926 927 /** {@inheritDoc} */ 928 @Override 929 public void section2_() 930 { 931 currentSink.section2_(); 932 } 933 934 /** {@inheritDoc} */ 935 @Override 936 public void section3() 937 { 938 currentSink.section3(); 939 } 940 941 /** {@inheritDoc} */ 942 @Override 943 public void section3_() 944 { 945 currentSink.section3_(); 946 } 947 948 /** {@inheritDoc} */ 949 @Override 950 public void section4() 951 { 952 currentSink.section4(); 953 } 954 955 /** {@inheritDoc} */ 956 @Override 957 public void section4_() 958 { 959 currentSink.section4_(); 960 } 961 962 /** {@inheritDoc} */ 963 @Override 964 public void section5() 965 { 966 currentSink.section5(); 967 } 968 969 /** {@inheritDoc} */ 970 @Override 971 public void section5_() 972 { 973 currentSink.section5_(); 974 } 975 976 /** {@inheritDoc} */ 977 @Override 978 public void section6() 979 { 980 currentSink.section5(); 981 } 982 983 /** {@inheritDoc} */ 984 @Override 985 public void section6_() 986 { 987 currentSink.section5_(); 988 } 989 990 /** {@inheritDoc} */ 991 @Override 992 public void sectionTitle() 993 { 994 currentSink.sectionTitle(); 995 } 996 997 /** {@inheritDoc} */ 998 @Override 999 public void sectionTitle( int level, SinkEventAttributes attributes ) 1000 { 1001 currentSink.sectionTitle( level, attributes ); 1002 } 1003 1004 /** {@inheritDoc} */ 1005 @Override 1006 public void sectionTitle1() 1007 { 1008 currentSink.sectionTitle1(); 1009 } 1010 1011 /** {@inheritDoc} */ 1012 @Override 1013 public void sectionTitle1_() 1014 { 1015 currentSink.sectionTitle1_(); 1016 } 1017 1018 /** {@inheritDoc} */ 1019 @Override 1020 public void sectionTitle2() 1021 { 1022 currentSink.sectionTitle2(); 1023 } 1024 1025 /** {@inheritDoc} */ 1026 @Override 1027 public void sectionTitle2_() 1028 { 1029 currentSink.sectionTitle2_(); 1030 } 1031 1032 /** {@inheritDoc} */ 1033 @Override 1034 public void sectionTitle3() 1035 { 1036 currentSink.sectionTitle3(); 1037 } 1038 1039 /** {@inheritDoc} */ 1040 @Override 1041 public void sectionTitle3_() 1042 { 1043 currentSink.sectionTitle3_(); 1044 } 1045 1046 /** {@inheritDoc} */ 1047 @Override 1048 public void sectionTitle4() 1049 { 1050 currentSink.sectionTitle4(); 1051 } 1052 1053 /** {@inheritDoc} */ 1054 @Override 1055 public void sectionTitle4_() 1056 { 1057 currentSink.sectionTitle4_(); 1058 } 1059 1060 /** {@inheritDoc} */ 1061 @Override 1062 public void sectionTitle5() 1063 { 1064 currentSink.sectionTitle5(); 1065 } 1066 1067 /** {@inheritDoc} */ 1068 @Override 1069 public void sectionTitle5_() 1070 { 1071 currentSink.sectionTitle5_(); 1072 } 1073 1074 /** {@inheritDoc} */ 1075 @Override 1076 public void sectionTitle6() 1077 { 1078 currentSink.sectionTitle5(); 1079 } 1080 1081 /** {@inheritDoc} */ 1082 @Override 1083 public void sectionTitle6_() 1084 { 1085 currentSink.sectionTitle5_(); 1086 } 1087 1088 /** {@inheritDoc} */ 1089 @Override 1090 public void sectionTitle_() 1091 { 1092 currentSink.sectionTitle_(); 1093 } 1094 1095 /** {@inheritDoc} */ 1096 @Override 1097 public void sectionTitle_( int level ) 1098 { 1099 currentSink.sectionTitle_( level ); 1100 } 1101 1102 /** {@inheritDoc} */ 1103 @Override 1104 public void section_( int level ) 1105 { 1106 currentSink.section_( level ); 1107 } 1108 1109 /** {@inheritDoc} */ 1110 @Override 1111 public void sidebar() 1112 { 1113 currentSink.sidebar(); 1114 } 1115 1116 /** {@inheritDoc} */ 1117 @Override 1118 public void sidebar( SinkEventAttributes attributes ) 1119 { 1120 currentSink.sidebar( attributes ); 1121 } 1122 1123 /** {@inheritDoc} */ 1124 @Override 1125 public void sidebar_() 1126 { 1127 currentSink.sidebar_(); 1128 } 1129 1130 /** {@inheritDoc} */ 1131 @Override 1132 public void table() 1133 { 1134 currentSink.table(); 1135 } 1136 1137 /** {@inheritDoc} */ 1138 @Override 1139 public void table( SinkEventAttributes attributes ) 1140 { 1141 currentSink.table( attributes ); 1142 } 1143 1144 /** {@inheritDoc} */ 1145 @Override 1146 public void tableCaption() 1147 { 1148 currentSink.tableCaption(); 1149 } 1150 1151 /** {@inheritDoc} */ 1152 @Override 1153 public void tableCaption( SinkEventAttributes attributes ) 1154 { 1155 currentSink.tableCaption( attributes ); 1156 } 1157 1158 /** {@inheritDoc} */ 1159 @Override 1160 public void tableCaption_() 1161 { 1162 currentSink.tableCaption_(); 1163 } 1164 1165 /** {@inheritDoc} */ 1166 @Override 1167 public void tableCell() 1168 { 1169 currentSink.tableCell(); 1170 } 1171 1172 /** {@inheritDoc} */ 1173 @Override 1174 public void tableCell( String width ) 1175 { 1176 currentSink.tableCell( width ); 1177 } 1178 1179 /** {@inheritDoc} */ 1180 @Override 1181 public void tableCell( SinkEventAttributes attributes ) 1182 { 1183 currentSink.tableCell( attributes ); 1184 } 1185 1186 /** {@inheritDoc} */ 1187 @Override 1188 public void tableCell_() 1189 { 1190 currentSink.tableCell_(); 1191 } 1192 1193 /** {@inheritDoc} */ 1194 @Override 1195 public void tableHeaderCell() 1196 { 1197 currentSink.tableHeaderCell(); 1198 } 1199 1200 /** {@inheritDoc} */ 1201 @Override 1202 public void tableHeaderCell( String width ) 1203 { 1204 currentSink.tableHeaderCell( width ); 1205 } 1206 1207 /** {@inheritDoc} */ 1208 @Override 1209 public void tableHeaderCell( SinkEventAttributes attributes ) 1210 { 1211 currentSink.tableHeaderCell( attributes ); 1212 } 1213 1214 /** {@inheritDoc} */ 1215 @Override 1216 public void tableHeaderCell_() 1217 { 1218 currentSink.tableHeaderCell_(); 1219 } 1220 1221 /** {@inheritDoc} */ 1222 @Override 1223 public void tableRow() 1224 { 1225 currentSink.tableRow(); 1226 } 1227 1228 /** {@inheritDoc} */ 1229 @Override 1230 public void tableRow( SinkEventAttributes attributes ) 1231 { 1232 currentSink.tableRow( attributes ); 1233 } 1234 1235 /** {@inheritDoc} */ 1236 @Override 1237 public void tableRow_() 1238 { 1239 currentSink.tableRow_(); 1240 } 1241 1242 /** {@inheritDoc} */ 1243 @Override 1244 public void tableRows( int[] justification, boolean grid ) 1245 { 1246 currentSink.tableRows( justification, grid ); 1247 } 1248 1249 /** {@inheritDoc} */ 1250 @Override 1251 public void tableRows_() 1252 { 1253 currentSink.tableRows_(); 1254 } 1255 1256 /** {@inheritDoc} */ 1257 @Override 1258 public void table_() 1259 { 1260 currentSink.table_(); 1261 } 1262 1263 /** {@inheritDoc} */ 1264 @Override 1265 public void text( String text ) 1266 { 1267 currentSink.text( text ); 1268 } 1269 1270 /** {@inheritDoc} */ 1271 @Override 1272 public void text( String text, SinkEventAttributes attributes ) 1273 { 1274 currentSink.text( text, attributes ); 1275 } 1276 1277 /** {@inheritDoc} */ 1278 @Override 1279 public void time( String datetime ) 1280 { 1281 currentSink.time( datetime ); 1282 } 1283 1284 /** {@inheritDoc} */ 1285 @Override 1286 public void time( String datetime, SinkEventAttributes attributes ) 1287 { 1288 currentSink.time( datetime, attributes ); 1289 } 1290 1291 /** {@inheritDoc} */ 1292 @Override 1293 public void time_() 1294 { 1295 currentSink.time_(); 1296 } 1297 1298 /** {@inheritDoc} */ 1299 @Override 1300 public void title() 1301 { 1302 currentSink.title(); 1303 } 1304 1305 /** {@inheritDoc} */ 1306 @Override 1307 public void title( SinkEventAttributes attributes ) 1308 { 1309 currentSink.title( attributes ); 1310 } 1311 1312 /** {@inheritDoc} */ 1313 @Override 1314 public void title_() 1315 { 1316 currentSink.title_(); 1317 } 1318 1319 /** {@inheritDoc} */ 1320 @Override 1321 public void unknown( String name, Object[] requiredParams, SinkEventAttributes attributes ) 1322 { 1323 currentSink.unknown( name, requiredParams, attributes ); 1324 } 1325 1326 /** {@inheritDoc} */ 1327 @Override 1328 public void verbatim( boolean boxed ) 1329 { 1330 currentSink.verbatim( boxed ); 1331 } 1332 1333 /** {@inheritDoc} */ 1334 @Override 1335 public void verbatim( SinkEventAttributes attributes ) 1336 { 1337 currentSink.verbatim( attributes ); 1338 } 1339 1340 /** {@inheritDoc} */ 1341 @Override 1342 public void verbatim_() 1343 { 1344 currentSink.verbatim_(); 1345 } 1346 1347 /** {@inheritDoc} */ 1348 @Override 1349 public void enableLogging( Log log ) 1350 { 1351 currentSink.enableLogging( log ); 1352 } 1353}