fw.RenderHTML(w, tmpl, getVars())
	})

	_ = context.JSONRouter().StrictSlash(true).NewRoute().Methods("GET").Path("/").HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
		fw.RenderJSON(w, http.StatusOK, getVars())
	})

    List<EclipseSourceDir> getSourceDirs() {
        return this.classpath.classpathentry.findAll { it.@kind == 'src' && !******@****.***With('/') }.collect { new EclipseSourceDir(it) }
    }

    List<EclipseLibrary> getVars() {
        return this.classpath.classpathentry.findAll { it.@kind == 'var' }.collect { new EclipseLibrary(it) }
    }

    abstract class EclipseClasspathEntry {
        final Node entry

  LogicalResult matchAndRewrite(quantfork::DequantizeCastOp dq_op,
                                PatternRewriter& rewriter) const override {
    auto q_op = dq_op.getArg().getDefiningOp<quantfork::QuantizeCastOp>();
    if (!q_op) return failure();

    dq_op.replaceAllUsesWith(q_op.getArg());
    return success();
  }
};

class QuantizeSameScaleOpsPattern
    : public OpRewritePattern<quantfork::DequantizeCastOp> {
 public:

        !details.instanceMethods.contains(details.getProperty('prop').getters[0])
    }

    def "ignores overridden property getters and setters"() {
        expect:
        def details = ClassInspector.inspect(Overrides)

        def prop = details.getProperty('prop')
        prop.getters.size() == 1
        prop.getters[0].declaringClass == Overrides
        prop.setters.size() == 1

                    return "bar";
                }
                public String getBar3() {
                    return "bar";
                }
            }
        """
        file("src/main/java/com/example/Bar.java").java """
            package com.example;

            public class Bar {
                public String getBar() {
                    return "bar";
                }

  std::unique_ptr<OpQuantSpec> spec = GetTFOpQuantSpec(call_op);

  for (int32_t cur_idx = 0; cur_idx < call_op.getArgs().size(); cur_idx++) {
    // Check if the only the weight index has QuantizeCastOp.
    auto cur_op = dyn_cast_or_null<quantfork::QuantizeCastOp>(
        call_op.getArgs()[cur_idx].getDefiningOp());
    if (!cur_op && spec->quantizable_operands.contains(cur_idx)) {
      return false;

 * However, when both getter methods are present, Gradle needs to decide which method to use to access the property value. This can be solved
 * by explicitly ignoring one of the two getters using the ignore annotation.
 * </p>
 *
 * <p>
 * A special case of this is when both getters are generated by Groovy.

            }
        }

        if (setters.size() != getters.size()) {
            throwParameterValidationError(clazz, "It contains a different number of getters and setters.");
        }

        for (String property : setters.keySet()) {
            if (!getters.containsKey(property)) {

    public List<Method> getGetters() {
        List<Method> getters;
        if (mostSpecificDeclaration.getReturnType()==Boolean.TYPE) {
            getters = new ArrayList<>();
            for (Method getter : declaringMethods) {
                if (Proxy.isProxyClass(getter.getDeclaringClass())) {
                    continue;
                }
                getters.add(getter);
            }
        } else {

    private final MethodSet getters = new MethodSet();
    private final MethodSet setters = new MethodSet();
    private Field field;

    MutablePropertyDetails(String name) {
        this.name = name;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public Collection<Method> getGetters() {
        return getters.getValues();
    }

    @Override