src/main/java/de/unixwork/uwproj/Project.java

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.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

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<>();
    
    private final Set<String> lang;

    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();
        }
        
        // create a list of all languages that are used
        lang = Stream.concat(
            namedDependencies.values().stream().flatMap(Collection::stream),
            dependencies.stream()
        ).flatMap(d -> d.getLang().stream()).collect(Collectors.toSet());

        // check if some targets want all named dependencies
        targets.stream().filter(Target::isAllDependencies).forEach(t -> {
            t.clearDependencies();
            namedDependencies.keySet().forEach(t::addDependency);
        });
    }

    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;
    }
    
    public Collection<String> getLang() {
        return lang;
    }
}