Plugin.java

Go to the documentation of this file.

/*
 * Gridarta MMORPG map editor for Crossfire, Daimonin and similar games.
 * Copyright (C) 2000-2023 The Gridarta Developers.
 *
 * This program 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 2 of the License, or
 * (at your option) any later version.
 *
 * 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, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
package net.sf.gridarta.plugin;
 
import bsh.EvalError;
import bsh.Interpreter;
import java.io.File;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import net.sf.gridarta.model.archetype.Archetype;
import net.sf.gridarta.model.filter.Filter;
import net.sf.gridarta.model.gameobject.GameObject;
import net.sf.gridarta.model.maparchobject.MapArchObject;
import net.sf.gridarta.plugin.parameter.NoSuchParameterException;
import net.sf.gridarta.plugin.parameter.PluginParameter;
import net.sf.gridarta.plugin.parameter.PluginParameterCodec;
import net.sf.gridarta.plugin.parameter.PluginParameterFactory;
import net.sf.gridarta.plugin.parameter.PluginParameterListener;
import net.sf.gridarta.plugin.parameter.StringParameter;
import nu.xom.Element;
import nu.xom.Node;
import org.apache.log4j.Category;
import org.apache.log4j.Logger;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public class Plugin<G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> implements Iterable<PluginParameter<G, A, R, ?>> {
 
    @NotNull
    private static final Category LOG = Logger.getLogger(Plugin.class);
 
    @NotNull
    private String code = "";
 
    @NotNull
    private final List<PluginParameter<G, A, R, ?>> parameters = new ArrayList<>();
 
    @NotNull
    private final String name;
 
    @NotNull
    private final PluginParameterFactory<G, A, R> pluginParameterFactory;
 
    @NotNull
    private final PluginParameterCodec<G, A, R> codec = new PluginParameterCodec<>();
 
    private boolean autoBoot;
 
    private boolean filter;
 
    private boolean script;
 
    @NotNull
    private final Collection<PluginListener> listeners = new CopyOnWriteArrayList<>();
 
    @Nullable
    private File file;
 
    private boolean modified;
 
    @NotNull
    private final PluginParameterListener pluginParameterListener = this::setModified;
 
    public Plugin(@NotNull final String name, @NotNull final PluginParameterFactory<G, A, R> pluginParameterFactory) {
        this.name = name;
        this.pluginParameterFactory = pluginParameterFactory;
    }
 
    @NotNull
    public String getName() {
        return name;
    }
 
    @NotNull
    public String getCode() {
        return code;
    }
 
    public void setCode(@NotNull final String code) {
        if (this.code.equals(code)) {
            return;
        }
 
        this.code = code;
        setModified();
    }
 
    public boolean hasParameters() {
        return !parameters.isEmpty();
    }
 
    public int getParameter(@NotNull final String parameterName) {
        int index = 0;
        for (final PluginParameter<G, A, R, ?> parameter : parameters) {
            if (parameter.getName().equals(parameterName)) {
                return index;
            }
            index++;
        }
        return -1;
    }
 
    @NotNull
    @Override
    public String toString() {
        return name;
    }
 
    public void newParameter() {
        final PluginParameter<G, A, R, ?> pluginParameter;
        try {
            pluginParameter = pluginParameterFactory.createParameter(StringParameter.PARAMETER_TYPE);
        } catch (final NoSuchParameterException ex) {
            LOG.warn("Cannot create parameter: " + ex.getMessage());
            return;
        }
        parameters.add(pluginParameter);
        pluginParameter.addPluginParameterListener(pluginParameterListener);
        setModified();
        notifyParametersChangedListeners();
    }
 
    public void removeParameter(final int index) {
        parameters.remove(index).removePluginParameterListener(pluginParameterListener);
        setModified();
        notifyParametersChangedListeners();
    }
 
    public void addPluginListener(@NotNull final PluginListener listener) {
        listeners.add(listener);
    }
 
    public void removePluginListener(@NotNull final PluginListener listener) {
        listeners.remove(listener);
    }
 
    private void notifyParametersChangedListeners() {
        for (final PluginListener listener : listeners) {
            listener.parametersChanged();
        }
    }
 
    @NotNull
    public Plugin<G, A, R> clonePlugin() {
        final Plugin<G, A, R> model = new Plugin<>(name, pluginParameterFactory);
        model.code = code;
        model.autoBoot = autoBoot;
        model.filter = filter;
        model.script = script;
        model.file = file;
        model.modified = modified;
        for (final PluginParameter<G, A, R, ?> parameter : parameters) {
            final Element parameterXml = codec.toXML(parameter);
            final PluginParameter<G, A, R, ?> clonedParam;
            try {
                clonedParam = pluginParameterFactory.createParameter(parameterXml);
            } catch (final NoSuchParameterException ex) {
                throw new AssertionError(ex);
            }
            model.addParameter(clonedParam);
        }
        return model;
    }
 
    public void addParameter(@NotNull final PluginParameter<G, A, R, ?> pluginParameter) {
        parameters.add(pluginParameter);
        pluginParameter.addPluginParameterListener(pluginParameterListener);
        setModified();
        notifyParametersChangedListeners();
    }
 
    public PluginParameter<G, A, R, ?> getParameter(final int index) throws NoSuchParameterException {
        try {
            return parameters.get(index);
        } catch (final IndexOutOfBoundsException ex) {
            throw new NoSuchParameterException(index, ex);
        }
    }
 
    public boolean isAutoBoot() {
        return autoBoot;
    }
 
    public boolean isScript() {
        return script;
    }
 
    public boolean isFilter() {
        return filter;
    }
 
    public void setAutoBoot(final boolean autoBoot) {
        if (this.autoBoot == autoBoot) {
            return;
        }
        this.autoBoot = autoBoot;
        setModified();
    }
 
    public void setScript(final boolean script) {
        if (this.script == script) {
            return;
        }
        this.script = script;
        setModified();
    }
 
    public void setFilter(final boolean filter) {
        if (this.filter == filter) {
            return;
        }
        this.filter = filter;
        setModified();
    }
 
    public void convertType(@NotNull final PluginParameter<G, A, R, ?> pluginParameter, @NotNull final String newType) throws NoSuchParameterException {
        final int index = parameters.indexOf(pluginParameter);
        if (index == -1) {
            throw new NoSuchParameterException(pluginParameter);
        }
        final PluginParameter<G, A, R, ?> newParameter = pluginParameterFactory.createParameter(newType);
        final PluginParameter<G, A, R, ?> oldParameter = parameters.set(index, newParameter);
        oldParameter.removePluginParameterListener(pluginParameterListener);
        newParameter.addPluginParameterListener(pluginParameterListener);
        setModified();
        notifyParametersChangedListeners();
    }
 
    public boolean isModified() {
        return modified;
    }
 
    public void resetModified() {
        modified = false;
    }
 
    private void setModified() {
        modified = true;
    }
 
    @Nullable
    public File getFile() {
        return file;
    }
 
    public void setFile(@Nullable final File file) {
        this.file = file;
    }
 
    @NotNull
    @Override
    public Iterator<PluginParameter<G, A, R, ?>> iterator() {
        return Collections.unmodifiableList(parameters).iterator();
    }
 
    public void runPlugin(@NotNull final PluginParameters pluginParameters) {
        final Interpreter runner = new Interpreter();
        try {
            pluginParameters.setInterpreterValues(runner, PluginRunMode.AUTO_RUN);
            runner.eval(code);
        } catch (final EvalError e) {
            LOG.warn("Evaluation error on (auto-run)" + name, e);
        }
    }
 
    @Nullable
    public Filter<?, ?> getPluginAsFilter(@NotNull final PluginParameters pluginParameters) {
        final Interpreter runner = new Interpreter();
        try {
            pluginParameters.setInterpreterValues(runner, PluginRunMode.FILTER);
            return (Filter<?, ?>) runner.eval(code);
        } catch (final EvalError e) {
            LOG.warn("Evaluation error on (filter)" + name, e);
        } catch (final ClassCastException e) {
            LOG.warn("Plugin did not return a net.sf.gridarta.model.filter.Filter object" + name, e);
        }
        return null;
    }
 
    @NotNull
    public Node toXML(@NotNull final PluginParameter<G, A, R, ?> pluginParameter) {
        return codec.toXML(pluginParameter);
    }
 
}