source: trunk/JavaHelperLib/src/de/ugoe/cs/util/console/Console.java @ 290

package de.ugoe.cs.util.console;

import java.util.Collection;
import java.util.LinkedHashSet;

import de.ugoe.cs.util.StringTools;
import de.ugoe.cs.util.console.listener.ICommandListener;
import de.ugoe.cs.util.console.listener.IErrorListener;
import de.ugoe.cs.util.console.listener.IExceptionListener;
import de.ugoe.cs.util.console.listener.IOutputListener;
import de.ugoe.cs.util.console.listener.ITraceListener;

/**
 * <p>
 * This class provides an interface for communication with the user without have
 * to rely on a specific user interface. Thus, it can be used to decouple the
 * programs logic from its user interface.
 * </p>
 * <p>
 * {@link Command} objects can be used to execute behavior.
 * </p>
 * <p>
 * To send output to the user interface, the Observer pattern is used. The
 * Console is an observable, the concrete user interfaces are the observers. The
 * interface for the observers is {@link ConsoleObserver}.
 * </p>
 * 
 * @author Steffen Herbold
 * @version 1.0
 */
public final class Console {

        /**
         * <p>
         * Listeners for the output stream.
         * </p>
         */
        private Collection<IOutputListener> outputListener;

        /**
         * <p>
         * Listeners for the error stream.
         * </p>
         */
        private Collection<IErrorListener> errorListener;

        /**
         * <p>
         * Listeners for the trace stream.
         * </p>
         */
        private Collection<ITraceListener> traceListener;

        /**
         * <p>
         * Listeners for the command stream.
         * </p>
         */
        private Collection<ICommandListener> commandListener;

        /**
         * <p>
         * Listeners for the exception stream.
         * </p>
         */
        private Collection<IExceptionListener> exceptionListener;

        /**
         * <p>
         * Handle of the Console instance.
         * </p>
         */
        private static Console theInstance = new Console();

        /**
         * <p>
         * Returns the instance of Console. If no instances exists yet, a new one is
         * created.
         * </p>
         * 
         * @return instance of this class
         */
        public static Console getInstance() {
                return theInstance;
        }

        /**
         * <p>
         * Resets the Console by creating a new instance that has no registered
         * observers.
         * </p>
         */
        public static void reset() {
                theInstance.init();
        }

        /**
         * <p>
         * Creates a new Console. Private to prevent multiple instances (Singleton).
         * </p>
         */
        private Console() {
                init();
        }

        /**
         * <p>
         * Initializes the console.
         * </p>
         */
        private void init() {
                outputListener = new LinkedHashSet<IOutputListener>();
                errorListener = new LinkedHashSet<IErrorListener>();
                traceListener = new LinkedHashSet<ITraceListener>();
                commandListener = new LinkedHashSet<ICommandListener>();
                exceptionListener = new LinkedHashSet<IExceptionListener>();
        }

        /**
         * <p>
         * Register a new observer.
         * </p>
         * 
         * @deprecated use registerXYZListener instead
         * @param observer
         *            observer to be added
         */
        public void registerObserver(ConsoleObserver observer) {
                registerOutputListener(observer);
                registerErrorListener(observer);
                registerTraceListener(observer);
                registerCommandListener(observer);
                registerExceptionListener(observer);
        }

        /**
         * <p>
         * Registers an output listener.
         * </p>
         * 
         * @param listener
         *            listener that is registered
         */
        public void registerOutputListener(IOutputListener listener) {
                outputListener.add(listener);
        }

        /**
         * <p>
         * Registers an error listener.
         * </p>
         * 
         * @param listener
         *            listener that is registered
         */
        public void registerErrorListener(IErrorListener listener) {
                errorListener.add(listener);
        }

        /**
         * <p>
         * Registers a trace listener.
         * </p>
         * 
         * @param listener
         *            listener that is registered
         */
        public void registerTraceListener(ITraceListener listener) {
                traceListener.add(listener);
        }

        /**
         * <p>
         * Registers a command listener.
         * </p>
         * 
         * @param listener
         *            listener that is registered
         */
        public void registerCommandListener(ICommandListener listener) {
                commandListener.add(listener);
        }

        /**
         * <p>
         * Registers an exception listener.
         * </p>
         * 
         * @param listener
         *            listener that is registered
         */
        public void registerExceptionListener(IExceptionListener listener) {
                exceptionListener.add(listener);
        }

        /**
         * <p>
         * Remove an observer. If the observer is not found, nothing is done.
         * </p>
         * 
         * @deprecated use removeXYZListener instead
         * @param observer
         *            observer to be removed
         */
        public void deleteObserver(ConsoleObserver observer) {
                removeOutputListener(observer);
                removeErrorListener(observer);
                removeTraceListener(observer);
                removeCommandListener(observer);
                removeExceptionListener(observer);
        }

        /**
         * <p>
         * Removes an output listener.
         * </p>
         * 
         * @param listener
         *            listener that is removed
         */
        public void removeOutputListener(IOutputListener listener) {
                outputListener.remove(listener);
        }

        /**
         * <p>
         * Removes an error listener.
         * </p>
         * 
         * @param listener
         *            listener that is removed
         */
        public void removeErrorListener(IErrorListener listener) {
                errorListener.remove(listener);
        }

        /**
         * <p>
         * Removes an trace listener.
         * </p>
         * 
         * @param listener
         *            listener that is removed
         */
        public void removeTraceListener(ITraceListener listener) {
                traceListener.remove(listener);
        }

        /**
         * <p>
         * Removes a command listener.
         * </p>
         * 
         * @param listener
         *            listener that is removed
         */
        public void removeCommandListener(ICommandListener listener) {
                commandListener.remove(listener);
        }

        /**
         * <p>
         * Removes an exception listener.
         * </p>
         * 
         * @param listener
         *            listener that is removed
         */
        public void removeExceptionListener(IExceptionListener listener) {
                exceptionListener.remove(listener);
        }

        /**
         * <p>
         * Checks if a listener is registered.
         * </p>
         * 
         * @param listener
         *            listener that is checked
         * @return true, is listener is registered; false, otherwise
         */
        public boolean hasOutputListener(IOutputListener listener) {
                return outputListener.contains(listener);
        }

        /**
         * <p>
         * Checks if a listener is registered.
         * </p>
         * 
         * @param listener
         *            listener that is checked
         * @return true, is listener is registered; false, otherwise
         */
        public boolean hasErrorListener(IErrorListener listener) {
                return errorListener.contains(listener);
        }

        /**
         * <p>
         * Checks if a listener is registered.
         * </p>
         * 
         * @param listener
         *            listener that is checked
         * @return true, is listener is registered; false, otherwise
         */
        public boolean hasTraceListener(ITraceListener listener) {
                return traceListener.contains(listener);
        }

        /**
         * <p>
         * Checks if a listener is registered.
         * </p>
         * 
         * @param listener
         *            listener that is checked
         * @return true, is listener is registered; false, otherwise
         */
        public boolean hasCommandListener(ICommandListener listener) {
                return commandListener.contains(listener);
        }

        /**
         * <p>
         * Checks if a listener is registered.
         * </p>
         * 
         * @param listener
         *            listener that is checked
         * @return true, is listener is registered; false, otherwise
         */
        public boolean hasExceptionListener(IExceptionListener listener) {
                return exceptionListener.contains(listener);
        }

        /**
         * <p>
         * Sends a message to all observers containing the message that was passed
         * to this function.
         * </p>
         * 
         * @param msg
         *            message that is send to the console
         */
        public static void print(String msg) {
                for (IOutputListener observer : theInstance.outputListener) {
                        observer.outputMsg(msg);
                }
        }

        /**
         * <p>
         * Sends a message to all observers containing the message that was passed
         * to this function and adds an endline to the message.
         * </p>
         * 
         * @param msg
         *            message that is send to the observers
         */
        public static void println(String msg) {
                for (IOutputListener observer : theInstance.outputListener) {
                        observer.outputMsg(msg + StringTools.ENDLINE);
                }
        }

        /**
         * <p>
         * Sends an error message to all observers containing the message that was
         * passed to this function.
         * </p>
         * 
         * @param errMsg
         *            message that is send to the observers
         */
        public static void printerr(String errMsg) {
                for (IErrorListener observer : theInstance.errorListener) {
                        observer.errorMsg(errMsg);
                }
        }

        /**
         * <p>
         * Sends an error message to all observers containing the message that was
         * passed to this function and adds an endline to the message.
         * </p>
         * 
         * @param errMsg
         *            message that is send to the observers
         */
        public static void printerrln(String errMsg) {
                for (IErrorListener observer : theInstance.errorListener) {
                        observer.errorMsg(errMsg + StringTools.ENDLINE);
                }
        }

        /**
         * <p>
         * Sends an exception to all observers to print its stack trace.
         * </p>
         * 
         * @param e
         *            exception whose stack trace is to be printed
         */
        public static void logException(Exception e) {
                for (IExceptionListener observer : theInstance.exceptionListener) {
                        observer.logException(e);
                }
        }

        /**
         * <p>
         * Sends a debug message to all observers containing the message that was
         * passed to this function.
         * </p>
         * 
         * @param traceMsg
         *            message that is send to the observers
         */
        public static void trace(String traceMsg) {
                for (ITraceListener observer : theInstance.traceListener) {
                        observer.traceMsg(traceMsg);
                }
        }

        /**
         * <p>
         * Sends a debug message to all observers containing the message that was
         * passed to this function and adds an {@link StringTools#ENDLINE} to the
         * message.
         * </p>
         * 
         * @param traceMsg
         *            message that is send to the observers
         */
        public static void traceln(String traceMsg) {
                for (ITraceListener observer : theInstance.traceListener) {
                        observer.traceMsg(traceMsg + StringTools.ENDLINE);
                }
        }

        /**
         * <p>
         * Called by {@link CommandExecuter#exec(String)}.
         * </p>
         * 
         * @param command
         *            command that is executed
         */
        static void commandNotification(String command) {
                for (ICommandListener observer : theInstance.commandListener) {
                        observer.commandNotification(command);
                }
        }

}