Struct fraction::prelude::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: 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> 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, P> Eq for GenericDecimal<T, P> where
    T: Clone + GenericInteger + Eq,
    P: Copy + GenericInteger + Into<usize>, 

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

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> 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,
    P: Copy + Integer + Into<usize>, 

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

Formats the value using the given formatter.

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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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<S, T, P> ParseScalarValue<S> for GenericDecimal<T, P> where
    S: ScalarValue,
    &'a S: ScalarRefValue<'a>,
    T: Clone + GenericInteger + From<u8> + Display,
    P: Copy + GenericInteger + Into<usize> + From<u8>, 

fn from_str<'a>(value: ScalarToken<'a>) -> ParseScalarResult<'a, S>

See the trait documentation

impl<S, T, P> ToInputValue<S> for GenericDecimal<T, P> where
    S: ScalarValue,
    &'a S: ScalarRefValue<'a>,
    T: Clone + GenericInteger + Display + From<u8>,
    P: Copy + Integer + Into<usize>, 

fn to_input_value(&self) -> InputValue<S>

Performs the conversion.

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

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

Performs the conversion.

impl<S, T, P> GraphQLType<S> for GenericDecimal<T, P> where
    S: ScalarValue,
    &'a S: ScalarRefValue<'a>,
    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, S>) -> MetaType<'r, S> where
    S: 'r, 

The meta type representing this GraphQL type.

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

Resolve the provided selection set against the current object.

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

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<S>]>,
    executor: &Executor<Self::Context, S>
) -> Result<Value<S>, FieldError<S>>

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 + Send + Sync>>

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 + Send + Sync>>

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