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 java.util.Arrays;
import java.util.LinkedList;
import java.util.List;

import static de.unixwork.uwproj.Util.*;

public class Target {
    private String name = "";
    private String prefix;

    private final List<String> dependencies = new LinkedList<>();
    private final List<Define> defines = new LinkedList<>();
    private final List<Feature> features = new LinkedList<>();
    private final List<Option> options = new LinkedList<>();

    private boolean allDependencies = false;

    public static Target parse(Project project, Element element) throws Exception {
        var target = new Target();

        String name = element.getAttribute("name");
        if (!name.isBlank()) {
            target.setName(name);
        }

        NodeList nodes = element.getChildNodes();
        for (int i = 0; i < nodes.getLength(); i++) {
            Node node = nodes.item(i);
            if (node.getNodeType() == Node.ELEMENT_NODE) {
                Element elm = (Element) node;
                String n = elm.getNodeName();
                if (n.equals("feature")) {
                    target.addFeature(Feature.parse(project, elm));
                } else if (n.equals("define")) {
                    target.addDefine(
                            elm.getAttribute("name"),
                            elm.getAttribute("value")
                    );
                } else if (n.equals("dependencies")) {
                    Arrays.stream(Util.getContent(elm).split(","))
                            .map(String::trim)
                            .forEach(target::addDependency);
                } else if (n.equals("alldependencies")) {
                    target.setAllDependencies(true);
                } else if (n.equals("option")) {
                    var opt = Option.parse(elm);
                    target.addOption(opt);
                    project.addOption(opt);
                }
            }
        }

        if (isNullOrBlank(target.prefix) && isNotNullOrBlank(target.name)) {
            target.setPrefix(name.toUpperCase());
        }

        return target;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPrefix() {
        return prefix;
    }

    public void setPrefix(String prefix) {
        this.prefix = prefix;
    }

    private String withPrefix(String id) {
        return prefix == null ? id : String.format("%s_%s", prefix, id);
    }

    public String getCFlags() {
        return withPrefix("CFLAGS");
    }

    public String getLdFlags() {
        return withPrefix("LDFLAGS");
    }

    public String getCxxFlags() {
        return withPrefix("CXXFLAGS");
    }

    public void clearDependencies() {
        dependencies.clear();
    }

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

    public void addDependency(String dependency) {
        // we have to add the sanitized identifier to the list of dependencies
        dependencies.add(shId(dependency));
    }

    public boolean isAllDependencies() {
        return allDependencies;
    }

    public void setAllDependencies(boolean allDependencies) {
        this.allDependencies = allDependencies;
    }

    public void addDefine(String name, String value) {
        if (name.isBlank()) {
            throw new IllegalArgumentException("define element requires name attribute");
        }
        defines.add(new Define(name, value));
    }

    public List<Define> getDefines() {
        return defines;
    }

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

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

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

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