MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("name", name);
        if (opLambda != null) {
            opLambda.callback(builder);
        }
    }

    public void setName_Fuzzy(String name) {
        setName_Fuzzy(name, null);
    }

    public void setName_Fuzzy(String name, ConditionOptionCall<MatchQueryBuilder> opLambda) {
        MatchQueryBuilder builder = regFuzzyQ("name", name);

    private TotalHits totalHits;
    private Aggregations aggregations;

    private SearchRequestBuilder builder;

    public EsPagingResultBean(final SearchRequestBuilder builder) {
        this.builder = builder;
    }

    public String getQueryDsl() {
        return builder.toString();
    }

    public long getTook() {
        return took;
    }

    public void setTook(long took) {

            // Verify only one plugin remains
            Editor editor = new Editor(document);
            Element root = editor.root();
            Element build = DomUtils.findChildElement(root, "build");
            Element pluginManagement = DomUtils.findChildElement(build, "pluginManagement");
            Element plugins = DomUtils.findChildElement(pluginManagement, "plugins");

    }

    public String getArraySuffix() {
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < arrayDimensions; i++) {
            builder.append("[]");
        }
        if (varargs) {
            builder.append("...");
        }
        return builder.toString();
    }

    public TypeMetaData addTypeArg(TypeMetaData typeArg) {
        if (typeArgs == null) {

    // read in chunks to fixed array
    reader = new CharSequenceReader(charSequence);
    buf = new char[5];
    StringBuilder builder = new StringBuilder();
    int read;
    while ((read = reader.read(buf, 0, buf.length)) != -1) {
      builder.append(buf, 0, read);
    }
    assertEquals(expected, builder.toString());
    assertFullyRead(reader);

    // read all to one CharBuffer

        ScriptedMetricAggregationBuilder builder = regScriptedMetricA(name);
        if (opLambda != null) {
            opLambda.callback(builder);
        }
    }

    public void topHits(String name, ConditionOptionCall<TopHitsAggregationBuilder> opLambda) {
        TopHitsAggregationBuilder builder = regTopHitsA(name);
        if (opLambda != null) {
            opLambda.callback(builder);
        }
    }

        Collection<Integer> indexes, int scale, double[] dataset) {
      Arrays.sort(dataset);
      ImmutableMap.Builder<Integer, Double> builder = ImmutableMap.builder();
      for (int index : indexes) {
        builder.put(index, singleQuantileFromSorted(index, scale, dataset));
      }
      return builder.buildOrThrow();
    }

    private double singleQuantileFromSorted(int index, int scale, double[] dataset) {

    public ClassMetaData getOwnerClass() {
        return ownerClass;
    }

    public String getSignature() {
        StringBuilder builder = new StringBuilder();
        builder.append(type.getSignature());
        builder.append(' ');
        builder.append(name);
        return builder.toString();
    }

    public MethodMetaData getGetter() {
        return getter;
    }

import gradlebuild.buildutils.tasks.UpdateInitPluginTemplateVersionFile

tasks {
    register<UpdateInitPluginTemplateVersionFile>("updateInitPluginTemplateVersionFile") {
        group = "Build init"
        libraryVersionFile = layout.projectDirectory.file(
            "src/main/resources/org/gradle/buildinit/tasks/templates/library-versions.properties"
        )
    }

---

"_Honestly, what you've built looks super solid and polished. In many ways, it's what I wanted **Hug** to be - it's really inspiring to see someone build that._"