Mercurial > hg > uwproj / file revision

package de.unixwork.uwproj;

import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import javax.xml.parsers.DocumentBuilderFactory;
import java.io.File;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Optional;

public class Project {
    private final HashMap<String, List<Dependency>> namedDependencies = new HashMap<>();
    private final List<Dependency> dependencies = new LinkedList<>();
    private final List<Target> targets = new LinkedList<>();
    private final List<Option> options = new LinkedList<>();
    private final List<Feature> features = new LinkedList<>();

    private final HashMap<String, ConfigVar> configVars = new HashMap<>();
    private final List<ConfigVar> configVarsList = new LinkedList<>();

    public Project(File file) throws Exception {
        var root = DocumentBuilderFactory.
                newDefaultNSInstance().
                newDocumentBuilder().
                parse(file).
                getDocumentElement();
        NodeList dependency_nodes = root.getElementsByTagName("dependency");
        NodeList target_nodes = root.getElementsByTagName("target");
        NodeList config_nodes = root.getElementsByTagName("config");

        for (int i = 0; i < config_nodes.getLength(); i++) {
            NodeList cfgs = config_nodes.item(i).getChildNodes();
            for (int c = 0; c < cfgs.getLength(); c++) {
                Node node = cfgs.item(c);
                if (node.getNodeType() == Node.ELEMENT_NODE) {
                    if (node.getNodeName().equals("var")) {
                        Optional.ofNullable(ConfigVar.parse((Element) node)).ifPresent(v -> {
                            configVars.put(v.getVarName(), v);
                            configVarsList.add(v);
                        });
                    }
                }
            }
        }

        for (int i = 0; i < dependency_nodes.getLength(); i++) {
            addDependency(Dependency.parse((Element) dependency_nodes.item(i)));
        }
        for (int i = 0; i < target_nodes.getLength(); i++) {
            targets.add(Target.parse(this, (Element) target_nodes.item(i)));
        }

        if (targets.isEmpty()) {
            createDefaultTarget();
        }
    }

    private void createDefaultTarget() {
        var t = new Target();
        t.setAllDependencies(true);
        t.setName("default");
        addTarget(t);
    }

    public List<NamedDependency> getNamedDependencies() {
        var ret = new LinkedList<NamedDependency>();

        for (var entry : namedDependencies.entrySet()) {
            var d = new NamedDependency();
            d.setName(entry.getKey());
            d.setSubdependencies(entry.getValue());
            ret.add(d);
        }
        return ret;
    }

    public List<Dependency> getDependencies() {
        return dependencies;
    }

    public List<Target> getTargets() {
        return targets;
    }

    public void addDependency(Dependency dependency) {
        if(dependency.getName() != null) {
            List<Dependency> l = namedDependencies.computeIfAbsent(dependency.getName(), k -> new LinkedList<>());
            dependency.setNum(l.size());
            l.add(dependency);
        } else {
            dependencies.add(dependency);
        }
    }

    public void addTarget(Target target) {
        targets.add(target);
    }

    public void addOption(Option o) {
        options.add(o);
    }

    public List<Option> getOptions() {
        return options;
    }

    public void addFeature(Feature feature) {
        features.add(feature);
    }

    public List<Feature> getFeatures() {
        return features;
    }

    public List<ConfigVar> getVars() {
        return configVarsList;
    }
}