src/main/java/net/floodlightcontroller/core/module/FloodlightModuleContext.java

package net.floodlightcontroller.core.module;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

/**
 * The service registry for an IFloodlightProvider.
 *
 * @author alexreimers
 */
public class FloodlightModuleContext implements IFloodlightModuleContext {
    protected Map<Class<? extends IFloodlightService>, IFloodlightService> serviceMap;
    protected Map<Class<? extends IFloodlightModule>, Map<String, String>> configParams;
    protected Collection<IFloodlightModule> moduleSet;

    /**
     * Creates the ModuleContext for use with this IFloodlightProvider.
     * This will be used as a module registry for all IFloodlightModule(s).
     */
    public FloodlightModuleContext() {
        serviceMap =
                new HashMap<Class<? extends IFloodlightService>,
                        IFloodlightService>();
        configParams =
                new HashMap<Class<? extends IFloodlightModule>,
                        Map<String, String>>();
    }

    /**
     * Adds a IFloodlightModule for this Context.
     *
     * @param clazz   the service class
     * @param service The IFloodlightService to add to the registry
     */
    public void addService(Class<? extends IFloodlightService> clazz,
                           IFloodlightService service) {
        serviceMap.put(clazz, service);
    }

    @SuppressWarnings("unchecked")
    @Override
    public <T extends IFloodlightService> T getServiceImpl(Class<T> service) {
        IFloodlightService s = serviceMap.get(service);
        return (T) s;
    }

    @Override
    public Collection<Class<? extends IFloodlightService>> getAllServices() {
        return serviceMap.keySet();
    }

    @Override
    public Collection<IFloodlightModule> getAllModules() {
        return moduleSet;
    }

    public void setModuleSet(Collection<IFloodlightModule> modSet) {
        this.moduleSet = modSet;
    }

    /**
     * Gets the configuration parameter map for a module
     *
     * @param module The module to get the configuration map for, usually yourself
     * @return A map containing all the configuration parameters for the module, may be empty
     */
    @Override
    public Map<String, String> getConfigParams(IFloodlightModule module) {
        Map<String, String> retMap = configParams.get(module.getClass());
        if (retMap == null) {
            // Return an empty map if none exists so the module does not
            // need to null check the map
            retMap = new HashMap<String, String>();
            configParams.put(module.getClass(), retMap);
        }

        // also add any configuration parameters for superclasses, but
        // only if more specific configuration does not override it
        for (Class<? extends IFloodlightModule> c : configParams.keySet()) {
            if (c.isInstance(module)) {
                for (Map.Entry<String, String> ent : configParams.get(c).entrySet()) {
                    if (!retMap.containsKey(ent.getKey())) {
                        retMap.put(ent.getKey(), ent.getValue());
                    }
                }
            }
        }

        return retMap;
    }

    /**
     * Adds a configuration parameter for a module
     *
     * @param mod   The fully qualified module name to add the parameter to
     * @param key   The configuration parameter key
     * @param value The configuration parameter value
     */
    public void addConfigParam(IFloodlightModule mod, String key, String value) {
        Map<String, String> moduleParams = configParams.get(mod.getClass());
        if (moduleParams == null) {
            moduleParams = new HashMap<String, String>();
            configParams.put(mod.getClass(), moduleParams);
        }
        moduleParams.put(key, value);
    }
}