net.intelie.pipes.ArgumentFlags Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of pipes-api Show documentation
Intelie Pipes' API classes and interfaces
There is a newer version: 0.25.5
package net.intelie.pipes;

import net.intelie.pipes.ast.AstNode;
import net.intelie.pipes.util.Escapes;
import net.intelie.pipes.util.Iterables;

import java.io.Serializable;
import java.util.*;
import java.util.stream.Stream;

public class ArgumentFlags implements Serializable {
    private static final long serialVersionUID = 1L;

    public static final String LATE_BINDING = "late";
    public static final String OPTIONAL = "optional";
    public static final String EMPTY = "empty";
    public static final String VAR_ARGS = "varargs";

    public static final String ATT_BY = "#by";
    public static final String ATT_OVER = "#over";
    public static final String ATT_EVERY = "#every";
    public static final String ATT_MESSAGE = "#message";

    private final boolean late;
    private final boolean optional;
    private final boolean varargs;
    private final boolean empty;
    private final Set annotations;

    public ArgumentFlags(String... flags) throws PipeException {
        this(Arrays.asList(flags));
    }

    public ArgumentFlags(Collection flags) throws PipeException {
        LinkedHashSet set = new LinkedHashSet<>(flags);
        this.late = set.remove(LATE_BINDING);
        this.optional = set.remove(OPTIONAL);
        this.empty = set.remove(EMPTY);
        this.varargs = set.remove(VAR_ARGS);
        this.annotations = Collections.unmodifiableSet(extractAnnotations(set));

        PipeException.check(set.isEmpty(), "Unexpected argument flags: %s", set);
    }

    private Set extractAnnotations(Collection flags) {
        Set annotations = new LinkedHashSet<>();
        for (Iterator iterator = flags.iterator(); iterator.hasNext(); ) {
            String flag = iterator.next();
            if (flag.startsWith("#")) {
                annotations.add(flag);
                iterator.remove();
            }
        }
        return annotations;
    }

    public boolean isLate() {
        return late;
    }

    public boolean isOptional() {
        return optional;
    }

    public boolean isEmpty() {
        return empty;
    }

    public boolean isVarargs() {
        return varargs;
    }

    public Set getAnnotations() {
        return annotations;
    }

    public boolean isSuffix() {
        return Stream.of(ATT_BY, ATT_OVER, ATT_EVERY).anyMatch(annotations::contains);
    }

    public String toString(String name, AstNode defaultValue) {
        StringBuilder sb = new StringBuilder();
        if (annotations.contains(ATT_BY)) sb.append("by ");
        if (annotations.contains(ATT_OVER)) sb.append("over ");
        if (annotations.contains(ATT_EVERY)) sb.append("every ");
        if (annotations.size() > 0)
            sb.append(Iterables.join("", annotations.stream()
                    .filter(x -> Stream.of(ATT_BY, ATT_OVER, ATT_EVERY).noneMatch(x::contains))
                    .map(x -> "[" + x + "]").toArray()));
        if (varargs) sb.append("*");
        if (late) sb.append("&");
        sb.append(Escapes.safeIdentifier(name));
        if (optional) {
            sb.append("=");
            if (!empty) sb.append(defaultValue);
        }
        return sb.toString();
    }

    public boolean hasAnnotations() {
        return !annotations.isEmpty();
    }
}