DefaultMessageHolder.java

package org.apache.maven.shared.io.logging;

/*
 * 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.PrintWriter;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * Default Message Holder.
 *
 */
public class DefaultMessageHolder
    implements MessageHolder
{

    private List<Message> messages = new ArrayList<Message>();

    private Message currentMessage;

    private int defaultMessageLevel = MessageLevels.LEVEL_INFO;

    private boolean[] messageLevelStates;

    private MessageSink onDemandSink;

    /**
     * Create instance.
     */
    public DefaultMessageHolder()
    {
        this.messageLevelStates = MessageLevels.getLevelStates( MessageLevels.LEVEL_INFO );
    }

    /**
     * @param maxMessageLevel max message level.
     * @param defaultMessageLevel default message level.
     */
    public DefaultMessageHolder( int maxMessageLevel, int defaultMessageLevel )
    {
        this.defaultMessageLevel = defaultMessageLevel;
        this.messageLevelStates = MessageLevels.getLevelStates( maxMessageLevel );
    }

    /**
     * @param maxMessageLevel max message level.
     * @param defaultMessageLevel default message level.
     * @param onDemandSink {@link MessageSink}
     */
    public DefaultMessageHolder( int maxMessageLevel, int defaultMessageLevel, MessageSink onDemandSink )
    {
        this.defaultMessageLevel = defaultMessageLevel;
        this.onDemandSink = onDemandSink;
        this.messageLevelStates = MessageLevels.getLevelStates( maxMessageLevel );
    }

    /** {@inheritDoc} */
    public MessageHolder addMessage( CharSequence messagePart, Throwable error )
    {
        return addMessage( defaultMessageLevel, messagePart, error );
    }

    /**
     * @param level Level.
     * @param messagePart Message part.
     * @param error {@link Throwable}
     * @return {@link MessageHolder}
     */
    protected MessageHolder addMessage( int level, CharSequence messagePart, Throwable error )
    {
        newMessage( level );
        append( messagePart.toString() );
        append( error );

        return this;
    }

    /** {@inheritDoc} */
    public MessageHolder addMessage( CharSequence messagePart )
    {
        return addMessage( defaultMessageLevel, messagePart );
    }

    /**
     * @param level level.
     * @param messagePart message part.
     * @return {@link MessageHolder}
     */
    protected MessageHolder addMessage( int level, CharSequence messagePart )
    {
        newMessage( level );
        append( messagePart.toString() );

        return this;
    }

    /** {@inheritDoc} */
    public MessageHolder addMessage( Throwable error )
    {
        return addMessage( defaultMessageLevel, error );
    }

    /**
     * @param level level.
     * @param error {@link Throwable}
     * @return {@link MessageHolder}
     */
    protected MessageHolder addMessage( int level, Throwable error )
    {
        newMessage( level );
        append( error );

        return this;
    }

    /** {@inheritDoc} */
    public MessageHolder append( CharSequence messagePart )
    {
        if ( currentMessage == null )
        {
            newMessage();
        }

        currentMessage.append( messagePart.toString() );

        return this;
    }

    /** {@inheritDoc} */
    public MessageHolder append( Throwable error )
    {
        if ( currentMessage == null )
        {
            newMessage();
        }

        currentMessage.setError( error );

        return this;
    }

    /** {@inheritDoc} */
    public boolean isEmpty()
    {
        return messages.isEmpty();
    }

    /** {@inheritDoc} */
    public MessageHolder newMessage()
    {
        newMessage( defaultMessageLevel );

        return this;
    }

    /**
     * @param messageLevel message level.
     */
    protected void newMessage( int messageLevel )
    {
        if ( onDemandSink != null && currentMessage != null )
        {
            renderTo( currentMessage, onDemandSink );
        }

        currentMessage = new Message( messageLevel, onDemandSink );
        messages.add( currentMessage );
    }

    /** {@inheritDoc} */
    public String render()
    {
        StringBuffer buffer = new StringBuffer();

        int counter = 1;
        for ( Iterator<Message> it = messages.iterator(); it.hasNext(); )
        {
            Message message = (Message) it.next();

            int ml = message.getMessageLevel();

            if ( ml >= messageLevelStates.length || ml < 0 )
            {
                ml = MessageLevels.LEVEL_DEBUG;
            }

            if ( !messageLevelStates[ml] )
            {
                continue;
            }

            CharSequence content = message.render();
            String label = MessageLevels.getLevelLabel( message.getMessageLevel() );

            if ( content.length() > label.length() + 3 )
            {
                buffer.append( '[' ).append( counter++ ).append( "] " );
                buffer.append( content.toString() );

                if ( it.hasNext() )
                {
                    buffer.append( "\n\n" );
                }
            }
        }

        return buffer.toString();
    }

    /** {@inheritDoc} */
    public int size()
    {
        return messages.size();
    }

    private static final class Message
    {
        private StringBuffer message = new StringBuffer();

        private Throwable error;

        private final int messageLevel;

        private final MessageSink onDemandSink;

        public Message( int messageLevel, MessageSink onDemandSink )
        {
            this.messageLevel = messageLevel;

            this.onDemandSink = onDemandSink;
        }

        public Message setError( Throwable pError )
        {
            this.error = pError;
            return this;
        }

        public Message append( CharSequence pMessage )
        {
            this.message.append( pMessage.toString() );
            return this;
        }

        /**
         * @return message level.
         */
        public int getMessageLevel()
        {
            return messageLevel;
        }

        /**
         * @return Sequence.
         */
        public CharSequence render()
        {
            StringBuffer buffer = new StringBuffer();

            if ( onDemandSink == null )
            {
                buffer.append( '[' ).append( MessageLevels.getLevelLabel( messageLevel ) ).append( "] " );
            }
            if ( message != null && message.length() > 0 )
            {
                buffer.append( message );

                if ( error != null )
                {
                    buffer.append( '\n' );
                }
            }

            if ( error != null )
            {
                buffer.append( "Error:\n" );

                StringWriter sw = new StringWriter();
                PrintWriter pw = new PrintWriter( sw );
                error.printStackTrace( pw );

                buffer.append( sw.toString() );
            }

            return buffer;
        }
    }

    /** {@inheritDoc} */
    public MessageHolder addDebugMessage( CharSequence messagePart, Throwable error )
    {
        return addMessage( MessageLevels.LEVEL_DEBUG, messagePart, error );
    }

    /** {@inheritDoc} */
    public MessageHolder addDebugMessage( CharSequence messagePart )
    {
        return addMessage( MessageLevels.LEVEL_DEBUG, messagePart );
    }

    /** {@inheritDoc} */
    public MessageHolder addDebugMessage( Throwable error )
    {
        return addMessage( MessageLevels.LEVEL_DEBUG, error );
    }

    /** {@inheritDoc} */
    public MessageHolder addErrorMessage( CharSequence messagePart, Throwable error )
    {
        return addMessage( MessageLevels.LEVEL_ERROR, messagePart, error );
    }

    /** {@inheritDoc} */
    public MessageHolder addErrorMessage( CharSequence messagePart )
    {
        return addMessage( MessageLevels.LEVEL_ERROR, messagePart );
    }

    /** {@inheritDoc} */
    public MessageHolder addErrorMessage( Throwable error )
    {
        return addMessage( MessageLevels.LEVEL_ERROR, error );
    }

    /** {@inheritDoc} */
    public MessageHolder addInfoMessage( CharSequence messagePart, Throwable error )
    {
        return addMessage( MessageLevels.LEVEL_INFO, messagePart, error );
    }

    /** {@inheritDoc} */
    public MessageHolder addInfoMessage( CharSequence messagePart )
    {
        return addMessage( MessageLevels.LEVEL_INFO, messagePart );
    }

    /** {@inheritDoc} */
    public MessageHolder addInfoMessage( Throwable error )
    {
        return addMessage( MessageLevels.LEVEL_INFO, error );
    }

    /** {@inheritDoc} */
    public MessageHolder addSevereMessage( CharSequence messagePart, Throwable error )
    {
        return addMessage( MessageLevels.LEVEL_SEVERE, messagePart, error );
    }

    /** {@inheritDoc} */
    public MessageHolder addSevereMessage( CharSequence messagePart )
    {
        return addMessage( MessageLevels.LEVEL_SEVERE, messagePart );
    }

    /** {@inheritDoc} */
    public MessageHolder addSevereMessage( Throwable error )
    {
        return addMessage( MessageLevels.LEVEL_SEVERE, error );
    }

    /** {@inheritDoc} */
    public MessageHolder addWarningMessage( CharSequence messagePart, Throwable error )
    {
        return addMessage( MessageLevels.LEVEL_WARNING, messagePart, error );
    }

    /** {@inheritDoc} */
    public MessageHolder addWarningMessage( CharSequence messagePart )
    {
        return addMessage( MessageLevels.LEVEL_WARNING, messagePart );
    }

    /** {@inheritDoc} */
    public MessageHolder addWarningMessage( Throwable error )
    {
        return addMessage( MessageLevels.LEVEL_WARNING, error );
    }

    /** {@inheritDoc} */
    public int countDebugMessages()
    {
        return countMessagesOfType( MessageLevels.LEVEL_DEBUG );
    }

    /** {@inheritDoc} */
    public int countErrorMessages()
    {
        return countMessagesOfType( MessageLevels.LEVEL_ERROR );
    }

    /** {@inheritDoc} */
    public int countInfoMessages()
    {
        return countMessagesOfType( MessageLevels.LEVEL_INFO );
    }

    /** {@inheritDoc} */
    public int countMessages()
    {
        return size();
    }

    /** {@inheritDoc} */
    public int countSevereMessages()
    {
        return countMessagesOfType( MessageLevels.LEVEL_SEVERE );
    }

    /** {@inheritDoc} */
    public int countWarningMessages()
    {
        return countMessagesOfType( MessageLevels.LEVEL_WARNING );
    }

    /**
     * @param messageLevel leve.
     * @return number of messages.
     */
    private int countMessagesOfType( int messageLevel )
    {
        int count = 0;

        for ( Message message : messages )
        {
            if ( messageLevel == message.getMessageLevel() )
            {
                count++;
            }
        }

        return count;
    }

    /** {@inheritDoc} */
    public boolean isDebugEnabled()
    {
        return messageLevelStates[MessageLevels.LEVEL_DEBUG];
    }

    /** {@inheritDoc} */
    public boolean isErrorEnabled()
    {
        return messageLevelStates[MessageLevels.LEVEL_ERROR];
    }

    /** {@inheritDoc} */
    public boolean isInfoEnabled()
    {
        return messageLevelStates[MessageLevels.LEVEL_INFO];
    }

    /** {@inheritDoc} */
    public boolean isSevereEnabled()
    {
        return messageLevelStates[MessageLevels.LEVEL_SEVERE];
    }

    /** {@inheritDoc} */
    public boolean isWarningEnabled()
    {
        return messageLevelStates[MessageLevels.LEVEL_WARNING];
    }

    /** {@inheritDoc} */
    public MessageHolder newDebugMessage()
    {
        if ( isDebugEnabled() )
        {
            newMessage( MessageLevels.LEVEL_DEBUG );
        }

        return this;
    }

    /** {@inheritDoc} */
    public MessageHolder newErrorMessage()
    {
        if ( isErrorEnabled() )
        {
            newMessage( MessageLevels.LEVEL_ERROR );
        }

        return this;
    }

    /** {@inheritDoc} */
    public MessageHolder newInfoMessage()
    {
        if ( isInfoEnabled() )
        {
            newMessage( MessageLevels.LEVEL_INFO );
        }

        return this;
    }

    /** {@inheritDoc} */
    public MessageHolder newSevereMessage()
    {
        if ( isSevereEnabled() )
        {
            newMessage( MessageLevels.LEVEL_SEVERE );
        }

        return this;
    }

    /** {@inheritDoc} */
    public MessageHolder newWarningMessage()
    {
        if ( isWarningEnabled() )
        {
            newMessage( MessageLevels.LEVEL_WARNING );
        }

        return this;
    }

    /** {@inheritDoc} */
    public void setDebugEnabled( boolean enabled )
    {
        messageLevelStates[MessageLevels.LEVEL_DEBUG] = enabled;
    }

    /** {@inheritDoc} */
    public void setErrorEnabled( boolean enabled )
    {
        messageLevelStates[MessageLevels.LEVEL_ERROR] = enabled;
    }

    /** {@inheritDoc} */
    public void setInfoEnabled( boolean enabled )
    {
        messageLevelStates[MessageLevels.LEVEL_INFO] = enabled;
    }

    /** {@inheritDoc} */
    public void setSevereEnabled( boolean enabled )
    {
        messageLevelStates[MessageLevels.LEVEL_SEVERE] = enabled;
    }

    /** {@inheritDoc} */
    public void setWarningEnabled( boolean enabled )
    {
        messageLevelStates[MessageLevels.LEVEL_WARNING] = enabled;
    }

    /** {@inheritDoc} */
    public void flush()
    {
        if ( onDemandSink != null && currentMessage != null )
        {
            renderTo( currentMessage, onDemandSink );
            currentMessage = null;
        }
    }

    /** {@inheritDoc} */
    public void render( MessageSink sink )
    {
        for ( Message message : messages )
        {
            renderTo( message, sink );
        }
    }

    /**
     * @param message {@link Message}
     * @param sink {@link MessageSink}
     */
    protected void renderTo( Message message, MessageSink sink )
    {
        switch ( message.getMessageLevel() )
        {
            case ( MessageLevels.LEVEL_SEVERE ):
                sink.severe( message.render().toString() );
                break;

            case ( MessageLevels.LEVEL_ERROR ):
                sink.error( message.render().toString() );
                break;

            case ( MessageLevels.LEVEL_WARNING ):
                sink.warning( message.render().toString() );
                break;

            case ( MessageLevels.LEVEL_INFO ):
                sink.info( message.render().toString() );
                break;

            default:
                sink.debug( message.render().toString() );
        }
    }

}