/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.doxia.sink.impl;

import org.apache.maven.doxia.parser.Parser;
import org.apache.maven.doxia.sink.Locator;
import org.apache.maven.doxia.sink.Sink;
import org.apache.maven.doxia.sink.SinkEventAttributes;

/**
 * By default a {@link SinkWrapper} just delegates each method to the wrapped sink's method.
 * For certain sink methods a derived wrapper may modify the sink before/after or instead of calling the delegate's method.
 * Sink wrappers can either be registered manually via {@link Parser#addSinkWrapperFactory(SinkWrapperFactory)} or
 * are automatically registered if provided as JSR330 component.
 * In addition Sink wrappers can be used programmatically without an according factory.
 * @since 2.0.0
 */
public class SinkWrapper extends AbstractSink {

    private Sink delegate;

    public SinkWrapper(Sink delegate) {
        super();
        this.delegate = delegate;
    }

    public Sink getWrappedSink() {
        return delegate;
    }

    public void setWrappedSink(Sink sink) {
        delegate = sink;
    }

    @Override
    public void head(SinkEventAttributes attributes) {
        delegate.head(attributes);
    }

    @Override
    public void head_() {
        delegate.head_();
    }

    @Override
    public void title(SinkEventAttributes attributes) {
        delegate.title(attributes);
    }

    @Override
    public void title_() {
        delegate.title_();
    }

    @Override
    public void author(SinkEventAttributes attributes) {
        delegate.author(attributes);
    }

    @Override
    public void author_() {
        delegate.author_();
    }

    @Override
    public void date(SinkEventAttributes attributes) {
        delegate.date(attributes);
    }

    @Override
    public void date_() {
        delegate.date_();
    }

    @Override
    public void body(SinkEventAttributes attributes) {
        delegate.body(attributes);
    }

    @Override
    public void body_() {
        delegate.body_();
    }

    @Override
    public void article(SinkEventAttributes attributes) {
        delegate.article(attributes);
    }

    @Override
    public void article_() {
        delegate.article_();
    }

    @Override
    public void navigation(SinkEventAttributes attributes) {
        delegate.navigation(attributes);
    }

    @Override
    public void navigation_() {
        delegate.navigation_();
    }

    @Override
    public void sidebar(SinkEventAttributes attributes) {
        delegate.sidebar(attributes);
    }

    @Override
    public void sidebar_() {
        delegate.sidebar_();
    }

    @Override
    public void section(int level, SinkEventAttributes attributes) {
        delegate.section(level, attributes);
    }

    @Override
    public void section_(int level) {
        delegate.section_(level);
    }

    @Override
    public void sectionTitle(int level, SinkEventAttributes attributes) {
        delegate.sectionTitle(level, attributes);
    }

    @Override
    public void sectionTitle_(int level) {
        delegate.sectionTitle_(level);
    }

    @Override
    public void header(SinkEventAttributes attributes) {
        delegate.header(attributes);
    }

    @Override
    public void header_() {
        delegate.header_();
    }

    @Override
    public void content(SinkEventAttributes attributes) {
        delegate.content(attributes);
    }

    @Override
    public void content_() {
        delegate.content_();
    }

    @Override
    public void footer(SinkEventAttributes attributes) {
        delegate.footer(attributes);
    }

    @Override
    public void footer_() {
        delegate.footer_();
    }

    @Override
    public void list(SinkEventAttributes attributes) {
        delegate.list(attributes);
    }

    @Override
    public void list_() {
        delegate.list_();
    }

    @Override
    public void listItem(SinkEventAttributes attributes) {
        delegate.listItem(attributes);
    }

    @Override
    public void listItem_() {
        delegate.listItem_();
    }

    @Override
    public void numberedList(int numbering, SinkEventAttributes attributes) {
        delegate.numberedList(numbering, attributes);
    }

    @Override
    public void numberedList_() {
        delegate.numberedList_();
    }

    @Override
    public void numberedListItem(SinkEventAttributes attributes) {
        delegate.numberedListItem(attributes);
    }

    @Override
    public void numberedListItem_() {
        delegate.numberedListItem_();
    }

    @Override
    public void definitionList(SinkEventAttributes attributes) {
        delegate.definitionList(attributes);
    }

    @Override
    public void definitionList_() {
        delegate.definitionList_();
    }

    @Override
    public void definitionListItem(SinkEventAttributes attributes) {
        delegate.definitionListItem(attributes);
    }

    @Override
    public void definitionListItem_() {
        delegate.definitionListItem_();
    }

    @Override
    public void definition(SinkEventAttributes attributes) {
        delegate.definition(attributes);
    }

    @Override
    public void definition_() {
        delegate.definition_();
    }

    @Override
    public void definedTerm(SinkEventAttributes attributes) {
        delegate.definedTerm(attributes);
    }

    @Override
    public void definedTerm_() {
        delegate.definedTerm_();
    }

    @Override
    public void figure(SinkEventAttributes attributes) {
        delegate.figure(attributes);
    }

    @Override
    public void figure_() {
        delegate.figure_();
    }

    @Override
    public void figureCaption(SinkEventAttributes attributes) {
        delegate.figureCaption(attributes);
    }

    @Override
    public void figureCaption_() {
        delegate.figureCaption_();
    }

    @Override
    public void figureGraphics(String src, SinkEventAttributes attributes) {
        delegate.figureGraphics(src, attributes);
    }

    @Override
    public void table(SinkEventAttributes attributes) {
        delegate.table(attributes);
    }

    @Override
    public void table_() {
        delegate.table_();
    }

    @Override
    public void tableRows(int[] justification, boolean grid) {
        delegate.tableRows(justification, grid);
    }

    @Override
    public void tableRows_() {
        delegate.tableRows_();
    }

    @Override
    public void tableRow(SinkEventAttributes attributes) {
        delegate.tableRow(attributes);
    }

    @Override
    public void tableRow_() {
        delegate.tableRow_();
    }

    @Override
    public void tableCell(SinkEventAttributes attributes) {
        delegate.tableCell(attributes);
    }

    @Override
    public void tableCell_() {
        delegate.tableCell_();
    }

    @Override
    public void tableHeaderCell(SinkEventAttributes attributes) {
        delegate.tableHeaderCell(attributes);
    }

    @Override
    public void tableHeaderCell_() {
        delegate.tableHeaderCell_();
    }

    @Override
    public void tableCaption(SinkEventAttributes attributes) {
        delegate.tableCaption(attributes);
    }

    @Override
    public void tableCaption_() {
        delegate.tableCaption_();
    }

    @Override
    public void paragraph(SinkEventAttributes attributes) {
        delegate.paragraph(attributes);
    }

    @Override
    public void paragraph_() {
        delegate.paragraph_();
    }

    @Override
    public void data(String value, SinkEventAttributes attributes) {
        delegate.data(value, attributes);
    }

    @Override
    public void data_() {
        delegate.data_();
    }

    @Override
    public void time(String datetime, SinkEventAttributes attributes) {
        delegate.time(datetime, attributes);
    }

    @Override
    public void time_() {
        delegate.time_();
    }

    @Override
    public void address(SinkEventAttributes attributes) {
        delegate.address(attributes);
    }

    @Override
    public void address_() {
        delegate.address_();
    }

    @Override
    public void blockquote(SinkEventAttributes attributes) {
        delegate.blockquote(attributes);
    }

    @Override
    public void blockquote_() {
        delegate.blockquote_();
    }

    @Override
    public void division(SinkEventAttributes attributes) {
        delegate.division(attributes);
    }

    @Override
    public void division_() {
        delegate.division_();
    }

    @Override
    public void verbatim(SinkEventAttributes attributes) {
        delegate.verbatim(attributes);
    }

    @Override
    public void verbatim_() {
        delegate.verbatim_();
    }

    @Override
    public void horizontalRule(SinkEventAttributes attributes) {
        delegate.horizontalRule(attributes);
    }

    @Override
    public void pageBreak() {
        delegate.pageBreak();
    }

    @Override
    public void anchor(String name, SinkEventAttributes attributes) {
        delegate.anchor(name, attributes);
    }

    @Override
    public void anchor_() {
        delegate.anchor_();
    }

    @Override
    public void link(String name, SinkEventAttributes attributes) {
        delegate.link(name, attributes);
    }

    @Override
    public void link_() {
        delegate.link_();
    }

    @Override
    public void inline(SinkEventAttributes attributes) {
        delegate.inline(attributes);
    }

    @Override
    public void inline_() {
        delegate.inline_();
    }

    @Override
    public void italic() {
        delegate.italic();
    }

    @Override
    public void italic_() {
        delegate.italic_();
    }

    @Override
    public void bold() {
        delegate.bold();
    }

    @Override
    public void bold_() {
        delegate.bold_();
    }

    @Override
    public void monospaced() {
        delegate.monospaced();
    }

    @Override
    public void monospaced_() {
        delegate.monospaced_();
    }

    @Override
    public void lineBreak(SinkEventAttributes attributes) {
        delegate.lineBreak(attributes);
    }

    @Override
    public void lineBreakOpportunity(SinkEventAttributes attributes) {
        delegate.lineBreakOpportunity(attributes);
    }

    @Override
    public void nonBreakingSpace() {
        delegate.nonBreakingSpace();
    }

    @Override
    public void text(String text, SinkEventAttributes attributes) {
        delegate.text(text, attributes);
    }

    @Override
    public void rawText(String text) {
        delegate.rawText(text);
    }

    @Override
    public void comment(String comment) {
        delegate.comment(comment);
    }

    @Override
    public void markupLineBreak(int indentLevel) {
        delegate.markupLineBreak(indentLevel);
    }

    @Override
    public void unknown(String name, Object[] requiredParams, SinkEventAttributes attributes) {
        delegate.unknown(name, requiredParams, attributes);
    }

    @Override
    public void flush() {
        delegate.flush();
    }

    @Override
    public void close() {
        delegate.close();
    }

    @Override
    public void setDocumentLocator(Locator locator) {
        delegate.setDocumentLocator(locator);
    }

    @Override
    public Locator getDocumentLocator() {
        return delegate.getDocumentLocator();
    }
}
