Struct VldBool 

pub struct VldBool<S> { /* private fields */ }

A validated boolean column: a bool that passed schema S (checked as {"value": b}).

Implementations

impl<S: VldParse> VldBool<S>

pub fn new(input: impl Into<bool>) -> Result<Self, VldSqlxError>

Create a validated value; input is checked as {"value": input} against S.

impl<S> VldBool<S>

pub fn new_unchecked(input: impl Into<bool>) -> Self

Create without validation (e.g. for data loaded from a trusted DB).

impl<S> VldBool<S>

pub fn get(&self) -> bool

Get the inner value.

Methods from Deref<Target = bool>

pub fn then_some<T>(self, t: T) -> Option<T>

Returns Some(t) if the bool is true, or None otherwise.

Arguments passed to then_some are eagerly evaluated; if you are passing the result of a function call, it is recommended to use then, which is lazily evaluated.

Examples

assert_eq!(false.then_some(0), None);
assert_eq!(true.then_some(0), Some(0));

let mut a = 0;
let mut function_with_side_effects = || { a += 1; };

true.then_some(function_with_side_effects());
false.then_some(function_with_side_effects());

// `a` is incremented twice because the value passed to `then_some` is
// evaluated eagerly.
assert_eq!(a, 2);

pub fn then<T, F>(self, f: F) -> Option<T>

where F: FnOnce() -> T,

Returns Some(f()) if the bool is true, or None otherwise.

Examples

assert_eq!(false.then(|| 0), None);
assert_eq!(true.then(|| 0), Some(0));

let mut a = 0;

true.then(|| { a += 1; });
false.then(|| { a += 1; });

// `a` is incremented once because the closure is evaluated lazily by
// `then`.
assert_eq!(a, 1);

pub fn ok_or<E>(self, err: E) -> Result<(), E>

Returns Ok(()) if the bool is true, or Err(err) otherwise.

Arguments passed to ok_or are eagerly evaluated; if you are passing the result of a function call, it is recommended to use ok_or_else, which is lazily evaluated.

Examples

assert_eq!(false.ok_or(0), Err(0));
assert_eq!(true.ok_or(0), Ok(()));

let mut a = 0;
let mut function_with_side_effects = || { a += 1; };

assert!(true.ok_or(function_with_side_effects()).is_ok());
assert!(false.ok_or(function_with_side_effects()).is_err());

// `a` is incremented twice because the value passed to `ok_or` is
// evaluated eagerly.
assert_eq!(a, 2);

pub fn ok_or_else<E, F>(self, f: F) -> Result<(), E>

where F: FnOnce() -> E,

Returns Ok(()) if the bool is true, or Err(f()) otherwise.

Examples

assert_eq!(false.ok_or_else(|| 0), Err(0));
assert_eq!(true.ok_or_else(|| 0), Ok(()));

let mut a = 0;

assert!(true.ok_or_else(|| { a += 1; }).is_ok());
assert!(false.ok_or_else(|| { a += 1; }).is_err());

// `a` is incremented once because the closure is evaluated lazily by
// `ok_or_else`.
assert_eq!(a, 1);

pub unsafe fn unchecked_disjoint_bitor(self, rhs: bool) -> bool

🔬This is a nightly-only experimental API. (disjoint_bitor)

Disjoint, bitwise or. Computes self | rhs, assuming at most one, true value.

Practically, this requires that self | rhs and self ^ rhs both yield the same result, allowing for any of the two to be emitted in codegen – depending on whichever is cheapest.

Examples

#![feature(disjoint_bitor)]

assert_eq!(
    // SAFETY: Only one, true value is passed.
    unsafe { false.unchecked_disjoint_bitor(true) },
    true,
);

assert_eq!(
    // SAFETY: No true values are passed.
    unsafe { false.unchecked_disjoint_bitor(false) },
    false,
);

Safety

This results in undefined behaviour if both self and rhs are true.

Trait Implementations

impl<S> Clone for VldBool<S>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S> Copy for VldBool<S>

impl<S> Debug for VldBool<S>

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

Formats the value using the given formatter.

impl<'r, S, DB: Database> Decode<'r, DB> for VldBool<S>

where bool: Decode<'r, DB>,

fn decode(value: <DB as Database>::ValueRef<'r>) -> Result<Self, BoxDynError>

Decode a new value of this type using a raw value from the database.

impl<S> Deref for VldBool<S>

type Target = bool

The resulting type after dereferencing.

fn deref(&self) -> &bool

Dereferences the value.

impl<'de, S: VldParse> Deserialize<'de> for VldBool<S>

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<S> Display for VldBool<S>

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

Formats the value using the given formatter.

impl<'q, S, DB: Database> Encode<'q, DB> for VldBool<S>

where bool: Encode<'q, DB>,

fn encode_by_ref( &self, buf: &mut <DB as Database>::ArgumentBuffer, ) -> Result<IsNull, BoxDynError>

Writes the value of self into buf without moving self.

fn encode( self, buf: &mut <DB as Database>::ArgumentBuffer, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>

where Self: Sized,

Writes the value of self into buf in the expected format for the database.

fn produces(&self) -> Option<<DB as Database>::TypeInfo>

fn size_hint(&self) -> usize

impl<S> Eq for VldBool<S>

impl<S> Hash for VldBool<S>

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<S> Ord for VldBool<S>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl<S> PartialEq for VldBool<S>

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

Equality operator ==.

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

Inequality operator !=.

impl<S> PartialOrd for VldBool<S>

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<S> Serialize for VldBool<S>

fn serialize<Ser: Serializer>( &self, serializer: Ser, ) -> Result<Ser::Ok, Ser::Error>

Serialize this value into the given Serde serializer.

impl<S, DB: Database> Type<DB> for VldBool<S>

where bool: Type<DB>,

fn type_info() -> DB::TypeInfo

Returns the canonical SQL type for this Rust type.

fn compatible(ty: &DB::TypeInfo) -> bool

Determines if this Rust type is compatible with the given SQL type.