package org.apache.maven.doxia.sink;

 /*

  * 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.

  */

 import java.io.ByteArrayOutputStream;

 import java.io.File;

 import java.io.FileOutputStream;

 import java.io.IOException;

 import java.io.OutputStream;

 import java.util.ArrayList;

 import java.util.List;

 import org.apache.maven.doxia.logging.Log;

 /**

  * The RandomAccessSink provides the ability to create a {@link Sink} with hooks.

  * A page can be prepared by first creating its structure and specifying the positions of these hooks.

  * After specifying the structure, the page can be filled with content from one or more models.

  * These hooks can prevent you to have to loop over the model multiple times to build the page as desired. 

  * 

  * @author Robert Scholte

  * @since 1.3

  */

 public class RandomAccessSink

     implements Sink

 {

     private SinkFactory sinkFactory;

     private String encoding;

     private OutputStream coreOutputStream;

     private Sink coreSink;

     private List<Sink> sinks = new ArrayList<Sink>();

     private List<ByteArrayOutputStream> outputStreams = new ArrayList<ByteArrayOutputStream>();

     private Sink currentSink;

     public RandomAccessSink( SinkFactory sinkFactory, OutputStream stream )

         throws IOException

     {

         this.sinkFactory = sinkFactory;

         this.coreOutputStream = stream;

         this.coreSink = this.currentSink = sinkFactory.createSink( stream );

     }

     public RandomAccessSink( SinkFactory sinkFactory, OutputStream stream, String encoding )

         throws IOException

     {

         this.sinkFactory = sinkFactory;

         this.coreOutputStream = stream;

         this.encoding = encoding;

         this.coreSink = this.currentSink = sinkFactory.createSink( stream, encoding );

     }

     public RandomAccessSink( SinkFactory sinkFactory, File outputDirectory, String outputName )

         throws IOException

     {

         this.sinkFactory = sinkFactory;

         this.coreOutputStream = new FileOutputStream( new File( outputDirectory, outputName ) );

         this.coreSink = this.currentSink = sinkFactory.createSink( coreOutputStream );

     }

     public RandomAccessSink( SinkFactory sinkFactory, File outputDirectory, String outputName, String encoding )

         throws IOException

     {

         this.sinkFactory = sinkFactory;

         this.coreOutputStream = new FileOutputStream( new File( outputDirectory, outputName ) );

         this.encoding = encoding;

         this.coreSink = this.currentSink = sinkFactory.createSink( coreOutputStream, encoding );

     }

     /**

      * By calling this method a sink reference is added at the current position. You can write to both the new sink

      * reference and the original sink. After flushing all sinks will be flushed in the right order.

      * 

      * @return a subsink reference you can write to

      */

     public Sink addSinkHook()

     {

         Sink subSink = null;

         try

         {

             ByteArrayOutputStream subOut = new ByteArrayOutputStream();

             ByteArrayOutputStream newOut = new ByteArrayOutputStream();

             outputStreams.add( subOut );

             outputStreams.add( newOut );

             if ( encoding != null )

             {

                 subSink = sinkFactory.createSink( subOut, encoding );

                 currentSink = sinkFactory.createSink( newOut, encoding );

             }

             else

             {

                 subSink = sinkFactory.createSink( subOut );

                 currentSink = sinkFactory.createSink( newOut );

             }

             sinks.add( subSink );

             sinks.add( currentSink );

         }

         catch ( IOException e )

         {

             // IOException can only be caused by our own ByteArrayOutputStream

         }

         return subSink;

     }

     /** {@inheritDoc} */

     public void anchor( String name )

     {

         currentSink.anchor( name );

     }

     /** {@inheritDoc} */

     public void anchor( String name, SinkEventAttributes attributes )

     {

         currentSink.anchor( name, attributes );

     }

     /** {@inheritDoc} */

     public void anchor_()

     {

         currentSink.anchor_();

     }

     /** {@inheritDoc} */

     public void author()

     {

         currentSink.author();

     }

     /** {@inheritDoc} */

     public void author( SinkEventAttributes attributes )

     {

         currentSink.author( attributes );

     }

     /** {@inheritDoc} */

     public void author_()

     {

         currentSink.author_();

     }

     /** {@inheritDoc} */

     public void body()

     {

         currentSink.body();

     }

     /** {@inheritDoc} */

     public void body( SinkEventAttributes attributes )

     {

         currentSink.body( attributes );

     }

     /** {@inheritDoc} */

     public void body_()

     {

         currentSink.body_();

     }

     /** {@inheritDoc} */

     public void bold()

     {

         currentSink.bold();

     }

     /** {@inheritDoc} */

     public void bold_()

     {

         currentSink.bold_();

     }

     /**

      * Close all sinks

      */

     public void close()

     {

         for ( Sink sink  : sinks )

         {

             // sink is responsible for closing it's stream

             sink.close();

         }

         coreSink.close();

     }

     /** {@inheritDoc} */

     public void comment( String comment )

     {

         currentSink.comment( comment );

     }

     /** {@inheritDoc} */

     public void date()

     {

         currentSink.date();

     }

     /** {@inheritDoc} */

     public void date( SinkEventAttributes attributes )

     {

         currentSink.date( attributes );

     }

     /** {@inheritDoc} */

     public void date_()

     {

         currentSink.date_();

     }

     /** {@inheritDoc} */

     public void definedTerm()

     {

         currentSink.definedTerm();

     }

     /** {@inheritDoc} */

     public void definedTerm( SinkEventAttributes attributes )

     {

         currentSink.definedTerm( attributes );

     }

     /** {@inheritDoc} */

     public void definedTerm_()

     {

         currentSink.definedTerm_();

     }

     /** {@inheritDoc} */

     public void definition()

     {

         currentSink.definition();

     }

     /** {@inheritDoc} */

     public void definition( SinkEventAttributes attributes )

     {

         currentSink.definition( attributes );

     }

     /** {@inheritDoc} */

     public void definitionList()

     {

         currentSink.definitionList();

     }

     /** {@inheritDoc} */

     public void definitionList( SinkEventAttributes attributes )

     {

         currentSink.definitionList( attributes );

     }

     /** {@inheritDoc} */

     public void definitionListItem()

     {

         currentSink.definitionListItem();

     }

     /** {@inheritDoc} */

     public void definitionListItem( SinkEventAttributes attributes )

     {

         currentSink.definitionListItem( attributes );

     }

     /** {@inheritDoc} */

     public void definitionListItem_()

     {

         currentSink.definitionListItem_();

     }

     /** {@inheritDoc} */

     public void definitionList_()

     {

         currentSink.definitionList_();

     }

     /** {@inheritDoc} */

     public void definition_()

     {

         currentSink.definition_();

     }

     /** {@inheritDoc} */

     public void figure()

     {

         currentSink.figure();

     }

     /** {@inheritDoc} */

     public void figure( SinkEventAttributes attributes )

     {

         currentSink.figure( attributes );

     }

     /** {@inheritDoc} */

     public void figureCaption()

     {

         currentSink.figureCaption();

     }

     /** {@inheritDoc} */

     public void figureCaption( SinkEventAttributes attributes )

     {

         currentSink.figureCaption( attributes );

     }

     /** {@inheritDoc} */

     public void figureCaption_()

     {

         currentSink.figureCaption_();

     }

     /** {@inheritDoc} */

     public void figureGraphics( String name )

     {

         currentSink.figureGraphics( name );

     }

     /** {@inheritDoc} */

     public void figureGraphics( String src, SinkEventAttributes attributes )

     {

         currentSink.figureGraphics( src, attributes );

     }

     /** {@inheritDoc} */

     public void figure_()

     {

         currentSink.figure_();

     }

     /**

      * Flush all sinks

      */

     public void flush()

     {

         for ( int i = 0; i < sinks.size(); i++ )

         {

             // first flush to get complete buffer

             // sink is responsible for flushing it's stream

             Sink sink = sinks.get( i );

             sink.flush();

             ByteArrayOutputStream stream = outputStreams.get( i );

             try

             {

                 coreOutputStream.write( stream.toByteArray() );

             }

             catch ( IOException e )

             {

                 // @todo

             }

         }

         coreSink.flush();

     }

     /** {@inheritDoc} */

     public void head()

     {

         currentSink.head();

     }

     /** {@inheritDoc} */

     public void head( SinkEventAttributes attributes )

     {

         currentSink.head( attributes );

     }

     /** {@inheritDoc} */

     public void head_()

     {

         currentSink.head_();

     }

     /** {@inheritDoc} */

     public void horizontalRule()

     {

         currentSink.horizontalRule();

     }

     /** {@inheritDoc} */

     public void horizontalRule( SinkEventAttributes attributes )

     {

         currentSink.horizontalRule( attributes );

     }

     /** {@inheritDoc} */

     public void italic()

     {

         currentSink.italic();

     }

     /** {@inheritDoc} */

     public void italic_()

     {

         currentSink.italic_();

     }

     /** {@inheritDoc} */

     public void lineBreak()

     {

         currentSink.lineBreak();

     }

     /** {@inheritDoc} */

     public void lineBreak( SinkEventAttributes attributes )

     {

         currentSink.lineBreak( attributes );

     }

     /** {@inheritDoc} */

     public void link( String name )

     {

         currentSink.link( name );

     }

     /** {@inheritDoc} */

     public void link( String name, SinkEventAttributes attributes )

     {

         currentSink.link( name, attributes );

     }

     /** {@inheritDoc} */

     public void link_()

     {

         currentSink.link_();

     }

     /** {@inheritDoc} */

     public void list()

     {

         currentSink.list();

     }

     /** {@inheritDoc} */

     public void list( SinkEventAttributes attributes )

     {

         currentSink.list( attributes );

     }

     /** {@inheritDoc} */

     public void listItem()

     {

         currentSink.listItem();

     }

     /** {@inheritDoc} */

     public void listItem( SinkEventAttributes attributes )

     {

         currentSink.listItem( attributes );

     }

     /** {@inheritDoc} */

     public void listItem_()

     {

         currentSink.listItem_();

     }

     /** {@inheritDoc} */

     public void list_()

     {

         currentSink.list_();

     }

     /** {@inheritDoc} */

     public void monospaced()

     {

         currentSink.monospaced();

     }

     /** {@inheritDoc} */

     public void monospaced_()

     {

         currentSink.monospaced_();

     }

     /** {@inheritDoc} */

     public void nonBreakingSpace()

     {

         currentSink.nonBreakingSpace();

     }

     /** {@inheritDoc} */

     public void numberedList( int numbering )

     {

         currentSink.numberedList( numbering );

     }

     /** {@inheritDoc} */

     public void numberedList( int numbering, SinkEventAttributes attributes )

     {

         currentSink.numberedList( numbering, attributes );

     }

     /** {@inheritDoc} */

     public void numberedListItem()

     {

         currentSink.numberedListItem();

     }

     /** {@inheritDoc} */

     public void numberedListItem( SinkEventAttributes attributes )

     {

         currentSink.numberedListItem( attributes );

     }

     /** {@inheritDoc} */

     public void numberedListItem_()

     {

         currentSink.numberedListItem_();

     }

     /** {@inheritDoc} */

     public void numberedList_()

     {

         currentSink.numberedList_();

     }

     /** {@inheritDoc} */

     public void pageBreak()

     {

         currentSink.pageBreak();

     }

     /** {@inheritDoc} */

     public void paragraph()

     {

         currentSink.paragraph();

     }

     /** {@inheritDoc} */

     public void paragraph( SinkEventAttributes attributes )

     {

         currentSink.paragraph( attributes );

     }

     /** {@inheritDoc} */

     public void paragraph_()

     {

         currentSink.paragraph_();

     }

     /** {@inheritDoc} */

     public void rawText( String text )

     {

         currentSink.rawText( text );

     }

     /** {@inheritDoc} */

     public void section( int level, SinkEventAttributes attributes )

     {

         currentSink.section( level, attributes );

     }

     /** {@inheritDoc} */

     public void section1()

     {

         currentSink.section1();

     }

     /** {@inheritDoc} */

     public void section1_()

     {

         currentSink.section1_();

     }

     /** {@inheritDoc} */

     public void section2()

     {

         currentSink.section2();

     }

     /** {@inheritDoc} */

     public void section2_()

     {

         currentSink.section2_();

     }

     /** {@inheritDoc} */

     public void section3()

     {

         currentSink.section3();

     }

     /** {@inheritDoc} */

     public void section3_()

     {

         currentSink.section3_();

     }

     /** {@inheritDoc} */

     public void section4()

     {

         currentSink.section4();

     }

     /** {@inheritDoc} */

     public void section4_()

     {

         currentSink.section4_();

     }

     /** {@inheritDoc} */

     public void section5()

     {

         currentSink.section5();

     }

     /** {@inheritDoc} */

     public void section5_()

     {

         currentSink.section5_();

     }

     /** {@inheritDoc} */

     public void sectionTitle()

     {

         currentSink.sectionTitle();

     }

     /** {@inheritDoc} */

     public void sectionTitle( int level, SinkEventAttributes attributes )

     {

         currentSink.sectionTitle( level, attributes );

     }

     /** {@inheritDoc} */

     public void sectionTitle1()

     {

         currentSink.sectionTitle1();

     }

     /** {@inheritDoc} */

     public void sectionTitle1_()

     {

         currentSink.sectionTitle1_();

     }

     /** {@inheritDoc} */

     public void sectionTitle2()

     {

         currentSink.sectionTitle2();

     }

     /** {@inheritDoc} */

     public void sectionTitle2_()

     {

         currentSink.sectionTitle2_();

     }

     /** {@inheritDoc} */

     public void sectionTitle3()

     {

         currentSink.sectionTitle3();

     }

     /** {@inheritDoc} */

     public void sectionTitle3_()

     {

         currentSink.sectionTitle3_();

     }

     /** {@inheritDoc} */

     public void sectionTitle4()

     {

         currentSink.sectionTitle4();

     }

     /** {@inheritDoc} */

     public void sectionTitle4_()

     {

         currentSink.sectionTitle4_();

     }

     /** {@inheritDoc} */

     public void sectionTitle5()

     {

         currentSink.sectionTitle5();

     }

     /** {@inheritDoc} */

     public void sectionTitle5_()

     {

         currentSink.sectionTitle5_();

     }

     /** {@inheritDoc} */

     public void sectionTitle_()

     {

         currentSink.sectionTitle_();

     }

     /** {@inheritDoc} */

     public void sectionTitle_( int level )

     {

         currentSink.sectionTitle_( level );

     }

     /** {@inheritDoc} */

     public void section_( int level )

     {

         currentSink.section_( level );

     }

     /** {@inheritDoc} */

     public void table()

     {

         currentSink.table();

     }

     /** {@inheritDoc} */

     public void table( SinkEventAttributes attributes )

     {

         currentSink.table( attributes );

     }

     /** {@inheritDoc} */

     public void tableCaption()

     {

         currentSink.tableCaption();

     }

     /** {@inheritDoc} */

     public void tableCaption( SinkEventAttributes attributes )

     {

         currentSink.tableCaption( attributes );

     }

     /** {@inheritDoc} */

     public void tableCaption_()

     {

         currentSink.tableCaption_();

     }

     /** {@inheritDoc} */

     public void tableCell()

     {

         currentSink.tableCell();

     }

     /** {@inheritDoc} */

     public void tableCell( String width )

     {

         currentSink.tableCell( width );

     }

     /** {@inheritDoc} */

     public void tableCell( SinkEventAttributes attributes )

     {

         currentSink.tableCell( attributes );

     }

     /** {@inheritDoc} */

     public void tableCell_()

     {

         currentSink.tableCell_();

     }

     /** {@inheritDoc} */

     public void tableHeaderCell()

     {

         currentSink.tableHeaderCell();

     }

     /** {@inheritDoc} */

     public void tableHeaderCell( String width )

     {

         currentSink.tableHeaderCell( width );

     }

     /** {@inheritDoc} */

     public void tableHeaderCell( SinkEventAttributes attributes )

     {

         currentSink.tableHeaderCell( attributes );

     }

     /** {@inheritDoc} */

     public void tableHeaderCell_()

     {

         currentSink.tableHeaderCell_();

     }

     /** {@inheritDoc} */

     public void tableRow()

     {

         currentSink.tableRow();

     }

     /** {@inheritDoc} */

     public void tableRow( SinkEventAttributes attributes )

     {

         currentSink.tableRow( attributes );

     }

     /** {@inheritDoc} */

     public void tableRow_()

     {

         currentSink.tableRow_();

     }

     /** {@inheritDoc} */

     public void tableRows( int[] justification, boolean grid )

     {

         currentSink.tableRows( justification, grid );

     }

     /** {@inheritDoc} */

     public void tableRows_()

     {

         currentSink.tableRows_();

     }

     /** {@inheritDoc} */

     public void table_()

     {

         currentSink.table_();

     }

     /** {@inheritDoc} */

     public void text( String text )

     {

         currentSink.text( text );

     }

     /** {@inheritDoc} */

     public void text( String text, SinkEventAttributes attributes )

     {

         currentSink.text( text, attributes );

     }

     /** {@inheritDoc} */

     public void title()

     {

         currentSink.title();

     }

     /** {@inheritDoc} */

     public void title( SinkEventAttributes attributes )

     {

         currentSink.title( attributes );

     }

     /** {@inheritDoc} */

     public void title_()

     {

         currentSink.title_();

     }

     /** {@inheritDoc} */

     public void unknown( String name, Object[] requiredParams, SinkEventAttributes attributes )

     {

         currentSink.unknown( name, requiredParams, attributes );

     }

     /** {@inheritDoc} */

     public void verbatim( boolean boxed )

     {

         currentSink.verbatim( boxed );

     }

     /** {@inheritDoc} */

     public void verbatim( SinkEventAttributes attributes )

     {

         currentSink.verbatim( attributes );

     }

     /** {@inheritDoc} */

     public void verbatim_()

     {

         currentSink.verbatim_();

     }

     /** {@inheritDoc} */

     public void enableLogging( Log log )

     {

         currentSink.enableLogging( log );

     }

 }