PluginRegistry.java

/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.addthis.codec.plugins;

import javax.annotation.Nonnull;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import com.google.common.annotations.Beta;
import com.google.common.base.Objects;
import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
import com.google.common.collect.Maps;

import com.typesafe.config.Config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Beta
public class PluginRegistry {

    private static final Logger log = LoggerFactory.getLogger(PluginRegistry.class);

    public static final String PLUGIN_DEFAULTS_PATH = "addthis.codec.plugins.defaults";
    public static final String PLUGINS_PATH_PATH    = "addthis.codec.plugins.path";

    public static PluginRegistry defaultRegistry() {
        return DefaultRegistry.DEFAULT;
    }

    @Nonnull private final Map<String, PluginMap> pluginMapsByCategory;
    @Nonnull private final BiMap<Class<?>, PluginMap> pluginMapsByClass;
    @Nonnull private final Config config;

    public PluginRegistry(@Nonnull Config config) {
        this.config = config;
        Config defaultPluginMapSettings = config.getConfig(PLUGIN_DEFAULTS_PATH);
        String pluginPath = config.getString(PLUGINS_PATH_PATH);
        Config pluginConfigs = config.getConfig(pluginPath);

        Set<String> categories = pluginConfigs.root().keySet();
        Map<String, PluginMap> mapsFromConfig = new HashMap<>(categories.size());
        BiMap<Class<?>, PluginMap> mapsFromConfigByClass = HashBiMap.create(categories.size());
        for (String category : categories) {
            Config pluginConfig = pluginConfigs.getConfig(category)
                                               .withFallback(defaultPluginMapSettings);
            PluginMap pluginMap = new PluginMap(category, pluginConfig);
            mapsFromConfig.put(category, pluginMap);
            if (pluginMap.baseClass() != null) {
                mapsFromConfigByClass.put(pluginMap.baseClass(), pluginMap);
            }
        }
        pluginMapsByCategory = Collections.unmodifiableMap(mapsFromConfig);
        pluginMapsByClass = Maps.unmodifiableBiMap(mapsFromConfigByClass);
    }

    /** For immutable 'with' methods. */
    private PluginRegistry(@Nonnull Config config,
                           @Nonnull Map<String, PluginMap> pluginMapsByCategory,
                           @Nonnull BiMap<Class<?>, PluginMap> pluginMapsByClass) {
        this.config = config;
        this.pluginMapsByCategory = pluginMapsByCategory;
        this.pluginMapsByClass = pluginMapsByClass;
    }

    /**
     * Similar to calling {@code new PluginRegistry(overrides.withFallback(previousRegistry.config()))},
     * but may be more efficient. Currently only really benefits when only global defaults have been
     * changed, but may be expanded upon in the future.
     */
    public PluginRegistry withOverrides(Config overrides) {
        Config newConfig = overrides.withFallback(config);
        String pluginPath = config.getString(PLUGINS_PATH_PATH);
        if (overrides.hasPath(PLUGIN_DEFAULTS_PATH)
            || overrides.hasPath(PLUGINS_PATH_PATH)
            || overrides.hasPath(pluginPath)) {
            return new PluginRegistry(newConfig);
        } else {
            return new PluginRegistry(newConfig, pluginMapsByCategory, pluginMapsByClass);
        }
    }

    public Config config() {
        return config;
    }

    public Map<String, PluginMap> asMap() {
        return pluginMapsByCategory;
    }

    public Map<String, PluginMap> byCategory() {
        return pluginMapsByCategory;
    }

    public Map<Class<?>, PluginMap> byClass() {
        return pluginMapsByClass;
    }

    @Override public String toString() {
        return Objects.toStringHelper(this)
                      .add("config.origin", config.origin())
                      .add("pluginMapsByCategory", pluginMapsByCategory)
                      .add("pluginMapsByClass", pluginMapsByClass)
                      .toString();
    }
}