Cache.java

/*
 * GovWay - A customizable API Gateway 
 * https://govway.org
 * 
 * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 3, as published by
 * the Free Software Foundation.
 *
 * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

package org.openspcoop2.utils.cache;

import java.io.ByteArrayOutputStream;
import java.io.OutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import org.openspcoop2.utils.UtilsException;
import org.slf4j.Logger;

/**
 * Cache
 *
 * @author Poli Andrea (apoli@link.it)
 * @author $Author$
 * @version $Rev$, $Date$
 */
public class Cache {

    public static boolean DEBUG_CACHE = false; 
    
    private static Map<String, ICacheImpl> caches = new HashMap<String, ICacheImpl>();
    
    public static void setLog4jSystem() {
        JCS3CacheImpl.setLog4jSystem();
    }
    
    public static boolean initialize(Logger logConsole,Logger logCore,
            String cachePropertiesName,
            String rootDirectory,Properties objectProperties,
            String OPENSPCOOP2_LOCAL_HOME,String OPENSPCOOP2_CACHE_PROPERTIES,String OPENSPCOOP2_CACHE_LOCAL_PATH){
        return JCS3CacheImpl.initialize(logConsole, logCore, 
                cachePropertiesName, 
                rootDirectory, objectProperties, 
                OPENSPCOOP2_LOCAL_HOME, OPENSPCOOP2_CACHE_PROPERTIES, OPENSPCOOP2_CACHE_LOCAL_PATH);
    }
    
    public static String printStatistics(String separatorStat, String separatorCache) throws UtilsException {
        try{
            ByteArrayOutputStream bout = new ByteArrayOutputStream();
            printStatistics(bout,separatorStat,separatorCache);
            bout.flush();
            bout.close();
            return bout.toString();
        }catch(Exception e){
            throw new UtilsException(e.getMessage(),e);
        }
    }
    public static void printStatistics(OutputStream out, String separatorStat, String separatorCache) throws UtilsException {
        try{
            if(Cache.caches!=null && !Cache.caches.isEmpty()) {
                List<String> keys = new ArrayList<>();
                keys.addAll(Cache.caches.keySet());
                Collections.sort(keys);
                for (String key : keys) {
                    try {
                        ICacheImpl cache = Cache.caches.get(key);
                        if(cache!=null) {
                            String s = cache.printStats(separatorStat);
                            out.write(s.getBytes());
                            out.write(separatorCache.getBytes());
                        }
                    }catch(Throwable t) {}
                }
            }
        }catch(Exception e){
            throw new UtilsException(e.getMessage(),e);
        }
    }
    
    
    
    
    private ICacheImpl cache = null;
    
    public Cache(CacheType cacheType, String name) throws UtilsException{
        switch (cacheType) {
        case JCS:
            this.cache = new JCS3CacheImpl(name);
            break;
        case LimitedHashMap:
            this.cache = new LimitedHashMapCacheImpl(name);
            break;
        case EH:
            this.cache = new EHCacheImpl(name);
            break;
        }
    }
        
    public static boolean DEFAULT_DISABLE_SYNCRONIZED_GET = false;
    public static boolean DISABLE_SYNCRONIZED_GET = true;
    public static void disableSyncronizedGetAsDefault() {
        DEFAULT_DISABLE_SYNCRONIZED_GET = DISABLE_SYNCRONIZED_GET;
    }
    public static boolean isDisableSyncronizedGetAsDefault() {
        return DEFAULT_DISABLE_SYNCRONIZED_GET;
    }
    
    @SuppressWarnings("deprecation")
    @Deprecated
    public void disableSyncronizedGet() throws UtilsException {
        if(this.cache==null) {
            throw new UtilsException("Cache disabled");
        }
        this.cache.disableSyncronizedGet();
    }
    @SuppressWarnings("deprecation")
    @Deprecated
    public boolean isDisableSyncronizedGet() throws UtilsException {
        if(this.cache==null) {
            throw new UtilsException("Cache disabled");
        }
        return this.cache.isDisableSyncronizedGet();
    }
    
    @SuppressWarnings("deprecation")
    @Deprecated
    public void enableDebugSystemOut() throws UtilsException {
        if(this.cache==null) {
            throw new UtilsException("Cache disabled");
        }
        this.cache.enableDebugSystemOut();
    }
    @SuppressWarnings("deprecation")
    @Deprecated
    boolean isEnableDebugSystemOut() throws UtilsException {
        if(this.cache==null) {
            throw new UtilsException("Cache disabled");
        }
        return this.cache.isEnableDebugSystemOut();
    }
    

    public int getCacheSize() {
        if(this.cache==null) {
            throw new RuntimeException("Cache not initialized");
        }
        return this.cache.getCacheSize();
    }
    public void setCacheSize(int cacheSize) {
        if(this.cache==null) {
            throw new RuntimeException("Cache not initialized");
        }
        this.cache.setCacheSize(cacheSize);
    }

    public CacheAlgorithm getCacheAlgoritm() {
        if(this.cache==null) {
            throw new RuntimeException("Cache not initialized");
        }
        return this.cache.getCacheAlgoritm();
    }
    public void setCacheAlgoritm(CacheAlgorithm cacheAlgoritm) {
        if(this.cache==null) {
            throw new RuntimeException("Cache not initialized");
        }
        this.cache.setCacheAlgoritm(cacheAlgoritm);
    }

    public long getItemIdleTime() throws UtilsException {
        if(this.cache==null) {
            throw new RuntimeException("Cache not initialized");
        }
        return this.cache.getItemIdleTime();
    }
    public void setItemIdleTime(long itemIdleTimeCache) throws UtilsException {
        if(this.cache==null) {
            throw new RuntimeException("Cache not initialized");
        }
        this.cache.setItemIdleTime(itemIdleTimeCache);
    }

    public long getItemLifeTime() throws UtilsException {
        if(this.cache==null) {
            throw new RuntimeException("Cache not initialized");
        }
        return this.cache.getItemLifeTime();
    }
    public boolean isEternal() throws UtilsException {
        if(this.cache==null) {
            throw new RuntimeException("Cache not initialized");
        }
        return this.cache.isEternal();
    }
    public void setItemLifeTime(long itemLifeTimeCache) throws UtilsException {
        if(this.cache==null) {
            throw new RuntimeException("Cache not initialized");
        }
        this.cache.setItemLifeTime(itemLifeTimeCache);
    }
    
    public void build() throws UtilsException{
        if(this.cache==null) {
            throw new RuntimeException("Cache not initialized");
        }
        this.cache.build();
        Cache.caches.put(this.cache.getName(), this.cache);
    }

    
    
    
    public void clear() throws UtilsException{
        if(this.cache!=null){
            try{
                this.cache.clear();
            }catch(Exception e){
                throw new UtilsException(e.getMessage(),e);
            }
        }
    }

    public Object get(String key){
        if(this.cache==null) {
            throw new RuntimeException("Cache not initialized");
        }
        if(DEBUG_CACHE) {
            System.out.println("GET @"+this.cache.getName()+" ["+key+"]");
        }
        return this.cache.get(key);
    }
    
    public void remove(String key) throws UtilsException{
        if(this.cache==null) {
            throw new RuntimeException("Cache not initialized");
        }
        try{
            this.cache.remove(key);
        }catch(Exception e){
            throw new UtilsException(e.getMessage(),e);
        }   
    }
    
    public void put(String key,org.openspcoop2.utils.cache.CacheResponse value) throws UtilsException{
        if(this.cache==null) {
            throw new RuntimeException("Cache not initialized");
        }
        try{
            this.cache.put(key, value);
        }catch(Exception e){
            throw new UtilsException(e.getMessage(),e);
        }
    }
    public void put(String key,Serializable value) throws UtilsException{
        if(this.cache==null) {
            throw new RuntimeException("Cache not initialized");
        }
        try{
            this.cache.put(key, value);
        }catch(Exception e){
            throw new UtilsException(e.getMessage(),e);
        }
    }
    
    public int getItemCount()  throws UtilsException {
        if(this.cache==null) {
            throw new RuntimeException("Cache not initialized");
        }
        return this.cache.getItemCount();
    }
    
    public List<String> keys() throws UtilsException {
        if(this.cache==null) {
            throw new RuntimeException("Cache not initialized");
        }
        return this.cache.keys();
    }
    
    public String printStats(String separator) throws UtilsException {
        if(this.cache==null) {
            throw new RuntimeException("Cache not initialized");
        }
        return this.cache.printStats(separator);
    }
    public void printStats(OutputStream out, String separator) throws UtilsException {
        if(this.cache==null) {
            throw new RuntimeException("Cache not initialized");
        }
        this.cache.printStats(out, separator);
    }
        
    @Override
    public String toString(){
        if(this.cache==null) {
            //throw new RuntimeException("Cache not initialized");
            return "NonDisponibile";
        }
        return this.cache.toString();
    }
    public String printKeys(String separator) throws UtilsException{
        if(this.cache==null) {
            throw new RuntimeException("Cache not initialized");
        }
        return this.cache.printKeys(separator);
    }


}