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

Go to download
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"));
    }
}