public static List<String> getAvailableProviders() {
        List<RdmaProvider> allProviders = Arrays.asList(new DisniRdmaProvider(), new TcpRdmaProvider());

        return allProviders.stream()
                .filter(RdmaProvider::isAvailable)
                .map(RdmaProvider::getProviderName)
                .collect(java.util.stream.Collectors.toList());
    }

      // Delay and Defer any initialisation of Conscrypt and BouncyCastle
      DeferredSocketAdapter(ConscryptSocketAdapter.factory),
      DeferredSocketAdapter(BouncyCastleSocketAdapter.factory),
    ).filter { it.isSupported() }

  override fun trustManager(sslSocketFactory: SSLSocketFactory): X509TrustManager? =
    socketAdapters
      .find { it.matchesSocketFactory(sslSocketFactory) }
      ?.trustManager(sslSocketFactory)

    // Needs to go away
    private Set<Artifact> artifactDependencies;

    private ArtifactRepository localRepository;

    private List<ArtifactRepository> remoteRepositories;

    // This is like a filter but overrides all transitive versions
    private Map managedVersionMap;

    /** result type - flat list; the default */
    private boolean asList = true;

    /** result type - dirty tree */

        });

        userBhv.selectCursor(cb -> cb.query().setRoles_Equal(role.getId()), entity -> {
            entity.setRoles(
                    stream(entity.getRoles()).get(stream -> stream.filter(s -> !s.equals(role.getId())).toArray(n -> new String[n])));
            userBhv.insertOrUpdate(entity);
        });
    }

    /**
     * Sets up the list condition for the role query.

labels.ldap_admin_security_principal=Bind DN
labels.ldap_admin_security_credentials=Password
labels.ldap_base_dn=Base DN
labels.ldapAccountFilter=Account Filter
labels.ldapGroupFilter=Group Filter
labels.ldapMemberofAttribute=memberOf Attribute
labels.ldap_account_filter=Account Filter
labels.ldap_group_filter=Group Filter
labels.ldap_memberof_attribute=memberOf Attribute
labels.notification_login=Login Page
labels.notification_search_top=Search Top Page

mc event add myminio/images arn:minio:sqs::1:postgresql --suffix .jpg
# Print out the notification configuration on the `images` bucket.
mc event list myminio/images
mc event list myminio/images
arn:minio:sqs::1:postgresql s3:ObjectCreated:*,s3:ObjectRemoved:* Filter: suffix=”.jpg”
```

### Step 4: Test on PostgreSQL

  private static class HasBoth extends TypeA implements TypeB {}

  @GwtIncompatible // Iterables.filter(Iterable, Class)
  public void testFilterByType_iterator() throws Exception {
    HasBoth hasBoth = new HasBoth();
    Iterable<TypeA> alist = Lists.newArrayList(new TypeA(), new TypeA(), hasBoth, new TypeA());
    Iterable<TypeB> blist = filter(alist, TypeB.class);
    assertThat(blist).containsExactly(hasBoth).inOrder();
  }

        final PermissionHelper permissionHelper = ComponentUtil.getPermissionHelper();
        body.permissions = stream(entity.getPermissions()).get(stream -> stream.map(s -> permissionHelper.decode(s))
                .filter(StringUtil::isNotBlank)
                .distinct()
                .collect(Collectors.joining("\n")));
        return asJson(new ApiResult.ApiConfigResponse().setting(body).status(ApiResult.Status.OK).result());
    }

1. Click **Management**.
1. Click **Index Patterns**.
1. Click **Create index pattern** button
1. Input "fess\_log\*" to the textbox of **index pattern**.
1. Click **Next step**.
1. Set "requestedAt" to the **Time Filter field name**.
1. Click **Create index pattern**.
1. Click **Saved Objects**.
1. Click **Import** and select "fess\_log.ndjson" to import example settings.
1. Click **Dashboard**.
1. Select "fess\_log" dashboard.

        bool((must, should, mustNot, filter) -> {
            filteredLambda.callback(must, filter);
        }, opLambda);
    }

    public void not(OperatorCall<GroupCQ> notLambda) {
        not(notLambda, null);
    }

    public void not(final OperatorCall<GroupCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {
        bool((must, should, mustNot, filter) -> notLambda.callback(mustNot), opLambda);
    }