@Generated(value="software.amazon.awssdk:codegen") @ThreadSafe public interface CleanRoomsAsyncClient extends AwsClient
builder() method.
Welcome to the Clean Rooms API Reference.
Clean Rooms is an Amazon Web Services service that helps multiple parties to join their data together in a secure collaboration workspace. In the collaboration, members who can query and receive results can get insights into the collective datasets without either party getting access to the other party's raw data.
To learn more about Clean Rooms concepts, procedures, and best practices, see the Clean Rooms User Guide.
| Modifier and Type | Field and Description |
|---|---|
static String |
SERVICE_METADATA_ID
Value for looking up the service's metadata from the
ServiceMetadataProvider. |
static String |
SERVICE_NAME |
serviceNameclosestatic final String SERVICE_NAME
static final String SERVICE_METADATA_ID
ServiceMetadataProvider.default CompletableFuture<BatchGetCollaborationAnalysisTemplateResponse> batchGetCollaborationAnalysisTemplate(BatchGetCollaborationAnalysisTemplateRequest batchGetCollaborationAnalysisTemplateRequest)
Retrieves multiple analysis templates within a collaboration by their Amazon Resource Names (ARNs).
batchGetCollaborationAnalysisTemplateRequest - default CompletableFuture<BatchGetCollaborationAnalysisTemplateResponse> batchGetCollaborationAnalysisTemplate(Consumer<BatchGetCollaborationAnalysisTemplateRequest.Builder> batchGetCollaborationAnalysisTemplateRequest)
Retrieves multiple analysis templates within a collaboration by their Amazon Resource Names (ARNs).
This is a convenience which creates an instance of the
BatchGetCollaborationAnalysisTemplateRequest.Builder avoiding the need to create one manually via
BatchGetCollaborationAnalysisTemplateRequest.builder()
batchGetCollaborationAnalysisTemplateRequest - A Consumer that will call methods on
BatchGetCollaborationAnalysisTemplateRequest.Builder
to create a request.default CompletableFuture<BatchGetSchemaResponse> batchGetSchema(BatchGetSchemaRequest batchGetSchemaRequest)
Retrieves multiple schemas by their identifiers.
batchGetSchemaRequest - default CompletableFuture<BatchGetSchemaResponse> batchGetSchema(Consumer<BatchGetSchemaRequest.Builder> batchGetSchemaRequest)
Retrieves multiple schemas by their identifiers.
This is a convenience which creates an instance of the BatchGetSchemaRequest.Builder avoiding the need to
create one manually via BatchGetSchemaRequest.builder()
batchGetSchemaRequest - A Consumer that will call methods on
BatchGetSchemaRequest.Builder to create a
request.default CompletableFuture<CreateAnalysisTemplateResponse> createAnalysisTemplate(CreateAnalysisTemplateRequest createAnalysisTemplateRequest)
Creates a new analysis template.
createAnalysisTemplateRequest - default CompletableFuture<CreateAnalysisTemplateResponse> createAnalysisTemplate(Consumer<CreateAnalysisTemplateRequest.Builder> createAnalysisTemplateRequest)
Creates a new analysis template.
This is a convenience which creates an instance of the CreateAnalysisTemplateRequest.Builder avoiding the
need to create one manually via CreateAnalysisTemplateRequest.builder()
createAnalysisTemplateRequest - A Consumer that will call methods on
CreateAnalysisTemplateRequest.Builder to create a
request.default CompletableFuture<CreateCollaborationResponse> createCollaboration(CreateCollaborationRequest createCollaborationRequest)
Creates a new collaboration.
createCollaborationRequest - default CompletableFuture<CreateCollaborationResponse> createCollaboration(Consumer<CreateCollaborationRequest.Builder> createCollaborationRequest)
Creates a new collaboration.
This is a convenience which creates an instance of the CreateCollaborationRequest.Builder avoiding the
need to create one manually via CreateCollaborationRequest.builder()
createCollaborationRequest - A Consumer that will call methods on
CreateCollaborationRequest.Builder to create a
request.default CompletableFuture<CreateConfiguredTableResponse> createConfiguredTable(CreateConfiguredTableRequest createConfiguredTableRequest)
Creates a new configured table resource.
createConfiguredTableRequest - default CompletableFuture<CreateConfiguredTableResponse> createConfiguredTable(Consumer<CreateConfiguredTableRequest.Builder> createConfiguredTableRequest)
Creates a new configured table resource.
This is a convenience which creates an instance of the CreateConfiguredTableRequest.Builder avoiding the
need to create one manually via CreateConfiguredTableRequest.builder()
createConfiguredTableRequest - A Consumer that will call methods on
CreateConfiguredTableRequest.Builder to create a
request.default CompletableFuture<CreateConfiguredTableAnalysisRuleResponse> createConfiguredTableAnalysisRule(CreateConfiguredTableAnalysisRuleRequest createConfiguredTableAnalysisRuleRequest)
Creates a new analysis rule for a configured table. Currently, only one analysis rule can be created for a given configured table.
createConfiguredTableAnalysisRuleRequest - default CompletableFuture<CreateConfiguredTableAnalysisRuleResponse> createConfiguredTableAnalysisRule(Consumer<CreateConfiguredTableAnalysisRuleRequest.Builder> createConfiguredTableAnalysisRuleRequest)
Creates a new analysis rule for a configured table. Currently, only one analysis rule can be created for a given configured table.
This is a convenience which creates an instance of the CreateConfiguredTableAnalysisRuleRequest.Builder
avoiding the need to create one manually via CreateConfiguredTableAnalysisRuleRequest.builder()
createConfiguredTableAnalysisRuleRequest - A Consumer that will call methods on
CreateConfiguredTableAnalysisRuleRequest.Builder
to create a request.default CompletableFuture<CreateConfiguredTableAssociationResponse> createConfiguredTableAssociation(CreateConfiguredTableAssociationRequest createConfiguredTableAssociationRequest)
Creates a configured table association. A configured table association links a configured table with a collaboration.
createConfiguredTableAssociationRequest - default CompletableFuture<CreateConfiguredTableAssociationResponse> createConfiguredTableAssociation(Consumer<CreateConfiguredTableAssociationRequest.Builder> createConfiguredTableAssociationRequest)
Creates a configured table association. A configured table association links a configured table with a collaboration.
This is a convenience which creates an instance of the CreateConfiguredTableAssociationRequest.Builder
avoiding the need to create one manually via CreateConfiguredTableAssociationRequest.builder()
createConfiguredTableAssociationRequest - A Consumer that will call methods on
CreateConfiguredTableAssociationRequest.Builder
to create a request.default CompletableFuture<CreateMembershipResponse> createMembership(CreateMembershipRequest createMembershipRequest)
Creates a membership for a specific collaboration identifier and joins the collaboration.
createMembershipRequest - default CompletableFuture<CreateMembershipResponse> createMembership(Consumer<CreateMembershipRequest.Builder> createMembershipRequest)
Creates a membership for a specific collaboration identifier and joins the collaboration.
This is a convenience which creates an instance of the CreateMembershipRequest.Builder avoiding the need
to create one manually via CreateMembershipRequest.builder()
createMembershipRequest - A Consumer that will call methods on
CreateMembershipRequest.Builder to create a
request.default CompletableFuture<DeleteAnalysisTemplateResponse> deleteAnalysisTemplate(DeleteAnalysisTemplateRequest deleteAnalysisTemplateRequest)
Deletes an analysis template.
deleteAnalysisTemplateRequest - default CompletableFuture<DeleteAnalysisTemplateResponse> deleteAnalysisTemplate(Consumer<DeleteAnalysisTemplateRequest.Builder> deleteAnalysisTemplateRequest)
Deletes an analysis template.
This is a convenience which creates an instance of the DeleteAnalysisTemplateRequest.Builder avoiding the
need to create one manually via DeleteAnalysisTemplateRequest.builder()
deleteAnalysisTemplateRequest - A Consumer that will call methods on
DeleteAnalysisTemplateRequest.Builder to create a
request.default CompletableFuture<DeleteCollaborationResponse> deleteCollaboration(DeleteCollaborationRequest deleteCollaborationRequest)
Deletes a collaboration. It can only be called by the collaboration owner.
deleteCollaborationRequest - default CompletableFuture<DeleteCollaborationResponse> deleteCollaboration(Consumer<DeleteCollaborationRequest.Builder> deleteCollaborationRequest)
Deletes a collaboration. It can only be called by the collaboration owner.
This is a convenience which creates an instance of the DeleteCollaborationRequest.Builder avoiding the
need to create one manually via DeleteCollaborationRequest.builder()
deleteCollaborationRequest - A Consumer that will call methods on
DeleteCollaborationRequest.Builder to create a
request.default CompletableFuture<DeleteConfiguredTableResponse> deleteConfiguredTable(DeleteConfiguredTableRequest deleteConfiguredTableRequest)
Deletes a configured table.
deleteConfiguredTableRequest - default CompletableFuture<DeleteConfiguredTableResponse> deleteConfiguredTable(Consumer<DeleteConfiguredTableRequest.Builder> deleteConfiguredTableRequest)
Deletes a configured table.
This is a convenience which creates an instance of the DeleteConfiguredTableRequest.Builder avoiding the
need to create one manually via DeleteConfiguredTableRequest.builder()
deleteConfiguredTableRequest - A Consumer that will call methods on
DeleteConfiguredTableRequest.Builder to create a
request.default CompletableFuture<DeleteConfiguredTableAnalysisRuleResponse> deleteConfiguredTableAnalysisRule(DeleteConfiguredTableAnalysisRuleRequest deleteConfiguredTableAnalysisRuleRequest)
Deletes a configured table analysis rule.
deleteConfiguredTableAnalysisRuleRequest - default CompletableFuture<DeleteConfiguredTableAnalysisRuleResponse> deleteConfiguredTableAnalysisRule(Consumer<DeleteConfiguredTableAnalysisRuleRequest.Builder> deleteConfiguredTableAnalysisRuleRequest)
Deletes a configured table analysis rule.
This is a convenience which creates an instance of the DeleteConfiguredTableAnalysisRuleRequest.Builder
avoiding the need to create one manually via DeleteConfiguredTableAnalysisRuleRequest.builder()
deleteConfiguredTableAnalysisRuleRequest - A Consumer that will call methods on
DeleteConfiguredTableAnalysisRuleRequest.Builder
to create a request.default CompletableFuture<DeleteConfiguredTableAssociationResponse> deleteConfiguredTableAssociation(DeleteConfiguredTableAssociationRequest deleteConfiguredTableAssociationRequest)
Deletes a configured table association.
deleteConfiguredTableAssociationRequest - default CompletableFuture<DeleteConfiguredTableAssociationResponse> deleteConfiguredTableAssociation(Consumer<DeleteConfiguredTableAssociationRequest.Builder> deleteConfiguredTableAssociationRequest)
Deletes a configured table association.
This is a convenience which creates an instance of the DeleteConfiguredTableAssociationRequest.Builder
avoiding the need to create one manually via DeleteConfiguredTableAssociationRequest.builder()
deleteConfiguredTableAssociationRequest - A Consumer that will call methods on
DeleteConfiguredTableAssociationRequest.Builder
to create a request.default CompletableFuture<DeleteMemberResponse> deleteMember(DeleteMemberRequest deleteMemberRequest)
Removes the specified member from a collaboration. The removed member is placed in the Removed status and can't interact with the collaboration. The removed member's data is inaccessible to active members of the collaboration.
deleteMemberRequest - default CompletableFuture<DeleteMemberResponse> deleteMember(Consumer<DeleteMemberRequest.Builder> deleteMemberRequest)
Removes the specified member from a collaboration. The removed member is placed in the Removed status and can't interact with the collaboration. The removed member's data is inaccessible to active members of the collaboration.
This is a convenience which creates an instance of the DeleteMemberRequest.Builder avoiding the need to
create one manually via DeleteMemberRequest.builder()
deleteMemberRequest - A Consumer that will call methods on
DeleteMemberRequest.Builder to create a request.default CompletableFuture<DeleteMembershipResponse> deleteMembership(DeleteMembershipRequest deleteMembershipRequest)
Deletes a specified membership. All resources under a membership must be deleted.
deleteMembershipRequest - default CompletableFuture<DeleteMembershipResponse> deleteMembership(Consumer<DeleteMembershipRequest.Builder> deleteMembershipRequest)
Deletes a specified membership. All resources under a membership must be deleted.
This is a convenience which creates an instance of the DeleteMembershipRequest.Builder avoiding the need
to create one manually via DeleteMembershipRequest.builder()
deleteMembershipRequest - A Consumer that will call methods on
DeleteMembershipRequest.Builder to create a
request.default CompletableFuture<GetAnalysisTemplateResponse> getAnalysisTemplate(GetAnalysisTemplateRequest getAnalysisTemplateRequest)
Retrieves an analysis template.
getAnalysisTemplateRequest - default CompletableFuture<GetAnalysisTemplateResponse> getAnalysisTemplate(Consumer<GetAnalysisTemplateRequest.Builder> getAnalysisTemplateRequest)
Retrieves an analysis template.
This is a convenience which creates an instance of the GetAnalysisTemplateRequest.Builder avoiding the
need to create one manually via GetAnalysisTemplateRequest.builder()
getAnalysisTemplateRequest - A Consumer that will call methods on
GetAnalysisTemplateRequest.Builder to create a
request.default CompletableFuture<GetCollaborationResponse> getCollaboration(GetCollaborationRequest getCollaborationRequest)
Returns metadata about a collaboration.
getCollaborationRequest - default CompletableFuture<GetCollaborationResponse> getCollaboration(Consumer<GetCollaborationRequest.Builder> getCollaborationRequest)
Returns metadata about a collaboration.
This is a convenience which creates an instance of the GetCollaborationRequest.Builder avoiding the need
to create one manually via GetCollaborationRequest.builder()
getCollaborationRequest - A Consumer that will call methods on
GetCollaborationRequest.Builder to create a
request.default CompletableFuture<GetCollaborationAnalysisTemplateResponse> getCollaborationAnalysisTemplate(GetCollaborationAnalysisTemplateRequest getCollaborationAnalysisTemplateRequest)
Retrieves an analysis template within a collaboration.
getCollaborationAnalysisTemplateRequest - default CompletableFuture<GetCollaborationAnalysisTemplateResponse> getCollaborationAnalysisTemplate(Consumer<GetCollaborationAnalysisTemplateRequest.Builder> getCollaborationAnalysisTemplateRequest)
Retrieves an analysis template within a collaboration.
This is a convenience which creates an instance of the GetCollaborationAnalysisTemplateRequest.Builder
avoiding the need to create one manually via GetCollaborationAnalysisTemplateRequest.builder()
getCollaborationAnalysisTemplateRequest - A Consumer that will call methods on
GetCollaborationAnalysisTemplateRequest.Builder
to create a request.default CompletableFuture<GetConfiguredTableResponse> getConfiguredTable(GetConfiguredTableRequest getConfiguredTableRequest)
Retrieves a configured table.
getConfiguredTableRequest - default CompletableFuture<GetConfiguredTableResponse> getConfiguredTable(Consumer<GetConfiguredTableRequest.Builder> getConfiguredTableRequest)
Retrieves a configured table.
This is a convenience which creates an instance of the GetConfiguredTableRequest.Builder avoiding the
need to create one manually via GetConfiguredTableRequest.builder()
getConfiguredTableRequest - A Consumer that will call methods on
GetConfiguredTableRequest.Builder to create a
request.default CompletableFuture<GetConfiguredTableAnalysisRuleResponse> getConfiguredTableAnalysisRule(GetConfiguredTableAnalysisRuleRequest getConfiguredTableAnalysisRuleRequest)
Retrieves a configured table analysis rule.
getConfiguredTableAnalysisRuleRequest - default CompletableFuture<GetConfiguredTableAnalysisRuleResponse> getConfiguredTableAnalysisRule(Consumer<GetConfiguredTableAnalysisRuleRequest.Builder> getConfiguredTableAnalysisRuleRequest)
Retrieves a configured table analysis rule.
This is a convenience which creates an instance of the GetConfiguredTableAnalysisRuleRequest.Builder
avoiding the need to create one manually via GetConfiguredTableAnalysisRuleRequest.builder()
getConfiguredTableAnalysisRuleRequest - A Consumer that will call methods on
GetConfiguredTableAnalysisRuleRequest.Builder to
create a request.default CompletableFuture<GetConfiguredTableAssociationResponse> getConfiguredTableAssociation(GetConfiguredTableAssociationRequest getConfiguredTableAssociationRequest)
Retrieves a configured table association.
getConfiguredTableAssociationRequest - default CompletableFuture<GetConfiguredTableAssociationResponse> getConfiguredTableAssociation(Consumer<GetConfiguredTableAssociationRequest.Builder> getConfiguredTableAssociationRequest)
Retrieves a configured table association.
This is a convenience which creates an instance of the GetConfiguredTableAssociationRequest.Builder
avoiding the need to create one manually via GetConfiguredTableAssociationRequest.builder()
getConfiguredTableAssociationRequest - A Consumer that will call methods on
GetConfiguredTableAssociationRequest.Builder to
create a request.default CompletableFuture<GetMembershipResponse> getMembership(GetMembershipRequest getMembershipRequest)
Retrieves a specified membership for an identifier.
getMembershipRequest - default CompletableFuture<GetMembershipResponse> getMembership(Consumer<GetMembershipRequest.Builder> getMembershipRequest)
Retrieves a specified membership for an identifier.
This is a convenience which creates an instance of the GetMembershipRequest.Builder avoiding the need to
create one manually via GetMembershipRequest.builder()
getMembershipRequest - A Consumer that will call methods on
GetMembershipRequest.Builder to create a request.default CompletableFuture<GetProtectedQueryResponse> getProtectedQuery(GetProtectedQueryRequest getProtectedQueryRequest)
Returns query processing metadata.
getProtectedQueryRequest - default CompletableFuture<GetProtectedQueryResponse> getProtectedQuery(Consumer<GetProtectedQueryRequest.Builder> getProtectedQueryRequest)
Returns query processing metadata.
This is a convenience which creates an instance of the GetProtectedQueryRequest.Builder avoiding the need
to create one manually via GetProtectedQueryRequest.builder()
getProtectedQueryRequest - A Consumer that will call methods on
GetProtectedQueryRequest.Builder to create a
request.default CompletableFuture<GetSchemaResponse> getSchema(GetSchemaRequest getSchemaRequest)
Retrieves the schema for a relation within a collaboration.
getSchemaRequest - default CompletableFuture<GetSchemaResponse> getSchema(Consumer<GetSchemaRequest.Builder> getSchemaRequest)
Retrieves the schema for a relation within a collaboration.
This is a convenience which creates an instance of the GetSchemaRequest.Builder avoiding the need to
create one manually via GetSchemaRequest.builder()
getSchemaRequest - A Consumer that will call methods on
GetSchemaRequest.Builder to create a request.default CompletableFuture<GetSchemaAnalysisRuleResponse> getSchemaAnalysisRule(GetSchemaAnalysisRuleRequest getSchemaAnalysisRuleRequest)
Retrieves a schema analysis rule.
getSchemaAnalysisRuleRequest - default CompletableFuture<GetSchemaAnalysisRuleResponse> getSchemaAnalysisRule(Consumer<GetSchemaAnalysisRuleRequest.Builder> getSchemaAnalysisRuleRequest)
Retrieves a schema analysis rule.
This is a convenience which creates an instance of the GetSchemaAnalysisRuleRequest.Builder avoiding the
need to create one manually via GetSchemaAnalysisRuleRequest.builder()
getSchemaAnalysisRuleRequest - A Consumer that will call methods on
GetSchemaAnalysisRuleRequest.Builder to create a
request.default CompletableFuture<ListAnalysisTemplatesResponse> listAnalysisTemplates(ListAnalysisTemplatesRequest listAnalysisTemplatesRequest)
Lists analysis templates that the caller owns.
listAnalysisTemplatesRequest - default CompletableFuture<ListAnalysisTemplatesResponse> listAnalysisTemplates(Consumer<ListAnalysisTemplatesRequest.Builder> listAnalysisTemplatesRequest)
Lists analysis templates that the caller owns.
This is a convenience which creates an instance of the ListAnalysisTemplatesRequest.Builder avoiding the
need to create one manually via ListAnalysisTemplatesRequest.builder()
listAnalysisTemplatesRequest - A Consumer that will call methods on
ListAnalysisTemplatesRequest.Builder to create a
request.default ListAnalysisTemplatesPublisher listAnalysisTemplatesPaginator(ListAnalysisTemplatesRequest listAnalysisTemplatesRequest)
Lists analysis templates that the caller owns.
This is a variant of
listAnalysisTemplates(software.amazon.awssdk.services.cleanrooms.model.ListAnalysisTemplatesRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.cleanrooms.paginators.ListAnalysisTemplatesPublisher publisher = client.listAnalysisTemplatesPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.cleanrooms.paginators.ListAnalysisTemplatesPublisher publisher = client.listAnalysisTemplatesPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.cleanrooms.model.ListAnalysisTemplatesResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.cleanrooms.model.ListAnalysisTemplatesResponse response) { //... };
});
As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.
Note: If you prefer to have control on service calls, use the
listAnalysisTemplates(software.amazon.awssdk.services.cleanrooms.model.ListAnalysisTemplatesRequest)
operation.
listAnalysisTemplatesRequest - default ListAnalysisTemplatesPublisher listAnalysisTemplatesPaginator(Consumer<ListAnalysisTemplatesRequest.Builder> listAnalysisTemplatesRequest)
Lists analysis templates that the caller owns.
This is a variant of
listAnalysisTemplates(software.amazon.awssdk.services.cleanrooms.model.ListAnalysisTemplatesRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.cleanrooms.paginators.ListAnalysisTemplatesPublisher publisher = client.listAnalysisTemplatesPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.cleanrooms.paginators.ListAnalysisTemplatesPublisher publisher = client.listAnalysisTemplatesPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.cleanrooms.model.ListAnalysisTemplatesResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.cleanrooms.model.ListAnalysisTemplatesResponse response) { //... };
});
As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.
Note: If you prefer to have control on service calls, use the
listAnalysisTemplates(software.amazon.awssdk.services.cleanrooms.model.ListAnalysisTemplatesRequest)
operation.
This is a convenience which creates an instance of the ListAnalysisTemplatesRequest.Builder avoiding the
need to create one manually via ListAnalysisTemplatesRequest.builder()
listAnalysisTemplatesRequest - A Consumer that will call methods on
ListAnalysisTemplatesRequest.Builder to create a
request.default CompletableFuture<ListCollaborationAnalysisTemplatesResponse> listCollaborationAnalysisTemplates(ListCollaborationAnalysisTemplatesRequest listCollaborationAnalysisTemplatesRequest)
Lists analysis templates within a collaboration.
listCollaborationAnalysisTemplatesRequest - default CompletableFuture<ListCollaborationAnalysisTemplatesResponse> listCollaborationAnalysisTemplates(Consumer<ListCollaborationAnalysisTemplatesRequest.Builder> listCollaborationAnalysisTemplatesRequest)
Lists analysis templates within a collaboration.
This is a convenience which creates an instance of the ListCollaborationAnalysisTemplatesRequest.Builder
avoiding the need to create one manually via ListCollaborationAnalysisTemplatesRequest.builder()
listCollaborationAnalysisTemplatesRequest - A Consumer that will call methods on
ListCollaborationAnalysisTemplatesRequest.Builder
to create a request.default ListCollaborationAnalysisTemplatesPublisher listCollaborationAnalysisTemplatesPaginator(ListCollaborationAnalysisTemplatesRequest listCollaborationAnalysisTemplatesRequest)
Lists analysis templates within a collaboration.
This is a variant of
listCollaborationAnalysisTemplates(software.amazon.awssdk.services.cleanrooms.model.ListCollaborationAnalysisTemplatesRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.cleanrooms.paginators.ListCollaborationAnalysisTemplatesPublisher publisher = client.listCollaborationAnalysisTemplatesPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.cleanrooms.paginators.ListCollaborationAnalysisTemplatesPublisher publisher = client.listCollaborationAnalysisTemplatesPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.cleanrooms.model.ListCollaborationAnalysisTemplatesResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.cleanrooms.model.ListCollaborationAnalysisTemplatesResponse response) { //... };
});
As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.
Note: If you prefer to have control on service calls, use the
listCollaborationAnalysisTemplates(software.amazon.awssdk.services.cleanrooms.model.ListCollaborationAnalysisTemplatesRequest)
operation.
listCollaborationAnalysisTemplatesRequest - default ListCollaborationAnalysisTemplatesPublisher listCollaborationAnalysisTemplatesPaginator(Consumer<ListCollaborationAnalysisTemplatesRequest.Builder> listCollaborationAnalysisTemplatesRequest)
Lists analysis templates within a collaboration.
This is a variant of
listCollaborationAnalysisTemplates(software.amazon.awssdk.services.cleanrooms.model.ListCollaborationAnalysisTemplatesRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.cleanrooms.paginators.ListCollaborationAnalysisTemplatesPublisher publisher = client.listCollaborationAnalysisTemplatesPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.cleanrooms.paginators.ListCollaborationAnalysisTemplatesPublisher publisher = client.listCollaborationAnalysisTemplatesPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.cleanrooms.model.ListCollaborationAnalysisTemplatesResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.cleanrooms.model.ListCollaborationAnalysisTemplatesResponse response) { //... };
});
As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.
Note: If you prefer to have control on service calls, use the
listCollaborationAnalysisTemplates(software.amazon.awssdk.services.cleanrooms.model.ListCollaborationAnalysisTemplatesRequest)
operation.
This is a convenience which creates an instance of the ListCollaborationAnalysisTemplatesRequest.Builder
avoiding the need to create one manually via ListCollaborationAnalysisTemplatesRequest.builder()
listCollaborationAnalysisTemplatesRequest - A Consumer that will call methods on
ListCollaborationAnalysisTemplatesRequest.Builder
to create a request.default CompletableFuture<ListCollaborationsResponse> listCollaborations(ListCollaborationsRequest listCollaborationsRequest)
Lists collaborations the caller owns, is active in, or has been invited to.
listCollaborationsRequest - default CompletableFuture<ListCollaborationsResponse> listCollaborations(Consumer<ListCollaborationsRequest.Builder> listCollaborationsRequest)
Lists collaborations the caller owns, is active in, or has been invited to.
This is a convenience which creates an instance of the ListCollaborationsRequest.Builder avoiding the
need to create one manually via ListCollaborationsRequest.builder()
listCollaborationsRequest - A Consumer that will call methods on
ListCollaborationsRequest.Builder to create a
request.default ListCollaborationsPublisher listCollaborationsPaginator(ListCollaborationsRequest listCollaborationsRequest)
Lists collaborations the caller owns, is active in, or has been invited to.
This is a variant of
listCollaborations(software.amazon.awssdk.services.cleanrooms.model.ListCollaborationsRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.cleanrooms.paginators.ListCollaborationsPublisher publisher = client.listCollaborationsPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.cleanrooms.paginators.ListCollaborationsPublisher publisher = client.listCollaborationsPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.cleanrooms.model.ListCollaborationsResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.cleanrooms.model.ListCollaborationsResponse response) { //... };
});
As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.
Note: If you prefer to have control on service calls, use the
listCollaborations(software.amazon.awssdk.services.cleanrooms.model.ListCollaborationsRequest)
operation.
listCollaborationsRequest - default ListCollaborationsPublisher listCollaborationsPaginator(Consumer<ListCollaborationsRequest.Builder> listCollaborationsRequest)
Lists collaborations the caller owns, is active in, or has been invited to.
This is a variant of
listCollaborations(software.amazon.awssdk.services.cleanrooms.model.ListCollaborationsRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.cleanrooms.paginators.ListCollaborationsPublisher publisher = client.listCollaborationsPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.cleanrooms.paginators.ListCollaborationsPublisher publisher = client.listCollaborationsPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.cleanrooms.model.ListCollaborationsResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.cleanrooms.model.ListCollaborationsResponse response) { //... };
});
As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.
Note: If you prefer to have control on service calls, use the
listCollaborations(software.amazon.awssdk.services.cleanrooms.model.ListCollaborationsRequest)
operation.
This is a convenience which creates an instance of the ListCollaborationsRequest.Builder avoiding the
need to create one manually via ListCollaborationsRequest.builder()
listCollaborationsRequest - A Consumer that will call methods on
ListCollaborationsRequest.Builder to create a
request.default CompletableFuture<ListConfiguredTableAssociationsResponse> listConfiguredTableAssociations(ListConfiguredTableAssociationsRequest listConfiguredTableAssociationsRequest)
Lists configured table associations for a membership.
listConfiguredTableAssociationsRequest - default CompletableFuture<ListConfiguredTableAssociationsResponse> listConfiguredTableAssociations(Consumer<ListConfiguredTableAssociationsRequest.Builder> listConfiguredTableAssociationsRequest)
Lists configured table associations for a membership.
This is a convenience which creates an instance of the ListConfiguredTableAssociationsRequest.Builder
avoiding the need to create one manually via ListConfiguredTableAssociationsRequest.builder()
listConfiguredTableAssociationsRequest - A Consumer that will call methods on
ListConfiguredTableAssociationsRequest.Builder to
create a request.default ListConfiguredTableAssociationsPublisher listConfiguredTableAssociationsPaginator(ListConfiguredTableAssociationsRequest listConfiguredTableAssociationsRequest)
Lists configured table associations for a membership.
This is a variant of
listConfiguredTableAssociations(software.amazon.awssdk.services.cleanrooms.model.ListConfiguredTableAssociationsRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.cleanrooms.paginators.ListConfiguredTableAssociationsPublisher publisher = client.listConfiguredTableAssociationsPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.cleanrooms.paginators.ListConfiguredTableAssociationsPublisher publisher = client.listConfiguredTableAssociationsPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.cleanrooms.model.ListConfiguredTableAssociationsResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.cleanrooms.model.ListConfiguredTableAssociationsResponse response) { //... };
});
As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.
Note: If you prefer to have control on service calls, use the
listConfiguredTableAssociations(software.amazon.awssdk.services.cleanrooms.model.ListConfiguredTableAssociationsRequest)
operation.
listConfiguredTableAssociationsRequest - default ListConfiguredTableAssociationsPublisher listConfiguredTableAssociationsPaginator(Consumer<ListConfiguredTableAssociationsRequest.Builder> listConfiguredTableAssociationsRequest)
Lists configured table associations for a membership.
This is a variant of
listConfiguredTableAssociations(software.amazon.awssdk.services.cleanrooms.model.ListConfiguredTableAssociationsRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.cleanrooms.paginators.ListConfiguredTableAssociationsPublisher publisher = client.listConfiguredTableAssociationsPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.cleanrooms.paginators.ListConfiguredTableAssociationsPublisher publisher = client.listConfiguredTableAssociationsPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.cleanrooms.model.ListConfiguredTableAssociationsResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.cleanrooms.model.ListConfiguredTableAssociationsResponse response) { //... };
});
As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.
Note: If you prefer to have control on service calls, use the
listConfiguredTableAssociations(software.amazon.awssdk.services.cleanrooms.model.ListConfiguredTableAssociationsRequest)
operation.
This is a convenience which creates an instance of the ListConfiguredTableAssociationsRequest.Builder
avoiding the need to create one manually via ListConfiguredTableAssociationsRequest.builder()
listConfiguredTableAssociationsRequest - A Consumer that will call methods on
ListConfiguredTableAssociationsRequest.Builder to
create a request.default CompletableFuture<ListConfiguredTablesResponse> listConfiguredTables(ListConfiguredTablesRequest listConfiguredTablesRequest)
Lists configured tables.
listConfiguredTablesRequest - default CompletableFuture<ListConfiguredTablesResponse> listConfiguredTables(Consumer<ListConfiguredTablesRequest.Builder> listConfiguredTablesRequest)
Lists configured tables.
This is a convenience which creates an instance of the ListConfiguredTablesRequest.Builder avoiding the
need to create one manually via ListConfiguredTablesRequest.builder()
listConfiguredTablesRequest - A Consumer that will call methods on
ListConfiguredTablesRequest.Builder to create a
request.default ListConfiguredTablesPublisher listConfiguredTablesPaginator(ListConfiguredTablesRequest listConfiguredTablesRequest)
Lists configured tables.
This is a variant of
listConfiguredTables(software.amazon.awssdk.services.cleanrooms.model.ListConfiguredTablesRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.cleanrooms.paginators.ListConfiguredTablesPublisher publisher = client.listConfiguredTablesPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.cleanrooms.paginators.ListConfiguredTablesPublisher publisher = client.listConfiguredTablesPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.cleanrooms.model.ListConfiguredTablesResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.cleanrooms.model.ListConfiguredTablesResponse response) { //... };
});
As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.
Note: If you prefer to have control on service calls, use the
listConfiguredTables(software.amazon.awssdk.services.cleanrooms.model.ListConfiguredTablesRequest)
operation.
listConfiguredTablesRequest - default ListConfiguredTablesPublisher listConfiguredTablesPaginator(Consumer<ListConfiguredTablesRequest.Builder> listConfiguredTablesRequest)
Lists configured tables.
This is a variant of
listConfiguredTables(software.amazon.awssdk.services.cleanrooms.model.ListConfiguredTablesRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.cleanrooms.paginators.ListConfiguredTablesPublisher publisher = client.listConfiguredTablesPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.cleanrooms.paginators.ListConfiguredTablesPublisher publisher = client.listConfiguredTablesPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.cleanrooms.model.ListConfiguredTablesResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.cleanrooms.model.ListConfiguredTablesResponse response) { //... };
});
As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.
Note: If you prefer to have control on service calls, use the
listConfiguredTables(software.amazon.awssdk.services.cleanrooms.model.ListConfiguredTablesRequest)
operation.
This is a convenience which creates an instance of the ListConfiguredTablesRequest.Builder avoiding the
need to create one manually via ListConfiguredTablesRequest.builder()
listConfiguredTablesRequest - A Consumer that will call methods on
ListConfiguredTablesRequest.Builder to create a
request.default CompletableFuture<ListMembersResponse> listMembers(ListMembersRequest listMembersRequest)
Lists all members within a collaboration.
listMembersRequest - default CompletableFuture<ListMembersResponse> listMembers(Consumer<ListMembersRequest.Builder> listMembersRequest)
Lists all members within a collaboration.
This is a convenience which creates an instance of the ListMembersRequest.Builder avoiding the need to
create one manually via ListMembersRequest.builder()
listMembersRequest - A Consumer that will call methods on
ListMembersRequest.Builder to create a request.default ListMembersPublisher listMembersPaginator(ListMembersRequest listMembersRequest)
Lists all members within a collaboration.
This is a variant of listMembers(software.amazon.awssdk.services.cleanrooms.model.ListMembersRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.cleanrooms.paginators.ListMembersPublisher publisher = client.listMembersPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.cleanrooms.paginators.ListMembersPublisher publisher = client.listMembersPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.cleanrooms.model.ListMembersResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.cleanrooms.model.ListMembersResponse response) { //... };
});
As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.
Note: If you prefer to have control on service calls, use the
listMembers(software.amazon.awssdk.services.cleanrooms.model.ListMembersRequest) operation.
listMembersRequest - default ListMembersPublisher listMembersPaginator(Consumer<ListMembersRequest.Builder> listMembersRequest)
Lists all members within a collaboration.
This is a variant of listMembers(software.amazon.awssdk.services.cleanrooms.model.ListMembersRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.cleanrooms.paginators.ListMembersPublisher publisher = client.listMembersPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.cleanrooms.paginators.ListMembersPublisher publisher = client.listMembersPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.cleanrooms.model.ListMembersResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.cleanrooms.model.ListMembersResponse response) { //... };
});
As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.
Note: If you prefer to have control on service calls, use the
listMembers(software.amazon.awssdk.services.cleanrooms.model.ListMembersRequest) operation.
This is a convenience which creates an instance of the ListMembersRequest.Builder avoiding the need to
create one manually via ListMembersRequest.builder()
listMembersRequest - A Consumer that will call methods on
ListMembersRequest.Builder to create a request.default CompletableFuture<ListMembershipsResponse> listMemberships(ListMembershipsRequest listMembershipsRequest)
Lists all memberships resources within the caller's account.
listMembershipsRequest - default CompletableFuture<ListMembershipsResponse> listMemberships(Consumer<ListMembershipsRequest.Builder> listMembershipsRequest)
Lists all memberships resources within the caller's account.
This is a convenience which creates an instance of the ListMembershipsRequest.Builder avoiding the need
to create one manually via ListMembershipsRequest.builder()
listMembershipsRequest - A Consumer that will call methods on
ListMembershipsRequest.Builder to create a
request.default ListMembershipsPublisher listMembershipsPaginator(ListMembershipsRequest listMembershipsRequest)
Lists all memberships resources within the caller's account.
This is a variant of
listMemberships(software.amazon.awssdk.services.cleanrooms.model.ListMembershipsRequest) operation. The
return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.cleanrooms.paginators.ListMembershipsPublisher publisher = client.listMembershipsPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.cleanrooms.paginators.ListMembershipsPublisher publisher = client.listMembershipsPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.cleanrooms.model.ListMembershipsResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.cleanrooms.model.ListMembershipsResponse response) { //... };
});
As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.
Note: If you prefer to have control on service calls, use the
listMemberships(software.amazon.awssdk.services.cleanrooms.model.ListMembershipsRequest) operation.
listMembershipsRequest - default ListMembershipsPublisher listMembershipsPaginator(Consumer<ListMembershipsRequest.Builder> listMembershipsRequest)
Lists all memberships resources within the caller's account.
This is a variant of
listMemberships(software.amazon.awssdk.services.cleanrooms.model.ListMembershipsRequest) operation. The
return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.cleanrooms.paginators.ListMembershipsPublisher publisher = client.listMembershipsPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.cleanrooms.paginators.ListMembershipsPublisher publisher = client.listMembershipsPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.cleanrooms.model.ListMembershipsResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.cleanrooms.model.ListMembershipsResponse response) { //... };
});
As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.
Note: If you prefer to have control on service calls, use the
listMemberships(software.amazon.awssdk.services.cleanrooms.model.ListMembershipsRequest) operation.
This is a convenience which creates an instance of the ListMembershipsRequest.Builder avoiding the need
to create one manually via ListMembershipsRequest.builder()
listMembershipsRequest - A Consumer that will call methods on
ListMembershipsRequest.Builder to create a
request.default CompletableFuture<ListProtectedQueriesResponse> listProtectedQueries(ListProtectedQueriesRequest listProtectedQueriesRequest)
Lists protected queries, sorted by the most recent query.
listProtectedQueriesRequest - default CompletableFuture<ListProtectedQueriesResponse> listProtectedQueries(Consumer<ListProtectedQueriesRequest.Builder> listProtectedQueriesRequest)
Lists protected queries, sorted by the most recent query.
This is a convenience which creates an instance of the ListProtectedQueriesRequest.Builder avoiding the
need to create one manually via ListProtectedQueriesRequest.builder()
listProtectedQueriesRequest - A Consumer that will call methods on
ListProtectedQueriesRequest.Builder to create a
request.default ListProtectedQueriesPublisher listProtectedQueriesPaginator(ListProtectedQueriesRequest listProtectedQueriesRequest)
Lists protected queries, sorted by the most recent query.
This is a variant of
listProtectedQueries(software.amazon.awssdk.services.cleanrooms.model.ListProtectedQueriesRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.cleanrooms.paginators.ListProtectedQueriesPublisher publisher = client.listProtectedQueriesPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.cleanrooms.paginators.ListProtectedQueriesPublisher publisher = client.listProtectedQueriesPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.cleanrooms.model.ListProtectedQueriesResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.cleanrooms.model.ListProtectedQueriesResponse response) { //... };
});
As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.
Note: If you prefer to have control on service calls, use the
listProtectedQueries(software.amazon.awssdk.services.cleanrooms.model.ListProtectedQueriesRequest)
operation.
listProtectedQueriesRequest - default ListProtectedQueriesPublisher listProtectedQueriesPaginator(Consumer<ListProtectedQueriesRequest.Builder> listProtectedQueriesRequest)
Lists protected queries, sorted by the most recent query.
This is a variant of
listProtectedQueries(software.amazon.awssdk.services.cleanrooms.model.ListProtectedQueriesRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.cleanrooms.paginators.ListProtectedQueriesPublisher publisher = client.listProtectedQueriesPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.cleanrooms.paginators.ListProtectedQueriesPublisher publisher = client.listProtectedQueriesPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.cleanrooms.model.ListProtectedQueriesResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.cleanrooms.model.ListProtectedQueriesResponse response) { //... };
});
As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.
Note: If you prefer to have control on service calls, use the
listProtectedQueries(software.amazon.awssdk.services.cleanrooms.model.ListProtectedQueriesRequest)
operation.
This is a convenience which creates an instance of the ListProtectedQueriesRequest.Builder avoiding the
need to create one manually via ListProtectedQueriesRequest.builder()
listProtectedQueriesRequest - A Consumer that will call methods on
ListProtectedQueriesRequest.Builder to create a
request.default CompletableFuture<ListSchemasResponse> listSchemas(ListSchemasRequest listSchemasRequest)
Lists the schemas for relations within a collaboration.
listSchemasRequest - default CompletableFuture<ListSchemasResponse> listSchemas(Consumer<ListSchemasRequest.Builder> listSchemasRequest)
Lists the schemas for relations within a collaboration.
This is a convenience which creates an instance of the ListSchemasRequest.Builder avoiding the need to
create one manually via ListSchemasRequest.builder()
listSchemasRequest - A Consumer that will call methods on
ListSchemasRequest.Builder to create a request.default ListSchemasPublisher listSchemasPaginator(ListSchemasRequest listSchemasRequest)
Lists the schemas for relations within a collaboration.
This is a variant of listSchemas(software.amazon.awssdk.services.cleanrooms.model.ListSchemasRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.cleanrooms.paginators.ListSchemasPublisher publisher = client.listSchemasPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.cleanrooms.paginators.ListSchemasPublisher publisher = client.listSchemasPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.cleanrooms.model.ListSchemasResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.cleanrooms.model.ListSchemasResponse response) { //... };
});
As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.
Note: If you prefer to have control on service calls, use the
listSchemas(software.amazon.awssdk.services.cleanrooms.model.ListSchemasRequest) operation.
listSchemasRequest - default ListSchemasPublisher listSchemasPaginator(Consumer<ListSchemasRequest.Builder> listSchemasRequest)
Lists the schemas for relations within a collaboration.
This is a variant of listSchemas(software.amazon.awssdk.services.cleanrooms.model.ListSchemasRequest)
operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
SDK will internally handle making service calls for you.
When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
failures only after you start streaming the data. The subscribe method should be called as a request to start
streaming data. For more info, see
Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe
method will result in a new Subscription i.e., a new contract to stream data from the
starting request.
The following are few ways to use the response class:
1) Using the subscribe helper method
software.amazon.awssdk.services.cleanrooms.paginators.ListSchemasPublisher publisher = client.listSchemasPaginator(request);
CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
future.get();
2) Using a custom subscriber
software.amazon.awssdk.services.cleanrooms.paginators.ListSchemasPublisher publisher = client.listSchemasPaginator(request);
publisher.subscribe(new Subscriber<software.amazon.awssdk.services.cleanrooms.model.ListSchemasResponse>() {
public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
public void onNext(software.amazon.awssdk.services.cleanrooms.model.ListSchemasResponse response) { //... };
});
As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.
Note: If you prefer to have control on service calls, use the
listSchemas(software.amazon.awssdk.services.cleanrooms.model.ListSchemasRequest) operation.
This is a convenience which creates an instance of the ListSchemasRequest.Builder avoiding the need to
create one manually via ListSchemasRequest.builder()
listSchemasRequest - A Consumer that will call methods on
ListSchemasRequest.Builder to create a request.default CompletableFuture<ListTagsForResourceResponse> listTagsForResource(ListTagsForResourceRequest listTagsForResourceRequest)
Lists all of the tags that have been added to a resource.
listTagsForResourceRequest - default CompletableFuture<ListTagsForResourceResponse> listTagsForResource(Consumer<ListTagsForResourceRequest.Builder> listTagsForResourceRequest)
Lists all of the tags that have been added to a resource.
This is a convenience which creates an instance of the ListTagsForResourceRequest.Builder avoiding the
need to create one manually via ListTagsForResourceRequest.builder()
listTagsForResourceRequest - A Consumer that will call methods on
ListTagsForResourceRequest.Builder to create a
request.default CompletableFuture<StartProtectedQueryResponse> startProtectedQuery(StartProtectedQueryRequest startProtectedQueryRequest)
Creates a protected query that is started by Clean Rooms .
startProtectedQueryRequest - default CompletableFuture<StartProtectedQueryResponse> startProtectedQuery(Consumer<StartProtectedQueryRequest.Builder> startProtectedQueryRequest)
Creates a protected query that is started by Clean Rooms .
This is a convenience which creates an instance of the StartProtectedQueryRequest.Builder avoiding the
need to create one manually via StartProtectedQueryRequest.builder()
startProtectedQueryRequest - A Consumer that will call methods on
StartProtectedQueryRequest.Builder to create a
request.default CompletableFuture<TagResourceResponse> tagResource(TagResourceRequest tagResourceRequest)
Tags a resource.
tagResourceRequest - default CompletableFuture<TagResourceResponse> tagResource(Consumer<TagResourceRequest.Builder> tagResourceRequest)
Tags a resource.
This is a convenience which creates an instance of the TagResourceRequest.Builder avoiding the need to
create one manually via TagResourceRequest.builder()
tagResourceRequest - A Consumer that will call methods on
TagResourceRequest.Builder to create a request.default CompletableFuture<UntagResourceResponse> untagResource(UntagResourceRequest untagResourceRequest)
Removes a tag or list of tags from a resource.
untagResourceRequest - default CompletableFuture<UntagResourceResponse> untagResource(Consumer<UntagResourceRequest.Builder> untagResourceRequest)
Removes a tag or list of tags from a resource.
This is a convenience which creates an instance of the UntagResourceRequest.Builder avoiding the need to
create one manually via UntagResourceRequest.builder()
untagResourceRequest - A Consumer that will call methods on
UntagResourceRequest.Builder to create a request.default CompletableFuture<UpdateAnalysisTemplateResponse> updateAnalysisTemplate(UpdateAnalysisTemplateRequest updateAnalysisTemplateRequest)
Updates the analysis template metadata.
updateAnalysisTemplateRequest - default CompletableFuture<UpdateAnalysisTemplateResponse> updateAnalysisTemplate(Consumer<UpdateAnalysisTemplateRequest.Builder> updateAnalysisTemplateRequest)
Updates the analysis template metadata.
This is a convenience which creates an instance of the UpdateAnalysisTemplateRequest.Builder avoiding the
need to create one manually via UpdateAnalysisTemplateRequest.builder()
updateAnalysisTemplateRequest - A Consumer that will call methods on
UpdateAnalysisTemplateRequest.Builder to create a
request.default CompletableFuture<UpdateCollaborationResponse> updateCollaboration(UpdateCollaborationRequest updateCollaborationRequest)
Updates collaboration metadata and can only be called by the collaboration owner.
updateCollaborationRequest - default CompletableFuture<UpdateCollaborationResponse> updateCollaboration(Consumer<UpdateCollaborationRequest.Builder> updateCollaborationRequest)
Updates collaboration metadata and can only be called by the collaboration owner.
This is a convenience which creates an instance of the UpdateCollaborationRequest.Builder avoiding the
need to create one manually via UpdateCollaborationRequest.builder()
updateCollaborationRequest - A Consumer that will call methods on
UpdateCollaborationRequest.Builder to create a
request.default CompletableFuture<UpdateConfiguredTableResponse> updateConfiguredTable(UpdateConfiguredTableRequest updateConfiguredTableRequest)
Updates a configured table.
updateConfiguredTableRequest - default CompletableFuture<UpdateConfiguredTableResponse> updateConfiguredTable(Consumer<UpdateConfiguredTableRequest.Builder> updateConfiguredTableRequest)
Updates a configured table.
This is a convenience which creates an instance of the UpdateConfiguredTableRequest.Builder avoiding the
need to create one manually via UpdateConfiguredTableRequest.builder()
updateConfiguredTableRequest - A Consumer that will call methods on
UpdateConfiguredTableRequest.Builder to create a
request.default CompletableFuture<UpdateConfiguredTableAnalysisRuleResponse> updateConfiguredTableAnalysisRule(UpdateConfiguredTableAnalysisRuleRequest updateConfiguredTableAnalysisRuleRequest)
Updates a configured table analysis rule.
updateConfiguredTableAnalysisRuleRequest - default CompletableFuture<UpdateConfiguredTableAnalysisRuleResponse> updateConfiguredTableAnalysisRule(Consumer<UpdateConfiguredTableAnalysisRuleRequest.Builder> updateConfiguredTableAnalysisRuleRequest)
Updates a configured table analysis rule.
This is a convenience which creates an instance of the UpdateConfiguredTableAnalysisRuleRequest.Builder
avoiding the need to create one manually via UpdateConfiguredTableAnalysisRuleRequest.builder()
updateConfiguredTableAnalysisRuleRequest - A Consumer that will call methods on
UpdateConfiguredTableAnalysisRuleRequest.Builder
to create a request.default CompletableFuture<UpdateConfiguredTableAssociationResponse> updateConfiguredTableAssociation(UpdateConfiguredTableAssociationRequest updateConfiguredTableAssociationRequest)
Updates a configured table association.
updateConfiguredTableAssociationRequest - default CompletableFuture<UpdateConfiguredTableAssociationResponse> updateConfiguredTableAssociation(Consumer<UpdateConfiguredTableAssociationRequest.Builder> updateConfiguredTableAssociationRequest)
Updates a configured table association.
This is a convenience which creates an instance of the UpdateConfiguredTableAssociationRequest.Builder
avoiding the need to create one manually via UpdateConfiguredTableAssociationRequest.builder()
updateConfiguredTableAssociationRequest - A Consumer that will call methods on
UpdateConfiguredTableAssociationRequest.Builder
to create a request.default CompletableFuture<UpdateMembershipResponse> updateMembership(UpdateMembershipRequest updateMembershipRequest)
Updates a membership.
updateMembershipRequest - default CompletableFuture<UpdateMembershipResponse> updateMembership(Consumer<UpdateMembershipRequest.Builder> updateMembershipRequest)
Updates a membership.
This is a convenience which creates an instance of the UpdateMembershipRequest.Builder avoiding the need
to create one manually via UpdateMembershipRequest.builder()
updateMembershipRequest - A Consumer that will call methods on
UpdateMembershipRequest.Builder to create a
request.default CompletableFuture<UpdateProtectedQueryResponse> updateProtectedQuery(UpdateProtectedQueryRequest updateProtectedQueryRequest)
Updates the processing of a currently running query.
updateProtectedQueryRequest - default CompletableFuture<UpdateProtectedQueryResponse> updateProtectedQuery(Consumer<UpdateProtectedQueryRequest.Builder> updateProtectedQueryRequest)
Updates the processing of a currently running query.
This is a convenience which creates an instance of the UpdateProtectedQueryRequest.Builder avoiding the
need to create one manually via UpdateProtectedQueryRequest.builder()
updateProtectedQueryRequest - A Consumer that will call methods on
UpdateProtectedQueryRequest.Builder to create a
request.default CleanRoomsServiceClientConfiguration serviceClientConfiguration()
serviceClientConfiguration in interface AwsClientserviceClientConfiguration in interface SdkClientstatic CleanRoomsAsyncClient create()
CleanRoomsAsyncClient with the region loaded from the
DefaultAwsRegionProviderChain and credentials loaded from the
DefaultCredentialsProvider.static CleanRoomsAsyncClientBuilder builder()
CleanRoomsAsyncClient.Copyright © 2023. All rights reserved.