de.tsl2.nano.incubation.specification.Pool Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of tsl2.nano.specification Show documentation
TSL2 Framework Specification (Pools of descripted and runnable Actions and Rules, Generic Tree)
There is a newer version: 2.5.1
Show newest version
/*
 * File: $HeadURL$
 * Id  : $Id$
 * 
 * created by: Tom, Thomas Schneider
 * created on: 26.02.2014
 * 
 * Copyright: (c) Thomas Schneider 2014, all rights reserved
 */
package de.tsl2.nano.incubation.specification;

import java.io.File;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.logging.Log;

import de.tsl2.nano.bean.BeanUtil;
import de.tsl2.nano.core.ENV;
import de.tsl2.nano.core.ManagedException;
import de.tsl2.nano.core.cls.BeanClass;
import de.tsl2.nano.core.log.LogFactory;
import de.tsl2.nano.core.util.StringUtil;
import de.tsl2.nano.execution.IPRunnable;

/**
 * Generic Pool holding all defined (loaded) instances of an {@link IPRunnable} implementation. Useful for e.g. Rules,
 * Queries and Actions.
 * 
 * should be used as singelton by a service-factory. persists its runnables in a directory, given by
 * {@link #getDirectory()} (using the pool instance generic type as directory name).
 * 
 * It is possible to hold different extensions of the given generic type. Then you access them through ghe getter
 * {@link #get(String, Class)} - otherwise it is sufficient to call {@link #get(String)} using internally the default
 * type, evaluated by {@link #getType()}.
 * 
 * @author Tom, Thomas Schneider
 * @version $Revision$
 */
@SuppressWarnings("rawtypes")
public class Pool> {

    private static final Log LOG = LogFactory.getLog(Pool.class);
    Map runnables;

    private static List> registeredPools = new ArrayList<>();
    
    protected static void registerPool(Class p) {
        registeredPools.add(p);
    }
    
    private Map runnables() {
        if (runnables == null)
            loadRunnables();
        return runnables;
    }

    private void loadRunnables() {
        runnables = new HashMap();
        String dirName = getDirectory();
        LOG.info("loading " + getType().getSimpleName().toLowerCase() + "(s) from " + dirName);
        File dir = new File(dirName);
        dir.mkdirs();
        if (!Modifier.isAbstract(getType().getModifiers())) {
            File[] runnableFiles = dir.listFiles();
            Class type = getType();
            for (int i = 0; i < runnableFiles.length; i++) {
                try {
                    loadRunnable(runnableFiles[i].getPath(), type);
                } catch (Exception e) {
                    LOG.error(e);
                }
            }
        }
    }

    /**
     * getDirectory
     * 
     * @return
     */
    public String getDirectory() {
        return ENV.getConfigPathRel()
            + "specification/"
            + StringUtil.substring(BeanClass.getDefiningClass(this.getClass()).getSimpleName().toLowerCase(), null,
                Pool.class.getSimpleName().toLowerCase()) + "/";
    }

    /**
     * default type, given by generic of this instance
     * 
     * @return type to load
     */
    @SuppressWarnings("unchecked")
    protected Class getType() {
        return (Class) BeanUtil.getGenericType(this.getClass());
    }

    private  I loadRunnable(String path, Class type) {
        try {
            I r = ENV.load(path, type, false);
            runnables.put(r.getName(), r);
            return r;
        } catch (Exception e) {
            ManagedException.forward(e);
            return null;
        }
    }

    public IPRunnable find(String name) {
        IPRunnable runner;
        for (Class p : registeredPools) {
            if ((runner = ENV.get(p).get(name)) != null)
                return runner;
        }
        return null;
    }
    
    /**
     * gets the runnable by name
     * 
     * @param name rule/query to find
     * @return rule/query or null
     */
    public T get(String name) {
        return get(name, getType());
    }

    /**
     * gets the runnable by name
     * 
     * @param name runnable to find
     * @param type runnable type
     * @return runnable or null
     */
    @SuppressWarnings("unchecked")
    public  I get(String name, Class type) {
        T runnable = runnables().get(name);
        //perhaps not loaded (new or recursive)
        if (type == null || Pool.class.equals(type)) {
            //TODO: if type not specified, try all...
            return null;
        } else  {
        return (I) (runnable != null ? runnable : loadRunnable(getFileName(name), type));
        }
    }

    protected String getFileName(String name) {
        return name.endsWith(".xml") ? name : getDirectory() + name + ".xml";
    }

    /**
     * delegates to {@link #add(String, IPRunnable)} using {@link IPRunnable#getName()}
     */
    public void add(T runnable) {
        add(runnable.getName(), runnable);
    }

    /**
     * adds the given runnable to the pool
     * 
     * @param name runnable name
     * @param runnable runnable to add
     */
    public void add(String name, T runnable) {
        runnables().put(name, runnable);
        String fileName = getFileName(runnable.getName());
        LOG.info("adding runnable '" + name + "' and saving it to " + fileName);
        ENV.save(fileName, runnable);
    }

    /**
     * reset
     */
    public void reset() {
        runnables = null;
    }

}