const QuantizationComponent& component,
                                  const BitType bit_type,
                                  const BitWidth bit_width) {
  spec->set_quantization_component(component);
  spec->set_bit_type(bit_type);
  spec->set_bit_width(bit_width);
}

::stablehlo::quantization::QuantizationOptions FillPresetQuantizationOptions(

    }

    @Override
    public String getExtension() {
        return GUtil.getOrDefault(extension, publishArtifact::getExtension);
    }

    @Override
    public String getType() {
        return GUtil.getOrDefault(type, publishArtifact::getType);
    }

    @Override
    public String getClassifier() {
        if (classifierSet) {
            return classifier;
        }
        return publishArtifact.getClassifier();

func (sb *SymbolBuilder) Sect() *sym.Section     { return sb.l.SymSect(sb.symIdx) }

// Setters for symbol properties.

func (sb *SymbolBuilder) SetType(kind sym.SymKind)   { sb.kind = kind }
func (sb *SymbolBuilder) SetSize(size int64)         { sb.size = size }
func (sb *SymbolBuilder) SetData(data []byte)        { sb.data = data }

  private val client = OkHttpClient()

  fun run() {
    // Use the imgur image upload API as documented at https://api.imgur.com/endpoints/image
    val requestBody =
      MultipartBody.Builder()
        .setType(MultipartBody.FORM)
        .addFormDataPart("title", "Square Logo")
        .addFormDataPart(
          "image",
          "logo-square.png",
          File("docs/images/logo-square.png").asRequestBody(MEDIA_TYPE_PNG),

    auto ranked_type = mlir::dyn_cast<RankedTensorType>(input.getType());
    if (!ranked_type) return false;
    auto input_shape = ranked_type.getShape();
    auto space_to_depth =
        BuildSpaceToDepth(cluster_func, input, block_size, input_shape);
    entry.value().set(space_to_depth);
    block_arg.setType(space_to_depth.getType());
  }
  return true;
}

        return name;
    }

    @Override
    public void setName(String name) {
        throw new IllegalStateException();
    }

    @Override
    public String getType() {
        return type;
    }

    @Override
    public void setType(String type) {
        throw new IllegalStateException();
    }

    @Nullable
    @Override
    public String getConf() {
        return conf;
    }

        return classifier;
    }

    public void setClassifier(String classifier) {
        this.classifier = classifier;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public Object getDatum() {
        return datum;
    }

    public void setDatum(Object datum) {

      arg.setType(new_arg_type);
    }

    // Update the function type.
    func.setType(mlir::FunctionType::get(module.getContext(),
                                         func.getBody().getArgumentTypes(),
                                         func.getFunctionType().getResults()));
  }
  return success();
}

}  // namespace tf_saved_model

 *
 * @see IsolatingProcessor
 */
class IsolatingProcessingStrategy extends IncrementalProcessingStrategy {

    IsolatingProcessingStrategy(AnnotationProcessorResult result) {
        super(result);
        result.setType(ISOLATING);
    }

    @Override
    public void recordProcessingInputs(Set<String> supportedAnnotationTypes, Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {

    }

    @Override

        this.name = name;
    }

    @Override
    public void setExtension(String extension) {
        this.extension = extension;
    }

    @Override
    public void setType(String type) {
        this.type = type;
    }

    @Override
    public void setClassifier(String classifier) {
        this.classifier = classifier;
    }

    public void setDate(Date date) {