Enum FieldScalarValue 

pub enum FieldScalarValue {
    Unit,
    Bool(bool),
    I8(i8),
    I16(i16),
    I32(i32),
    I64(i64),
    I128(i128),
    U8(u8),
    U16(u16),
    U32(u32),
    U64(u64),
    U128(u128),
    F32(f32),
    F64(f64),
    Char(char),
    String(String),
    Bytes(Vec<u8>),
    Option(Option<Box<FieldScalarValue>>),
}

Represents the scalar value extracted from a field.

This enum covers the range of primitive types and simple collections (like Vec<u8>) that the FieldExtractor can successfully extract.

Variants

Unit

Unit value (()).

Bool(bool)

Boolean value (bool).

I8(i8)

Signed 8-bit integer (i8).

I16(i16)

Signed 16-bit integer (i16).

I32(i32)

Signed 32-bit integer (i32).

I64(i64)

Signed 64-bit integer (i64).

I128(i128)

Signed 128-bit integer (i128).

U8(u8)

Unsigned 8-bit integer (u8).

U16(u16)

Unsigned 16-bit integer (u16).

U32(u32)

Unsigned 32-bit integer (u32).

U64(u64)

Unsigned 64-bit integer (u64).

U128(u128)

Unsigned 128-bit integer (u128).

F32(f32)

32-bit floating point number (f32).

F64(f64)

64-bit floating point number (f64).

Char(char)

Character (char).

String(String)

String (String).

Bytes(Vec<u8>)

Byte array (Vec<u8>), typically extracted using #[serde(with = "serde_bytes")].

Option(Option<Box<FieldScalarValue>>)

Optional scalar value (Option<T>). Contains None or Some(Box<FieldScalarValue>).

Trait Implementations

impl Clone for FieldScalarValue

fn clone(&self) -> FieldScalarValue

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FieldScalarValue

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FieldScalarValue

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for FieldScalarValue

fn eq(&self, other: &FieldScalarValue) -> 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 Serialize for FieldScalarValue

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for FieldScalarValue