NamedFilter.java

Go to the documentation of this file.

/*
 * Gridarta MMORPG map editor for Crossfire, Daimonin and similar games.
 * Copyright (C) 2000-2015 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.model.filter;
 
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.CopyOnWriteArrayList;
import net.sf.gridarta.model.gameobject.GameObject;
import net.sf.gridarta.model.match.NamedGameObjectMatcher;
import org.apache.log4j.Category;
import org.apache.log4j.Logger;
import org.jetbrains.annotations.NotNull;
 
public class NamedFilter implements Filter<NamedFilter, NamedFilterConfig> {
 
    @NotNull
    private static final Category LOG = Logger.getLogger(NamedFilter.class);
 
    @NotNull
    private final Map<String, Filter<?, ?>> subFilters;
 
    @NotNull
    private final Collection<NamedFilterListener> listenerList = new CopyOnWriteArrayList<>();
 
    public NamedFilter(@NotNull final Iterable<NamedGameObjectMatcher> matchers) {
        subFilters = new LinkedHashMap<>();
        for (final NamedGameObjectMatcher matcher : matchers) { // FIXME: use localized name; FIXME: sort by name
            subFilters.put(matcher.getName(), new NamedGameObjectMatcherFilter(matcher));
        }
    }
 
    public void resetConfig(@NotNull final NamedFilterConfig config) {
        for (final String name : subFilters.keySet()) {
            config.setSubFilterEnabled(name, false);
        }
    }
 
    @Override
    public boolean match(@NotNull final NamedFilterConfig config, @NotNull final GameObject<?, ?, ?> gameObject) {
        try {
            if (LOG.isDebugEnabled()) {
                LOG.debug("match called on " + gameObject.getArchetype().getArchetypeName());
            }
            for (final String name : subFilters.keySet()) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug("checking if filter " + name + " is enabled()");
                }
                if (config.isSubFilterEnabled(name)) {
                    if (LOG.isDebugEnabled()) {
                        LOG.debug("enabled!");
                    }
                    if (config.getConfig(name).match(gameObject)) {
                        if (LOG.isDebugEnabled()) {
                            LOG.debug("and matched!");
                        }
                        return !config.isInverted();
                    }
                }
            }
            if (LOG.isDebugEnabled()) {
                LOG.debug("finished scanning sub filters");
            }
            return config.isInverted();
        } catch (final Exception e) {
            return false;
        }
    }
 
    @Override
    public boolean reset(@NotNull final NamedFilterConfig config) {
        try {
            boolean didMatch = false;
            for (final String name : subFilters.keySet()) {
                final FilterConfig<?, ?> filterConfig = config.getConfig(name);
                if (filterConfig.reset()) {
                    didMatch = true;
                }
            }
            return didMatch ^ config.isInverted();
        } catch (final Exception e) {
            return false;
        }
    }
 
    @Override
    public boolean hasGlobalMatch(@NotNull final NamedFilterConfig config) {
        return false;
    }
 
    @NotNull
    @Override
    public NamedFilterConfig createConfig() {
        final NamedFilterConfig filterConfig = new NamedFilterConfig(this);
        for (final Entry<String, Filter<?, ?>> filterEntry : subFilters.entrySet()) {
            fireEvent(NamedFilterChangeType.ADD, filterEntry.getKey(), filterEntry.getValue());
        }
        resetConfig(filterConfig);
        return filterConfig;
    }
 
    public void addFilter(@NotNull final String name, @NotNull final Filter<?, ?> filter) {
        if (subFilters.containsKey(name)) {
            return;
        }
 
        subFilters.put(name, filter);
        fireEvent(NamedFilterChangeType.ADD, name, filter);
    }
 
    public void removeFilter(@NotNull final String name) {
        final Filter<?, ?> filter = subFilters.remove(name);
        if (filter == null) {
            return;
        }
 
        fireEvent(NamedFilterChangeType.REMOVE, name, filter);
    }
 
    private void fireEvent(@NotNull final NamedFilterChangeType type, @NotNull final String filterName, @NotNull final Filter<?, ?> filter) {
        for (final NamedFilterListener listener : listenerList) {
            listener.nameFilterChanged(type, filterName, filter);
        }
    }
 
    public void addFilterListener(@NotNull final NamedFilterListener listener) {
        listenerList.add(listener);
    }
 
    public void removeFilterListener(@NotNull final NamedFilterListener listener) {
        listenerList.remove(listener);
    }
 
    public boolean canShow(@NotNull final GameObject<?, ?, ?> gameObject, @NotNull final NamedFilterConfig filterOutConfig) {
        reset(filterOutConfig);
        if (hasGlobalMatch(filterOutConfig)) {
            match(filterOutConfig, gameObject);
            return !reset(filterOutConfig);
        }
 
        return !match(filterOutConfig, gameObject);
    }
 
}