cc.warlock.core.script.configuration.ScriptConfiguration.java Source code

Java tutorial

Introduction

Here is the source code for cc.warlock.core.script.configuration.ScriptConfiguration.java

Source

/**
 * Warlock, the open-source cross-platform game client
 *  
 * Copyright 2008, Warlock LLC, and individual contributors as indicated
 * by the @authors tag. 
 *
 * This is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * This software 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this software; if not, write to the Free
 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 */
package cc.warlock.core.script.configuration;

import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

import org.dom4j.DocumentHelper;
import org.dom4j.Element;

import cc.warlock.core.client.IProperty;
import cc.warlock.core.client.internal.Property;
import cc.warlock.core.configuration.ConfigurationUtil;
import cc.warlock.core.configuration.IConfigurationProvider;
import cc.warlock.core.script.javascript.JavascriptEngine;

public class ScriptConfiguration implements IConfigurationProvider {

    protected TreeSet<File> scriptDirectories = new TreeSet<File>();
    protected Property<Boolean> autoScan, suppressExceptions;
    protected Property<Long> scanTimeout;
    protected String scriptPrefix;

    protected HashMap<String, ArrayList<String>> engineExtensions = new HashMap<String, ArrayList<String>>();

    protected static ScriptConfiguration _instance;

    public static ScriptConfiguration instance() {
        if (_instance == null)
            _instance = new ScriptConfiguration();
        return _instance;
    }

    protected ScriptConfiguration() {
        autoScan = new Property<Boolean>(true);
        suppressExceptions = new Property<Boolean>(true);
        scanTimeout = new Property<Long>(500L);
        scriptPrefix = ".";

        addEngineExtension(JavascriptEngine.ENGINE_ID, "js");

        scriptDirectories.add(ConfigurationUtil.getUserDirectory("scripts", false));
        scriptDirectories.add(ConfigurationUtil.getUserDirectory("warlock-scripts", false));
        scriptDirectories.add(ConfigurationUtil.getConfigurationDirectory("scripts", false));
    }

    protected void clear() {
        scriptDirectories.clear();
        autoScan.set(true);
        suppressExceptions.set(false);
        scanTimeout.set((long) 500);
        engineExtensions.clear();
        scriptPrefix = ".";
    }

    public List<Element> getTopLevelElements() {
        ArrayList<Element> elements = new ArrayList<Element>();

        Element scriptConfig = DocumentHelper.createElement("script-config");
        elements.add(scriptConfig);

        addScriptConfigElements(scriptConfig);

        return elements;
    }

    protected void addScriptConfigElements(Element scriptConfig) {
        for (File dir : scriptDirectories) {
            Element dirElement = DocumentHelper.createElement("dir");
            dirElement.setText(dir.getAbsolutePath());

            scriptConfig.add(dirElement);
        }

        Element autoScanElement = DocumentHelper.createElement("autoScan");
        autoScanElement.addAttribute("timeout", "" + scanTimeout.get());
        autoScanElement.setText(autoScan.get() + "");
        scriptConfig.add(autoScanElement);

        Element suppressExceptionsElement = DocumentHelper.createElement("suppressExceptions");
        suppressExceptionsElement.setText(suppressExceptions.get() + "");
        scriptConfig.add(suppressExceptionsElement);

        Element scriptPrefixElement = DocumentHelper.createElement("script-prefix");
        scriptPrefixElement.setText(scriptPrefix);
        scriptConfig.add(scriptPrefixElement);

        addEngineExtensionsConfig(scriptConfig);
    }

    public void addEngineExtension(String engineId, String extension) {
        ArrayList<String> extensions;
        if (engineExtensions.containsKey(engineId)) {
            extensions = engineExtensions.get(engineId);
        } else {
            extensions = new ArrayList<String>();
            engineExtensions.put(engineId, extensions);
        }

        // If we already have the extension, don't add it
        if (!extensions.contains(extension))
            extensions.add(extension);
    }

    protected void addEngineExtensionsConfig(Element scriptConfig) {
        for (Map.Entry<String, ArrayList<String>> entry : engineExtensions.entrySet()) {
            Element engineElement = DocumentHelper.createElement("engine-file-extensions");
            engineElement.addAttribute("engineId", entry.getKey());
            scriptConfig.add(engineElement);

            for (String extension : entry.getValue()) {
                Element extElement = DocumentHelper.createElement("extension");
                extElement.setText(extension);
                engineElement.add(extElement);
            }
        }
    }

    public void parseElement(Element element) {
        if (element.getName().equals("script-config")) {
            parseScriptConfig(element);
        }
    }

    public void parseScriptConfig(Element scriptConfig) {
        // clear();

        for (Element element : (List<Element>) scriptConfig.elements()) {
            if ("dir".equals(element.getName())) {
                scriptDirectories.add(new File(element.getTextTrim()));
            } else if ("autoScan".equals(element.getName())) {
                scanTimeout.set(Long.parseLong(element.attributeValue("timeout")));
                autoScan.set(Boolean.parseBoolean(element.getTextTrim()));
            } else if ("suppressExceptions".equals(element.getName())) {
                suppressExceptions.set(Boolean.parseBoolean(element.getTextTrim()));
            } else if ("script-prefix".equals(element.getName())) {
                scriptPrefix = element.getTextTrim();
            } else if ("engine-file-extensions".equals(element.getName())) {
                for (Element extElement : (List<Element>) element.elements()) {
                    addEngineExtension(element.attributeValue("engineId"), extElement.getTextTrim());
                }
            }
        }
    }

    public boolean supportsElement(Element element) {
        if (element.getName().equals("script-config")) {
            return true;
        }
        return false;
    }

    public IProperty<Boolean> getAutoScan() {
        return autoScan;
    }

    public IProperty<Long> getScanTimeout() {
        return scanTimeout;
    }

    public IProperty<Boolean> getSupressExceptions() {
        return suppressExceptions;
    }

    public List<String> getEngineExtensions(String engineId) {
        if (engineExtensions.containsKey(engineId))
            return engineExtensions.get(engineId);
        return Collections.emptyList();
    }

    public Set<File> getScriptDirectories() {
        return scriptDirectories;
    }

    public String getScriptPrefix() {
        return scriptPrefix;
    }

    public void setScriptPrefix(String scriptPrefix) {
        this.scriptPrefix = scriptPrefix;
    }
}