return true;
    }

    /**
     * Returns a filtered list of classpath elements. This method is invoked when the caller
     * requested that all dependencies are placed on the classpath, with no module-path element.
     *
     * @param scopeFilter a filter returning {@code true} for the artifact scopes to accept.
     * @param includeTestDir whether to include the test directory in the classpath elements.

                .hasScopeCloserThan(scopeForQualifiedAccess, expressionInScope)) return false
        val candidatesWithinSamePriorityScopes = candidates.filter { it.candidate.originScope == scopeForQualifiedAccess }

        // TODO isInBestCandidates should probably be used more actively to filter candidates
        return candidatesWithinSamePriorityScopes.isEmpty() ||

            return;
        }
        String filter = subRoleSet.stream().map(s -> String.format(groupFilter, s)).collect(Collectors.joining());
        if (subRoleSet.size() > 1) {
            filter = "(|" + filter + ")";
        }

        if (logger.isDebugEnabled()) {
            logger.debug("Group Filter: {}", filter);
        }
        search(bindDn, filter, null, () -> ldapUser.getEnvironment(), result -> {

        setSystemProperty(Constants.LDAP_ACCOUNT_FILTER, value);
    }

    default String getLdapAccountFilter() {
        return getSystemProperty(Constants.LDAP_ACCOUNT_FILTER);
    }

    default void setLdapGroupFilter(final String value) {
        setSystemProperty(Constants.LDAP_GROUP_FILTER, value);
    }

    default String getLdapGroupFilter() {

			return nil, err
		}
		if listenerTyped.Name == model.VirtualInboundListenerName {
			for _, filterChain := range listenerTyped.FilterChains {
				for _, filter := range filterChain.Filters {
					hcm := &hcm.HttpConnectionManager{}
					if err := filter.GetTypedConfig().UnmarshalTo(hcm); err == nil {
						return hcm, nil
					}
				}
			}
		}

	Available  uint64 // in bytes
	MaxUsedPct int    // Used disk percentage of most filled disk, rounded down.
}

// TotalAvailable - total available space
func (p serverPoolsAvailableSpace) TotalAvailable() uint64 {
	total := uint64(0)
	for _, z := range p {
		total += z.Available
	}
	return total
}

// FilterMaxUsed will filter out any pools that has used percent bigger than max,

  /// Returns pointer to an array of available configuration options and their
  /// current/default values in `options` and number of options in array in
  /// `num_options`. Ownership of the array is transferred to caller and the
  /// caller is responsible of freeing the buffers using respective file systems
  /// allocation API.
  ///
  /// Plugins:
  ///   * Must set `status` to `TF_OK` if `options` and `num_options` set.

                                        },
                                        "health_status": "HEALTHY",
                                        "metadata": {
                                            "filter_metadata": {
                                                "envoy.transport_socket_match": {
                                                    "tlsMode": "istio"
                                                },

	hasTags := len(r.Flags.Filter.Tags) != 0
	isMetadata := len(r.Flags.Filter.Metadata) != 0
	isStorageClassOnly := len(r.Flags.Filter.Metadata) == 1 && strings.EqualFold(r.Flags.Filter.Metadata[0].Key, xhttp.AmzStorageClass)

	skip := func(oi ObjectInfo) (ok bool) {
		if r.Flags.Filter.OlderThan > 0 && time.Since(oi.ModTime) < r.Flags.Filter.OlderThan {

     *
     * @param filter
     *            a file filter to exclude files from the results
     * @return An array of <tt>SmbResource</tt> objects
     * @throws SmbException
     */
    public SmbFile[] listFiles ( SmbFileFilter filter ) throws SmbException {
        return SmbEnumerationUtil.listFiles(this, "*", ATTR_DIRECTORY | ATTR_HIDDEN | ATTR_SYSTEM, null, filter);
    }


    @Override