//	"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);

  return ret;
}

void ModularFileSystem::FlushCaches(TransactionToken* token) {
  if (ops_->flush_caches != nullptr) ops_->flush_caches(filesystem_.get());
}

Status ModularFileSystem::SetOption(const std::string& name,
                                    const std::vector<string>& values) {
  if (ops_->set_filesystem_configuration == nullptr) {
    return errors::Unimplemented(

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

            si++;

                    mark = si + 1;
                    if ( key == null )
                        key = "endpoint";
                    if ( binding != null ) {
                        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);
    }

        noSince = optionFile.getOption(OPTION_NOSINCE);
        noTree = optionFile.getOption(OPTION_NOTREE);
        noIndex = optionFile.getOption(OPTION_NOINDEX);
        noHelp = optionFile.getOption(OPTION_NOHELP);
        noNavBar = optionFile.getOption(OPTION_NONAVBAR);
        helpFile = optionFile.getOption(OPTION_HELPFILE);
        stylesheetFile = optionFile.getOption(OPTION_STYLESHEETFILE);