Struct fraction::GenericDecimal

pub struct GenericDecimal<T, P>(_, _)
 where
    T: Clone + Integer,
    P: Copy + Integer + Into<usize>;

Decimal type implementation

T is the type for data P is the type for precision

Uses GenericFraction internally to represent the data. Precision is being used for representation purposes only. Calculations do not use precision, but comparison does.

Examples

use fraction::GenericDecimal;

type Decimal = GenericDecimal<u64, u8>;

let d1 = Decimal::from(12);
let d2 = Decimal::from(0.5);

let mul = d1 * d2;
let div = d1 / d2;
let add = d1 + d2;

assert_eq!(mul, 6.into());
assert_eq!(div, Decimal::from("24.00"));
assert_eq!(add, Decimal::from(12.5));

Methods

impl<T, P> GenericDecimal<T, P> where     T: Clone + GenericInteger,     P: Copy + GenericInteger + Into<usize>,

pub fn sign(&self) -> Option<Sign> where     T: CheckedAdd + CheckedMul + CheckedSub,

pub fn set_precision(self, precision: P) -> Self

pub fn get_precision(&self) -> P

pub fn calc_precision(self) -> Self where     T: CheckedMul + DivAssign + MulAssign + SubAssign + ToPrimitive + GenericInteger,     P: Bounded + CheckedAdd,

pub fn nan() -> Self

pub fn infinity() -> Self

pub fn neg_infinity() -> Self

pub fn neg_zero() -> Self

pub fn min_positive_value() -> Self where     T: Bounded,     P: Bounded,

pub fn is_nan(&self) -> bool

pub fn is_infinite(&self) -> bool

pub fn is_finite(&self) -> bool

pub fn is_normal(&self) -> bool

pub fn classify(&self) -> FpCategory

pub fn floor(&self) -> Self

pub fn ceil(&self) -> Self

pub fn round(&self) -> Self

pub fn trunc(&self) -> Self

pub fn fract(&self) -> Self

pub fn abs(&self) -> Self

pub fn signum(&self) -> Self

pub fn is_sign_positive(&self) -> bool

pub fn is_sign_negative(&self) -> bool

pub fn mul_add(&self, a: Self, b: Self) -> Self

pub fn recip(&self) -> Self

pub fn map(     self,     fun: impl FnOnce(GenericFraction<T>) -> GenericFraction<T> ) -> Self

pub fn map_mut(     &mut self,     fun: impl FnOnce(&mut GenericFraction<T>) )

pub fn map_ref(     &self,     fun: impl FnOnce(&GenericFraction<T>) -> GenericFraction<T> ) -> Self

pub fn apply_ref<R>(     &self,     fun: impl FnOnce(&GenericFraction<T>, P) -> R ) -> R

pub fn from_decimal_str(val: &str) -> Result<Self, ParseError> where     T: CheckedAdd + CheckedMul + CheckedSub,     P: From<u8> + CheckedAdd,

pub fn from_fraction(fraction: GenericFraction<T>) -> Self where     T: GenericInteger + ToPrimitive,     P: Bounded + CheckedAdd,

Convert from a GenericFraction

Automatically calculates precision, so for "bad" numbers may take a lot of CPU cycles, especially if precision represented by big types (e.g. usize)

Examples

use fraction::{Fraction, Decimal};

let from_fraction = Decimal::from_fraction(Fraction::new(1u64, 3u64));
let from_division = Decimal::from(1) / Decimal::from(3);

let d1 = Decimal::from(4) / from_fraction;
let d2 = Decimal::from(4) / from_division;

assert_eq!(d1, d2);
assert_eq!(d1, Decimal::from(12));

Trait Implementations

impl<T, F, P1, P2> TryToConvertFrom<GenericDecimal<F, P1>> for GenericDecimal<T, P2> where     T: Copy + Integer + TryToConvertFrom<F>,     F: Copy + Integer,     P2: Copy + Integer + Into<usize> + TryToConvertFrom<P1>,     P1: Copy + Integer + Into<usize>,

fn try_to_convert_from(src: GenericDecimal<F, P1>) -> Option<Self>

impl<T, P> PartialOrd<GenericDecimal<T, P>> for GenericDecimal<T, P> where     T: Clone + GenericInteger + PartialOrd,     P: Copy + GenericInteger + Into<usize>,

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use] fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use] fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use] fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use] fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, P> PartialEq<GenericDecimal<T, P>> for GenericDecimal<T, P> where     T: Clone + GenericInteger + PartialEq,     P: Copy + GenericInteger + Into<usize>,

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

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T, P> From<f32> for GenericDecimal<T, P> where     T: Clone + GenericInteger,     P: Copy + GenericInteger + Into<usize> + From<u8>,

fn from(value: f32) -> Self

Performs the conversion.

impl<T, P> From<f64> for GenericDecimal<T, P> where     T: Clone + GenericInteger,     P: Copy + GenericInteger + Into<usize> + From<u8>,

fn from(value: f64) -> Self

Performs the conversion.

impl<T, P> From<u8> for GenericDecimal<T, P> where     T: Clone + GenericInteger,     P: Copy + GenericInteger + Into<usize>,

fn from(value: u8) -> Self

Performs the conversion.

impl<T, P> From<i8> for GenericDecimal<T, P> where     T: Clone + GenericInteger,     P: Copy + GenericInteger + Into<usize>,

fn from(value: i8) -> Self

Performs the conversion.

impl<T, P> From<u16> for GenericDecimal<T, P> where     T: Clone + GenericInteger,     P: Copy + GenericInteger + Into<usize>,

fn from(value: u16) -> Self

Performs the conversion.

impl<T, P> From<i16> for GenericDecimal<T, P> where     T: Clone + GenericInteger,     P: Copy + GenericInteger + Into<usize>,

fn from(value: i16) -> Self

Performs the conversion.

impl<T, P> From<u32> for GenericDecimal<T, P> where     T: Clone + GenericInteger,     P: Copy + GenericInteger + Into<usize>,

fn from(value: u32) -> Self

Performs the conversion.

impl<T, P> From<i32> for GenericDecimal<T, P> where     T: Clone + GenericInteger,     P: Copy + GenericInteger + Into<usize>,

fn from(value: i32) -> Self

Performs the conversion.

impl<T, P> From<u64> for GenericDecimal<T, P> where     T: Clone + GenericInteger,     P: Copy + GenericInteger + Into<usize>,

fn from(value: u64) -> Self

Performs the conversion.

impl<T, P> From<i64> for GenericDecimal<T, P> where     T: Clone + GenericInteger,     P: Copy + GenericInteger + Into<usize>,

fn from(value: i64) -> Self

Performs the conversion.

impl<T, P> From<u128> for GenericDecimal<T, P> where     T: Clone + GenericInteger,     P: Copy + GenericInteger + Into<usize>,

fn from(value: u128) -> Self

Performs the conversion.

impl<T, P> From<i128> for GenericDecimal<T, P> where     T: Clone + GenericInteger,     P: Copy + GenericInteger + Into<usize>,

fn from(value: i128) -> Self

Performs the conversion.

impl<T, P> From<usize> for GenericDecimal<T, P> where     T: Clone + GenericInteger,     P: Copy + GenericInteger + Into<usize>,

fn from(value: usize) -> Self

Performs the conversion.

impl<T, P> From<isize> for GenericDecimal<T, P> where     T: Clone + GenericInteger,     P: Copy + GenericInteger + Into<usize>,

fn from(value: isize) -> Self

Performs the conversion.

impl<'a, T, P> From<&'a str> for GenericDecimal<T, P> where     T: Clone + GenericInteger,     P: Copy + GenericInteger + Into<usize> + From<u8>,

fn from(value: &'a str) -> Self

Performs the conversion.

impl<T, P> From<BigUint> for GenericDecimal<T, P> where     T: Clone + GenericInteger,     P: Copy + GenericInteger + Into<usize>,

fn from(value: BigUint) -> Self

Performs the conversion.

impl<T, P> From<BigInt> for GenericDecimal<T, P> where     T: Clone + GenericInteger,     P: Copy + GenericInteger + Into<usize>,

fn from(value: BigInt) -> Self

Performs the conversion.

impl<T: Clone, P: Clone> Clone for GenericDecimal<T, P> where     T: Clone + Integer,     P: Copy + Integer + Into<usize>,

fn clone(&self) -> GenericDecimal<T, P>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, P> Copy for GenericDecimal<T, P> where     T: Copy + Integer,     P: Copy + Integer + Into<usize>,

impl<T, P> Eq for GenericDecimal<T, P> where     T: Clone + GenericInteger + Eq,     P: Copy + GenericInteger + Into<usize>,

impl<T, P> Debug for GenericDecimal<T, P> where     T: Clone + GenericInteger + From<u8> + ToPrimitive + Debug,     P: Copy + Integer + Into<usize>,

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

Formats the value using the given formatter.

impl<T, P> Display for GenericDecimal<T, P> where     T: Clone + GenericInteger + From<u8> + ToPrimitive + Display,     P: Copy + Integer + Into<usize>,

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

Formats the value using the given formatter.

impl<T, P> Sub<GenericDecimal<T, P>> for GenericDecimal<T, P> where     T: Clone + GenericInteger + Sub,     P: Copy + GenericInteger + Into<usize>,

type Output = Self

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self::Output

Performs the - operation.

impl<'a, T, P> Sub<&'a GenericDecimal<T, P>> for &'a GenericDecimal<T, P> where     T: Clone + GenericInteger + Sub,     P: Copy + GenericInteger + Into<usize>,     &'a T: Sub<Output = T>,

type Output = GenericDecimal<T, P>

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self::Output

Performs the - operation.

impl<T, P> Add<GenericDecimal<T, P>> for GenericDecimal<T, P> where     T: Clone + GenericInteger + Add,     P: Copy + GenericInteger + Into<usize>,

type Output = Self

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self::Output

Performs the + operation.

impl<'a, T, P> Add<&'a GenericDecimal<T, P>> for &'a GenericDecimal<T, P> where     T: Clone + GenericInteger + Add,     P: Copy + GenericInteger + Into<usize>,     &'a T: Add<Output = T>,

type Output = GenericDecimal<T, P>

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self::Output

Performs the + operation.

impl<T, P> Mul<GenericDecimal<T, P>> for GenericDecimal<T, P> where     T: Clone + GenericInteger + Mul,     P: Copy + GenericInteger + Into<usize>,

type Output = Self

The resulting type after applying the * operator.

fn mul(self, other: Self) -> Self::Output

Performs the * operation.

impl<'a, T, P> Mul<&'a GenericDecimal<T, P>> for &'a GenericDecimal<T, P> where     T: Clone + GenericInteger + Mul,     P: Copy + GenericInteger + Into<usize>,     &'a T: Mul<Output = T>,

type Output = GenericDecimal<T, P>

The resulting type after applying the * operator.

fn mul(self, other: Self) -> Self::Output

Performs the * operation.

impl<T, P> Div<GenericDecimal<T, P>> for GenericDecimal<T, P> where     T: Clone + GenericInteger + Div,     P: Copy + GenericInteger + Into<usize>,

type Output = Self

The resulting type after applying the / operator.

fn div(self, other: Self) -> Self::Output

Performs the / operation.

impl<'a, T, P> Div<&'a GenericDecimal<T, P>> for &'a GenericDecimal<T, P> where     T: Clone + GenericInteger + Div,     P: Copy + GenericInteger + Into<usize>,     &'a T: Div<Output = T>,

type Output = GenericDecimal<T, P>

The resulting type after applying the / operator.

fn div(self, other: Self) -> Self::Output

Performs the / operation.

impl<T, P> Rem<GenericDecimal<T, P>> for GenericDecimal<T, P> where     T: Clone + GenericInteger + Rem,     P: Copy + GenericInteger + Into<usize>,

type Output = Self

The resulting type after applying the % operator.

fn rem(self, other: Self) -> Self::Output

Performs the % operation.

impl<'a, T, P> Rem<&'a GenericDecimal<T, P>> for &'a GenericDecimal<T, P> where     T: Clone + GenericInteger + Rem,     P: Copy + GenericInteger + Into<usize>,     &'a T: Rem<Output = T>,

type Output = GenericDecimal<T, P>

The resulting type after applying the % operator.

fn rem(self, other: Self) -> Self::Output

Performs the % operation.

impl<T, P> Neg for GenericDecimal<T, P> where     T: Clone + GenericInteger,     P: Copy + Integer + Into<usize>,

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a, T, P> Neg for &'a GenericDecimal<T, P> where     T: Clone + GenericInteger,     P: Copy + Integer + Into<usize>,     &'a T: Neg<Output = T>,

type Output = GenericDecimal<T, P>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T, P> AddAssign<GenericDecimal<T, P>> for GenericDecimal<T, P> where     T: Clone + GenericInteger + DivAssign + SubAssign + MulAssign + AddAssign,     P: Copy + GenericInteger + Into<usize>,

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl<'a, T, P> AddAssign<&'a GenericDecimal<T, P>> for GenericDecimal<T, P> where     T: Clone + Integer + AddAssign + AddAssign<&'a T>,     P: Copy + Integer + Into<usize>,

fn add_assign(&mut self, other: &'a Self)

Performs the += operation.

impl<T, P> SubAssign<GenericDecimal<T, P>> for GenericDecimal<T, P> where     T: Clone + GenericInteger + DivAssign + SubAssign + MulAssign + SubAssign,     P: Copy + GenericInteger + Into<usize>,

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

impl<'a, T, P> SubAssign<&'a GenericDecimal<T, P>> for GenericDecimal<T, P> where     T: Clone + Integer + SubAssign + SubAssign<&'a T>,     P: Copy + Integer + Into<usize>,

fn sub_assign(&mut self, other: &'a Self)

Performs the -= operation.

impl<T, P> MulAssign<GenericDecimal<T, P>> for GenericDecimal<T, P> where     T: Clone + GenericInteger + DivAssign + SubAssign + MulAssign + MulAssign,     P: Copy + GenericInteger + Into<usize>,

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

impl<'a, T, P> MulAssign<&'a GenericDecimal<T, P>> for GenericDecimal<T, P> where     T: Clone + Integer + MulAssign + MulAssign<&'a T>,     P: Copy + Integer + Into<usize>,

fn mul_assign(&mut self, other: &'a Self)

Performs the *= operation.

impl<T, P> DivAssign<GenericDecimal<T, P>> for GenericDecimal<T, P> where     T: Clone + GenericInteger + DivAssign + SubAssign + MulAssign + DivAssign,     P: Copy + GenericInteger + Into<usize>,

fn div_assign(&mut self, other: Self)

Performs the /= operation.

impl<'a, T, P> DivAssign<&'a GenericDecimal<T, P>> for GenericDecimal<T, P> where     T: Clone + Integer + DivAssign + DivAssign<&'a T>,     P: Copy + Integer + Into<usize>,

fn div_assign(&mut self, other: &'a Self)

Performs the /= operation.

impl<T, P> RemAssign<GenericDecimal<T, P>> for GenericDecimal<T, P> where     T: Clone + GenericInteger + DivAssign + SubAssign + MulAssign + RemAssign,     P: Copy + GenericInteger + Into<usize>,

fn rem_assign(&mut self, other: Self)

Performs the %= operation.

impl<'a, T, P> RemAssign<&'a GenericDecimal<T, P>> for GenericDecimal<T, P> where     T: Clone + Integer + RemAssign + RemAssign<&'a T>,     P: Copy + Integer + Into<usize>,

fn rem_assign(&mut self, other: &'a Self)

Performs the %= operation.

impl<T, P> Hash for GenericDecimal<T, P> where     T: Clone + GenericInteger + PartialEq,     P: Copy + GenericInteger + Into<usize>,

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where     H: Hasher,

Feeds a slice of this type into the given [Hasher].

impl<T, P> ToPrimitive for GenericDecimal<T, P> where     T: Clone + GenericInteger + ToPrimitive,     P: Copy + GenericInteger + Into<usize>,

fn to_i64(&self) -> Option<i64>

Converts the value of self to an i64.

fn to_u64(&self) -> Option<u64>

Converts the value of self to an u64.

fn to_f64(&self) -> Option<f64>

Converts the value of self to an f64.

fn to_isize(&self) -> Option<isize>

Converts the value of self to an isize.

fn to_i8(&self) -> Option<i8>

Converts the value of self to an i8.

fn to_i16(&self) -> Option<i16>

Converts the value of self to an i16.

fn to_i32(&self) -> Option<i32>

Converts the value of self to an i32.

fn to_i128(&self) -> Option<i128>

Converts the value of self to an i128.

fn to_usize(&self) -> Option<usize>

Converts the value of self to a usize.

fn to_u8(&self) -> Option<u8>

Converts the value of self to an u8.

fn to_u16(&self) -> Option<u16>

Converts the value of self to an u16.

fn to_u32(&self) -> Option<u32>

Converts the value of self to an u32.

fn to_u128(&self) -> Option<u128>

Converts the value of self to an u128.

fn to_f32(&self) -> Option<f32>

Converts the value of self to an f32.

impl<T, P> Num for GenericDecimal<T, P> where     T: Clone + GenericInteger,     P: Copy + GenericInteger + Into<usize> + From<u8>,

type FromStrRadixErr = ParseError

fn from_str_radix(value: &str, base: u32) -> Result<Self, ParseError>

Convert from a string and radix <= 36.

impl<T, P> Bounded for GenericDecimal<T, P> where     T: Clone + GenericInteger + Bounded,     P: Copy + GenericInteger + Into<usize> + Bounded,

fn min_value() -> Self

returns the smallest finite number this type can represent

fn max_value() -> Self

returns the largest finite number this type can represent

impl<T, P> Zero for GenericDecimal<T, P> where     T: Clone + GenericInteger,     P: Copy + GenericInteger + Into<usize> + Zero,

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

impl<T, P> One for GenericDecimal<T, P> where     T: Clone + GenericInteger,     P: Copy + GenericInteger + Into<usize>,

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool where     Self: PartialEq<Self>,

Returns true if self is equal to the multiplicative identity.

impl<T, P> CheckedSub for GenericDecimal<T, P> where     T: Clone + GenericInteger + CheckedAdd + CheckedDiv + CheckedMul + CheckedSub + CheckedSub,     P: Copy + GenericInteger + Into<usize>,

fn checked_sub(&self, other: &Self) -> Option<Self>

Subtracts two numbers, checking for underflow. If underflow happens, None is returned.

impl<T, P> CheckedAdd for GenericDecimal<T, P> where     T: Clone + GenericInteger + CheckedAdd + CheckedDiv + CheckedMul + CheckedSub + CheckedAdd,     P: Copy + GenericInteger + Into<usize>,

fn checked_add(&self, other: &Self) -> Option<Self>

Adds two numbers, checking for overflow. If overflow happens, None is returned.

impl<T, P> CheckedMul for GenericDecimal<T, P> where     T: Clone + GenericInteger + CheckedAdd + CheckedDiv + CheckedMul + CheckedSub + CheckedMul,     P: Copy + GenericInteger + Into<usize>,

fn checked_mul(&self, other: &Self) -> Option<Self>

Multiplies two numbers, checking for underflow or overflow. If underflow or overflow happens, None is returned.

impl<T, P> CheckedDiv for GenericDecimal<T, P> where     T: Clone + GenericInteger + CheckedAdd + CheckedDiv + CheckedMul + CheckedSub + CheckedDiv,     P: Copy + GenericInteger + Into<usize>,

fn checked_div(&self, other: &Self) -> Option<Self>

Divides two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl<T, P> Signed for GenericDecimal<T, P> where     T: Clone + GenericInteger + Neg,     P: Copy + GenericInteger + Into<usize> + From<u8>,

fn abs(&self) -> Self

Computes the absolute value.

fn abs_sub(&self, other: &Self) -> Self

The positive difference of two numbers.

fn signum(&self) -> Self

Returns the sign of the number.

fn is_positive(&self) -> bool

Returns true if the number is positive and false if the number is zero or negative.

fn is_negative(&self) -> bool

Returns true if the number is negative and false if the number is zero or positive.

impl<T, P> Serialize for GenericDecimal<T, P> where     T: Clone + Integer,     P: Copy + Integer + Into<usize>,     T: Serialize,     P: Serialize,

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

Serialize this value into the given Serde serializer.

impl<'de, T, P> Deserialize<'de> for GenericDecimal<T, P> where     T: Clone + Integer,     P: Copy + Integer + Into<usize>,     T: Deserialize<'de>,     P: 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, P> ToInputValue for GenericDecimal<T, P> where     T: Clone + GenericInteger + Display + From<u8>,     P: Copy + Integer + Into<usize>,

fn to_input_value(&self) -> InputValue

Performs the conversion.

impl<T, P> FromInputValue for GenericDecimal<T, P> where     T: Clone + GenericInteger,     P: Copy + GenericInteger + Into<usize> + From<u8>,

fn from_input_value(value: &InputValue) -> Option<Self>

Performs the conversion.

impl<T, P> GraphQLType for GenericDecimal<T, P> where     T: Clone + GenericInteger + From<u8> + Display,     P: Copy + GenericInteger + Into<usize> + From<u8>,

type Context = ()

The expected context type for this GraphQL type

type TypeInfo = ()

Type that may carry additional schema information

fn name(_: &()) -> Option<&str>

The name of the GraphQL type to expose.

fn meta<'r>(info: &(), registry: &mut Registry<'r>) -> MetaType<'r>

The meta type representing this GraphQL type.

fn resolve(     &self,     _: &(),     _: Option<&[Selection]>,     _: &Executor<Self::Context> ) -> Value

Resolve the provided selection set against the current object.

fn resolve_field(     &self,     info: &Self::TypeInfo,     field_name: &str,     arguments: &Arguments,     executor: &Executor<Self::Context> ) -> Result<Value, FieldError>

Resolve the value of a single field on this type.

fn resolve_into_type(     &self,     info: &Self::TypeInfo,     type_name: &str,     selection_set: Option<&[Selection]>,     executor: &Executor<Self::Context> ) -> Result<Value, FieldError>

Resolve this interface or union into a concrete type

fn concrete_type_name(     &self,     context: &Self::Context,     info: &Self::TypeInfo ) -> String

Return the concrete type name for this instance/union.

impl<T, P> ToSql for GenericDecimal<T, P> where     T: Clone + GenericInteger + From<u8> + Debug,     P: Copy + GenericInteger + Into<usize> + Debug,

fn to_sql(     &self,     ty: &Type,     buf: &mut Vec<u8> ) -> Result<IsNull, Box<dyn Error + Sync + Send>>

Converts the value of self into the binary format of the specified Postgres Type, appending it to out.

fn accepts(ty: &Type) -> bool

Determines if a value of this type can be converted to the specified Postgres Type.

fn to_sql_checked(     &self,     ty: &Type,     out: &mut Vec<u8> ) -> Result<IsNull, Box<dyn Error + Sync + Send>>

An adaptor method used internally by Rust-Postgres.

impl<T, P> FromSql for GenericDecimal<T, P> where     T: Clone + GenericInteger + From<u16>,     P: Copy + GenericInteger + Into<usize> + Bounded + TryToConvertFrom<i16> + Display,

fn from_sql(ty: &Type, raw: &[u8]) -> Result<Self, Box<dyn Error + Sync + Send>>

Creates a new value of this type from a buffer of data of the specified Postgres Type in its binary format.

fn accepts(ty: &Type) -> bool

Determines if a value of this type can be created from the specified Postgres Type.

fn from_sql_null(     ty: &Type ) -> Result<Self, Box<dyn Error + 'static + Sync + Send>>

Creates a new value of this type from a NULL SQL value.

fn from_sql_nullable(     ty: &Type,     raw: Option<&[u8]> ) -> Result<Self, Box<dyn Error + 'static + Sync + Send>>

A convenience function that delegates to from_sql and from_sql_null depending on the value of raw.