core/io/src/main/java/org/qi4j/io/Outputs.java

/*
 * Copyright (c) 2010, Rickard Öberg. All Rights Reserved.
 *
 * Licensed 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.qi4j.io;

import java.io.BufferedOutputStream;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.util.Collection;
import java.util.zip.GZIPOutputStream;

/**
 * Utility methods for creating standard Outputs
 */
public class Outputs
{
    // START SNIPPET: method

    /**
     * Write lines to a text file with UTF-8 encoding. Separate each line with a newline ("\n" character). If the writing or sending fails,
     * the file is deleted.
     * <p>
     * If the filename ends with .gz, then the data is automatically GZipped.
     * </p>
     * @param file the file to save the text to
     *
     * @return an Output for storing text in a file
     */
    public static Output<String, IOException> text( final File file )
    // END SNIPPET: method
    {
        return text( file, "UTF-8" );
    }

    // START SNIPPET: method

    /**
     * Write lines to a text file. Separate each line with a newline ("\n" character). If the writing or sending fails,
     * the file is deleted.
     * <p>
     * If the filename ends with .gz, then the data is automatically GZipped.
     * </p>
     * @param file the file to save the text to
     *
     * @return an Output for storing text in a file
     */
    public static Output<String, IOException> text( final File file, final String encoding )
    // END SNIPPET: method
    {
        return new Output<String, IOException>()
        {
            @Override
            @SuppressWarnings( "unchecked" )
            public <SenderThrowableType extends Throwable> void receiveFrom( Sender<? extends String, SenderThrowableType> sender )
                throws IOException, SenderThrowableType
            {
                File tmpFile = Files.createTemporayFileOf( file );

                OutputStream stream = new FileOutputStream( tmpFile );

                // If file should be gzipped, do that automatically
                if( file.getName().endsWith( ".gz" ) )
                {
                    stream = new GZIPOutputStream( stream );
                }

                final BufferedWriter writer = new BufferedWriter( new OutputStreamWriter( stream, encoding ) );

                try
                {
                    sender.sendTo( new Receiver<String, IOException>()
                    {
                        @Override
                        public void receive( String item )
                            throws IOException
                        {
                            writer.append( item ).append( '\n' );
                        }
                    } );
                    writer.close();

                    // Replace file with temporary file
                    if( !file.exists() || file.delete() )
                    {
                        if( ! tmpFile.renameTo( file ) )
                        {
                            // TODO: What?? Throw an Exception?
                            System.err.println( "Unable to rename file: " + tmpFile + " to " + file );
                        }
                    }
                }
                catch( IOException e )
                {
                    // We failed writing - close and delete
                    writer.close();
                    if( ! tmpFile.delete() )
                    {
                        System.err.println("Unable to delete temporary file." );
                        tmpFile.deleteOnExit();
                    }
                }
                catch( Throwable senderThrowableType )
                {
                    // We failed writing - close and delete
                    writer.close();
                    if( ! tmpFile.delete() )
                    {
                        System.err.println("Unable to delete temporary file." );
                        tmpFile.deleteOnExit();
                    }
                    throw (SenderThrowableType) senderThrowableType;
                }
            }
        };
    }

    // START SNIPPET: method

    /**
     * Write lines to a Writer. Separate each line with a newline ("\n" character).
     *
     * @param writer the Writer to write the text to
     * @return an Output for storing text in a Writer
     */
    public static Output<String, IOException> text( final Writer writer )
    // END SNIPPET: method
    {
        return new Output<String, IOException>()
        {

            @Override
            public <SenderThrowableType extends Throwable> void receiveFrom( Sender<? extends String, SenderThrowableType> sender )
                throws IOException, SenderThrowableType
            {
                sender.sendTo( new Receiver<String, IOException>()
                {

                    @Override
                    public void receive( String item )
                        throws IOException
                    {
                        writer.append( item ).append( "\n" );
                    }

                } );
            }

        };
    }

    // START SNIPPET: method

    /**
     * Write lines to a StringBuilder. Separate each line with a newline ("\n" character).
     *
     * @param builder the StringBuilder to append the text to
     * @return an Output for storing text in a StringBuilder
     */
    public static Output<String, IOException> text( final StringBuilder builder )
    // END SNIPPET: method
    {
        return new Output<String, IOException>()
        {

            @Override
            public <SenderThrowableType extends Throwable> void receiveFrom( Sender<? extends String, SenderThrowableType> sender )
                throws IOException, SenderThrowableType
            {
                sender.sendTo( new Receiver<String, IOException>()
                {

                    @Override
                    public void receive( String item )
                        throws IOException
                    {
                        builder.append( item ).append( "\n" );
                    }

                } );
            }

        };
    }

    // START SNIPPET: method

    /**
     * Write ByteBuffer data to a file. If the writing or sending of data fails the file will be deleted.
     *
     * @param file The destination file.
     *
     * @return The Output ByteBuffer instance backed by a File.
     */
    public static Output<ByteBuffer, IOException> byteBuffer( final File file )
    // END SNIPPET: method
    {
        return new Output<ByteBuffer, IOException>()
        {
            @Override
            @SuppressWarnings( "unchecked" )
            public <SenderThrowableType extends Throwable> void receiveFrom( Sender<? extends ByteBuffer, SenderThrowableType> sender )
                throws IOException, SenderThrowableType
            {
                File tmpFile = Files.createTemporayFileOf( file );
                FileOutputStream stream = new FileOutputStream( tmpFile );
                final FileChannel fco = stream.getChannel();

                try
                {
                    sender.sendTo( new Receiver<ByteBuffer, IOException>()
                    {
                        @Override
                        public void receive( ByteBuffer item )
                            throws IOException
                        {
                            fco.write( item );
                        }
                    } );
                    stream.close();

                    // Replace file with temporary file
                    if( !file.exists() || file.delete() )
                    {
                        if( ! tmpFile.renameTo( file ) )
                        {
                            // TODO: What can be done in this case?
                            System.err.println( "Unable to rename file: " + tmpFile + " to " + file );
                        }
                    }
                }
                catch( IOException e )
                {
                    // We failed writing - close and delete
                    stream.close();
                    if( ! tmpFile.delete() )
                    {
                        System.err.println("Unable to delete temporary file." );
                        tmpFile.deleteOnExit();
                    }

                }
                catch( Throwable senderThrowableType )
                {
                    // We failed writing - close and delete
                    stream.close();
                    if( ! tmpFile.delete() )
                    {
                        System.err.println("Unable to delete temporary file." );
                        tmpFile.deleteOnExit();
                    }
                    throw (SenderThrowableType) senderThrowableType;
                }
            }
        };
    }

    // START SNIPPET: method

    /**
     * Write ByteBuffer data to an OutputStream.
     *
     * @param stream Destination OutputStream
     *
     * @return The Output of ByteBuffer that will be backed by the OutputStream.
     */
    public static Output<ByteBuffer, IOException> byteBuffer( final OutputStream stream )
    // END SNIPPET: method
    {
        return new Output<ByteBuffer, IOException>()
        {
            @Override
            public <SenderThrowableType extends Throwable> void receiveFrom( Sender<? extends ByteBuffer, SenderThrowableType> sender )
                throws IOException, SenderThrowableType
            {
                try
                {
                    sender.sendTo( new Receiver<ByteBuffer, IOException>()
                    {
                        @Override
                        public void receive( ByteBuffer item )
                            throws IOException
                        {
                            if( item.hasArray() )
                            {
                                stream.write( item.array(), item.arrayOffset(), item.limit() );
                            }
                            else
                            {
                                for( int i = 0; i < item.limit(); i++ )
                                {
                                    stream.write( item.get( i ) );
                                }
                            }
                        }
                    } );
                }
                finally
                {
                    stream.close();
                }
            }
        };
    }

    // START SNIPPET: method

    /**
     * Write byte array data to a file. If the writing or sending of data fails the file will be deleted.
     *
     * @param file The File to be written to.
     * @param bufferSize The size of the ByteBuffer.
     *
     * @return An Output instance that will write to the given File.
     */
    public static Output<byte[], IOException> bytes( final File file, final int bufferSize )
    // END SNIPPET: method
    {
        return new Output<byte[], IOException>()
        {
            @Override
            @SuppressWarnings( "unchecked" )
            public <SenderThrowableType extends Throwable> void receiveFrom( Sender<? extends byte[], SenderThrowableType> sender )
                throws IOException, SenderThrowableType
            {
                File tmpFile = Files.createTemporayFileOf( file );
                final OutputStream stream = new BufferedOutputStream( new FileOutputStream( tmpFile ), bufferSize );

                try
                {
                    sender.sendTo( new Receiver<byte[], IOException>()
                    {
                        @Override
                        public void receive( byte[] item )
                            throws IOException
                        {
                            stream.write( item );
                        }
                    } );
                    stream.close();

                    // Replace file with temporary file
                    if( !file.exists() || file.delete() )
                    {
                        if( ! tmpFile.renameTo( file ) )
                        {
                            // TODO: WHAT???
                            System.err.println( "Unable to rename " + tmpFile + " to " + file );
                        }
                    }
                }
                catch( IOException e )
                {
                    // We failed writing - close and delete
                    stream.close();
                    if( ! tmpFile.delete() )
                    {
                        System.err.println("Unable to delete temporary file." );
                        tmpFile.deleteOnExit();
                    }
                }
                catch( Throwable senderThrowableType )
                {
                    // We failed writing - close and delete
                    stream.close();
                    if( ! tmpFile.delete() )
                    {
                        System.err.println("Unable to delete temporary file." );
                        tmpFile.deleteOnExit();
                    }
                    throw (SenderThrowableType) senderThrowableType;
                }
            }
        };
    }

    // START SNIPPET: method

    /**
     * Do nothing. Use this if you have all logic in filters and/or specifications
     *
     * @param <T> The item type.
     *
     * @return An Output instance that ignores all data.
     */
    public static <T> Output<T, RuntimeException> noop()
    // END SNIPPET: method
    {
        return withReceiver( new Receiver<T, RuntimeException>()
        {
            @Override
            public void receive( T item )
                throws RuntimeException
            {
                // Do nothing
            }
        } );
    }

    // START SNIPPET: method

    /**
     * Use given receiver as Output. Use this if there is no need to create a "transaction" for each transfer, and no need
     * to do batch writes or similar.
     *
     * @param <T> The item type
     * @param receiver receiver for this Output
     *
     * @return An Output instance backed by a Receiver of items.
     */
    public static <T, ReceiverThrowableType extends Throwable> Output<T, ReceiverThrowableType> withReceiver( final Receiver<T, ReceiverThrowableType> receiver )
    // END SNIPPET: method
    {
        return new Output<T, ReceiverThrowableType>()
        {
            @Override
            public <SenderThrowableType extends Throwable> void receiveFrom( Sender<? extends T, SenderThrowableType> sender )
                throws ReceiverThrowableType, SenderThrowableType
            {
                sender.sendTo( receiver );
            }
        };
    }

    // START SNIPPET: method

    /**
     * Write objects to System.out.println.
     *
     * @return An Output instance that is backed by System.out
     */
    public static Output<Object, RuntimeException> systemOut()
    // END SNIPPET: method
    {
        return new Output<Object, RuntimeException>()
        {
            @Override
            public <SenderThrowableType extends Throwable> void receiveFrom( Sender<?, SenderThrowableType> sender )
                throws RuntimeException, SenderThrowableType
            {
                sender.sendTo( new Receiver<Object, RuntimeException>()
                {
                    @Override
                    public void receive( Object item )
                    {
                        System.out.println( item );
                    }
                } );
            }
        };
    }

    // START SNIPPET: method

    /**
     * Write objects to System.err.println.
     *
     * @return An Output instance backed by System.in
     */
    @SuppressWarnings( "UnusedDeclaration" )
    public static Output<Object, RuntimeException> systemErr()
    // END SNIPPET: method
    {
        return new Output<Object, RuntimeException>()
        {
            @Override
            public <SenderThrowableType extends Throwable> void receiveFrom( Sender<?, SenderThrowableType> sender )
                throws RuntimeException, SenderThrowableType
            {
                sender.sendTo( new Receiver<Object, RuntimeException>()
                {
                    @Override
                    public void receive( Object item )
                    {
                        System.err.println( item );
                    }
                } );
            }
        };
    }

    // START SNIPPET: method

    /**
     * Add items to a collection
     */
    public static <T> Output<T, RuntimeException> collection( final Collection<T> collection )
    // END SNIPPET: method
    {
        return new Output<T, RuntimeException>()
        {
            @Override
            public <SenderThrowableType extends Throwable> void receiveFrom( Sender<? extends T, SenderThrowableType> sender )
                throws RuntimeException, SenderThrowableType
            {
                sender.sendTo( new Receiver<T, RuntimeException>()
                {
                    @Override
                    public void receive( T item )
                        throws RuntimeException
                    {
                        collection.add( item );
                    }
                } );
            }
        };
    }

    private Outputs()
    {
    }
}