public void close() {
        C instance = getInstance();
        state.closer().execute(instance);
    }

    protected abstract C initialValue();

    @SuppressWarnings("unchecked")
    public Object setValue(Object values) {
        state.assertCanMutate();
        if (values == null) {
            setBackingValue(null);
            return null;
        } else {

  for (const auto& value : attr.getValues<APInt>())
    permutation.push_back(value.getSExtValue());

  // Check if we can fold transpose into the operation.
  if (fold_operands && fold_transpose_in_ops) {
    SmallVector<int64_t, 8> permutation;

    auto attr = mlir::cast<DenseElementsAttr>(permutation_op.getValue());
    for (const auto& value : attr.getValues<APInt>())

        this.updatedTime = value;
    }

    public String getValue() {
        checkSpecifiedProperty("value");
        return convertEmptyToNull(value);
    }

    public void setValue(String value) {
        registerModifiedProperty("value");
        this.value = value;
    }

    public String getWebConfigId() {
        checkSpecifiedProperty("webConfigId");

    }

    @Managed
    abstract class ManagedType  {
        abstract String getValue()
        abstract void setValue(String value)
    }

    def "detects managed property"() {
        expect:

      stats_op.emitError("Stats should have 2 values.");
      return failure();
    }
    quant::QuantizedType quant_type;
    double min = FloatAttr::getValueAsDouble(stats.getValues<APFloat>()[0]);
    double max = FloatAttr::getValueAsDouble(stats.getValues<APFloat>()[1]);
    // Make sure the range includes zero.
    min = std::min(min, 0.0);
    max = std::max(max, 0.0);
    Type expressed = getElementTypeOrSelf(stats_op.getType());

    public Set<String> getAvailableValues() {
        return Collections.emptySet();
    }

    @Override
    public void apply(Object object, List<String> parameterValues) throws TypeConversionException {
        setter.setValue(object, newOptionValue);
    }

    private static String removeDisablePrefix(String optionName) {
        return optionName.substring(DISABLE_NAME_PREFIX.length());
    }

        def normalisedPath = path.replace('"', '').replaceAll("'", "")

        when:
        buildScript """
            @Managed
            interface Item {
                String getValue()
                void setValue(String value)
            }

            @Managed
            interface A extends Item {
                B getB()
            }

            @Managed
            interface B extends Item {

          window_dimensions.getValues<IntegerAttr>()[i].getInt());
    }

    for (auto i = 0; i < window_strides.size(); ++i) {
      window_strides_vec.push_back(
          window_strides.getValues<IntegerAttr>()[i].getInt());
    }

    for (auto i = 0; i < base_dilations.size(); ++i) {
      base_dilations_vec.push_back(
          base_dilations.getValues<IntegerAttr>()[i].getInt());
    }

    }

    @Override
    public int hashCode() {
      assertTrue(Thread.holdsLock(mutex));
      return super.hashCode();
    }

    @Override
    public V setValue(V value) {
      assertTrue(Thread.holdsLock(mutex));
      return super.setValue(value);
    }

    private static final long serialVersionUID = 0;
  }

  static class TestMap<K, V> extends SynchronizedMapTest.TestMap<K, V>

     * <p>
     * <b>Example</b>
     * <p>
     * Here is an example of a valid parameter type declaration:
     * <pre>{@code
     * public interface MyParameter {
     *     String getValue();
     *     void setValue(String value);
     *
     *     boolean isFlag();
     *     void setFlag(boolean value);
     * }
     * }</pre>
     *
     * @return The type of the parameter.
     */
    Class<T> getParameterType();