Struct Product 

pub struct Product<T, U>
where
    T: Unsigned,
    U: Float,
{
    pub quantity: T,
    pub weight: U,
    pub dimensions: Dimensions<U>,
    pub description: String,
    pub id: Option<u32>,
}

Fields

quantity: T

weight: U

dimensions: Dimensions<U>

description: String

id: Option<u32>

Implementations

impl<T, U> Product<T, U>

where T: Unsigned + Serialize + Default, U: Float + Serialize + Default,

pub fn new() -> Self

Creates a new empty Product instance

This is a convenience function to create a valid Product fast

Examples

For example, there is an opaque function that modifies the product

// use transdirect::prelude::Product;
// 
// fn deliver_extra(prod: &mut Product) -> Result<(), String> {
//     
// }
// let m = Product::new();
                

Trait Implementations

impl<T, U> Clone for Product<T, U>

where T: Unsigned + Clone, U: Float + Clone,

fn clone(&self) -> Product<T, U>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, U> Debug for Product<T, U>

where T: Unsigned + Debug, U: Float + Debug,

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

Formats the value using the given formatter.

impl<T, U> Default for Product<T, U>

where T: Unsigned + Default, U: Float + Default,

fn default() -> Product<T, U>

Returns the “default value” for a type.

impl<'de, T, U> Deserialize<'de> for Product<T, U>

where T: Unsigned + Deserialize<'de>, U: Float + Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T, U> PartialEq for Product<T, U>

where T: Unsigned + PartialEq, U: Float + PartialEq,

fn eq(&self, other: &Product<T, U>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T, U> Serialize for Product<T, U>

where T: Unsigned + Serialize, U: Float + Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T, U> Eq for Product<T, U>

where T: Unsigned + Eq, U: Float + Eq,

impl<T, U> StructuralPartialEq for Product<T, U>

where T: Unsigned, U: Float,