// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
/// Paginator for [`DescribeAggregateComplianceByConfigRules`](crate::operation::DescribeAggregateComplianceByConfigRules)
pub struct DescribeAggregateComplianceByConfigRulesPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_aggregate_compliance_by_config_rules_input::Builder,
stop_on_duplicate_token: bool,
}
impl DescribeAggregateComplianceByConfigRulesPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_aggregate_compliance_by_config_rules_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::DescribeAggregateComplianceByConfigRulesOutput,
aws_smithy_http::result::SdkError<
crate::error::DescribeAggregateComplianceByConfigRulesError,
>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_describe_aggregate_compliance_by_config_rules_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`DescribeAggregateComplianceByConformancePacks`](crate::operation::DescribeAggregateComplianceByConformancePacks)
pub struct DescribeAggregateComplianceByConformancePacksPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_aggregate_compliance_by_conformance_packs_input::Builder,
stop_on_duplicate_token: bool,
}
impl DescribeAggregateComplianceByConformancePacksPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_aggregate_compliance_by_conformance_packs_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `aggregate_compliance_by_conformance_packs`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(
self,
) -> crate::paginator::DescribeAggregateComplianceByConformancePacksPaginatorItems {
crate::paginator::DescribeAggregateComplianceByConformancePacksPaginatorItems(self)
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::DescribeAggregateComplianceByConformancePacksOutput,
aws_smithy_http::result::SdkError<
crate::error::DescribeAggregateComplianceByConformancePacksError,
>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_describe_aggregate_compliance_by_conformance_packs_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`DescribeAggregationAuthorizations`](crate::operation::DescribeAggregationAuthorizations)
pub struct DescribeAggregationAuthorizationsPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_aggregation_authorizations_input::Builder,
stop_on_duplicate_token: bool,
}
impl DescribeAggregationAuthorizationsPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_aggregation_authorizations_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `aggregation_authorizations`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::DescribeAggregationAuthorizationsPaginatorItems {
crate::paginator::DescribeAggregationAuthorizationsPaginatorItems(self)
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::DescribeAggregationAuthorizationsOutput,
aws_smithy_http::result::SdkError<crate::error::DescribeAggregationAuthorizationsError>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_describe_aggregation_authorizations_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`DescribeComplianceByConfigRule`](crate::operation::DescribeComplianceByConfigRule)
pub struct DescribeComplianceByConfigRulePaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_compliance_by_config_rule_input::Builder,
stop_on_duplicate_token: bool,
}
impl DescribeComplianceByConfigRulePaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_compliance_by_config_rule_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `compliance_by_config_rules`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::DescribeComplianceByConfigRulePaginatorItems {
crate::paginator::DescribeComplianceByConfigRulePaginatorItems(self)
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::DescribeComplianceByConfigRuleOutput,
aws_smithy_http::result::SdkError<crate::error::DescribeComplianceByConfigRuleError>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_describe_compliance_by_config_rule_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`DescribeComplianceByResource`](crate::operation::DescribeComplianceByResource)
pub struct DescribeComplianceByResourcePaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_compliance_by_resource_input::Builder,
stop_on_duplicate_token: bool,
}
impl DescribeComplianceByResourcePaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_compliance_by_resource_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `compliance_by_resources`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::DescribeComplianceByResourcePaginatorItems {
crate::paginator::DescribeComplianceByResourcePaginatorItems(self)
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::DescribeComplianceByResourceOutput,
aws_smithy_http::result::SdkError<crate::error::DescribeComplianceByResourceError>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_describe_compliance_by_resource_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`DescribeConfigRuleEvaluationStatus`](crate::operation::DescribeConfigRuleEvaluationStatus)
pub struct DescribeConfigRuleEvaluationStatusPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_config_rule_evaluation_status_input::Builder,
stop_on_duplicate_token: bool,
}
impl DescribeConfigRuleEvaluationStatusPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_config_rule_evaluation_status_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `config_rules_evaluation_status`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::DescribeConfigRuleEvaluationStatusPaginatorItems {
crate::paginator::DescribeConfigRuleEvaluationStatusPaginatorItems(self)
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::DescribeConfigRuleEvaluationStatusOutput,
aws_smithy_http::result::SdkError<
crate::error::DescribeConfigRuleEvaluationStatusError,
>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_describe_config_rule_evaluation_status_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`DescribeConfigRules`](crate::operation::DescribeConfigRules)
pub struct DescribeConfigRulesPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_config_rules_input::Builder,
stop_on_duplicate_token: bool,
}
impl DescribeConfigRulesPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_config_rules_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `config_rules`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::DescribeConfigRulesPaginatorItems {
crate::paginator::DescribeConfigRulesPaginatorItems(self)
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::DescribeConfigRulesOutput,
aws_smithy_http::result::SdkError<crate::error::DescribeConfigRulesError>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_describe_config_rules_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`DescribeConfigurationAggregators`](crate::operation::DescribeConfigurationAggregators)
pub struct DescribeConfigurationAggregatorsPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_configuration_aggregators_input::Builder,
stop_on_duplicate_token: bool,
}
impl DescribeConfigurationAggregatorsPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_configuration_aggregators_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `configuration_aggregators`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::DescribeConfigurationAggregatorsPaginatorItems {
crate::paginator::DescribeConfigurationAggregatorsPaginatorItems(self)
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::DescribeConfigurationAggregatorsOutput,
aws_smithy_http::result::SdkError<crate::error::DescribeConfigurationAggregatorsError>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_describe_configuration_aggregators_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`DescribeConfigurationAggregatorSourcesStatus`](crate::operation::DescribeConfigurationAggregatorSourcesStatus)
pub struct DescribeConfigurationAggregatorSourcesStatusPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_configuration_aggregator_sources_status_input::Builder,
stop_on_duplicate_token: bool,
}
impl DescribeConfigurationAggregatorSourcesStatusPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_configuration_aggregator_sources_status_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `aggregated_source_status_list`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(
self,
) -> crate::paginator::DescribeConfigurationAggregatorSourcesStatusPaginatorItems {
crate::paginator::DescribeConfigurationAggregatorSourcesStatusPaginatorItems(self)
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::DescribeConfigurationAggregatorSourcesStatusOutput,
aws_smithy_http::result::SdkError<
crate::error::DescribeConfigurationAggregatorSourcesStatusError,
>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_describe_configuration_aggregator_sources_status_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`DescribeConformancePackCompliance`](crate::operation::DescribeConformancePackCompliance)
pub struct DescribeConformancePackCompliancePaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_conformance_pack_compliance_input::Builder,
stop_on_duplicate_token: bool,
}
impl DescribeConformancePackCompliancePaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_conformance_pack_compliance_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::DescribeConformancePackComplianceOutput,
aws_smithy_http::result::SdkError<crate::error::DescribeConformancePackComplianceError>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_describe_conformance_pack_compliance_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`DescribeConformancePacks`](crate::operation::DescribeConformancePacks)
pub struct DescribeConformancePacksPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_conformance_packs_input::Builder,
stop_on_duplicate_token: bool,
}
impl DescribeConformancePacksPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_conformance_packs_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `conformance_pack_details`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::DescribeConformancePacksPaginatorItems {
crate::paginator::DescribeConformancePacksPaginatorItems(self)
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::DescribeConformancePacksOutput,
aws_smithy_http::result::SdkError<crate::error::DescribeConformancePacksError>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_describe_conformance_packs_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`DescribeConformancePackStatus`](crate::operation::DescribeConformancePackStatus)
pub struct DescribeConformancePackStatusPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_conformance_pack_status_input::Builder,
stop_on_duplicate_token: bool,
}
impl DescribeConformancePackStatusPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_conformance_pack_status_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `conformance_pack_status_details`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::DescribeConformancePackStatusPaginatorItems {
crate::paginator::DescribeConformancePackStatusPaginatorItems(self)
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::DescribeConformancePackStatusOutput,
aws_smithy_http::result::SdkError<crate::error::DescribeConformancePackStatusError>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_describe_conformance_pack_status_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`DescribeOrganizationConfigRules`](crate::operation::DescribeOrganizationConfigRules)
pub struct DescribeOrganizationConfigRulesPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_organization_config_rules_input::Builder,
stop_on_duplicate_token: bool,
}
impl DescribeOrganizationConfigRulesPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_organization_config_rules_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `organization_config_rules`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::DescribeOrganizationConfigRulesPaginatorItems {
crate::paginator::DescribeOrganizationConfigRulesPaginatorItems(self)
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::DescribeOrganizationConfigRulesOutput,
aws_smithy_http::result::SdkError<crate::error::DescribeOrganizationConfigRulesError>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_describe_organization_config_rules_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`DescribeOrganizationConfigRuleStatuses`](crate::operation::DescribeOrganizationConfigRuleStatuses)
pub struct DescribeOrganizationConfigRuleStatusesPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_organization_config_rule_statuses_input::Builder,
stop_on_duplicate_token: bool,
}
impl DescribeOrganizationConfigRuleStatusesPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_organization_config_rule_statuses_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `organization_config_rule_statuses`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::DescribeOrganizationConfigRuleStatusesPaginatorItems {
crate::paginator::DescribeOrganizationConfigRuleStatusesPaginatorItems(self)
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::DescribeOrganizationConfigRuleStatusesOutput,
aws_smithy_http::result::SdkError<
crate::error::DescribeOrganizationConfigRuleStatusesError,
>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_describe_organization_config_rule_statuses_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`DescribeOrganizationConformancePacks`](crate::operation::DescribeOrganizationConformancePacks)
pub struct DescribeOrganizationConformancePacksPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_organization_conformance_packs_input::Builder,
stop_on_duplicate_token: bool,
}
impl DescribeOrganizationConformancePacksPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_organization_conformance_packs_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `organization_conformance_packs`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::DescribeOrganizationConformancePacksPaginatorItems {
crate::paginator::DescribeOrganizationConformancePacksPaginatorItems(self)
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::DescribeOrganizationConformancePacksOutput,
aws_smithy_http::result::SdkError<
crate::error::DescribeOrganizationConformancePacksError,
>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_describe_organization_conformance_packs_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`DescribeOrganizationConformancePackStatuses`](crate::operation::DescribeOrganizationConformancePackStatuses)
pub struct DescribeOrganizationConformancePackStatusesPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_organization_conformance_pack_statuses_input::Builder,
stop_on_duplicate_token: bool,
}
impl DescribeOrganizationConformancePackStatusesPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_organization_conformance_pack_statuses_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `organization_conformance_pack_statuses`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(
self,
) -> crate::paginator::DescribeOrganizationConformancePackStatusesPaginatorItems {
crate::paginator::DescribeOrganizationConformancePackStatusesPaginatorItems(self)
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::DescribeOrganizationConformancePackStatusesOutput,
aws_smithy_http::result::SdkError<
crate::error::DescribeOrganizationConformancePackStatusesError,
>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_describe_organization_conformance_pack_statuses_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`DescribePendingAggregationRequests`](crate::operation::DescribePendingAggregationRequests)
pub struct DescribePendingAggregationRequestsPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_pending_aggregation_requests_input::Builder,
stop_on_duplicate_token: bool,
}
impl DescribePendingAggregationRequestsPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_pending_aggregation_requests_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `pending_aggregation_requests`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::DescribePendingAggregationRequestsPaginatorItems {
crate::paginator::DescribePendingAggregationRequestsPaginatorItems(self)
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::DescribePendingAggregationRequestsOutput,
aws_smithy_http::result::SdkError<
crate::error::DescribePendingAggregationRequestsError,
>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_describe_pending_aggregation_requests_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`DescribeRemediationExceptions`](crate::operation::DescribeRemediationExceptions)
pub struct DescribeRemediationExceptionsPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_remediation_exceptions_input::Builder,
stop_on_duplicate_token: bool,
}
impl DescribeRemediationExceptionsPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_remediation_exceptions_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::DescribeRemediationExceptionsOutput,
aws_smithy_http::result::SdkError<crate::error::DescribeRemediationExceptionsError>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_describe_remediation_exceptions_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`DescribeRemediationExecutionStatus`](crate::operation::DescribeRemediationExecutionStatus)
pub struct DescribeRemediationExecutionStatusPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_remediation_execution_status_input::Builder,
stop_on_duplicate_token: bool,
}
impl DescribeRemediationExecutionStatusPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_remediation_execution_status_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `remediation_execution_statuses`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::DescribeRemediationExecutionStatusPaginatorItems {
crate::paginator::DescribeRemediationExecutionStatusPaginatorItems(self)
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::DescribeRemediationExecutionStatusOutput,
aws_smithy_http::result::SdkError<
crate::error::DescribeRemediationExecutionStatusError,
>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_describe_remediation_execution_status_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`DescribeRetentionConfigurations`](crate::operation::DescribeRetentionConfigurations)
pub struct DescribeRetentionConfigurationsPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_retention_configurations_input::Builder,
stop_on_duplicate_token: bool,
}
impl DescribeRetentionConfigurationsPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_retention_configurations_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `retention_configurations`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::DescribeRetentionConfigurationsPaginatorItems {
crate::paginator::DescribeRetentionConfigurationsPaginatorItems(self)
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::DescribeRetentionConfigurationsOutput,
aws_smithy_http::result::SdkError<crate::error::DescribeRetentionConfigurationsError>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_describe_retention_configurations_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`GetAggregateComplianceDetailsByConfigRule`](crate::operation::GetAggregateComplianceDetailsByConfigRule)
pub struct GetAggregateComplianceDetailsByConfigRulePaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_aggregate_compliance_details_by_config_rule_input::Builder,
stop_on_duplicate_token: bool,
}
impl GetAggregateComplianceDetailsByConfigRulePaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_aggregate_compliance_details_by_config_rule_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `aggregate_evaluation_results`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(
self,
) -> crate::paginator::GetAggregateComplianceDetailsByConfigRulePaginatorItems {
crate::paginator::GetAggregateComplianceDetailsByConfigRulePaginatorItems(self)
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::GetAggregateComplianceDetailsByConfigRuleOutput,
aws_smithy_http::result::SdkError<
crate::error::GetAggregateComplianceDetailsByConfigRuleError,
>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_get_aggregate_compliance_details_by_config_rule_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`GetAggregateConfigRuleComplianceSummary`](crate::operation::GetAggregateConfigRuleComplianceSummary)
pub struct GetAggregateConfigRuleComplianceSummaryPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_aggregate_config_rule_compliance_summary_input::Builder,
stop_on_duplicate_token: bool,
}
impl GetAggregateConfigRuleComplianceSummaryPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_aggregate_config_rule_compliance_summary_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::GetAggregateConfigRuleComplianceSummaryOutput,
aws_smithy_http::result::SdkError<
crate::error::GetAggregateConfigRuleComplianceSummaryError,
>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_get_aggregate_config_rule_compliance_summary_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`GetAggregateConformancePackComplianceSummary`](crate::operation::GetAggregateConformancePackComplianceSummary)
pub struct GetAggregateConformancePackComplianceSummaryPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_aggregate_conformance_pack_compliance_summary_input::Builder,
stop_on_duplicate_token: bool,
}
impl GetAggregateConformancePackComplianceSummaryPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_aggregate_conformance_pack_compliance_summary_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::GetAggregateConformancePackComplianceSummaryOutput,
aws_smithy_http::result::SdkError<
crate::error::GetAggregateConformancePackComplianceSummaryError,
>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_get_aggregate_conformance_pack_compliance_summary_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`GetAggregateDiscoveredResourceCounts`](crate::operation::GetAggregateDiscoveredResourceCounts)
pub struct GetAggregateDiscoveredResourceCountsPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_aggregate_discovered_resource_counts_input::Builder,
stop_on_duplicate_token: bool,
}
impl GetAggregateDiscoveredResourceCountsPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_aggregate_discovered_resource_counts_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::GetAggregateDiscoveredResourceCountsOutput,
aws_smithy_http::result::SdkError<
crate::error::GetAggregateDiscoveredResourceCountsError,
>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_get_aggregate_discovered_resource_counts_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`GetComplianceDetailsByConfigRule`](crate::operation::GetComplianceDetailsByConfigRule)
pub struct GetComplianceDetailsByConfigRulePaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_compliance_details_by_config_rule_input::Builder,
stop_on_duplicate_token: bool,
}
impl GetComplianceDetailsByConfigRulePaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_compliance_details_by_config_rule_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `evaluation_results`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::GetComplianceDetailsByConfigRulePaginatorItems {
crate::paginator::GetComplianceDetailsByConfigRulePaginatorItems(self)
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::GetComplianceDetailsByConfigRuleOutput,
aws_smithy_http::result::SdkError<crate::error::GetComplianceDetailsByConfigRuleError>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_get_compliance_details_by_config_rule_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`GetComplianceDetailsByResource`](crate::operation::GetComplianceDetailsByResource)
pub struct GetComplianceDetailsByResourcePaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_compliance_details_by_resource_input::Builder,
stop_on_duplicate_token: bool,
}
impl GetComplianceDetailsByResourcePaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_compliance_details_by_resource_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `evaluation_results`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::GetComplianceDetailsByResourcePaginatorItems {
crate::paginator::GetComplianceDetailsByResourcePaginatorItems(self)
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::GetComplianceDetailsByResourceOutput,
aws_smithy_http::result::SdkError<crate::error::GetComplianceDetailsByResourceError>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_get_compliance_details_by_resource_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`GetConformancePackComplianceDetails`](crate::operation::GetConformancePackComplianceDetails)
pub struct GetConformancePackComplianceDetailsPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_conformance_pack_compliance_details_input::Builder,
stop_on_duplicate_token: bool,
}
impl GetConformancePackComplianceDetailsPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_conformance_pack_compliance_details_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::GetConformancePackComplianceDetailsOutput,
aws_smithy_http::result::SdkError<
crate::error::GetConformancePackComplianceDetailsError,
>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_get_conformance_pack_compliance_details_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`GetConformancePackComplianceSummary`](crate::operation::GetConformancePackComplianceSummary)
pub struct GetConformancePackComplianceSummaryPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_conformance_pack_compliance_summary_input::Builder,
stop_on_duplicate_token: bool,
}
impl GetConformancePackComplianceSummaryPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_conformance_pack_compliance_summary_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `conformance_pack_compliance_summary_list`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::GetConformancePackComplianceSummaryPaginatorItems {
crate::paginator::GetConformancePackComplianceSummaryPaginatorItems(self)
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::GetConformancePackComplianceSummaryOutput,
aws_smithy_http::result::SdkError<
crate::error::GetConformancePackComplianceSummaryError,
>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_get_conformance_pack_compliance_summary_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`GetDiscoveredResourceCounts`](crate::operation::GetDiscoveredResourceCounts)
pub struct GetDiscoveredResourceCountsPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_discovered_resource_counts_input::Builder,
stop_on_duplicate_token: bool,
}
impl GetDiscoveredResourceCountsPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_discovered_resource_counts_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::GetDiscoveredResourceCountsOutput,
aws_smithy_http::result::SdkError<crate::error::GetDiscoveredResourceCountsError>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_get_discovered_resource_counts_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`GetOrganizationConfigRuleDetailedStatus`](crate::operation::GetOrganizationConfigRuleDetailedStatus)
pub struct GetOrganizationConfigRuleDetailedStatusPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_organization_config_rule_detailed_status_input::Builder,
stop_on_duplicate_token: bool,
}
impl GetOrganizationConfigRuleDetailedStatusPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_organization_config_rule_detailed_status_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `organization_config_rule_detailed_status`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::GetOrganizationConfigRuleDetailedStatusPaginatorItems {
crate::paginator::GetOrganizationConfigRuleDetailedStatusPaginatorItems(self)
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::GetOrganizationConfigRuleDetailedStatusOutput,
aws_smithy_http::result::SdkError<
crate::error::GetOrganizationConfigRuleDetailedStatusError,
>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_get_organization_config_rule_detailed_status_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`GetOrganizationConformancePackDetailedStatus`](crate::operation::GetOrganizationConformancePackDetailedStatus)
pub struct GetOrganizationConformancePackDetailedStatusPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_organization_conformance_pack_detailed_status_input::Builder,
stop_on_duplicate_token: bool,
}
impl GetOrganizationConformancePackDetailedStatusPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_organization_conformance_pack_detailed_status_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `organization_conformance_pack_detailed_statuses`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(
self,
) -> crate::paginator::GetOrganizationConformancePackDetailedStatusPaginatorItems {
crate::paginator::GetOrganizationConformancePackDetailedStatusPaginatorItems(self)
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::GetOrganizationConformancePackDetailedStatusOutput,
aws_smithy_http::result::SdkError<
crate::error::GetOrganizationConformancePackDetailedStatusError,
>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_get_organization_conformance_pack_detailed_status_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`GetResourceConfigHistory`](crate::operation::GetResourceConfigHistory)
pub struct GetResourceConfigHistoryPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_resource_config_history_input::Builder,
stop_on_duplicate_token: bool,
}
impl GetResourceConfigHistoryPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_resource_config_history_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `configuration_items`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::GetResourceConfigHistoryPaginatorItems {
crate::paginator::GetResourceConfigHistoryPaginatorItems(self)
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::GetResourceConfigHistoryOutput,
aws_smithy_http::result::SdkError<crate::error::GetResourceConfigHistoryError>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_get_resource_config_history_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`ListAggregateDiscoveredResources`](crate::operation::ListAggregateDiscoveredResources)
pub struct ListAggregateDiscoveredResourcesPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_aggregate_discovered_resources_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListAggregateDiscoveredResourcesPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_aggregate_discovered_resources_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `resource_identifiers`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListAggregateDiscoveredResourcesPaginatorItems {
crate::paginator::ListAggregateDiscoveredResourcesPaginatorItems(self)
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::ListAggregateDiscoveredResourcesOutput,
aws_smithy_http::result::SdkError<crate::error::ListAggregateDiscoveredResourcesError>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_list_aggregate_discovered_resources_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`ListConformancePackComplianceScores`](crate::operation::ListConformancePackComplianceScores)
pub struct ListConformancePackComplianceScoresPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_conformance_pack_compliance_scores_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListConformancePackComplianceScoresPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_conformance_pack_compliance_scores_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::ListConformancePackComplianceScoresOutput,
aws_smithy_http::result::SdkError<
crate::error::ListConformancePackComplianceScoresError,
>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_list_conformance_pack_compliance_scores_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`ListDiscoveredResources`](crate::operation::ListDiscoveredResources)
pub struct ListDiscoveredResourcesPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_discovered_resources_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListDiscoveredResourcesPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_discovered_resources_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `resource_identifiers`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListDiscoveredResourcesPaginatorItems {
crate::paginator::ListDiscoveredResourcesPaginatorItems(self)
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::ListDiscoveredResourcesOutput,
aws_smithy_http::result::SdkError<crate::error::ListDiscoveredResourcesError>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_list_discovered_resources_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`ListResourceEvaluations`](crate::operation::ListResourceEvaluations)
pub struct ListResourceEvaluationsPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_resource_evaluations_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListResourceEvaluationsPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_resource_evaluations_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `resource_evaluations`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListResourceEvaluationsPaginatorItems {
crate::paginator::ListResourceEvaluationsPaginatorItems(self)
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::ListResourceEvaluationsOutput,
aws_smithy_http::result::SdkError<crate::error::ListResourceEvaluationsError>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_list_resource_evaluations_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`ListStoredQueries`](crate::operation::ListStoredQueries)
pub struct ListStoredQueriesPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_stored_queries_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListStoredQueriesPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_stored_queries_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `max_results`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.max_results = Some(limit);
self
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::ListStoredQueriesOutput,
aws_smithy_http::result::SdkError<crate::error::ListStoredQueriesError>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_list_stored_queries_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`ListTagsForResource`](crate::operation::ListTagsForResource)
pub struct ListTagsForResourcePaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_tags_for_resource_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListTagsForResourcePaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_tags_for_resource_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `tags`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListTagsForResourcePaginatorItems {
crate::paginator::ListTagsForResourcePaginatorItems(self)
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::ListTagsForResourceOutput,
aws_smithy_http::result::SdkError<crate::error::ListTagsForResourceError>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_list_tags_for_resource_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`SelectAggregateResourceConfig`](crate::operation::SelectAggregateResourceConfig)
pub struct SelectAggregateResourceConfigPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::select_aggregate_resource_config_input::Builder,
stop_on_duplicate_token: bool,
}
impl SelectAggregateResourceConfigPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::select_aggregate_resource_config_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `results`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::SelectAggregateResourceConfigPaginatorItems {
crate::paginator::SelectAggregateResourceConfigPaginatorItems(self)
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::SelectAggregateResourceConfigOutput,
aws_smithy_http::result::SdkError<crate::error::SelectAggregateResourceConfigError>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_select_aggregate_resource_config_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`SelectResourceConfig`](crate::operation::SelectResourceConfig)
pub struct SelectResourceConfigPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::select_resource_config_input::Builder,
stop_on_duplicate_token: bool,
}
impl SelectResourceConfigPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::select_resource_config_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `limit`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.limit = Some(limit);
self
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `results`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::SelectResourceConfigPaginatorItems {
crate::paginator::SelectResourceConfigPaginatorItems(self)
}
/// Stop paginating when the service returns the same pagination token twice in a row.
///
/// Defaults to true.
///
/// For certain operations, it may be useful to continue on duplicate token. For example,
/// if an operation is for tailing a log file in real-time, then continuing may be desired.
/// This option can be set to `false` to accommodate these use cases.
pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
self.stop_on_duplicate_token = stop_on_duplicate_token;
self
}
/// Create the pagination stream
///
/// _Note:_ No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next)).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::output::SelectResourceConfigOutput,
aws_smithy_http::result::SdkError<crate::error::SelectResourceConfigError>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_select_resource_config_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Flattened paginator for `DescribeAggregateComplianceByConformancePacksPaginator`
///
/// This is created with [`.items()`](DescribeAggregateComplianceByConformancePacksPaginator::items)
pub struct DescribeAggregateComplianceByConformancePacksPaginatorItems(
DescribeAggregateComplianceByConformancePacksPaginator,
);
impl DescribeAggregateComplianceByConformancePacksPaginatorItems {
/// Create the pagination stream
///
/// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
///
/// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::model::AggregateComplianceByConformancePack,
aws_smithy_http::result::SdkError<
crate::error::DescribeAggregateComplianceByConformancePacksError,
>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_describe_aggregate_compliance_by_conformance_packs_output_aggregate_compliance_by_conformance_packs(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `DescribeAggregationAuthorizationsPaginator`
///
/// This is created with [`.items()`](DescribeAggregationAuthorizationsPaginator::items)
pub struct DescribeAggregationAuthorizationsPaginatorItems(
DescribeAggregationAuthorizationsPaginator,
);
impl DescribeAggregationAuthorizationsPaginatorItems {
/// Create the pagination stream
///
/// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
///
/// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::model::AggregationAuthorization,
aws_smithy_http::result::SdkError<crate::error::DescribeAggregationAuthorizationsError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_describe_aggregation_authorizations_output_aggregation_authorizations(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `DescribeComplianceByConfigRulePaginator`
///
/// This is created with [`.items()`](DescribeComplianceByConfigRulePaginator::items)
pub struct DescribeComplianceByConfigRulePaginatorItems(DescribeComplianceByConfigRulePaginator);
impl DescribeComplianceByConfigRulePaginatorItems {
/// Create the pagination stream
///
/// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
///
/// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::model::ComplianceByConfigRule,
aws_smithy_http::result::SdkError<crate::error::DescribeComplianceByConfigRuleError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_describe_compliance_by_config_rule_output_compliance_by_config_rules(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `DescribeComplianceByResourcePaginator`
///
/// This is created with [`.items()`](DescribeComplianceByResourcePaginator::items)
pub struct DescribeComplianceByResourcePaginatorItems(DescribeComplianceByResourcePaginator);
impl DescribeComplianceByResourcePaginatorItems {
/// Create the pagination stream
///
/// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
///
/// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::model::ComplianceByResource,
aws_smithy_http::result::SdkError<crate::error::DescribeComplianceByResourceError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_describe_compliance_by_resource_output_compliance_by_resources(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `DescribeConfigRuleEvaluationStatusPaginator`
///
/// This is created with [`.items()`](DescribeConfigRuleEvaluationStatusPaginator::items)
pub struct DescribeConfigRuleEvaluationStatusPaginatorItems(
DescribeConfigRuleEvaluationStatusPaginator,
);
impl DescribeConfigRuleEvaluationStatusPaginatorItems {
/// Create the pagination stream
///
/// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
///
/// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::model::ConfigRuleEvaluationStatus,
aws_smithy_http::result::SdkError<
crate::error::DescribeConfigRuleEvaluationStatusError,
>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_describe_config_rule_evaluation_status_output_config_rules_evaluation_status(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `DescribeConfigRulesPaginator`
///
/// This is created with [`.items()`](DescribeConfigRulesPaginator::items)
pub struct DescribeConfigRulesPaginatorItems(DescribeConfigRulesPaginator);
impl DescribeConfigRulesPaginatorItems {
/// Create the pagination stream
///
/// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
///
/// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::model::ConfigRule,
aws_smithy_http::result::SdkError<crate::error::DescribeConfigRulesError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| {
crate::lens::lens_structure_crate_output_describe_config_rules_output_config_rules(page)
.unwrap_or_default()
.into_iter()
})
}
}
/// Flattened paginator for `DescribeConfigurationAggregatorsPaginator`
///
/// This is created with [`.items()`](DescribeConfigurationAggregatorsPaginator::items)
pub struct DescribeConfigurationAggregatorsPaginatorItems(
DescribeConfigurationAggregatorsPaginator,
);
impl DescribeConfigurationAggregatorsPaginatorItems {
/// Create the pagination stream
///
/// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
///
/// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::model::ConfigurationAggregator,
aws_smithy_http::result::SdkError<crate::error::DescribeConfigurationAggregatorsError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_describe_configuration_aggregators_output_configuration_aggregators(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `DescribeConfigurationAggregatorSourcesStatusPaginator`
///
/// This is created with [`.items()`](DescribeConfigurationAggregatorSourcesStatusPaginator::items)
pub struct DescribeConfigurationAggregatorSourcesStatusPaginatorItems(
DescribeConfigurationAggregatorSourcesStatusPaginator,
);
impl DescribeConfigurationAggregatorSourcesStatusPaginatorItems {
/// Create the pagination stream
///
/// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
///
/// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::model::AggregatedSourceStatus,
aws_smithy_http::result::SdkError<
crate::error::DescribeConfigurationAggregatorSourcesStatusError,
>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_describe_configuration_aggregator_sources_status_output_aggregated_source_status_list(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `DescribeConformancePacksPaginator`
///
/// This is created with [`.items()`](DescribeConformancePacksPaginator::items)
pub struct DescribeConformancePacksPaginatorItems(DescribeConformancePacksPaginator);
impl DescribeConformancePacksPaginatorItems {
/// Create the pagination stream
///
/// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
///
/// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::model::ConformancePackDetail,
aws_smithy_http::result::SdkError<crate::error::DescribeConformancePacksError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_describe_conformance_packs_output_conformance_pack_details(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `DescribeConformancePackStatusPaginator`
///
/// This is created with [`.items()`](DescribeConformancePackStatusPaginator::items)
pub struct DescribeConformancePackStatusPaginatorItems(DescribeConformancePackStatusPaginator);
impl DescribeConformancePackStatusPaginatorItems {
/// Create the pagination stream
///
/// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
///
/// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::model::ConformancePackStatusDetail,
aws_smithy_http::result::SdkError<crate::error::DescribeConformancePackStatusError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_describe_conformance_pack_status_output_conformance_pack_status_details(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `DescribeOrganizationConfigRulesPaginator`
///
/// This is created with [`.items()`](DescribeOrganizationConfigRulesPaginator::items)
pub struct DescribeOrganizationConfigRulesPaginatorItems(DescribeOrganizationConfigRulesPaginator);
impl DescribeOrganizationConfigRulesPaginatorItems {
/// Create the pagination stream
///
/// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
///
/// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::model::OrganizationConfigRule,
aws_smithy_http::result::SdkError<crate::error::DescribeOrganizationConfigRulesError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_describe_organization_config_rules_output_organization_config_rules(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `DescribeOrganizationConfigRuleStatusesPaginator`
///
/// This is created with [`.items()`](DescribeOrganizationConfigRuleStatusesPaginator::items)
pub struct DescribeOrganizationConfigRuleStatusesPaginatorItems(
DescribeOrganizationConfigRuleStatusesPaginator,
);
impl DescribeOrganizationConfigRuleStatusesPaginatorItems {
/// Create the pagination stream
///
/// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
///
/// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::model::OrganizationConfigRuleStatus,
aws_smithy_http::result::SdkError<
crate::error::DescribeOrganizationConfigRuleStatusesError,
>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_describe_organization_config_rule_statuses_output_organization_config_rule_statuses(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `DescribeOrganizationConformancePacksPaginator`
///
/// This is created with [`.items()`](DescribeOrganizationConformancePacksPaginator::items)
pub struct DescribeOrganizationConformancePacksPaginatorItems(
DescribeOrganizationConformancePacksPaginator,
);
impl DescribeOrganizationConformancePacksPaginatorItems {
/// Create the pagination stream
///
/// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
///
/// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::model::OrganizationConformancePack,
aws_smithy_http::result::SdkError<
crate::error::DescribeOrganizationConformancePacksError,
>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_describe_organization_conformance_packs_output_organization_conformance_packs(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `DescribeOrganizationConformancePackStatusesPaginator`
///
/// This is created with [`.items()`](DescribeOrganizationConformancePackStatusesPaginator::items)
pub struct DescribeOrganizationConformancePackStatusesPaginatorItems(
DescribeOrganizationConformancePackStatusesPaginator,
);
impl DescribeOrganizationConformancePackStatusesPaginatorItems {
/// Create the pagination stream
///
/// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
///
/// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::model::OrganizationConformancePackStatus,
aws_smithy_http::result::SdkError<
crate::error::DescribeOrganizationConformancePackStatusesError,
>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_describe_organization_conformance_pack_statuses_output_organization_conformance_pack_statuses(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `DescribePendingAggregationRequestsPaginator`
///
/// This is created with [`.items()`](DescribePendingAggregationRequestsPaginator::items)
pub struct DescribePendingAggregationRequestsPaginatorItems(
DescribePendingAggregationRequestsPaginator,
);
impl DescribePendingAggregationRequestsPaginatorItems {
/// Create the pagination stream
///
/// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
///
/// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::model::PendingAggregationRequest,
aws_smithy_http::result::SdkError<
crate::error::DescribePendingAggregationRequestsError,
>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_describe_pending_aggregation_requests_output_pending_aggregation_requests(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `DescribeRemediationExecutionStatusPaginator`
///
/// This is created with [`.items()`](DescribeRemediationExecutionStatusPaginator::items)
pub struct DescribeRemediationExecutionStatusPaginatorItems(
DescribeRemediationExecutionStatusPaginator,
);
impl DescribeRemediationExecutionStatusPaginatorItems {
/// Create the pagination stream
///
/// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
///
/// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::model::RemediationExecutionStatus,
aws_smithy_http::result::SdkError<
crate::error::DescribeRemediationExecutionStatusError,
>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_describe_remediation_execution_status_output_remediation_execution_statuses(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `DescribeRetentionConfigurationsPaginator`
///
/// This is created with [`.items()`](DescribeRetentionConfigurationsPaginator::items)
pub struct DescribeRetentionConfigurationsPaginatorItems(DescribeRetentionConfigurationsPaginator);
impl DescribeRetentionConfigurationsPaginatorItems {
/// Create the pagination stream
///
/// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
///
/// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::model::RetentionConfiguration,
aws_smithy_http::result::SdkError<crate::error::DescribeRetentionConfigurationsError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_describe_retention_configurations_output_retention_configurations(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `GetAggregateComplianceDetailsByConfigRulePaginator`
///
/// This is created with [`.items()`](GetAggregateComplianceDetailsByConfigRulePaginator::items)
pub struct GetAggregateComplianceDetailsByConfigRulePaginatorItems(
GetAggregateComplianceDetailsByConfigRulePaginator,
);
impl GetAggregateComplianceDetailsByConfigRulePaginatorItems {
/// Create the pagination stream
///
/// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
///
/// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::model::AggregateEvaluationResult,
aws_smithy_http::result::SdkError<
crate::error::GetAggregateComplianceDetailsByConfigRuleError,
>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_get_aggregate_compliance_details_by_config_rule_output_aggregate_evaluation_results(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `GetComplianceDetailsByConfigRulePaginator`
///
/// This is created with [`.items()`](GetComplianceDetailsByConfigRulePaginator::items)
pub struct GetComplianceDetailsByConfigRulePaginatorItems(
GetComplianceDetailsByConfigRulePaginator,
);
impl GetComplianceDetailsByConfigRulePaginatorItems {
/// Create the pagination stream
///
/// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
///
/// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::model::EvaluationResult,
aws_smithy_http::result::SdkError<crate::error::GetComplianceDetailsByConfigRuleError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_get_compliance_details_by_config_rule_output_evaluation_results(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `GetComplianceDetailsByResourcePaginator`
///
/// This is created with [`.items()`](GetComplianceDetailsByResourcePaginator::items)
pub struct GetComplianceDetailsByResourcePaginatorItems(GetComplianceDetailsByResourcePaginator);
impl GetComplianceDetailsByResourcePaginatorItems {
/// Create the pagination stream
///
/// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
///
/// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::model::EvaluationResult,
aws_smithy_http::result::SdkError<crate::error::GetComplianceDetailsByResourceError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_get_compliance_details_by_resource_output_evaluation_results(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `GetConformancePackComplianceSummaryPaginator`
///
/// This is created with [`.items()`](GetConformancePackComplianceSummaryPaginator::items)
pub struct GetConformancePackComplianceSummaryPaginatorItems(
GetConformancePackComplianceSummaryPaginator,
);
impl GetConformancePackComplianceSummaryPaginatorItems {
/// Create the pagination stream
///
/// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
///
/// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::model::ConformancePackComplianceSummary,
aws_smithy_http::result::SdkError<
crate::error::GetConformancePackComplianceSummaryError,
>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_get_conformance_pack_compliance_summary_output_conformance_pack_compliance_summary_list(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `GetOrganizationConfigRuleDetailedStatusPaginator`
///
/// This is created with [`.items()`](GetOrganizationConfigRuleDetailedStatusPaginator::items)
pub struct GetOrganizationConfigRuleDetailedStatusPaginatorItems(
GetOrganizationConfigRuleDetailedStatusPaginator,
);
impl GetOrganizationConfigRuleDetailedStatusPaginatorItems {
/// Create the pagination stream
///
/// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
///
/// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::model::MemberAccountStatus,
aws_smithy_http::result::SdkError<
crate::error::GetOrganizationConfigRuleDetailedStatusError,
>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_get_organization_config_rule_detailed_status_output_organization_config_rule_detailed_status(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `GetOrganizationConformancePackDetailedStatusPaginator`
///
/// This is created with [`.items()`](GetOrganizationConformancePackDetailedStatusPaginator::items)
pub struct GetOrganizationConformancePackDetailedStatusPaginatorItems(
GetOrganizationConformancePackDetailedStatusPaginator,
);
impl GetOrganizationConformancePackDetailedStatusPaginatorItems {
/// Create the pagination stream
///
/// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
///
/// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::model::OrganizationConformancePackDetailedStatus,
aws_smithy_http::result::SdkError<
crate::error::GetOrganizationConformancePackDetailedStatusError,
>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_get_organization_conformance_pack_detailed_status_output_organization_conformance_pack_detailed_statuses(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `GetResourceConfigHistoryPaginator`
///
/// This is created with [`.items()`](GetResourceConfigHistoryPaginator::items)
pub struct GetResourceConfigHistoryPaginatorItems(GetResourceConfigHistoryPaginator);
impl GetResourceConfigHistoryPaginatorItems {
/// Create the pagination stream
///
/// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
///
/// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::model::ConfigurationItem,
aws_smithy_http::result::SdkError<crate::error::GetResourceConfigHistoryError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_get_resource_config_history_output_configuration_items(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `ListAggregateDiscoveredResourcesPaginator`
///
/// This is created with [`.items()`](ListAggregateDiscoveredResourcesPaginator::items)
pub struct ListAggregateDiscoveredResourcesPaginatorItems(
ListAggregateDiscoveredResourcesPaginator,
);
impl ListAggregateDiscoveredResourcesPaginatorItems {
/// Create the pagination stream
///
/// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
///
/// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::model::AggregateResourceIdentifier,
aws_smithy_http::result::SdkError<crate::error::ListAggregateDiscoveredResourcesError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_list_aggregate_discovered_resources_output_resource_identifiers(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `ListDiscoveredResourcesPaginator`
///
/// This is created with [`.items()`](ListDiscoveredResourcesPaginator::items)
pub struct ListDiscoveredResourcesPaginatorItems(ListDiscoveredResourcesPaginator);
impl ListDiscoveredResourcesPaginatorItems {
/// Create the pagination stream
///
/// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
///
/// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::model::ResourceIdentifier,
aws_smithy_http::result::SdkError<crate::error::ListDiscoveredResourcesError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_list_discovered_resources_output_resource_identifiers(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `ListResourceEvaluationsPaginator`
///
/// This is created with [`.items()`](ListResourceEvaluationsPaginator::items)
pub struct ListResourceEvaluationsPaginatorItems(ListResourceEvaluationsPaginator);
impl ListResourceEvaluationsPaginatorItems {
/// Create the pagination stream
///
/// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
///
/// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::model::ResourceEvaluation,
aws_smithy_http::result::SdkError<crate::error::ListResourceEvaluationsError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_list_resource_evaluations_output_resource_evaluations(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `ListTagsForResourcePaginator`
///
/// This is created with [`.items()`](ListTagsForResourcePaginator::items)
pub struct ListTagsForResourcePaginatorItems(ListTagsForResourcePaginator);
impl ListTagsForResourcePaginatorItems {
/// Create the pagination stream
///
/// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
///
/// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
crate::model::Tag,
aws_smithy_http::result::SdkError<crate::error::ListTagsForResourceError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| {
crate::lens::lens_structure_crate_output_list_tags_for_resource_output_tags(page)
.unwrap_or_default()
.into_iter()
})
}
}
/// Flattened paginator for `SelectAggregateResourceConfigPaginator`
///
/// This is created with [`.items()`](SelectAggregateResourceConfigPaginator::items)
pub struct SelectAggregateResourceConfigPaginatorItems(SelectAggregateResourceConfigPaginator);
impl SelectAggregateResourceConfigPaginatorItems {
/// Create the pagination stream
///
/// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
///
/// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
std::string::String,
aws_smithy_http::result::SdkError<crate::error::SelectAggregateResourceConfigError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_select_aggregate_resource_config_output_results(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `SelectResourceConfigPaginator`
///
/// This is created with [`.items()`](SelectResourceConfigPaginator::items)
pub struct SelectResourceConfigPaginatorItems(SelectResourceConfigPaginator);
impl SelectResourceConfigPaginatorItems {
/// Create the pagination stream
///
/// _Note: No requests will be dispatched until the stream is used (eg. with [`.next().await`](tokio_stream::StreamExt::next))._
///
/// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](tokio_stream::StreamExt::collect).
pub fn send(
self,
) -> impl tokio_stream::Stream<
Item = std::result::Result<
std::string::String,
aws_smithy_http::result::SdkError<crate::error::SelectResourceConfigError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| {
crate::lens::lens_structure_crate_output_select_resource_config_output_results(page)
.unwrap_or_default()
.into_iter()
})
}
}