Struct aws_sdk_ec2::model::volume_modification::Builder

source ·

pub struct Builder { /* private fields */ }

Expand description

The modification completion or failure time.

Examples found in repository ?

src/xml_deser.rs (line 38044)

pub fn deser_structure_crate_model_volume_modification(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::VolumeModification, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::VolumeModification::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("volumeId") /* VolumeId com.amazonaws.ec2#VolumeModification$VolumeId */ =>  {
                let var_1586 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_volume_id(var_1586);
            }
            ,
            s if s.matches("modificationState") /* ModificationState com.amazonaws.ec2#VolumeModification$ModificationState */ =>  {
                let var_1587 =
                    Some(
                        Result::<crate::model::VolumeModificationState, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::VolumeModificationState::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_modification_state(var_1587);
            }
            ,
            s if s.matches("statusMessage") /* StatusMessage com.amazonaws.ec2#VolumeModification$StatusMessage */ =>  {
                let var_1588 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_status_message(var_1588);
            }
            ,
            s if s.matches("targetSize") /* TargetSize com.amazonaws.ec2#VolumeModification$TargetSize */ =>  {
                let var_1589 =
                    Some(
                         {
                            <i32 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (integer: `com.amazonaws.ec2#Integer`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_target_size(var_1589);
            }
            ,
            s if s.matches("targetIops") /* TargetIops com.amazonaws.ec2#VolumeModification$TargetIops */ =>  {
                let var_1590 =
                    Some(
                         {
                            <i32 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (integer: `com.amazonaws.ec2#Integer`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_target_iops(var_1590);
            }
            ,
            s if s.matches("targetVolumeType") /* TargetVolumeType com.amazonaws.ec2#VolumeModification$TargetVolumeType */ =>  {
                let var_1591 =
                    Some(
                        Result::<crate::model::VolumeType, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::VolumeType::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_target_volume_type(var_1591);
            }
            ,
            s if s.matches("targetThroughput") /* TargetThroughput com.amazonaws.ec2#VolumeModification$TargetThroughput */ =>  {
                let var_1592 =
                    Some(
                         {
                            <i32 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (integer: `com.amazonaws.ec2#Integer`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_target_throughput(var_1592);
            }
            ,
            s if s.matches("targetMultiAttachEnabled") /* TargetMultiAttachEnabled com.amazonaws.ec2#VolumeModification$TargetMultiAttachEnabled */ =>  {
                let var_1593 =
                    Some(
                         {
                            <bool as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (boolean: `com.amazonaws.ec2#Boolean`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_target_multi_attach_enabled(var_1593);
            }
            ,
            s if s.matches("originalSize") /* OriginalSize com.amazonaws.ec2#VolumeModification$OriginalSize */ =>  {
                let var_1594 =
                    Some(
                         {
                            <i32 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (integer: `com.amazonaws.ec2#Integer`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_original_size(var_1594);
            }
            ,
            s if s.matches("originalIops") /* OriginalIops com.amazonaws.ec2#VolumeModification$OriginalIops */ =>  {
                let var_1595 =
                    Some(
                         {
                            <i32 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (integer: `com.amazonaws.ec2#Integer`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_original_iops(var_1595);
            }
            ,
            s if s.matches("originalVolumeType") /* OriginalVolumeType com.amazonaws.ec2#VolumeModification$OriginalVolumeType */ =>  {
                let var_1596 =
                    Some(
                        Result::<crate::model::VolumeType, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::VolumeType::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_original_volume_type(var_1596);
            }
            ,
            s if s.matches("originalThroughput") /* OriginalThroughput com.amazonaws.ec2#VolumeModification$OriginalThroughput */ =>  {
                let var_1597 =
                    Some(
                         {
                            <i32 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (integer: `com.amazonaws.ec2#Integer`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_original_throughput(var_1597);
            }
            ,
            s if s.matches("originalMultiAttachEnabled") /* OriginalMultiAttachEnabled com.amazonaws.ec2#VolumeModification$OriginalMultiAttachEnabled */ =>  {
                let var_1598 =
                    Some(
                         {
                            <bool as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (boolean: `com.amazonaws.ec2#Boolean`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_original_multi_attach_enabled(var_1598);
            }
            ,
            s if s.matches("progress") /* Progress com.amazonaws.ec2#VolumeModification$Progress */ =>  {
                let var_1599 =
                    Some(
                         {
                            <i64 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (long: `com.amazonaws.ec2#Long`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_progress(var_1599);
            }
            ,
            s if s.matches("startTime") /* StartTime com.amazonaws.ec2#VolumeModification$StartTime */ =>  {
                let var_1600 =
                    Some(
                        aws_smithy_types::DateTime::from_str(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            , aws_smithy_types::date_time::Format::DateTime
                        )
                        .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (timestamp: `com.amazonaws.ec2#DateTime`)"))
                        ?
                    )
                ;
                builder = builder.set_start_time(var_1600);
            }
            ,
            s if s.matches("endTime") /* EndTime com.amazonaws.ec2#VolumeModification$EndTime */ =>  {
                let var_1601 =
                    Some(
                        aws_smithy_types::DateTime::from_str(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            , aws_smithy_types::date_time::Format::DateTime
                        )
                        .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (timestamp: `com.amazonaws.ec2#DateTime`)"))
                        ?
                    )
                ;
                builder = builder.set_end_time(var_1601);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

source

pub fn build(self) -> VolumeModification

Consumes the builder and constructs a VolumeModification.

Examples found in repository ?

src/xml_deser.rs (line 38050)

pub fn deser_structure_crate_model_volume_modification(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::VolumeModification, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::VolumeModification::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("volumeId") /* VolumeId com.amazonaws.ec2#VolumeModification$VolumeId */ =>  {
                let var_1586 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_volume_id(var_1586);
            }
            ,
            s if s.matches("modificationState") /* ModificationState com.amazonaws.ec2#VolumeModification$ModificationState */ =>  {
                let var_1587 =
                    Some(
                        Result::<crate::model::VolumeModificationState, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::VolumeModificationState::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_modification_state(var_1587);
            }
            ,
            s if s.matches("statusMessage") /* StatusMessage com.amazonaws.ec2#VolumeModification$StatusMessage */ =>  {
                let var_1588 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_status_message(var_1588);
            }
            ,
            s if s.matches("targetSize") /* TargetSize com.amazonaws.ec2#VolumeModification$TargetSize */ =>  {
                let var_1589 =
                    Some(
                         {
                            <i32 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (integer: `com.amazonaws.ec2#Integer`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_target_size(var_1589);
            }
            ,
            s if s.matches("targetIops") /* TargetIops com.amazonaws.ec2#VolumeModification$TargetIops */ =>  {
                let var_1590 =
                    Some(
                         {
                            <i32 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (integer: `com.amazonaws.ec2#Integer`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_target_iops(var_1590);
            }
            ,
            s if s.matches("targetVolumeType") /* TargetVolumeType com.amazonaws.ec2#VolumeModification$TargetVolumeType */ =>  {
                let var_1591 =
                    Some(
                        Result::<crate::model::VolumeType, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::VolumeType::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_target_volume_type(var_1591);
            }
            ,
            s if s.matches("targetThroughput") /* TargetThroughput com.amazonaws.ec2#VolumeModification$TargetThroughput */ =>  {
                let var_1592 =
                    Some(
                         {
                            <i32 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (integer: `com.amazonaws.ec2#Integer`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_target_throughput(var_1592);
            }
            ,
            s if s.matches("targetMultiAttachEnabled") /* TargetMultiAttachEnabled com.amazonaws.ec2#VolumeModification$TargetMultiAttachEnabled */ =>  {
                let var_1593 =
                    Some(
                         {
                            <bool as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (boolean: `com.amazonaws.ec2#Boolean`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_target_multi_attach_enabled(var_1593);
            }
            ,
            s if s.matches("originalSize") /* OriginalSize com.amazonaws.ec2#VolumeModification$OriginalSize */ =>  {
                let var_1594 =
                    Some(
                         {
                            <i32 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (integer: `com.amazonaws.ec2#Integer`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_original_size(var_1594);
            }
            ,
            s if s.matches("originalIops") /* OriginalIops com.amazonaws.ec2#VolumeModification$OriginalIops */ =>  {
                let var_1595 =
                    Some(
                         {
                            <i32 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (integer: `com.amazonaws.ec2#Integer`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_original_iops(var_1595);
            }
            ,
            s if s.matches("originalVolumeType") /* OriginalVolumeType com.amazonaws.ec2#VolumeModification$OriginalVolumeType */ =>  {
                let var_1596 =
                    Some(
                        Result::<crate::model::VolumeType, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::VolumeType::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_original_volume_type(var_1596);
            }
            ,
            s if s.matches("originalThroughput") /* OriginalThroughput com.amazonaws.ec2#VolumeModification$OriginalThroughput */ =>  {
                let var_1597 =
                    Some(
                         {
                            <i32 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (integer: `com.amazonaws.ec2#Integer`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_original_throughput(var_1597);
            }
            ,
            s if s.matches("originalMultiAttachEnabled") /* OriginalMultiAttachEnabled com.amazonaws.ec2#VolumeModification$OriginalMultiAttachEnabled */ =>  {
                let var_1598 =
                    Some(
                         {
                            <bool as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (boolean: `com.amazonaws.ec2#Boolean`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_original_multi_attach_enabled(var_1598);
            }
            ,
            s if s.matches("progress") /* Progress com.amazonaws.ec2#VolumeModification$Progress */ =>  {
                let var_1599 =
                    Some(
                         {
                            <i64 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (long: `com.amazonaws.ec2#Long`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_progress(var_1599);
            }
            ,
            s if s.matches("startTime") /* StartTime com.amazonaws.ec2#VolumeModification$StartTime */ =>  {
                let var_1600 =
                    Some(
                        aws_smithy_types::DateTime::from_str(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            , aws_smithy_types::date_time::Format::DateTime
                        )
                        .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (timestamp: `com.amazonaws.ec2#DateTime`)"))
                        ?
                    )
                ;
                builder = builder.set_start_time(var_1600);
            }
            ,
            s if s.matches("endTime") /* EndTime com.amazonaws.ec2#VolumeModification$EndTime */ =>  {
                let var_1601 =
                    Some(
                        aws_smithy_types::DateTime::from_str(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            , aws_smithy_types::date_time::Format::DateTime
                        )
                        .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (timestamp: `com.amazonaws.ec2#DateTime`)"))
                        ?
                    )
                ;
                builder = builder.set_end_time(var_1601);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

Trait Implementations§

source §

impl Clone for Builder

source §

fn clone(&self) -> Builder

Returns a copy of the value. Read more

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason. Read more

source §

impl StructuralPartialEq for Builder

impl<T> ToOwned for Twhere
T: Clone,

§

type Owned = T

impl<T> WithSubscriber for T

source §

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

source §

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more

Struct aws_sdk_ec2::model::volume_modification::Builder

Implementations§

impl Builder

pub fn volume_id(self, input: impl Into<String>) -> Self

pub fn set_volume_id(self, input: Option<String>) -> Self

pub fn modification_state(self, input: VolumeModificationState) -> Self

pub fn set_modification_state( self, input: Option<VolumeModificationState>) -> Self

pub fn status_message(self, input: impl Into<String>) -> Self

pub fn set_status_message(self, input: Option<String>) -> Self

pub fn target_size(self, input: i32) -> Self

pub fn set_target_size(self, input: Option<i32>) -> Self

pub fn target_iops(self, input: i32) -> Self

pub fn set_target_iops(self, input: Option<i32>) -> Self

pub fn target_volume_type(self, input: VolumeType) -> Self

pub fn set_target_volume_type(self, input: Option<VolumeType>) -> Self

pub fn target_throughput(self, input: i32) -> Self

pub fn set_target_throughput(self, input: Option<i32>) -> Self

pub fn target_multi_attach_enabled(self, input: bool) -> Self

pub fn set_target_multi_attach_enabled(self, input: Option<bool>) -> Self

pub fn original_size(self, input: i32) -> Self

pub fn set_original_size(self, input: Option<i32>) -> Self

pub fn original_iops(self, input: i32) -> Self

pub fn set_original_iops(self, input: Option<i32>) -> Self

pub fn original_volume_type(self, input: VolumeType) -> Self

pub fn set_original_volume_type(self, input: Option<VolumeType>) -> Self

pub fn original_throughput(self, input: i32) -> Self

pub fn set_original_throughput(self, input: Option<i32>) -> Self

pub fn original_multi_attach_enabled(self, input: bool) -> Self

pub fn set_original_multi_attach_enabled(self, input: Option<bool>) -> Self

pub fn progress(self, input: i64) -> Self

pub fn set_progress(self, input: Option<i64>) -> Self

pub fn start_time(self, input: DateTime) -> Self

pub fn set_start_time(self, input: Option<DateTime>) -> Self

pub fn end_time(self, input: DateTime) -> Self

pub fn set_end_time(self, input: Option<DateTime>) -> Self

pub fn build(self) -> VolumeModification

Trait Implementations§

impl Clone for Builder

fn clone(&self) -> Builder

fn clone_from(&mut self, source: &Self)

impl Debug for Builder

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Default for Builder

fn default() -> Builder

impl PartialEq<Builder> for Builder

fn eq(&self, other: &Builder) -> bool

fn ne(&self, other: &Rhs) -> bool

impl StructuralPartialEq for Builder

Auto Trait Implementations§

impl RefUnwindSafe for Builder

impl Send for Builder

impl Sync for Builder

impl Unpin for Builder

impl UnwindSafe for Builder

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> From<T> for T

fn from(t: T) -> T

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

fn in_current_span(self) -> Instrumented<Self>

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T> Same<T> for T

type Output = T

impl<T> ToOwned for Twhere T: Clone,

type Owned = T

fn to_owned(&self) -> T

fn clone_into(&self, target: &mut T)

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

pub fn set_modification_state(
self,
input: Option<VolumeModificationState>
) -> Self

impl<T> Any for Twhere
T: 'static + ?Sized,

impl<T> Borrow<T> for Twhere
T: ?Sized,

impl<T> BorrowMut<T> for Twhere
T: ?Sized,

impl<T, U> Into<U> for Twhere
U: From<T>,

impl<T> ToOwned for Twhere
T: Clone,

impl<T, U> TryFrom<U> for Twhere
U: Into<T>,

impl<T, U> TryInto<U> for Twhere
U: TryFrom<T>,

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
S: Into<Dispatch>,