// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
/// Paginator for [`DescribeDomainAutoTunes`](crate::operation::DescribeDomainAutoTunes)
pub struct DescribeDomainAutoTunesPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_domain_auto_tunes_input::Builder,
stop_on_duplicate_token: bool,
}
impl DescribeDomainAutoTunesPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_domain_auto_tunes_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::DescribeDomainAutoTunesOutput,
aws_smithy_http::result::SdkError<crate::error::DescribeDomainAutoTunesError>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_describe_domain_auto_tunes_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 [`DescribeInboundConnections`](crate::operation::DescribeInboundConnections)
pub struct DescribeInboundConnectionsPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_inbound_connections_input::Builder,
stop_on_duplicate_token: bool,
}
impl DescribeInboundConnectionsPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_inbound_connections_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::DescribeInboundConnectionsOutput,
aws_smithy_http::result::SdkError<crate::error::DescribeInboundConnectionsError>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_describe_inbound_connections_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 [`DescribeOutboundConnections`](crate::operation::DescribeOutboundConnections)
pub struct DescribeOutboundConnectionsPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_outbound_connections_input::Builder,
stop_on_duplicate_token: bool,
}
impl DescribeOutboundConnectionsPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_outbound_connections_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::DescribeOutboundConnectionsOutput,
aws_smithy_http::result::SdkError<crate::error::DescribeOutboundConnectionsError>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_describe_outbound_connections_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 [`DescribePackages`](crate::operation::DescribePackages)
pub struct DescribePackagesPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_packages_input::Builder,
stop_on_duplicate_token: bool,
}
impl DescribePackagesPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_packages_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::DescribePackagesOutput,
aws_smithy_http::result::SdkError<crate::error::DescribePackagesError>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_describe_packages_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 [`DescribeReservedInstanceOfferings`](crate::operation::DescribeReservedInstanceOfferings)
pub struct DescribeReservedInstanceOfferingsPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_reserved_instance_offerings_input::Builder,
stop_on_duplicate_token: bool,
}
impl DescribeReservedInstanceOfferingsPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_reserved_instance_offerings_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::DescribeReservedInstanceOfferingsOutput,
aws_smithy_http::result::SdkError<crate::error::DescribeReservedInstanceOfferingsError>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_describe_reserved_instance_offerings_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 [`DescribeReservedInstances`](crate::operation::DescribeReservedInstances)
pub struct DescribeReservedInstancesPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_reserved_instances_input::Builder,
stop_on_duplicate_token: bool,
}
impl DescribeReservedInstancesPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::describe_reserved_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
}
/// 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::DescribeReservedInstancesOutput,
aws_smithy_http::result::SdkError<crate::error::DescribeReservedInstancesError>,
>,
> + Unpin {
// Move individual fields out of self for the borrow checker
let builder = self.builder;
let handle = self.handle;
aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
Box::pin(async move {
// Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
let mut input = match builder
.build()
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(input) => input,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
loop {
let op = match input
.make_operation(&handle.conf)
.await
.map_err(aws_smithy_http::result::SdkError::construction_failure)
{
Ok(op) => op,
Err(e) => {
let _ = tx.send(Err(e)).await;
return;
}
};
let resp = handle.client.call(op).await;
// If the input member is None or it was an error
let done = match resp {
Ok(ref resp) => {
let new_token = crate::lens::reflens_structure_crate_output_describe_reserved_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 [`GetPackageVersionHistory`](crate::operation::GetPackageVersionHistory)
pub struct GetPackageVersionHistoryPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_package_version_history_input::Builder,
stop_on_duplicate_token: bool,
}
impl GetPackageVersionHistoryPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_package_version_history_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `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::GetPackageVersionHistoryOutput,
aws_smithy_http::result::SdkError<crate::error::GetPackageVersionHistoryError>,
>,
> + 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_package_version_history_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`GetUpgradeHistory`](crate::operation::GetUpgradeHistory)
pub struct GetUpgradeHistoryPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_upgrade_history_input::Builder,
stop_on_duplicate_token: bool,
}
impl GetUpgradeHistoryPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::get_upgrade_history_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `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::GetUpgradeHistoryOutput,
aws_smithy_http::result::SdkError<crate::error::GetUpgradeHistoryError>,
>,
> + 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_upgrade_history_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`ListDomainsForPackage`](crate::operation::ListDomainsForPackage)
pub struct ListDomainsForPackagePaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_domains_for_package_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListDomainsForPackagePaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_domains_for_package_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::ListDomainsForPackageOutput,
aws_smithy_http::result::SdkError<crate::error::ListDomainsForPackageError>,
>,
> + 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_domains_for_package_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 [`ListInstanceTypeDetails`](crate::operation::ListInstanceTypeDetails)
pub struct ListInstanceTypeDetailsPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_instance_type_details_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListInstanceTypeDetailsPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_instance_type_details_input::Builder,
) -> Self {
Self {
handle,
builder,
stop_on_duplicate_token: true,
}
}
/// Set the page size
///
/// _Note: this method will override any previously set value for `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::ListInstanceTypeDetailsOutput,
aws_smithy_http::result::SdkError<crate::error::ListInstanceTypeDetailsError>,
>,
> + 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_type_details_output_next_token(resp);
let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
if !is_empty
&& new_token == input.next_token.as_ref()
&& self.stop_on_duplicate_token
{
true
} else {
input.next_token = new_token.cloned();
is_empty
}
}
Err(_) => true,
};
if tx.send(resp).await.is_err() {
// receiving end was dropped
return;
}
if done {
return;
}
}
})
})
}
}
/// Paginator for [`ListPackagesForDomain`](crate::operation::ListPackagesForDomain)
pub struct ListPackagesForDomainPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_packages_for_domain_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListPackagesForDomainPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_packages_for_domain_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::ListPackagesForDomainOutput,
aws_smithy_http::result::SdkError<crate::error::ListPackagesForDomainError>,
>,
> + 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_packages_for_domain_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 [`ListVersions`](crate::operation::ListVersions)
pub struct ListVersionsPaginator {
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_versions_input::Builder,
stop_on_duplicate_token: bool,
}
impl ListVersionsPaginator {
/// Create a new paginator-wrapper
pub(crate) fn new(
handle: std::sync::Arc<crate::client::Handle>,
builder: crate::input::list_versions_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::ListVersionsOutput,
aws_smithy_http::result::SdkError<crate::error::ListVersionsError>,
>,
> + 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_versions_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;
}
}
})
})
}
}