com.reprezen.genflow.api.template.GenTemplateInfo Maven / Gradle / Ivy

package com.reprezen.genflow.api.template;

import static com.reprezen.genflow.api.template.GenTemplateDependency.GenTemplateDependencyType.GENERATOR;
import static com.reprezen.genflow.api.template.GenTemplateDependency.GenTemplateDependencyType.NAMED_SOURCE;
import static com.reprezen.genflow.api.template.GenTemplateDependency.GenTemplateDependencyType.PARAMETER;
import static com.reprezen.genflow.api.template.GenTemplateDependency.GenTemplateDependencyType.PRIMARY_SOURCE;
import static java.util.stream.Collectors.toList;

import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Stream;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.reprezen.genflow.api.GenerationException;
import com.reprezen.genflow.api.template.GenTemplateDependency.GenTemplateDependencyType;

/**
 * Class that can supply all the metadata for a GenTemplate.
 *
 * @author Andy Lowry
 *
 */
public class GenTemplateInfo implements Comparable {

	@JsonIgnore
	private IGenTemplate instance;
	private String id;
	private String name;
	private List akaIds;
	private String className;
	private boolean suppressed;
	private SourceInfo primarySource;
	private Map namedSources = new LinkedHashMap<>();
	private Map parameters = new LinkedHashMap<>();
	private Map prereqs = new LinkedHashMap<>();
	@JsonIgnore // do this later
	private Map properties;

	public GenTemplateInfo(IGenTemplate genTemplate) {
		this.instance = genTemplate;
		extractIdInfo(genTemplate);
		extractSourceInfo(genTemplate);
		extractParameterInfo(genTemplate);
		extractPrereqInfo(genTemplate);
		extractProperties(genTemplate);
		this.suppressed = genTemplate.isSuppressed();
	};

	@JsonCreator
	private GenTemplateInfo() {
	}

	public IGenTemplate getInstance() throws GenerationException {
		if (instance == null) {
			try {
				// TODO this won't work because some GenTemplates don't have no-art constructors
				// (e.g. SCG and OAG
				// instances, which need their modelInfo). So for now we need to avoid this by
				// always keeping the
				// discovered instance. This will prevent de/serialization, so we're OK until we
				// want to rely on that.
				instance = (IGenTemplate) this.getClass().getClassLoader().loadClass(className).newInstance();
			} catch (Exception e) {
				e.printStackTrace();
				throw new GenerationException("Failed to instantiate GenTemplate class " + className, e);
			}
		}
		return instance != null ? instance.newInstance() : null;
	}

	public String getId() {
		return id;
	}

	public String getName() {
		return name;
	}

	public List getAkaIds() {
		return Collections.unmodifiableList(akaIds);
	}

	public String getClassName() {
		return className;
	}

	public boolean isSuppressed() {
		return suppressed;
	}

	public Optional getPrimarySource() {
		return Optional.ofNullable(primarySource);
	}

	public Optional> getPrimarySourceType() {
		return getPrimarySource().map(si -> si.getValueType());
	}

	public boolean isSuppressedForValueType(Class valueType) {
		try {
			return getInstance().isSuppressed(valueType);
		} catch (GenerationException e) {
			e.printStackTrace();
			return false;
		}
	}

	public Map getNamedSources() {
		return Collections.unmodifiableMap(namedSources);
	}

	public Optional getNamedSource(String name) {
		return Optional.ofNullable(namedSources.get(name));
	}

	public Optional> getNamedSourceType(String name) {
		return getNamedSource(name).map(si -> si.getValueType());
	}

	public Map getParameters() {
		return Collections.unmodifiableMap(parameters);
	}

	public Optional getParameter(String name) {
		return Optional.ofNullable(parameters.get(name));
	}

	public Map getPrereqs() {
		return Collections.unmodifiableMap(prereqs);
	}

	public Optional getPrereq(String name) {
		return Optional.ofNullable(prereqs.get(name));
	}

	public Map getProperties() {
		return Collections.unmodifiableMap(properties);
	}

	public Optional getProperty(String name) {
		return Optional.ofNullable(properties.get(name));
	}

	public Optional getProperty(Enum nameEnum) {
		return getProperty(nameEnum.name());
	}

	private void extractIdInfo(IGenTemplate genTemplate) {
		this.id = genTemplate.getId();
		this.name = genTemplate.getName();
		if (genTemplate instanceof AbstractGenTemplate) {
			try {
				this.akaIds = ((AbstractGenTemplate) genTemplate).getAlsoKnownAsIds();
			} catch (GenerationException e) {
				e.printStackTrace();
				this.akaIds = Collections.emptyList();
			}
		}
		this.className = genTemplate.getClass().getName();
	}

	private void extractSourceInfo(IGenTemplate genTemplate) {
		Optional primary = getDependencies(genTemplate, PRIMARY_SOURCE).findFirst();
		primary.ifPresent(d -> {
			this.primarySource = new SourceInfo(d);
		});
		for (GenTemplateDependency d : getDependencies(genTemplate, NAMED_SOURCE).collect(toList())) {
			this.namedSources.put(d.getName(), new SourceInfo(d));
		}
	}

	private void extractParameterInfo(IGenTemplate genTemplate) {
		for (GenTemplateDependency d : getDependencies(genTemplate, PARAMETER).collect(toList())) {
			this.parameters.put(d.getName(), new ParameterInfo(d));
		}
	}

	private void extractPrereqInfo(IGenTemplate genTemplate) {
		for (GenTemplateDependency d : getDependencies(genTemplate, GENERATOR).collect(toList())) {
			this.prereqs.put(d.getName(), new PrereqInfo(d));
		}
	}

	private void extractProperties(IGenTemplate genTemplate) {
		try {
			this.properties = genTemplate.getProperties();
		} catch (GenerationException e) {
			e.printStackTrace();
			this.properties = Collections.emptyMap();
		}
	}

	private Stream getDependencies(IGenTemplate genTemplate, GenTemplateDependencyType type) {
		try {
			return genTemplate.getDependencies().stream().filter(d -> d.getType() == type);
		} catch (GenerationException e) {
			e.printStackTrace();
			return Stream.of();
		}
	}

	@Override
	public int compareTo(GenTemplateInfo o) {
		return name.toLowerCase().compareTo(o.name.toLowerCase());
	}

	public static class SourceInfo {
		private String name;
		private String valueClassName;
		private String description;
		private boolean required;
		private boolean primary;

		public SourceInfo(GenTemplateDependency d) {
			this.name = d.getName();
			this.valueClassName = d.getInfo();
			this.description = d.getDescription();
			this.required = d.isRequired();
			this.primary = d.getType() == PRIMARY_SOURCE;
		}

		@JsonCreator
		private SourceInfo() {
		}

		public String getName() {
			return name;
		}

		public String getValueClassName() {
			return valueClassName;
		}

		public Class getValueType() {
			if (valueClassName != null) {
				try {
					return this.getClass().getClassLoader().loadClass(valueClassName);
				} catch (ClassNotFoundException e) {
				}
			}
			return null;
		}

		public String getDescription() {
			return description;
		}

		public boolean isRequired() {
			return required;
		}

		public boolean isPrimary() {
			return primary;
		}
	}

	public static class ParameterInfo {
		private String name;
		private String description;
		private String defaultValue;
		private boolean required;

		public ParameterInfo(GenTemplateDependency d) {
			this.name = d.getName();
			this.description = d.getDescription();
			this.defaultValue = d.getInfo();
			this.required = d.isRequired();
		}

		@JsonCreator
		private ParameterInfo() {
		}

		public String getName() {
			return name;
		}

		public String getDescription() {
			return description;
		}

		public String getDefaultValue() {
			return defaultValue;
		}

		public boolean isRequired() {
			return required;
		}
	}

	public static class PrereqInfo {
		private String name;
		private String description;
		private String id;
		private boolean required;

		public PrereqInfo(GenTemplateDependency d) {
			this.name = d.getName();
			this.description = d.getDescription();
			this.id = d.getInfo();
			this.required = d.isRequired();
		}

		@JsonCreator
		private PrereqInfo() {
		}

		public String getName() {
			return name;
		}

		public String getDescription() {
			return description;
		}

		public String getId() {
			return id;
		}

		public boolean isRequired() {
			return required;
		}
	}

	@Override
	public String toString() {
		return String.format("GenTemplateInfo[id: %s, name: %s, primType: %s]", getId(), getName(),
				getPrimarySource().map(s -> s.getValueClassName()).orElse("none"));
	}
}