assertArgumentNotNull("prefix", prefix);
        assertArgumentNotNull("handler", handler);

        final int startPos = prefix.length();
        for (final JarEntry entry : iterable(jarFile.entries())) {
            final String entryName = entry.getName().replace('\\', '/');
            if (entryName.startsWith(prefix) && entryName.endsWith(CLASS_SUFFIX)) {

	// Prefix validation below may check that either Rule.Prefix or Rule.Filter.Prefix exist but not both.
	// Here, we assume the pre-existing rule created using PutBucketLifecycle API is already valid and won't fail the validation if Rule.Prefix is empty.

	if r.Prefix.set && !r.Filter.IsEmpty() && r.Filter.Prefix.set {
		return errXMLNotWellFormed
	}

	if r.Filter.set {

				})
			}

			return listerAt(files), nil
		}

		prefix = retainSlash(prefix)

		for object := range clnt.ListObjects(r.Context(), bucket, minio.ListObjectsOptions{
			Prefix:    prefix,
			Recursive: false,
		}) {
			if object.Err != nil {
				return nil, object.Err
			}

			if object.Key == prefix {
				continue
			}

			isDir := strings.HasSuffix(object.Key, SlashSeparator)

package event

import (
	"strings"

	"github.com/minio/pkg/v3/wildcard"
)

// NewPattern - create new pattern for prefix/suffix.
func NewPattern(prefix, suffix string) (pattern string) {
	if prefix != "" {
		if !strings.HasSuffix(prefix, "*") {
			prefix += "*"
		}

		pattern = prefix
	}

	if suffix != "" {
		if !strings.HasPrefix(suffix, "*") {
			suffix = "*" + suffix
		}

		pattern += suffix

router_b_a.include_router(
    router_b_a_c_override, prefix="/c", default_response_class=HTMLResponse
)
router_b_override.include_router(router_b_a, prefix="/a")
router_a.include_router(router_a_a, prefix="/a")
router_a.include_router(
    router_a_b_override, prefix="/b", default_response_class=PlainTextResponse
)
app.include_router(router_a, prefix="/a")
app.include_router(
    router_b_override, prefix="/b", default_response_class=PlainTextResponse

    /**
     * Returns a {@link CopyOptions} with the specified prefix.
     * <p>
     * When a prefix is specified, only the properties from the source whose names start with the prefix will be copied.
     * Additionally, the prefix will be removed from the source property names to determine the target property names.
     * </p>
     *
     * @param prefix
     *            The prefix. Must not be {@literal null} or an empty string.

		Prefix:     &az.Prefix,
		MaxResults: &maxResults,
	})
	if !pager.More() {
		return false, nil
	}

	resp, err := pager.NextPage(ctx)
	if err != nil {
		if strings.Contains(err.Error(), "no more pages") {
			return false, nil
		}
		return false, azureToObjectError(err, az.Bucket, az.Prefix)
	}

	return len(resp.Segment.BlobItems) > 0, nil
}

		}
	default:
		// Always print Prefix field when both And & Tag are empty
		if err := e.EncodeElement(f.Prefix, xml.StartElement{Name: xml.Name{Local: "Prefix"}}); err != nil {
			return err
		}
	}

	return e.EncodeToken(xml.EndElement{Name: start.Name})
}

// Validate - validates the filter element
func (f Filter) Validate() error {
	// A Filter must have exactly one of Prefix, Tag, or And specified.
	if !f.And.isEmpty() {

	data.VersionIDMarker = versionIDMarker
	data.IsTruncated = resp.IsTruncated

	prefixes := make([]CommonPrefix, 0, len(resp.Prefixes))
	for _, prefix := range resp.Prefixes {
		prefixItem := CommonPrefix{}
		prefixItem.Prefix = s3EncodeName(prefix, encodingType)
		prefixes = append(prefixes, prefixItem)
	}
	data.CommonPrefixes = prefixes
	return data
}

        if (phase.startsWith(PhaseExecutionPoint.BEFORE.prefix())) {
            executionPoint = PhaseExecutionPoint.BEFORE;
            phaseStart = PhaseExecutionPoint.BEFORE.prefix().length();
        } else if (phase.startsWith(PhaseExecutionPoint.AFTER.prefix())) {
            executionPoint = PhaseExecutionPoint.AFTER;
            phaseStart = PhaseExecutionPoint.AFTER.prefix().length();
        } else {