public final K getKey() {
    return key;
  }

  @Override
  @ParametricNullness
  public final V getValue() {
    return value;
  }

  @Override
  @ParametricNullness
  public final V setValue(@ParametricNullness V value) {
    throw new UnsupportedOperationException();
  }

  private static final long serialVersionUID = 0;

    }

    @Override
    public String getValue() {
        return value;
    }

    public boolean isExcluded() {
        return excluded;
    }

    @Override
    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public void exclude() {
        excluded = true;
    }

        super(option, value);
        this.joinBy = joinBy;
    }

    @Override
    public T getValue() {
        return value;
    }

    @Override
    public void setValue(T value) {
        if (value == null) {
            this.value.clear();
        } else {
            this.value = value;
        }
    }

    @Override

               /*KeepEmpty=*/false);

    inputs_attrs.emplace_back(input_name);

    const std::string new_inputs_attr_str =
        llvm::join(std::move(inputs_attrs), /*Separator=*/",");

    named_attr.setValue(StringAttr::get(ctx, new_inputs_attr_str));
  }

  func_op->setAttr(kTfEntryFunctionAttr,
                   DictionaryAttr::get(ctx, entry_func_attrs));
}
}  // namespace quant

  if (!matchPattern(op.getS0(), m_Constant(&s0))) return false;
  if (!matchPattern(op.getS1(), m_Constant(&s1))) return false;

  for (auto s : s0.getValues<APInt>()) s0_shape.push_back(s.getSExtValue());
  for (auto s : s1.getValues<APInt>()) s1_shape.push_back(s.getSExtValue());

  return true;
}

// Calculates r0 & r1 output based on inputs and calculated broadcasted shape.
//

                                if (bitsField != null && !bitsField.getValues().isEmpty()) {
                                    docMap.put(fessConfig.getQueryCollapseInnerHitsName() + "_hash", bitsField.getValues().get(0));
                                }

                                                 bool enable_inliner) {
  PassManager bridge(module.getContext());

  StandardPipelineOptions pipeline_options;
  pipeline_options.enable_inliner.setValue(enable_inliner);
  CreateTFStandardPipeline(bridge, pipeline_options);

  mlir::StatusScopedDiagnosticHandler diag_handler(
      module.getContext(), /*propagate=*/false,
      /*filter_stack=*/!VLOG_IS_ON(1));

        return controller.getModel(CustomModel.class, CustomParameter.class, new Action<CustomParameter>() {
            @Override
            public void execute(CustomParameter customParameter) {
                customParameter.setValue("myParameter");
            }
        });
    }

        metadata.put(key, values);
    }

    public void putValue(final String key, final String value) {
        metadata.put(key, new String[] { value });
    }

    public String[] getValues(final String key) {
        return metadata.get(key);
    }

    public Set<String> getKeySet() {
        return metadata.keySet();
    }

    public String getContent() {
        return content;
    }

import java.util.List;

abstract class AbstractJavaPropertyRules extends RuleSource {
    AbstractJavaPropertyRules() {
    }

    @RuleInput
    abstract String getValue();
    abstract void setValue(String value);

    @RuleInput
    protected abstract int getNumber();
    protected abstract void setNumber(int value);

    @Model
    String thing(int number) {
        return String.valueOf(number);
    }