* Note that this node will not be filtered and only the children
     * and its descendant will be checked.
     *
     * @param filter the filter to apply
     * @return a new filtered graph
     */
    @Nonnull
    Node filter(@Nonnull Predicate<Node> filter);

    /**
     * Returns a detailed string representation of this dependency node.
     * <p>

    public ArtifactResolutionRequest setCollectionFilter(ArtifactFilter filter) {
        this.collectionFilter = filter;

        return this;
    }

    /**
     * Gets the artifact filter that controls downloading of artifact files. This filter operates on those artifacts
     * that have been included by the {@link #getCollectionFilter()}.
     *

	return "more than one prefix in filter rule"
}

// ErrFilterNameSuffix - more than one suffix usage error.
type ErrFilterNameSuffix struct{}

func (err ErrFilterNameSuffix) Error() string {
	return "more than one suffix in filter rule"
}

// ErrInvalidFilterValue - invalid filter value error.
type ErrInvalidFilterValue struct {
	FilterValue string
}

            ArtifactFilter filter)
            throws ArtifactResolutionException, ArtifactNotFoundException {
        return resolveTransitively(
                artifacts,
                originatingArtifact,
                Collections.emptyMap(),
                localRepository,
                remoteRepositories,
                source,
                filter);
    }

    @Override

     * @param filter additional resource name filter to apply
     * @param searchAttributes the file attributes to search for
     * @throws CIFSException if an error occurs during initialization
     */
    public DirFileEntryEnumIterator2(final SmbTreeHandleImpl th, final SmbResource parent, final String wildcard,
            final ResourceNameFilter filter, final int searchAttributes) throws CIFSException {

			ruleID := fmt.Sprintf("rule-%d", i)
			tag := Tag{
				Key:   tagKeys[i],
				Value: "minio",
			}
			lc.Rules = append(lc.Rules, Rule{
				ID:     ruleID,
				Status: "Enabled",
				Filter: Filter{
					Tag: tag,
					set: true,
				},
				NoncurrentVersionExpiration: NoncurrentVersionExpiration{
					NewerNoncurrentVersions: retainVersions[i],
					set:                     true,
				},
			})
		}

   */
  public static <E extends @Nullable Object> Collection<E> filter(
      Collection<E> unfiltered, Predicate<? super E> predicate) {
    if (unfiltered instanceof FilteredCollection) {
      // Support clear(), removeAll(), and retainAll() when filtering a filtered
      // collection.
      return ((FilteredCollection<E>) unfiltered).createCombined(predicate);
    }

            Element build = root.child("build").orElse(null);
            Element plugins = build.child("plugins").orElse(null);

            Element cleanPlugin = plugins.children("plugin")
                    .filter(p -> "maven-clean-plugin"
                            .equals(p.child("artifactId").orElse(null).textContent()))
                    .findFirst()
                    .orElse(null);
            assertNotNull(cleanPlugin);

    <modelVersion>4.0.0</modelVersion>

    <groupId>test</groupId>
    <artifactId>test</artifactId>
    <version>0.1-SNAPSHOT</version>
    <packaging>pom</packaging>

    <properties>
        <my.filter.value>hello</my.filter.value>
    </properties>

    <profiles>
        <profile>
            <id>two-conditions</id>
            <activation>
                <file>
                    <exists>simple.xml</exists>

    }

    /**
     * Adds a tag to filter by.
     * @param tag The tag.
     */
    public void addTag(final String tag) {
        tags.add(tag);
    }

    /**
     * Adds a role to filter by.
     * @param role The role.
     */
    public void addRole(final String role) {
        roles.add(role);
    }

    /**
     * Adds a field to filter by.
     * @param field The field name.