Struct aws_sdk_ec2::model::HostReservation

#[non_exhaustive]
pub struct HostReservation { /* private fields */ }

Details about the Dedicated Host Reservation and associated Dedicated Hosts.

Implementations

impl HostReservation

pub fn count(&self) -> Option<i32>

The number of Dedicated Hosts the reservation is associated with.

pub fn currency_code(&self) -> Option<&CurrencyCodeValues>

The currency in which the upfrontPrice and hourlyPrice amounts are specified. At this time, the only supported currency is USD.

pub fn duration(&self) -> Option<i32>

The length of the reservation's term, specified in seconds. Can be 31536000 (1 year) | 94608000 (3 years).

pub fn end(&self) -> Option<&DateTime>

The date and time that the reservation ends.

pub fn host_id_set(&self) -> Option<&[String]>

The IDs of the Dedicated Hosts associated with the reservation.

pub fn host_reservation_id(&self) -> Option<&str>

The ID of the reservation that specifies the associated Dedicated Hosts.

pub fn hourly_price(&self) -> Option<&str>

The hourly price of the reservation.

pub fn instance_family(&self) -> Option<&str>

The instance family of the Dedicated Host Reservation. The instance family on the Dedicated Host must be the same in order for it to benefit from the reservation.

pub fn offering_id(&self) -> Option<&str>

The ID of the reservation. This remains the same regardless of which Dedicated Hosts are associated with it.

pub fn payment_option(&self) -> Option<&PaymentOption>

The payment option selected for this reservation.

pub fn start(&self) -> Option<&DateTime>

The date and time that the reservation started.

pub fn state(&self) -> Option<&ReservationState>

The state of the reservation.

pub fn upfront_price(&self) -> Option<&str>

The upfront price of the reservation.

pub fn tags(&self) -> Option<&[Tag]>

Any tags assigned to the Dedicated Host Reservation.

impl HostReservation

pub fn builder() -> Builder

Creates a new builder-style object to manufacture HostReservation.

Examples found in repository

src/xml_deser.rs (line 45654)

pub fn deser_structure_crate_model_host_reservation(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::HostReservation, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::HostReservation::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("count") /* Count com.amazonaws.ec2#HostReservation$Count */ =>  {
                let var_2037 =
                    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_count(var_2037);
            }
            ,
            s if s.matches("currencyCode") /* CurrencyCode com.amazonaws.ec2#HostReservation$CurrencyCode */ =>  {
                let var_2038 =
                    Some(
                        Result::<crate::model::CurrencyCodeValues, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::CurrencyCodeValues::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_currency_code(var_2038);
            }
            ,
            s if s.matches("duration") /* Duration com.amazonaws.ec2#HostReservation$Duration */ =>  {
                let var_2039 =
                    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_duration(var_2039);
            }
            ,
            s if s.matches("end") /* End com.amazonaws.ec2#HostReservation$End */ =>  {
                let var_2040 =
                    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(var_2040);
            }
            ,
            s if s.matches("hostIdSet") /* HostIdSet com.amazonaws.ec2#HostReservation$HostIdSet */ =>  {
                let var_2041 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_ec2_response_host_id_set(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_host_id_set(var_2041);
            }
            ,
            s if s.matches("hostReservationId") /* HostReservationId com.amazonaws.ec2#HostReservation$HostReservationId */ =>  {
                let var_2042 =
                    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_host_reservation_id(var_2042);
            }
            ,
            s if s.matches("hourlyPrice") /* HourlyPrice com.amazonaws.ec2#HostReservation$HourlyPrice */ =>  {
                let var_2043 =
                    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_hourly_price(var_2043);
            }
            ,
            s if s.matches("instanceFamily") /* InstanceFamily com.amazonaws.ec2#HostReservation$InstanceFamily */ =>  {
                let var_2044 =
                    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_instance_family(var_2044);
            }
            ,
            s if s.matches("offeringId") /* OfferingId com.amazonaws.ec2#HostReservation$OfferingId */ =>  {
                let var_2045 =
                    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_offering_id(var_2045);
            }
            ,
            s if s.matches("paymentOption") /* PaymentOption com.amazonaws.ec2#HostReservation$PaymentOption */ =>  {
                let var_2046 =
                    Some(
                        Result::<crate::model::PaymentOption, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::PaymentOption::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_payment_option(var_2046);
            }
            ,
            s if s.matches("start") /* Start com.amazonaws.ec2#HostReservation$Start */ =>  {
                let var_2047 =
                    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(var_2047);
            }
            ,
            s if s.matches("state") /* State com.amazonaws.ec2#HostReservation$State */ =>  {
                let var_2048 =
                    Some(
                        Result::<crate::model::ReservationState, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::ReservationState::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_state(var_2048);
            }
            ,
            s if s.matches("upfrontPrice") /* UpfrontPrice com.amazonaws.ec2#HostReservation$UpfrontPrice */ =>  {
                let var_2049 =
                    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_upfront_price(var_2049);
            }
            ,
            s if s.matches("tagSet") /* Tags com.amazonaws.ec2#HostReservation$Tags */ =>  {
                let var_2050 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_ec2_tag_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_tags(var_2050);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

Trait Implementations

impl Clone for HostReservation

fn clone(&self) -> HostReservation

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for HostReservation

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

Formats the value using the given formatter.

impl PartialEq<HostReservation> for HostReservation

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl StructuralPartialEq for HostReservation