Matcher matcher = boundaryPattern.matcher(name);
        int pos = 0;
        StringBuilder builder = new StringBuilder();
        while (matcher.find()) {
            String prefix = name.substring(pos, matcher.start());
            if (prefix.length() > 0) {
                builder.append(Pattern.quote(prefix));
            }
            builder.append(Pattern.quote(matcher.group()));

        Matcher matcher = boundaryPattern.matcher(name);
        int pos = 0;
        StringBuilder builder = new StringBuilder();
        while (matcher.find()) {
            String prefix = name.substring(pos, matcher.start());
            if (prefix.length() > 0) {
                builder.append(Pattern.quote(prefix));
            }
            builder.append(Pattern.quote(matcher.group()));

        matcher.matches(["c"] as String[], 0)
        matcher.matches(["prefix", "c"] as String[], 1)
        matcher.matches(["a", "c"] as String[], 0)
        matcher.matches(["a", "c", "d"] as String[], 0)
        matcher.matches(["a", "b", "c", "d"] as String[], 0)
        matcher.matches(["a", "b", "c", "d"] as String[], 1)
    }

    def "every path is a prefix"() {

        if (!isArtifactExclude) {
            return false;
        }
        return matches(moduleId.getGroup(), module.getGroup())
            && matches(moduleId.getName(), module.getName())
            && matches(ivyArtifactName.getName(), artifact.getName())
            && matches(ivyArtifactName.getExtension(), artifact.getExtension())
            && matches(ivyArtifactName.getType(), artifact.getType());
    }

    @Override

  // Matches lifted functions by their names.
  FunctionNameMatcherSpec function_name = 1;
}

// Specifies how to quantize matched quantizable units.
message Method {
  oneof method {
    NoQuantization no_quantization = 1;
    StaticRangePtq static_range_ptq = 2;
    WeightOnlyPtq weight_only_ptq = 3;
  }
}

// A QuantizationSpec is essentially a (matcher spec, quantization method) pair,

        matcher.matches(["a", "c"] as String[], 0)
        matcher.matches(["a", "c", "d"] as String[], 0)
        matcher.matches(["prefix", "a", "c"] as String[], 1)

        and:
        !matcher.matches([] as String[], 0)
        !matcher.matches(["a"] as String[], 0)
        !matcher.matches(["other"] as String[], 0)
        !matcher.matches(["a", "other"] as String[], 0)
        !matcher.matches(["a", "other", "c"] as String[], 0)

        schema.matcher().matches([candidate3, candidate4, candidate5, candidate6], requested, explanationBuilder) == [candidate3]
        schema.matcher().matches([candidate4, candidate5, candidate6], requested, explanationBuilder) == [candidate4]
        schema.matcher().matches([candidate5, candidate6], requested, explanationBuilder) == [candidate5]
        schema.matcher().matches([candidate6], requested, explanationBuilder) == [candidate6]
    }

    @Factory
    public static Matcher<Task> dependsOn(final String... tasks) {
        return dependsOn(equalTo(new HashSet<String>(Arrays.asList(tasks))));
    }

    @Factory
    public static Matcher<Task> dependsOn(Matcher<? extends Iterable<String>> matcher) {
        return dependsOn(matcher, false);
    }

    @Factory
    public static Matcher<Task> dependsOnPaths(Matcher<? extends Iterable<String>> matcher) {

// There doesn't seem to be too much need for multiple types.
// Making it a concrete type allows MatchStrings to be a method, which will
// improve its discoverability.

// MatchStrings parses and matches the given strings until one of them matches
// the language in the Matcher. A string may be an Accept-Language header as
// handled by ParseAcceptLanguage. The default language is returned if no

}

type matcher struct {
	Matcher *matching.Matcher
}

func NewPolicyMatcher(m *matching.Matcher) PolicyMatcher {
	return &matcher{
		Matcher: m,
	}
}

// ValidateInitialization checks if Matcher is initialized.
func (c *matcher) ValidateInitialization() error {
	return c.Matcher.ValidateInitialization()
}