net.amygdalum.testrecorder.profile.AgentConfiguration Maven / Gradle / Ivy

Go to download
package net.amygdalum.testrecorder.profile;

import static java.util.Arrays.asList;
import static java.util.stream.Collectors.toList;
import static net.amygdalum.testrecorder.extensionpoint.ExtensionStrategy.EXTENDING;
import static net.amygdalum.testrecorder.extensionpoint.ExtensionStrategy.OVERRIDING;

import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Supplier;
import java.util.stream.Stream;
import java.util.stream.Stream.Builder;

import net.amygdalum.testrecorder.extensionpoint.ExtensionPoint;
import net.amygdalum.testrecorder.util.Logger;

public class AgentConfiguration {

	private List configurationLoaders;
	private Map, Supplier> defaultValues;
	private Map, Object> singleValues;
	private Map, List> multiValues;

	public AgentConfiguration(ConfigurationLoader... configurationLoaders) {
		this(asList(configurationLoaders));
	}

	public AgentConfiguration(List configurationLoaders) {
		this.configurationLoaders = configurationLoaders;
		this.defaultValues = new IdentityHashMap<>();
		this.singleValues = new IdentityHashMap<>();
		this.multiValues = new IdentityHashMap<>();
	}

	public List getConfigurationLoaders() {
		return configurationLoaders;
	}

	public void setConfigurationLoaders(List configurationLoaders) {
		this.configurationLoaders = configurationLoaders;
	}

	public void reset() {
		singleValues.clear();
		multiValues.clear();
	}

	public  AgentConfiguration withDefaultValue(Class clazz, Supplier defaultValue) {
		defaultValues.put(clazz, defaultValue);
		return this;
	}

	public  Optional loadOptionalConfiguration(Class clazz, Object... args) {
		assert clazz.isAnnotationPresent(ExtensionPoint.class);
		assert clazz.getAnnotation(ExtensionPoint.class).strategy() == OVERRIDING;
		if (args.length == 0) {
			Object cached = singleValues.get(clazz);
			if (cached != null) {
				return Optional.of(clazz.cast(cached));
			}
		}
		Optional config = load(clazz, args).findFirst();
		if (args.length == 0 && config.isPresent()) {
			singleValues.put(clazz, config.get());
		}
		return config;
	}

	public  T loadConfiguration(Class clazz, Object... args) {
		assert clazz.isAnnotationPresent(ExtensionPoint.class);
		assert clazz.getAnnotation(ExtensionPoint.class).strategy() == OVERRIDING;
		if (args.length == 0) {
			Object cached = singleValues.get(clazz);
			if (cached != null) {
				return clazz.cast(cached);
			}
		}
		Optional matchingConfig = load(clazz, args).findFirst();
		T config = matchingConfig.orElseGet(() -> loadDefault(clazz));
		if (args.length == 0) {
			singleValues.put(clazz, config);
		}
		return config;
	}

	protected  T loadDefault(Class clazz) {
		Supplier defaultConfigSupplier = defaultValues.get(clazz);
		if (defaultConfigSupplier == null) {
			return null;
		}
		T defaultConfig = clazz.cast(defaultConfigSupplier.get());
		logLoad("default", defaultConfig);
		return defaultConfig;
	}

	@SuppressWarnings("unchecked")
	public  List loadConfigurations(Class clazz, Object... args) {
		assert clazz.isAnnotationPresent(ExtensionPoint.class);
		assert clazz.getAnnotation(ExtensionPoint.class).strategy() == EXTENDING;
		if (args.length == 0) {
			List cached = multiValues.get(clazz);
			if (cached != null) {
				return (List) cached;
			}
		}
		List configs = load(clazz, args).collect(toList());
		if (args.length == 0) {
			multiValues.put(clazz, configs);
		}
		return configs;
	}

	protected  Stream load(Class clazz, Object... args) {
		Builder configurations = Stream. builder();

		for (ConfigurationLoader configurationLoader : configurationLoaders) {
			configurationLoader.load(clazz, args)
				.forEach(configurations::add);
		}

		return configurations.build().distinct();
	}

	private  T logLoad(String prefix, T object) {
		if (object != null) {
			Logger.info("loading " + prefix + " " + object.getClass().getSimpleName());
		}
		return object;
	}

}