//	"missingkey=error"
//		Execution stops immediately with an error.
func (t *Template) Option(opt ...string) *Template {
	t.init()
	for _, s := range opt {
		t.setOption(s)
	}
	return t
}

func (t *Template) setOption(opt string) {
	if opt == "" {
		panic("empty option string")
	}
	// key=value
	if key, value, ok := strings.Cut(opt, "="); ok {
		switch key {
		case "missingkey":

  void FlushCaches(TransactionToken* token) override;
  Status SetOption(const std::string& name,
                   const std::vector<string>& values) override;
  Status SetOption(const std::string& name,
                   const std::vector<int64_t>& values) override;
  Status SetOption(const std::string& name,
                   const std::vector<double>& values) override;

 private:

    HashMap options = null;
    UUID uuid = null;
    int major;
    int minor;

    DcerpcBinding(String proto, String server) {
        this.proto = proto;
        this.server = server;
    }

    void setOption(String key, Object val) throws DcerpcException {
        if (key.equals("endpoint")) {
            endpoint = val.toString();
            String lep = endpoint.toLowerCase();
            if (lep.startsWith("\\pipe\\")) {

     */
    int getMajor () {
        return this.major;
    }


    /**
     * @return the minor
     */
    int getMinor () {
        return this.minor;
    }


    void setOption ( String key, Object val ) throws DcerpcException {
        if ( key.equals("endpoint") ) {
            this.endpoint = val.toString();
            String lep = this.endpoint.toLowerCase(Locale.ENGLISH);

                        String val = str.substring(mark, si).trim();
                        if (key == null)
                            key = "endpoint";
                        binding.setOption(key, val);
                        key = null;
                    }
                    break;
                default:
                    si = arr.length;
            }

            si++;

        sysProps["prop4"] = "not anything much"

        expect:
        def value1 = options.getOption(new InternalFlag("prop1", false))
        value1.get()
        value1.explicit

        def value2 = options.getOption(new InternalFlag("prop2", false))
        value2.get()
        value2.explicit

        def value3 = options.getOption(new InternalFlag("prop3", true))
        !value3.get()
        value3.explicit

    public JavadocOptionFileOptionInternal<T> duplicate() {
        // TODO: We basically don't support copying custom Javadoc options
        return this;
    }

    @Override
    public String getOption() {
        return option.getOption();
    }

    @Override
    public T getValue() {
        return option.getValue();
    }

    @Override
    public void setValue(T value) {
        option.setValue(value);
    }

    public DefaultInternalOptions(Map<String, String> startParameterSystemProperties) {
        this.startParameterSystemProperties = startParameterSystemProperties;
    }

    @Override
    public <T> Option.Value<T> getOption(InternalOption<T> option) {
        String value = startParameterSystemProperties.get(option.getSystemPropertyName());
        if (value == null) {
            value = System.getProperty(option.getSystemPropertyName());

        url = "smb1://" + binding.server + "/IPC$/" + binding.endpoint.substring(6);

        String params = "", server, address;
        server = (String)binding.getOption("server");
        if (server != null)
            params += "&server=" + server;
        address = (String)binding.getOption("address");
        if (server != null)
            params += "&address=" + address;
        if (params.length() > 0)

 *
 * @param <T> The type which this option represents.
 */
@HasInternalProtocol
public interface JavadocOptionFileOption<T> extends OptionLessJavadocOptionFileOption<T> {
    String getOption();