return baselines
    }

    @Option(option = "warmups", description = "Number of warmups before measurements")
    void setWarmups(@Nullable String warmups) {
        this.warmups = warmups
    }

    @Option(option = "runs", description = "Number of iterations of measurements")
    void setRuns(@Nullable String runs) {
        this.runs = runs
    }

 */

package org.gradle.api.internal.tasks.options;

import org.gradle.api.tasks.options.Option;
import org.gradle.internal.exceptions.ValueCollectingDiagnosticsVisitor;
import org.gradle.internal.typeconversion.NotationParser;
import org.gradle.internal.typeconversion.TypeConversionException;

import java.util.List;
import java.util.Set;

/**
 * An option with a single argument.
 */

<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
  <component name="ProtobufSettings">
    <option name="includePaths">
      <list>
        <option value="$PROJECT_DIR$" />
      </list>
    </option>
  </component>

    }

    def "can handle invalid value for command line option with concrete hint"() {
        when:
        Origin.forCommandLine(OPTION).handleInvalidValue(VALUE, HINT)

        then:
        Throwable t = thrown(CommandLineArgumentException)
        t.message == "Argument value '0' given for --option option is invalid (must be positive)"
    }

 * or {@code List<String>} {@link Option}. At most one option values method may be provided for a
 * particular option.</p>
 *
 * <p>This annotation should be attached to a getter method that returns a {@link java.util.Collection} of
 * possible values. The entries in the collection may be of any type. If necessary, they are transformed

	"istio.io/istio/tools/docker-builder/builder"
)

// Option is a functional option for remote operations.
type Option func(*options) error

type options struct {
	args       map[string]string
	ignoreRuns bool
	baseDir    string
}

// WithArgs sets the input args to the dockerfile
func WithArgs(a map[string]string) Option {
	return func(o *options) error {
		o.args = a
		return nil
	}
}

     */
    @Input
    @Optional
    @Option(option = "configuration", description = "The name of the configuration to report")
    public abstract Property<String> getConfigurationName();

    /**
     * Shows all configurations, including legacy and deprecated configurations.
     *
     * @return property holding the flag to show all configurations
     */
    @Input
    @Optional

	Compact Option = compact
)

// TODO: option to preserve a normal form, if applicable?

type options struct {
	noLower bool
	simple  bool

	// TODO: segmenter, max ignorable, alternative versions, etc.

	ignoreFinalSigma bool
}

func getOpts(o ...Option) (res options) {
	for _, f := range o {
		res = f(res)
	}
	return
}

func noLower(o options) options {
	o.noLower = true

    }

    /**
     * Should this include non-buildable components in the report?
     */
    @Console
    public boolean isShowNonBuildable() {
        return showNonBuildable;
    }

    @Option(option = "non-buildable", description = "Show non-buildable components.")
    public void setShowNonBuildable(boolean showNonBuildable) {
        this.showNonBuildable = showNonBuildable;
    }

    /**

    private boolean showHidden;
    private Format format = Format.FULL;

    @Option(option = "showHidden", description = "Show hidden model elements.")
    public void setShowHidden(boolean showHidden) {
        this.showHidden = showHidden;
    }

    @Console
    public boolean isShowHidden() {
        return showHidden;
    }

    @Option(option = "format", description = "Output format (full, short)")