001/* 002 * Licensed to the Apache Software Foundation (ASF) under one 003 * or more contributor license agreements. See the NOTICE file 004 * distributed with this work for additional information 005 * regarding copyright ownership. The ASF licenses this file 006 * to you under the Apache License, Version 2.0 (the 007 * "License"); you may not use this file except in compliance 008 * with the License. You may obtain a copy of the License at 009 * 010 * http://www.apache.org/licenses/LICENSE-2.0 011 * 012 * Unless required by applicable law or agreed to in writing, 013 * software distributed under the License is distributed on an 014 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 015 * KIND, either express or implied. See the License for the 016 * specific language governing permissions and limitations 017 * under the License. 018 */ 019package org.apache.maven.doxia.sink.impl; 020 021import org.apache.maven.doxia.parser.Parser; 022import org.apache.maven.doxia.sink.Locator; 023import org.apache.maven.doxia.sink.Sink; 024import org.apache.maven.doxia.sink.SinkEventAttributes; 025 026/** 027 * By default a {@link SinkWrapper} just delegates each method to the wrapped sink's method. 028 * For certain sink methods a derived wrapper may modify the sink before/after or instead of calling the delegate's method. 029 * Sink wrappers can either be registered manually via {@link Parser#addSinkWrapperFactory(SinkWrapperFactory)} or 030 * are automatically registered if provided as JSR330 component. 031 * In addition Sink wrappers can be used programmatically without an according factory. 032 * @since 2.0.0 033 */ 034public class SinkWrapper extends AbstractSink { 035 036 private Sink delegate; 037 038 public SinkWrapper(Sink delegate) { 039 super(); 040 this.delegate = delegate; 041 } 042 043 public Sink getWrappedSink() { 044 return delegate; 045 } 046 047 public void setWrappedSink(Sink sink) { 048 delegate = sink; 049 } 050 051 @Override 052 public void head(SinkEventAttributes attributes) { 053 delegate.head(attributes); 054 } 055 056 @Override 057 public void head_() { 058 delegate.head_(); 059 } 060 061 @Override 062 public void title(SinkEventAttributes attributes) { 063 delegate.title(attributes); 064 } 065 066 @Override 067 public void title_() { 068 delegate.title_(); 069 } 070 071 @Override 072 public void author(SinkEventAttributes attributes) { 073 delegate.author(attributes); 074 } 075 076 @Override 077 public void author_() { 078 delegate.author_(); 079 } 080 081 @Override 082 public void date(SinkEventAttributes attributes) { 083 delegate.date(attributes); 084 } 085 086 @Override 087 public void date_() { 088 delegate.date_(); 089 } 090 091 @Override 092 public void body(SinkEventAttributes attributes) { 093 delegate.body(attributes); 094 } 095 096 @Override 097 public void body_() { 098 delegate.body_(); 099 } 100 101 @Override 102 public void article(SinkEventAttributes attributes) { 103 delegate.article(attributes); 104 } 105 106 @Override 107 public void article_() { 108 delegate.article_(); 109 } 110 111 @Override 112 public void navigation(SinkEventAttributes attributes) { 113 delegate.navigation(attributes); 114 } 115 116 @Override 117 public void navigation_() { 118 delegate.navigation_(); 119 } 120 121 @Override 122 public void sidebar(SinkEventAttributes attributes) { 123 delegate.sidebar(attributes); 124 } 125 126 @Override 127 public void sidebar_() { 128 delegate.sidebar_(); 129 } 130 131 @Override 132 public void section(int level, SinkEventAttributes attributes) { 133 delegate.section(level, attributes); 134 } 135 136 @Override 137 public void section_(int level) { 138 delegate.section_(level); 139 } 140 141 @Override 142 public void sectionTitle(int level, SinkEventAttributes attributes) { 143 delegate.sectionTitle(level, attributes); 144 } 145 146 @Override 147 public void sectionTitle_(int level) { 148 delegate.sectionTitle_(level); 149 } 150 151 @Override 152 public void header(SinkEventAttributes attributes) { 153 delegate.header(attributes); 154 } 155 156 @Override 157 public void header_() { 158 delegate.header_(); 159 } 160 161 @Override 162 public void content(SinkEventAttributes attributes) { 163 delegate.content(attributes); 164 } 165 166 @Override 167 public void content_() { 168 delegate.content_(); 169 } 170 171 @Override 172 public void footer(SinkEventAttributes attributes) { 173 delegate.footer(attributes); 174 } 175 176 @Override 177 public void footer_() { 178 delegate.footer_(); 179 } 180 181 @Override 182 public void list(SinkEventAttributes attributes) { 183 delegate.list(attributes); 184 } 185 186 @Override 187 public void list_() { 188 delegate.list_(); 189 } 190 191 @Override 192 public void listItem(SinkEventAttributes attributes) { 193 delegate.listItem(attributes); 194 } 195 196 @Override 197 public void listItem_() { 198 delegate.listItem_(); 199 } 200 201 @Override 202 public void numberedList(int numbering, SinkEventAttributes attributes) { 203 delegate.numberedList(numbering, attributes); 204 } 205 206 @Override 207 public void numberedList_() { 208 delegate.numberedList_(); 209 } 210 211 @Override 212 public void numberedListItem(SinkEventAttributes attributes) { 213 delegate.numberedListItem(attributes); 214 } 215 216 @Override 217 public void numberedListItem_() { 218 delegate.numberedListItem_(); 219 } 220 221 @Override 222 public void definitionList(SinkEventAttributes attributes) { 223 delegate.definitionList(attributes); 224 } 225 226 @Override 227 public void definitionList_() { 228 delegate.definitionList_(); 229 } 230 231 @Override 232 public void definitionListItem(SinkEventAttributes attributes) { 233 delegate.definitionListItem(attributes); 234 } 235 236 @Override 237 public void definitionListItem_() { 238 delegate.definitionListItem_(); 239 } 240 241 @Override 242 public void definition(SinkEventAttributes attributes) { 243 delegate.definition(attributes); 244 } 245 246 @Override 247 public void definition_() { 248 delegate.definition_(); 249 } 250 251 @Override 252 public void definedTerm(SinkEventAttributes attributes) { 253 delegate.definedTerm(attributes); 254 } 255 256 @Override 257 public void definedTerm_() { 258 delegate.definedTerm_(); 259 } 260 261 @Override 262 public void figure(SinkEventAttributes attributes) { 263 delegate.figure(attributes); 264 } 265 266 @Override 267 public void figure_() { 268 delegate.figure_(); 269 } 270 271 @Override 272 public void figureCaption(SinkEventAttributes attributes) { 273 delegate.figureCaption(attributes); 274 } 275 276 @Override 277 public void figureCaption_() { 278 delegate.figureCaption_(); 279 } 280 281 @Override 282 public void figureGraphics(String src, SinkEventAttributes attributes) { 283 delegate.figureGraphics(src, attributes); 284 } 285 286 @Override 287 public void table(SinkEventAttributes attributes) { 288 delegate.table(attributes); 289 } 290 291 @Override 292 public void table_() { 293 delegate.table_(); 294 } 295 296 @Override 297 public void tableRows(int[] justification, boolean grid) { 298 delegate.tableRows(justification, grid); 299 } 300 301 @Override 302 public void tableRows_() { 303 delegate.tableRows_(); 304 } 305 306 @Override 307 public void tableRow(SinkEventAttributes attributes) { 308 delegate.tableRow(attributes); 309 } 310 311 @Override 312 public void tableRow_() { 313 delegate.tableRow_(); 314 } 315 316 @Override 317 public void tableCell(SinkEventAttributes attributes) { 318 delegate.tableCell(attributes); 319 } 320 321 @Override 322 public void tableCell_() { 323 delegate.tableCell_(); 324 } 325 326 @Override 327 public void tableHeaderCell(SinkEventAttributes attributes) { 328 delegate.tableHeaderCell(attributes); 329 } 330 331 @Override 332 public void tableHeaderCell_() { 333 delegate.tableHeaderCell_(); 334 } 335 336 @Override 337 public void tableCaption(SinkEventAttributes attributes) { 338 delegate.tableCaption(attributes); 339 } 340 341 @Override 342 public void tableCaption_() { 343 delegate.tableCaption_(); 344 } 345 346 @Override 347 public void paragraph(SinkEventAttributes attributes) { 348 delegate.paragraph(attributes); 349 } 350 351 @Override 352 public void paragraph_() { 353 delegate.paragraph_(); 354 } 355 356 @Override 357 public void data(String value, SinkEventAttributes attributes) { 358 delegate.data(value, attributes); 359 } 360 361 @Override 362 public void data_() { 363 delegate.data_(); 364 } 365 366 @Override 367 public void time(String datetime, SinkEventAttributes attributes) { 368 delegate.time(datetime, attributes); 369 } 370 371 @Override 372 public void time_() { 373 delegate.time_(); 374 } 375 376 @Override 377 public void address(SinkEventAttributes attributes) { 378 delegate.address(attributes); 379 } 380 381 @Override 382 public void address_() { 383 delegate.address_(); 384 } 385 386 @Override 387 public void blockquote(SinkEventAttributes attributes) { 388 delegate.blockquote(attributes); 389 } 390 391 @Override 392 public void blockquote_() { 393 delegate.blockquote_(); 394 } 395 396 @Override 397 public void division(SinkEventAttributes attributes) { 398 delegate.division(attributes); 399 } 400 401 @Override 402 public void division_() { 403 delegate.division_(); 404 } 405 406 @Override 407 public void verbatim(SinkEventAttributes attributes) { 408 delegate.verbatim(attributes); 409 } 410 411 @Override 412 public void verbatim_() { 413 delegate.verbatim_(); 414 } 415 416 @Override 417 public void horizontalRule(SinkEventAttributes attributes) { 418 delegate.horizontalRule(attributes); 419 } 420 421 @Override 422 public void pageBreak() { 423 delegate.pageBreak(); 424 } 425 426 @Override 427 public void anchor(String name, SinkEventAttributes attributes) { 428 delegate.anchor(name, attributes); 429 } 430 431 @Override 432 public void anchor_() { 433 delegate.anchor_(); 434 } 435 436 @Override 437 public void link(String name, SinkEventAttributes attributes) { 438 delegate.link(name, attributes); 439 } 440 441 @Override 442 public void link_() { 443 delegate.link_(); 444 } 445 446 @Override 447 public void inline(SinkEventAttributes attributes) { 448 delegate.inline(attributes); 449 } 450 451 @Override 452 public void inline_() { 453 delegate.inline_(); 454 } 455 456 @Override 457 public void italic() { 458 delegate.italic(); 459 } 460 461 @Override 462 public void italic_() { 463 delegate.italic_(); 464 } 465 466 @Override 467 public void bold() { 468 delegate.bold(); 469 } 470 471 @Override 472 public void bold_() { 473 delegate.bold_(); 474 } 475 476 @Override 477 public void monospaced() { 478 delegate.monospaced(); 479 } 480 481 @Override 482 public void monospaced_() { 483 delegate.monospaced_(); 484 } 485 486 @Override 487 public void lineBreak(SinkEventAttributes attributes) { 488 delegate.lineBreak(attributes); 489 } 490 491 @Override 492 public void lineBreakOpportunity(SinkEventAttributes attributes) { 493 delegate.lineBreakOpportunity(attributes); 494 } 495 496 @Override 497 public void nonBreakingSpace() { 498 delegate.nonBreakingSpace(); 499 } 500 501 @Override 502 public void text(String text, SinkEventAttributes attributes) { 503 delegate.text(text, attributes); 504 } 505 506 @Override 507 public void rawText(String text) { 508 delegate.rawText(text); 509 } 510 511 @Override 512 public void comment(String comment) { 513 delegate.comment(comment); 514 } 515 516 @Override 517 public void unknown(String name, Object[] requiredParams, SinkEventAttributes attributes) { 518 delegate.unknown(name, requiredParams, attributes); 519 } 520 521 @Override 522 public void flush() { 523 delegate.flush(); 524 } 525 526 @Override 527 public void close() { 528 delegate.close(); 529 } 530 531 @Override 532 public void setDocumentLocator(Locator locator) { 533 delegate.setDocumentLocator(locator); 534 } 535 536 @Override 537 public Locator getDocumentLocator() { 538 return delegate.getDocumentLocator(); 539 } 540}