Logger_Sngltn.java

/*
==============================================================================
  Author: Zoltán Hrabovszki <zh@openkeyword.de>
 
  Copyright © 2012 - 2019 IT-Beratung Hrabovszki
  www.OpenKeyWord.de
============================================================================== 
 
This file is part of OpenKeyWord.
 
OpenKeyWord is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
 
OpenKeyWord is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with OpenKeyWord.  If not, see <http://www.gnu.org/licenses/>.
 
Diese Datei ist Teil von OpenKeyWord.
 
OpenKeyWord ist Freie Software: Sie können es unter den Bedingungen
der GNU General Public License, wie von der Free Software Foundation,
Version 3 der Lizenz oder (nach Ihrer Wahl) jeder späteren
veröffentlichten Version, weiterverbreiten und/oder modifizieren.
 
OpenKeyWord wird in der Hoffnung, dass es nützlich sein wird, aber
OHNE JEDE GEWÄHRLEISTUNG, bereitgestellt; sogar ohne die implizite
Gewährleistung der MARKTFÄHIGKEIT oder EIGNUNG FÜR EINEN BESTIMMTEN ZWECK.
Siehe die GNU General Public License für weitere Details.
 
Sie sollten eine Kopie der GNU General Public License zusammen mit 
OpenKeyWord erhalten haben. Wenn nicht, siehe <http://www.gnu.org/licenses/>.
*/
 
package okw.log;
 
import java.util.*;
 
import okw.OKW_Const_Sngltn;
 
public class Logger_Sngltn implements ILogger
{
 
    private static Boolean            cvbDebugMode = false;
    private static ArrayList<ILogger> LoggerList;
 
    private static Logger_Sngltn      Instance;
 
    
    public Boolean getDebugMode()
    {
        return cvbDebugMode;
    }
 
    public void setDebugMode( Boolean fpbDebugMode )
    {
        cvbDebugMode = fpbDebugMode;
 
        for ( ILogger myLogger : LoggerList )
        {
            myLogger.setDebugMode( cvbDebugMode );
        }
 
    }
    
    
    public static Logger_Sngltn getInstance()
    {
        // Lazy Initialization (If required then only)
 
        if ( Instance == null )
        {
            // Thread Safe. Might be costly operation in some case
            synchronized ( OKW_Const_Sngltn.class )
            {
                if ( Instance == null )
                {
                    Instance = new Logger_Sngltn();
                    init();
                }
            }
        }
        return Instance;
 
    }
 
    public static void init()
    {
        LoggerList.clear();
        LoggerList.add( new Log2Console() );
 
        Instance.setDebugMode( false );
    }
 
    private Logger_Sngltn()
    {
            LoggerList = new ArrayList<ILogger>();
    }
 
    public void addLogger( ILogger fpLogger )
    {
        LoggerList.add( fpLogger );
    }
 
    public void reset()
    {
        for ( ILogger myLogger : LoggerList )
        {
            myLogger.reset();
        }
    }
 
    public void LogError( String fps_Message )
    {
        for ( ILogger myLogger : LoggerList )
        {
            myLogger.LogError( fps_Message );
        }
    }
 
    public void LogException( String fps_Message )
    {
        for ( ILogger myLogger : LoggerList )
        {
            myLogger.LogException( fps_Message );
        }
    }
 
    public void LogFunctionEnd( String fps_Return )
    {
        if ( fps_Return != null )
        {
            for ( ILogger myLogger : LoggerList )
            {
                myLogger.LogFunctionEnd( fps_Return );
            }
        }
        else
        {
            this.LogFunctionEnd();
        }
    }
 
    public void LogFunctionEnd( Boolean fpb_Return )
    {
        if ( fpb_Return != null )
        {
            for ( ILogger myLogger : LoggerList )
            {
                myLogger.LogFunctionEnd( fpb_Return );
            }
        }
        else
        {
            this.LogFunctionEnd();
        }
    }
 
    public void LogFunctionEnd( List<String> fpls_Return )
    {
        if ( fpls_Return != null )
        {
            for ( ILogger myLogger : LoggerList )
            {
                myLogger.LogFunctionEnd( fpls_Return );
            }
        }
        else
        {
            this.LogFunctionEnd();
        }
    }
 
    public void LogFunctionEnd()
    {
        for ( ILogger myLogger : LoggerList )
        {
            myLogger.LogFunctionEnd();
        }
    }
 
    public void LogFunctionEndDebug()
    {
 
        for ( ILogger myLogger : LoggerList )
        {
            myLogger.LogFunctionEndDebug();
        }
    }
 
    public void LogFunctionEndDebug( String fps_Return )
    {
        if ( fps_Return != null )
        {
            for ( ILogger myLogger : LoggerList )
            {
                myLogger.LogFunctionEndDebug( fps_Return );
            }
        }
        else
        {
            this.LogFunctionEndDebug();
        }
    }
 
    public void LogFunctionEndDebug( List<String> fpLs_Return )
    {
        if ( fpLs_Return != null )
        {
            for ( ILogger myLogger : LoggerList )
            {
                myLogger.LogFunctionEndDebug( fpLs_Return );
            }
        }
        else
        {
            this.LogFunctionEndDebug();
        }
    }
 
    public void LogFunctionEndDebug( Boolean fpb_Return )
    {
        if ( fpb_Return != null )
        {
            for ( ILogger myLogger : LoggerList )
            {
                myLogger.LogFunctionEndDebug( fpb_Return );
            }
        }
        else
        {
            this.LogFunctionEndDebug();
        }
    }
 
    public void LogFunctionStart( String fps_FunctionName, String... fpsParameter )
    {
        for ( ILogger myLogger : LoggerList )
        {
            myLogger.LogFunctionStart( fps_FunctionName, fpsParameter );
        }
    }
 
    public void LogFunctionStartDebug( String fps_FunctionName, String... fpsParameter )
    {
 
        for ( ILogger myLogger : LoggerList )
        {
            myLogger.LogFunctionStartDebug( fps_FunctionName, fpsParameter );
        }
    }
 
    
    public void LogKeyWordEnd()
    {
        for ( ILogger myLogger : LoggerList )
        {
            myLogger.LogKeyWordEnd();
        }
    }
    
    
    public void LogStepStart( String categoryName, String categoryType, 
                    String choiceValue, String featureName,
                    String localCategoryName, String sourceExcerpt,
                    String type  )
    {
        for ( ILogger myLogger : LoggerList )
        {
            myLogger.LogStepStart( categoryName, categoryType, choiceValue, featureName, localCategoryName, sourceExcerpt, type  );
        }
    }    
    
    public void LogStepEnd()
    {
        for ( ILogger myLogger : LoggerList )
        {
            myLogger.LogStepEnd();
        }
    }
 
    
    public void LogLocalACCallStart( String Gherkin, String Type )
    {
        for ( ILogger myLogger : LoggerList )
        {
            myLogger.LogLocalACCallStart(  Gherkin, Type );
        }
    }    
    
    public void LogLocalACCallEnd()
    {
        for ( ILogger myLogger : LoggerList )
        {
            myLogger.LogLocalACCallEnd();
        }
    }
    
    
    public void LogRemoteACCallStart( String Gherkin, String Type )
    {
        for ( ILogger myLogger : LoggerList )
        {
            myLogger.LogRemoteACCallStart(  Gherkin, Type );
        }
    }    
    
    public void LogRemoteACCallEnd()
    {
        for ( ILogger myLogger : LoggerList )
        {
            myLogger.LogRemoteACCallEnd();
        }
    }
    
    
    public void LogSequenceEnd()
    {
        for ( ILogger myLogger : LoggerList )
        {
            myLogger.LogSequenceEnd();
        }
    }
 
 
    public void LogTestcaseEnd()
    {
        for ( ILogger myLogger : LoggerList )
        {
            myLogger.LogTestcaseEnd();
        }
    }
 
    public void LogKeyWordStart( String fpsKeyWordName, String... fpsParameter )
    {
        for ( ILogger myLogger : LoggerList )
        {
            myLogger.LogKeyWordStart( fpsKeyWordName, fpsParameter );
        }
    }
 
    public void LogSequenceStart( String fpsKeyWordName, String fpsWinowFN, String fpsSequenceName, String... fpsParameter )
    {
        for ( ILogger myLogger : LoggerList )
        {
            myLogger.LogSequenceStart( fpsKeyWordName, fpsWinowFN, fpsSequenceName, fpsParameter );
        }
    }
 
    public void LogTestcaseStart( String fps_TestcaseName )
    {
        for ( ILogger myLogger : LoggerList )
        {
            myLogger.LogTestcaseStart( fps_TestcaseName );
        }
    }
 
    public void LogPass( String fps_Message )
    {
        for ( ILogger myLogger : LoggerList )
        {
            myLogger.LogPass( fps_Message );
        }
    }
 
    public void LogPrint( String fps_Message )
    {
        for ( ILogger myLogger : LoggerList )
        {
            myLogger.LogPrint( fps_Message );
        }
    }
 
    public void LogPrintDebug( String fpsMessage )
    {
        for ( ILogger myLogger : LoggerList )
        {
            myLogger.LogPrintDebug( fpsMessage );
        }
    }
 
    
    public void LogWarning( String fps_Message )
    {
        for ( ILogger myLogger : LoggerList )
        {
            myLogger.LogWarning( fps_Message );
        }
    }
 
 
    
    public void LogSourceLocation( String Start, String End, String featureName, String sourceType )
    {
        for ( ILogger myLogger : LoggerList )
        {
            myLogger.LogSourceLocation( Start, End, featureName, sourceType );
        }
    }
 
    
    public void ResCloseList()
    {
        for ( ILogger myLogger : LoggerList )
        {
            myLogger.ResCloseList();
        }
    }
 
    public void ResCloseListDebug()
    {
        for ( ILogger myLogger : LoggerList )
        {
            myLogger.ResCloseListDebug();
        }
    }
 
    public void ResOpenList( String fps_Name )
    {
        for ( ILogger myLogger : LoggerList )
        {
            myLogger.ResOpenList( fps_Name );
        }
    }
 
    public void ResOpenListDebug( String fpsListCaption )
    {
        for ( ILogger myLogger : LoggerList )
        {
            myLogger.ResOpenListDebug( fpsListCaption );
        }
    }
}