OKW_Memorize_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;
 
//import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
 
//import javax.xml.bind.JAXBException;
//import javax.xml.parsers.ParserConfigurationException;
import javax.xml.xpath.XPathExpressionException;
 
//import org.xml.sax.SAXException;
 
import okw.exceptions.OKWMemorizeKeyNotExistsException;
import okw.log.Logger_Sngltn;
 
public class OKW_Memorize_Sngltn
{
    public String OKW_Memorize_xml  = "";
 
    protected Map<String, String> Value = new HashMap<String, String>();
 
   protected Map<String, String> ValuePersistent = new HashMap<String, String>();
 
    
    protected static OKW_Memorize_Sngltn    Instance;
 
    
    protected LogMessenger LM   = null;
 
    protected Logger_Sngltn Log = Logger_Sngltn.getInstance();
 
    protected OKW_Properties Properties  = OKW_Properties.getInstance();
    
    private OKW_Memorize_Sngltn()
    {
        try
        {
            LM = new LogMessenger("OKW_Memorize");
        }
        catch (Exception e)
        {
            OKW_HandleException.StopRunning(e, Instance.getClass());
        }
    }
 
    public static OKW_Memorize_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 OKW_Memorize_Sngltn();
                    Instance.init();
                }
            }
        }
        
        return Instance;
    }
 
    public static void reset()
    {
        Instance = null;
        getInstance();
    }
 
    public Boolean exists( String fpsKey )
    {
        Boolean lvbReturn = false;
 
        Log.LogFunctionStartDebug(Instance.getClass().getName() + ".Exists", "String fpsKey", fpsKey);
 
        if ( Value.containsKey(fpsKey))
        {
            lvbReturn = true;
        }
        else
        {
            lvbReturn = false;
        }
 
        Log.LogFunctionEndDebug(lvbReturn);
 
        return lvbReturn;
    }
 
    public String get( String fpsKey )
    {
        String lvsReturn = null;
 
        Log.LogFunctionStartDebug(Instance.getClass().getName() + ".Get", "String fpsKey", fpsKey);
 
        try
        {
            if ( Value.containsKey(fpsKey))
            {
                lvsReturn = Value.get(fpsKey);
            }
            else
            {
                String ErrorText = LM.GetMessage("Get", "OKWMemorizeKeyNotExistsException", fpsKey);
                throw new OKWMemorizeKeyNotExistsException(ErrorText);
            }
        }
        finally
        {
            Log.LogFunctionEndDebug(lvsReturn);
        }
 
        return lvsReturn;
    }
 
    public void init()
    {
        Log.LogFunctionStartDebug(this.getClass().getName() + ".Init");
 
        // Klassen Variablen erst löschen...
        
        Instance.OKW_Memorize_xml = "";
        Instance.Value.clear();
 
        // ... und dann alles Initialisieren!
        // 1. Setze Pfad und
        OKW_Memorize_xml = OKW_Ini_Sngltn.getInstance().OKW_Enviroment.getFile_OKW_Memorize_xml();
 
        if (!OKW_Helper.isStringNullOrEmpty(this.OKW_Memorize_xml))
        {
            this.Log.LogPrintDebug("OKW Memorize Datei = >>" + this.OKW_Memorize_xml + "<<");
            if (OKW_FileHelper.fileExists(this.OKW_Memorize_xml))
            {
                // Lesen der Daten...
                //this.Read();
            }
            else
            {
                // Deafault Werte Lesen.
                Log.LogWarning("Datei: >>" + this.OKW_Memorize_xml + "<< nicht gefunden.");
            }
        }
        else
        {
            Log.LogWarning("Enviroment variable 'OKWIni' not set!");
        }
 
        Log.LogFunctionEndDebug();
    }
 
        public void load()
        {
            Log.LogFunctionStartDebug(Instance.getClass().getName() + "load()");
    
            try
            {
                OKW_XmlReader myXMLReader = new OKW_XmlReader("xml/OKW_Memorize.xml");          
            }
            catch(Exception e)
            {
                Log.LogPrintDebug(e.getMessage());
            }
            finally
            {
                Log.LogFunctionEndDebug();
            }
        }
 
    public void save()
    {
        Log.LogFunctionStartDebug( Instance.getClass().getName() + ".save");
 
        try
        {
            // Hint: The Name of Property with the Path nad Filename of the Properties-file
            // to be loaded is "OKW_Memorize.properties"
            Properties.getProperty( "OKW_Memorize.properties", "OKW_Memorize.properties" );
            
        }
        finally
        {
            Log.LogFunctionEndDebug();
        }
    }
 
    public void set( String fpsKey, String fpsValue ) throws XPathExpressionException
    {
        Log.LogFunctionStartDebug(Instance.getClass().getName() + ".Set", "String fpsKey", fpsKey,
                "String fpsValue", fpsValue);
 
        try
        {
            // Are we overwriting an existing MemKey?
            if (Value.containsKey(fpsKey))
            {
                String lvsOverwriteKey = LM.GetMessage("Set", "OverwriteKey", fpsKey);
                String lvsOldValue = LM.GetMessage("Set", "OldValue", Value.get(fpsKey));
                String lvsNewValue = LM.GetMessage("Set", "NewValue", fpsValue);
                
                if (!lvsOldValue.equals( lvsNewValue ))
                {
                    Log.ResOpenList(lvsOverwriteKey);
                    Log.LogPrint(lvsOldValue);
                    Log.LogPrint(lvsNewValue);
                    Log.ResCloseList();
                }
                Instance.Value.put(fpsKey, fpsValue);
            }
            else
            {
                Instance.Value.put(fpsKey, fpsValue);
 
                Log.ResOpenList(LM.GetMessage("Set", "SetValue", fpsKey, fpsValue));
                String lvsMessage = LM.GetMessage("Set", "SetKeyAndValue", fpsKey, fpsValue);
                Log.LogPrint( lvsMessage);
                Log.ResCloseList();
            }
 
            // persistentes Speichern aller Daten...
            // TODO: Prüfen: das wurde ebntfern. Frage soll hier eine Persisntes eingebaut werden?
            // Instance.save();
        }
        finally
        {
            Log.LogFunctionEndDebug();
        }
    }
}