// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
/// Paginator for [`GetCurrentMetricData`](crate::operation::GetCurrentMetricData)
pub struct GetCurrentMetricDataPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_current_metric_data_input::Builder,
stop_on_duplicate_token: bool,
}
impl GetCurrentMetricDataPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_current_metric_data_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::GetCurrentMetricDataOutput,
aws_smithy_http::result::SdkError<crate::error::GetCurrentMetricDataError>,
>,
> + 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_current_metric_data_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 [`GetCurrentUserData`](crate::operation::GetCurrentUserData)
pub struct GetCurrentUserDataPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_current_user_data_input::Builder,
stop_on_duplicate_token: bool,
}
impl GetCurrentUserDataPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_current_user_data_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::GetCurrentUserDataOutput,
aws_smithy_http::result::SdkError<crate::error::GetCurrentUserDataError>,
>,
> + 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_current_user_data_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 [`GetMetricData`](crate::operation::GetMetricData)
pub struct GetMetricDataPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_metric_data_input::Builder,
stop_on_duplicate_token: bool,
}
impl GetMetricDataPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_metric_data_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::GetMetricDataOutput,
aws_smithy_http::result::SdkError<crate::error::GetMetricDataError>,
>,
> + 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_metric_data_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 [`ListAgentStatuses`](crate::operation::ListAgentStatuses)
pub struct ListAgentStatusesPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_agent_statuses_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListAgentStatusesPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_agent_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 `max_results`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.max_results = Some(limit);
self
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `agent_status_summary_list`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListAgentStatusesPaginatorItems {
crate::paginator::ListAgentStatusesPaginatorItems(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::ListAgentStatusesOutput,
aws_smithy_http::result::SdkError<crate::error::ListAgentStatusesError>,
>,
> + 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_agent_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 [`ListApprovedOrigins`](crate::operation::ListApprovedOrigins)
pub struct ListApprovedOriginsPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_approved_origins_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListApprovedOriginsPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_approved_origins_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `origins`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListApprovedOriginsPaginatorItems {
crate::paginator::ListApprovedOriginsPaginatorItems(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::ListApprovedOriginsOutput,
aws_smithy_http::result::SdkError<crate::error::ListApprovedOriginsError>,
>,
> + 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_approved_origins_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 [`ListBots`](crate::operation::ListBots)
pub struct ListBotsPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_bots_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListBotsPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_bots_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `lex_bots`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListBotsPaginatorItems {
crate::paginator::ListBotsPaginatorItems(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::ListBotsOutput,
aws_smithy_http::result::SdkError<crate::error::ListBotsError>,
>,
> + 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_bots_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 [`ListContactFlowModules`](crate::operation::ListContactFlowModules)
pub struct ListContactFlowModulesPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_contact_flow_modules_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListContactFlowModulesPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_contact_flow_modules_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `contact_flow_modules_summary_list`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListContactFlowModulesPaginatorItems {
crate::paginator::ListContactFlowModulesPaginatorItems(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::ListContactFlowModulesOutput,
aws_smithy_http::result::SdkError<crate::error::ListContactFlowModulesError>,
>,
> + 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_contact_flow_modules_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 [`ListContactFlows`](crate::operation::ListContactFlows)
pub struct ListContactFlowsPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_contact_flows_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListContactFlowsPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_contact_flows_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `contact_flow_summary_list`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListContactFlowsPaginatorItems {
crate::paginator::ListContactFlowsPaginatorItems(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::ListContactFlowsOutput,
aws_smithy_http::result::SdkError<crate::error::ListContactFlowsError>,
>,
> + 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_contact_flows_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 [`ListContactReferences`](crate::operation::ListContactReferences)
pub struct ListContactReferencesPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_contact_references_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListContactReferencesPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_contact_references_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `reference_summary_list`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListContactReferencesPaginatorItems {
crate::paginator::ListContactReferencesPaginatorItems(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::ListContactReferencesOutput,
aws_smithy_http::result::SdkError<crate::error::ListContactReferencesError>,
>,
> + 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_contact_references_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 [`ListDefaultVocabularies`](crate::operation::ListDefaultVocabularies)
pub struct ListDefaultVocabulariesPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_default_vocabularies_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListDefaultVocabulariesPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_default_vocabularies_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `default_vocabulary_list`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListDefaultVocabulariesPaginatorItems {
crate::paginator::ListDefaultVocabulariesPaginatorItems(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::ListDefaultVocabulariesOutput,
aws_smithy_http::result::SdkError<crate::error::ListDefaultVocabulariesError>,
>,
> + 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_default_vocabularies_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 [`ListHoursOfOperations`](crate::operation::ListHoursOfOperations)
pub struct ListHoursOfOperationsPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_hours_of_operations_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListHoursOfOperationsPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_hours_of_operations_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `hours_of_operation_summary_list`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListHoursOfOperationsPaginatorItems {
crate::paginator::ListHoursOfOperationsPaginatorItems(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::ListHoursOfOperationsOutput,
aws_smithy_http::result::SdkError<crate::error::ListHoursOfOperationsError>,
>,
> + 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_hours_of_operations_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 [`ListInstanceAttributes`](crate::operation::ListInstanceAttributes)
pub struct ListInstanceAttributesPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_instance_attributes_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListInstanceAttributesPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_instance_attributes_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `attributes`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListInstanceAttributesPaginatorItems {
crate::paginator::ListInstanceAttributesPaginatorItems(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::ListInstanceAttributesOutput,
aws_smithy_http::result::SdkError<crate::error::ListInstanceAttributesError>,
>,
> + 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_instance_attributes_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 [`ListInstances`](crate::operation::ListInstances)
pub struct ListInstancesPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_instances_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListInstancesPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_instances_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `instance_summary_list`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListInstancesPaginatorItems {
crate::paginator::ListInstancesPaginatorItems(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::ListInstancesOutput,
aws_smithy_http::result::SdkError<crate::error::ListInstancesError>,
>,
> + 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_instances_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 [`ListInstanceStorageConfigs`](crate::operation::ListInstanceStorageConfigs)
pub struct ListInstanceStorageConfigsPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_instance_storage_configs_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListInstanceStorageConfigsPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_instance_storage_configs_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `storage_configs`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListInstanceStorageConfigsPaginatorItems {
crate::paginator::ListInstanceStorageConfigsPaginatorItems(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::ListInstanceStorageConfigsOutput,
aws_smithy_http::result::SdkError<crate::error::ListInstanceStorageConfigsError>,
>,
> + 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_instance_storage_configs_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 [`ListIntegrationAssociations`](crate::operation::ListIntegrationAssociations)
pub struct ListIntegrationAssociationsPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_integration_associations_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListIntegrationAssociationsPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_integration_associations_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `integration_association_summary_list`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListIntegrationAssociationsPaginatorItems {
crate::paginator::ListIntegrationAssociationsPaginatorItems(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::ListIntegrationAssociationsOutput,
aws_smithy_http::result::SdkError<crate::error::ListIntegrationAssociationsError>,
>,
> + 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_integration_associations_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 [`ListLambdaFunctions`](crate::operation::ListLambdaFunctions)
pub struct ListLambdaFunctionsPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_lambda_functions_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListLambdaFunctionsPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_lambda_functions_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `lambda_functions`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListLambdaFunctionsPaginatorItems {
crate::paginator::ListLambdaFunctionsPaginatorItems(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::ListLambdaFunctionsOutput,
aws_smithy_http::result::SdkError<crate::error::ListLambdaFunctionsError>,
>,
> + 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_lambda_functions_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 [`ListLexBots`](crate::operation::ListLexBots)
pub struct ListLexBotsPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_lex_bots_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListLexBotsPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_lex_bots_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `lex_bots`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListLexBotsPaginatorItems {
crate::paginator::ListLexBotsPaginatorItems(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::ListLexBotsOutput,
aws_smithy_http::result::SdkError<crate::error::ListLexBotsError>,
>,
> + 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_lex_bots_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 [`ListPhoneNumbers`](crate::operation::ListPhoneNumbers)
pub struct ListPhoneNumbersPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_phone_numbers_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListPhoneNumbersPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_phone_numbers_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `phone_number_summary_list`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListPhoneNumbersPaginatorItems {
crate::paginator::ListPhoneNumbersPaginatorItems(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::ListPhoneNumbersOutput,
aws_smithy_http::result::SdkError<crate::error::ListPhoneNumbersError>,
>,
> + 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_phone_numbers_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 [`ListPhoneNumbersV2`](crate::operation::ListPhoneNumbersV2)
pub struct ListPhoneNumbersV2Paginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_phone_numbers_v2_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListPhoneNumbersV2Paginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_phone_numbers_v2_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `list_phone_numbers_summary_list`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListPhoneNumbersV2PaginatorItems {
crate::paginator::ListPhoneNumbersV2PaginatorItems(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::ListPhoneNumbersV2Output,
aws_smithy_http::result::SdkError<crate::error::ListPhoneNumbersV2Error>,
>,
> + 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_phone_numbers_v2_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 [`ListPrompts`](crate::operation::ListPrompts)
pub struct ListPromptsPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_prompts_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListPromptsPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_prompts_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `prompt_summary_list`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListPromptsPaginatorItems {
crate::paginator::ListPromptsPaginatorItems(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::ListPromptsOutput,
aws_smithy_http::result::SdkError<crate::error::ListPromptsError>,
>,
> + 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_prompts_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 [`ListQueueQuickConnects`](crate::operation::ListQueueQuickConnects)
pub struct ListQueueQuickConnectsPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_queue_quick_connects_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListQueueQuickConnectsPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_queue_quick_connects_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `quick_connect_summary_list`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListQueueQuickConnectsPaginatorItems {
crate::paginator::ListQueueQuickConnectsPaginatorItems(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::ListQueueQuickConnectsOutput,
aws_smithy_http::result::SdkError<crate::error::ListQueueQuickConnectsError>,
>,
> + 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_queue_quick_connects_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 [`ListQueues`](crate::operation::ListQueues)
pub struct ListQueuesPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_queues_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListQueuesPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_queues_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `queue_summary_list`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListQueuesPaginatorItems {
crate::paginator::ListQueuesPaginatorItems(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::ListQueuesOutput,
aws_smithy_http::result::SdkError<crate::error::ListQueuesError>,
>,
> + 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_queues_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 [`ListQuickConnects`](crate::operation::ListQuickConnects)
pub struct ListQuickConnectsPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_quick_connects_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListQuickConnectsPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_quick_connects_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `quick_connect_summary_list`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListQuickConnectsPaginatorItems {
crate::paginator::ListQuickConnectsPaginatorItems(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::ListQuickConnectsOutput,
aws_smithy_http::result::SdkError<crate::error::ListQuickConnectsError>,
>,
> + 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_quick_connects_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 [`ListRoutingProfileQueues`](crate::operation::ListRoutingProfileQueues)
pub struct ListRoutingProfileQueuesPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_routing_profile_queues_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListRoutingProfileQueuesPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_routing_profile_queues_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `routing_profile_queue_config_summary_list`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListRoutingProfileQueuesPaginatorItems {
crate::paginator::ListRoutingProfileQueuesPaginatorItems(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::ListRoutingProfileQueuesOutput,
aws_smithy_http::result::SdkError<crate::error::ListRoutingProfileQueuesError>,
>,
> + 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_routing_profile_queues_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 [`ListRoutingProfiles`](crate::operation::ListRoutingProfiles)
pub struct ListRoutingProfilesPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_routing_profiles_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListRoutingProfilesPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_routing_profiles_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `routing_profile_summary_list`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListRoutingProfilesPaginatorItems {
crate::paginator::ListRoutingProfilesPaginatorItems(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::ListRoutingProfilesOutput,
aws_smithy_http::result::SdkError<crate::error::ListRoutingProfilesError>,
>,
> + 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_routing_profiles_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 [`ListRules`](crate::operation::ListRules)
pub struct ListRulesPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_rules_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListRulesPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_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 `max_results`_
pub fn page_size(mut self, limit: i32) -> Self {
self.builder.max_results = Some(limit);
self
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `rule_summary_list`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListRulesPaginatorItems {
crate::paginator::ListRulesPaginatorItems(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::ListRulesOutput,
aws_smithy_http::result::SdkError<crate::error::ListRulesError>,
>,
> + 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_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 [`ListSecurityKeys`](crate::operation::ListSecurityKeys)
pub struct ListSecurityKeysPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_security_keys_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListSecurityKeysPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_security_keys_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `security_keys`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListSecurityKeysPaginatorItems {
crate::paginator::ListSecurityKeysPaginatorItems(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::ListSecurityKeysOutput,
aws_smithy_http::result::SdkError<crate::error::ListSecurityKeysError>,
>,
> + 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_security_keys_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 [`ListSecurityProfilePermissions`](crate::operation::ListSecurityProfilePermissions)
pub struct ListSecurityProfilePermissionsPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_security_profile_permissions_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListSecurityProfilePermissionsPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_security_profile_permissions_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `permissions`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListSecurityProfilePermissionsPaginatorItems {
crate::paginator::ListSecurityProfilePermissionsPaginatorItems(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::ListSecurityProfilePermissionsOutput,
aws_smithy_http::result::SdkError<crate::error::ListSecurityProfilePermissionsError>,
>,
> + 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_security_profile_permissions_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 [`ListSecurityProfiles`](crate::operation::ListSecurityProfiles)
pub struct ListSecurityProfilesPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_security_profiles_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListSecurityProfilesPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_security_profiles_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `security_profile_summary_list`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListSecurityProfilesPaginatorItems {
crate::paginator::ListSecurityProfilesPaginatorItems(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::ListSecurityProfilesOutput,
aws_smithy_http::result::SdkError<crate::error::ListSecurityProfilesError>,
>,
> + 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_security_profiles_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 [`ListTaskTemplates`](crate::operation::ListTaskTemplates)
pub struct ListTaskTemplatesPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_task_templates_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListTaskTemplatesPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_task_templates_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `task_templates`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListTaskTemplatesPaginatorItems {
crate::paginator::ListTaskTemplatesPaginatorItems(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::ListTaskTemplatesOutput,
aws_smithy_http::result::SdkError<crate::error::ListTaskTemplatesError>,
>,
> + 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_task_templates_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 [`ListTrafficDistributionGroups`](crate::operation::ListTrafficDistributionGroups)
pub struct ListTrafficDistributionGroupsPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_traffic_distribution_groups_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListTrafficDistributionGroupsPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_traffic_distribution_groups_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `traffic_distribution_group_summary_list`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListTrafficDistributionGroupsPaginatorItems {
crate::paginator::ListTrafficDistributionGroupsPaginatorItems(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::ListTrafficDistributionGroupsOutput,
aws_smithy_http::result::SdkError<crate::error::ListTrafficDistributionGroupsError>,
>,
> + 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_traffic_distribution_groups_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 [`ListUseCases`](crate::operation::ListUseCases)
pub struct ListUseCasesPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_use_cases_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListUseCasesPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_use_cases_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `use_case_summary_list`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListUseCasesPaginatorItems {
crate::paginator::ListUseCasesPaginatorItems(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::ListUseCasesOutput,
aws_smithy_http::result::SdkError<crate::error::ListUseCasesError>,
>,
> + 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_use_cases_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 [`ListUserHierarchyGroups`](crate::operation::ListUserHierarchyGroups)
pub struct ListUserHierarchyGroupsPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_user_hierarchy_groups_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListUserHierarchyGroupsPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_user_hierarchy_groups_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `user_hierarchy_group_summary_list`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListUserHierarchyGroupsPaginatorItems {
crate::paginator::ListUserHierarchyGroupsPaginatorItems(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::ListUserHierarchyGroupsOutput,
aws_smithy_http::result::SdkError<crate::error::ListUserHierarchyGroupsError>,
>,
> + 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_user_hierarchy_groups_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 [`ListUsers`](crate::operation::ListUsers)
pub struct ListUsersPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_users_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListUsersPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_users_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `user_summary_list`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::ListUsersPaginatorItems {
crate::paginator::ListUsersPaginatorItems(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::ListUsersOutput,
aws_smithy_http::result::SdkError<crate::error::ListUsersError>,
>,
> + 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_users_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 [`SearchAvailablePhoneNumbers`](crate::operation::SearchAvailablePhoneNumbers)
pub struct SearchAvailablePhoneNumbersPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::search_available_phone_numbers_input::Builder,
stop_on_duplicate_token: bool,
}
impl SearchAvailablePhoneNumbersPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::search_available_phone_numbers_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `available_numbers_list`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::SearchAvailablePhoneNumbersPaginatorItems {
crate::paginator::SearchAvailablePhoneNumbersPaginatorItems(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::SearchAvailablePhoneNumbersOutput,
aws_smithy_http::result::SdkError<crate::error::SearchAvailablePhoneNumbersError>,
>,
> + 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_search_available_phone_numbers_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 [`SearchQueues`](crate::operation::SearchQueues)
pub struct SearchQueuesPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::search_queues_input::Builder,
stop_on_duplicate_token: bool,
}
impl SearchQueuesPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::search_queues_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `queues`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::SearchQueuesPaginatorItems {
crate::paginator::SearchQueuesPaginatorItems(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::SearchQueuesOutput,
aws_smithy_http::result::SdkError<crate::error::SearchQueuesError>,
>,
> + 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_search_queues_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 [`SearchRoutingProfiles`](crate::operation::SearchRoutingProfiles)
pub struct SearchRoutingProfilesPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::search_routing_profiles_input::Builder,
stop_on_duplicate_token: bool,
}
impl SearchRoutingProfilesPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::search_routing_profiles_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `routing_profiles`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::SearchRoutingProfilesPaginatorItems {
crate::paginator::SearchRoutingProfilesPaginatorItems(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::SearchRoutingProfilesOutput,
aws_smithy_http::result::SdkError<crate::error::SearchRoutingProfilesError>,
>,
> + 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_search_routing_profiles_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 [`SearchSecurityProfiles`](crate::operation::SearchSecurityProfiles)
pub struct SearchSecurityProfilesPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::search_security_profiles_input::Builder,
stop_on_duplicate_token: bool,
}
impl SearchSecurityProfilesPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::search_security_profiles_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `security_profiles`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::SearchSecurityProfilesPaginatorItems {
crate::paginator::SearchSecurityProfilesPaginatorItems(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::SearchSecurityProfilesOutput,
aws_smithy_http::result::SdkError<crate::error::SearchSecurityProfilesError>,
>,
> + 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_search_security_profiles_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 [`SearchUsers`](crate::operation::SearchUsers)
pub struct SearchUsersPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::search_users_input::Builder,
stop_on_duplicate_token: bool,
}
impl SearchUsersPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::search_users_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `users`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::SearchUsersPaginatorItems {
crate::paginator::SearchUsersPaginatorItems(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::SearchUsersOutput,
aws_smithy_http::result::SdkError<crate::error::SearchUsersError>,
>,
> + 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_search_users_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 [`SearchVocabularies`](crate::operation::SearchVocabularies)
pub struct SearchVocabulariesPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::search_vocabularies_input::Builder,
stop_on_duplicate_token: bool,
}
impl SearchVocabulariesPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::search_vocabularies_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
}
/// Create a flattened paginator
///
/// This paginator automatically flattens results using `vocabulary_summary_list`. Queries to the underlying service
/// are dispatched lazily.
pub fn items(self) -> crate::paginator::SearchVocabulariesPaginatorItems {
crate::paginator::SearchVocabulariesPaginatorItems(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::SearchVocabulariesOutput,
aws_smithy_http::result::SdkError<crate::error::SearchVocabulariesError>,
>,
> + 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_search_vocabularies_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 `ListAgentStatusesPaginator`
///
/// This is created with [`.items()`](ListAgentStatusesPaginator::items)
pub struct ListAgentStatusesPaginatorItems(ListAgentStatusesPaginator);
impl ListAgentStatusesPaginatorItems {
/// 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::AgentStatusSummary,
aws_smithy_http::result::SdkError<crate::error::ListAgentStatusesError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_list_agent_statuses_output_agent_status_summary_list(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `ListApprovedOriginsPaginator`
///
/// This is created with [`.items()`](ListApprovedOriginsPaginator::items)
pub struct ListApprovedOriginsPaginatorItems(ListApprovedOriginsPaginator);
impl ListApprovedOriginsPaginatorItems {
/// 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::ListApprovedOriginsError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| {
crate::lens::lens_structure_crate_output_list_approved_origins_output_origins(page)
.unwrap_or_default()
.into_iter()
})
}
}
/// Flattened paginator for `ListBotsPaginator`
///
/// This is created with [`.items()`](ListBotsPaginator::items)
pub struct ListBotsPaginatorItems(ListBotsPaginator);
impl ListBotsPaginatorItems {
/// 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::LexBotConfig,
aws_smithy_http::result::SdkError<crate::error::ListBotsError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| {
crate::lens::lens_structure_crate_output_list_bots_output_lex_bots(page)
.unwrap_or_default()
.into_iter()
})
}
}
/// Flattened paginator for `ListContactFlowModulesPaginator`
///
/// This is created with [`.items()`](ListContactFlowModulesPaginator::items)
pub struct ListContactFlowModulesPaginatorItems(ListContactFlowModulesPaginator);
impl ListContactFlowModulesPaginatorItems {
/// 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::ContactFlowModuleSummary,
aws_smithy_http::result::SdkError<crate::error::ListContactFlowModulesError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_list_contact_flow_modules_output_contact_flow_modules_summary_list(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `ListContactFlowsPaginator`
///
/// This is created with [`.items()`](ListContactFlowsPaginator::items)
pub struct ListContactFlowsPaginatorItems(ListContactFlowsPaginator);
impl ListContactFlowsPaginatorItems {
/// 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::ContactFlowSummary,
aws_smithy_http::result::SdkError<crate::error::ListContactFlowsError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_list_contact_flows_output_contact_flow_summary_list(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `ListContactReferencesPaginator`
///
/// This is created with [`.items()`](ListContactReferencesPaginator::items)
pub struct ListContactReferencesPaginatorItems(ListContactReferencesPaginator);
impl ListContactReferencesPaginatorItems {
/// 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::ReferenceSummary,
aws_smithy_http::result::SdkError<crate::error::ListContactReferencesError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_list_contact_references_output_reference_summary_list(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `ListDefaultVocabulariesPaginator`
///
/// This is created with [`.items()`](ListDefaultVocabulariesPaginator::items)
pub struct ListDefaultVocabulariesPaginatorItems(ListDefaultVocabulariesPaginator);
impl ListDefaultVocabulariesPaginatorItems {
/// 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::DefaultVocabulary,
aws_smithy_http::result::SdkError<crate::error::ListDefaultVocabulariesError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_list_default_vocabularies_output_default_vocabulary_list(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `ListHoursOfOperationsPaginator`
///
/// This is created with [`.items()`](ListHoursOfOperationsPaginator::items)
pub struct ListHoursOfOperationsPaginatorItems(ListHoursOfOperationsPaginator);
impl ListHoursOfOperationsPaginatorItems {
/// 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::HoursOfOperationSummary,
aws_smithy_http::result::SdkError<crate::error::ListHoursOfOperationsError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_list_hours_of_operations_output_hours_of_operation_summary_list(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `ListInstanceAttributesPaginator`
///
/// This is created with [`.items()`](ListInstanceAttributesPaginator::items)
pub struct ListInstanceAttributesPaginatorItems(ListInstanceAttributesPaginator);
impl ListInstanceAttributesPaginatorItems {
/// 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::Attribute,
aws_smithy_http::result::SdkError<crate::error::ListInstanceAttributesError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| {
crate::lens::lens_structure_crate_output_list_instance_attributes_output_attributes(
page,
)
.unwrap_or_default()
.into_iter()
})
}
}
/// Flattened paginator for `ListInstancesPaginator`
///
/// This is created with [`.items()`](ListInstancesPaginator::items)
pub struct ListInstancesPaginatorItems(ListInstancesPaginator);
impl ListInstancesPaginatorItems {
/// 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::InstanceSummary,
aws_smithy_http::result::SdkError<crate::error::ListInstancesError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| {
crate::lens::lens_structure_crate_output_list_instances_output_instance_summary_list(
page,
)
.unwrap_or_default()
.into_iter()
})
}
}
/// Flattened paginator for `ListInstanceStorageConfigsPaginator`
///
/// This is created with [`.items()`](ListInstanceStorageConfigsPaginator::items)
pub struct ListInstanceStorageConfigsPaginatorItems(ListInstanceStorageConfigsPaginator);
impl ListInstanceStorageConfigsPaginatorItems {
/// 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::InstanceStorageConfig,
aws_smithy_http::result::SdkError<crate::error::ListInstanceStorageConfigsError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_list_instance_storage_configs_output_storage_configs(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `ListIntegrationAssociationsPaginator`
///
/// This is created with [`.items()`](ListIntegrationAssociationsPaginator::items)
pub struct ListIntegrationAssociationsPaginatorItems(ListIntegrationAssociationsPaginator);
impl ListIntegrationAssociationsPaginatorItems {
/// 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::IntegrationAssociationSummary,
aws_smithy_http::result::SdkError<crate::error::ListIntegrationAssociationsError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_list_integration_associations_output_integration_association_summary_list(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `ListLambdaFunctionsPaginator`
///
/// This is created with [`.items()`](ListLambdaFunctionsPaginator::items)
pub struct ListLambdaFunctionsPaginatorItems(ListLambdaFunctionsPaginator);
impl ListLambdaFunctionsPaginatorItems {
/// 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::ListLambdaFunctionsError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| {
crate::lens::lens_structure_crate_output_list_lambda_functions_output_lambda_functions(
page,
)
.unwrap_or_default()
.into_iter()
})
}
}
/// Flattened paginator for `ListLexBotsPaginator`
///
/// This is created with [`.items()`](ListLexBotsPaginator::items)
pub struct ListLexBotsPaginatorItems(ListLexBotsPaginator);
impl ListLexBotsPaginatorItems {
/// 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::LexBot,
aws_smithy_http::result::SdkError<crate::error::ListLexBotsError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| {
crate::lens::lens_structure_crate_output_list_lex_bots_output_lex_bots(page)
.unwrap_or_default()
.into_iter()
})
}
}
/// Flattened paginator for `ListPhoneNumbersPaginator`
///
/// This is created with [`.items()`](ListPhoneNumbersPaginator::items)
pub struct ListPhoneNumbersPaginatorItems(ListPhoneNumbersPaginator);
impl ListPhoneNumbersPaginatorItems {
/// 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::PhoneNumberSummary,
aws_smithy_http::result::SdkError<crate::error::ListPhoneNumbersError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_list_phone_numbers_output_phone_number_summary_list(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `ListPhoneNumbersV2Paginator`
///
/// This is created with [`.items()`](ListPhoneNumbersV2Paginator::items)
pub struct ListPhoneNumbersV2PaginatorItems(ListPhoneNumbersV2Paginator);
impl ListPhoneNumbersV2PaginatorItems {
/// 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::ListPhoneNumbersSummary,
aws_smithy_http::result::SdkError<crate::error::ListPhoneNumbersV2Error>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_list_phone_numbers_v2_output_list_phone_numbers_summary_list(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `ListPromptsPaginator`
///
/// This is created with [`.items()`](ListPromptsPaginator::items)
pub struct ListPromptsPaginatorItems(ListPromptsPaginator);
impl ListPromptsPaginatorItems {
/// 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::PromptSummary,
aws_smithy_http::result::SdkError<crate::error::ListPromptsError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| {
crate::lens::lens_structure_crate_output_list_prompts_output_prompt_summary_list(page)
.unwrap_or_default()
.into_iter()
})
}
}
/// Flattened paginator for `ListQueueQuickConnectsPaginator`
///
/// This is created with [`.items()`](ListQueueQuickConnectsPaginator::items)
pub struct ListQueueQuickConnectsPaginatorItems(ListQueueQuickConnectsPaginator);
impl ListQueueQuickConnectsPaginatorItems {
/// 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::QuickConnectSummary,
aws_smithy_http::result::SdkError<crate::error::ListQueueQuickConnectsError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_list_queue_quick_connects_output_quick_connect_summary_list(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `ListQueuesPaginator`
///
/// This is created with [`.items()`](ListQueuesPaginator::items)
pub struct ListQueuesPaginatorItems(ListQueuesPaginator);
impl ListQueuesPaginatorItems {
/// 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::QueueSummary,
aws_smithy_http::result::SdkError<crate::error::ListQueuesError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| {
crate::lens::lens_structure_crate_output_list_queues_output_queue_summary_list(page)
.unwrap_or_default()
.into_iter()
})
}
}
/// Flattened paginator for `ListQuickConnectsPaginator`
///
/// This is created with [`.items()`](ListQuickConnectsPaginator::items)
pub struct ListQuickConnectsPaginatorItems(ListQuickConnectsPaginator);
impl ListQuickConnectsPaginatorItems {
/// 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::QuickConnectSummary,
aws_smithy_http::result::SdkError<crate::error::ListQuickConnectsError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_list_quick_connects_output_quick_connect_summary_list(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `ListRoutingProfileQueuesPaginator`
///
/// This is created with [`.items()`](ListRoutingProfileQueuesPaginator::items)
pub struct ListRoutingProfileQueuesPaginatorItems(ListRoutingProfileQueuesPaginator);
impl ListRoutingProfileQueuesPaginatorItems {
/// 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::RoutingProfileQueueConfigSummary,
aws_smithy_http::result::SdkError<crate::error::ListRoutingProfileQueuesError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_list_routing_profile_queues_output_routing_profile_queue_config_summary_list(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `ListRoutingProfilesPaginator`
///
/// This is created with [`.items()`](ListRoutingProfilesPaginator::items)
pub struct ListRoutingProfilesPaginatorItems(ListRoutingProfilesPaginator);
impl ListRoutingProfilesPaginatorItems {
/// 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::RoutingProfileSummary,
aws_smithy_http::result::SdkError<crate::error::ListRoutingProfilesError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_list_routing_profiles_output_routing_profile_summary_list(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `ListRulesPaginator`
///
/// This is created with [`.items()`](ListRulesPaginator::items)
pub struct ListRulesPaginatorItems(ListRulesPaginator);
impl ListRulesPaginatorItems {
/// 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::RuleSummary,
aws_smithy_http::result::SdkError<crate::error::ListRulesError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| {
crate::lens::lens_structure_crate_output_list_rules_output_rule_summary_list(page)
.unwrap_or_default()
.into_iter()
})
}
}
/// Flattened paginator for `ListSecurityKeysPaginator`
///
/// This is created with [`.items()`](ListSecurityKeysPaginator::items)
pub struct ListSecurityKeysPaginatorItems(ListSecurityKeysPaginator);
impl ListSecurityKeysPaginatorItems {
/// 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::SecurityKey,
aws_smithy_http::result::SdkError<crate::error::ListSecurityKeysError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| {
crate::lens::lens_structure_crate_output_list_security_keys_output_security_keys(page)
.unwrap_or_default()
.into_iter()
})
}
}
/// Flattened paginator for `ListSecurityProfilePermissionsPaginator`
///
/// This is created with [`.items()`](ListSecurityProfilePermissionsPaginator::items)
pub struct ListSecurityProfilePermissionsPaginatorItems(ListSecurityProfilePermissionsPaginator);
impl ListSecurityProfilePermissionsPaginatorItems {
/// 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::ListSecurityProfilePermissionsError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_list_security_profile_permissions_output_permissions(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `ListSecurityProfilesPaginator`
///
/// This is created with [`.items()`](ListSecurityProfilesPaginator::items)
pub struct ListSecurityProfilesPaginatorItems(ListSecurityProfilesPaginator);
impl ListSecurityProfilesPaginatorItems {
/// 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::SecurityProfileSummary,
aws_smithy_http::result::SdkError<crate::error::ListSecurityProfilesError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_list_security_profiles_output_security_profile_summary_list(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `ListTaskTemplatesPaginator`
///
/// This is created with [`.items()`](ListTaskTemplatesPaginator::items)
pub struct ListTaskTemplatesPaginatorItems(ListTaskTemplatesPaginator);
impl ListTaskTemplatesPaginatorItems {
/// 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::TaskTemplateMetadata,
aws_smithy_http::result::SdkError<crate::error::ListTaskTemplatesError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| {
crate::lens::lens_structure_crate_output_list_task_templates_output_task_templates(page)
.unwrap_or_default()
.into_iter()
})
}
}
/// Flattened paginator for `ListTrafficDistributionGroupsPaginator`
///
/// This is created with [`.items()`](ListTrafficDistributionGroupsPaginator::items)
pub struct ListTrafficDistributionGroupsPaginatorItems(ListTrafficDistributionGroupsPaginator);
impl ListTrafficDistributionGroupsPaginatorItems {
/// 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::TrafficDistributionGroupSummary,
aws_smithy_http::result::SdkError<crate::error::ListTrafficDistributionGroupsError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_list_traffic_distribution_groups_output_traffic_distribution_group_summary_list(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `ListUseCasesPaginator`
///
/// This is created with [`.items()`](ListUseCasesPaginator::items)
pub struct ListUseCasesPaginatorItems(ListUseCasesPaginator);
impl ListUseCasesPaginatorItems {
/// 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::UseCase,
aws_smithy_http::result::SdkError<crate::error::ListUseCasesError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| {
crate::lens::lens_structure_crate_output_list_use_cases_output_use_case_summary_list(
page,
)
.unwrap_or_default()
.into_iter()
})
}
}
/// Flattened paginator for `ListUserHierarchyGroupsPaginator`
///
/// This is created with [`.items()`](ListUserHierarchyGroupsPaginator::items)
pub struct ListUserHierarchyGroupsPaginatorItems(ListUserHierarchyGroupsPaginator);
impl ListUserHierarchyGroupsPaginatorItems {
/// 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::HierarchyGroupSummary,
aws_smithy_http::result::SdkError<crate::error::ListUserHierarchyGroupsError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_list_user_hierarchy_groups_output_user_hierarchy_group_summary_list(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `ListUsersPaginator`
///
/// This is created with [`.items()`](ListUsersPaginator::items)
pub struct ListUsersPaginatorItems(ListUsersPaginator);
impl ListUsersPaginatorItems {
/// 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::UserSummary,
aws_smithy_http::result::SdkError<crate::error::ListUsersError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| {
crate::lens::lens_structure_crate_output_list_users_output_user_summary_list(page)
.unwrap_or_default()
.into_iter()
})
}
}
/// Flattened paginator for `SearchAvailablePhoneNumbersPaginator`
///
/// This is created with [`.items()`](SearchAvailablePhoneNumbersPaginator::items)
pub struct SearchAvailablePhoneNumbersPaginatorItems(SearchAvailablePhoneNumbersPaginator);
impl SearchAvailablePhoneNumbersPaginatorItems {
/// 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::AvailableNumberSummary,
aws_smithy_http::result::SdkError<crate::error::SearchAvailablePhoneNumbersError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_search_available_phone_numbers_output_available_numbers_list(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `SearchQueuesPaginator`
///
/// This is created with [`.items()`](SearchQueuesPaginator::items)
pub struct SearchQueuesPaginatorItems(SearchQueuesPaginator);
impl SearchQueuesPaginatorItems {
/// 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::Queue,
aws_smithy_http::result::SdkError<crate::error::SearchQueuesError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| {
crate::lens::lens_structure_crate_output_search_queues_output_queues(page)
.unwrap_or_default()
.into_iter()
})
}
}
/// Flattened paginator for `SearchRoutingProfilesPaginator`
///
/// This is created with [`.items()`](SearchRoutingProfilesPaginator::items)
pub struct SearchRoutingProfilesPaginatorItems(SearchRoutingProfilesPaginator);
impl SearchRoutingProfilesPaginatorItems {
/// 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::RoutingProfile,
aws_smithy_http::result::SdkError<crate::error::SearchRoutingProfilesError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_search_routing_profiles_output_routing_profiles(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `SearchSecurityProfilesPaginator`
///
/// This is created with [`.items()`](SearchSecurityProfilesPaginator::items)
pub struct SearchSecurityProfilesPaginatorItems(SearchSecurityProfilesPaginator);
impl SearchSecurityProfilesPaginatorItems {
/// 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::SecurityProfileSearchSummary,
aws_smithy_http::result::SdkError<crate::error::SearchSecurityProfilesError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_search_security_profiles_output_security_profiles(page).unwrap_or_default().into_iter())
}
}
/// Flattened paginator for `SearchUsersPaginator`
///
/// This is created with [`.items()`](SearchUsersPaginator::items)
pub struct SearchUsersPaginatorItems(SearchUsersPaginator);
impl SearchUsersPaginatorItems {
/// 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::UserSearchSummary,
aws_smithy_http::result::SdkError<crate::error::SearchUsersError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| {
crate::lens::lens_structure_crate_output_search_users_output_users(page)
.unwrap_or_default()
.into_iter()
})
}
}
/// Flattened paginator for `SearchVocabulariesPaginator`
///
/// This is created with [`.items()`](SearchVocabulariesPaginator::items)
pub struct SearchVocabulariesPaginatorItems(SearchVocabulariesPaginator);
impl SearchVocabulariesPaginatorItems {
/// 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::VocabularySummary,
aws_smithy_http::result::SdkError<crate::error::SearchVocabulariesError>,
>,
> + Unpin {
aws_smithy_async::future::fn_stream::TryFlatMap::new(self.0.send()).flat_map(|page| crate::lens::lens_structure_crate_output_search_vocabularies_output_vocabulary_summary_list(page).unwrap_or_default().into_iter())
}
}