MultiValues

prism3_value::multi_values

Enum MultiValues 

Source 
pub enum MultiValues {

Show 22 variants    Empty(DataType),
    Bool(Vec<bool>),
    Char(Vec<char>),
    Int8(Vec<i8>),
    Int16(Vec<i16>),
    Int32(Vec<i32>),
    Int64(Vec<i64>),
    Int128(Vec<i128>),
    UInt8(Vec<u8>),
    UInt16(Vec<u16>),
    UInt32(Vec<u32>),
    UInt64(Vec<u64>),
    UInt128(Vec<u128>),
    Float32(Vec<f32>),
    Float64(Vec<f64>),
    String(Vec<String>),
    Date(Vec<NaiveDate>),
    Time(Vec<NaiveTime>),
    DateTime(Vec<NaiveDateTime>),
    Instant(Vec<DateTime<Utc>>),
    BigInteger(Vec<BigInt>),
    BigDecimal(Vec<BigDecimal>),

}
Expand description

Multiple values container

Uses an enum to represent multiple values of different types, providing type-safe storage and access for multiple values.

§Features

  • Supports collections of multiple basic data types
  • Provides two sets of APIs for type checking and type conversion
  • Supports unified access to single and multiple values
  • Automatic memory management

§Example

ⓘ
use common_rs::util::value::MultiValues;

// Create integer multiple values
let mut values = MultiValues::Int32(vec![1, 2, 3]);
assert_eq!(values.count(), 3);
assert_eq!(values.get_first_int32().unwrap(), 1);

// Get all values
let all = values.get_int32s().unwrap();
assert_eq!(all, &[1, 2, 3]);

// Use generic method to add value
values.add(4).unwrap();
assert_eq!(values.count(), 4);

§Author

Haixing Hu

Variants§

§

Empty(DataType)

Empty value (has type but no values)

§

Bool(Vec<bool>)

Boolean value list

§

Char(Vec<char>)

Character value list

§

Int8(Vec<i8>)

i8 list

§

Int16(Vec<i16>)

i16 list

§

Int32(Vec<i32>)

i32 list

§

Int64(Vec<i64>)

i64 list

§

Int128(Vec<i128>)

i128 list

§

UInt8(Vec<u8>)

u8 list

§

UInt16(Vec<u16>)

u16 list

§

UInt32(Vec<u32>)

u32 list

§

UInt64(Vec<u64>)

u64 list

§

UInt128(Vec<u128>)

u128 list

§

Float32(Vec<f32>)

f32 list

§

Float64(Vec<f64>)

f64 list

§

String(Vec<String>)

String list

§

Date(Vec<NaiveDate>)

Date list

§

Time(Vec<NaiveTime>)

Time list

§

DateTime(Vec<NaiveDateTime>)

DateTime list

§

Instant(Vec<DateTime<Utc>>)

UTC instant list

§

BigInteger(Vec<BigInt>)

Big integer list

§

BigDecimal(Vec<BigDecimal>)

Big decimal list

Implementations§

Source§

impl MultiValues

Source

pub fn new<T>(values: Vec<T>) -> Self
where Self: MultiValuesConstructor<T>,

Generic constructor method

Creates MultiValues from Vec<T>, avoiding direct use of enum variants.

§Type Parameters
  • T - Element type
§Returns

Returns MultiValues wrapping the given value list

§Example
ⓘ
use crate::util::value::MultiValues;

// Basic types
let mv = MultiValues::new(vec![1, 2, 3]);
assert_eq!(mv.count(), 3);

// Strings
let mv = MultiValues::new(vec!["a".to_string(), "b".to_string()]);
assert_eq!(mv.count(), 2);

// Byte arrays
let mv = MultiValues::new(vec![vec![1u8, 2], vec![3, 4]]);
assert_eq!(mv.count(), 2);
Source

pub fn get<T>(&self) -> ValueResult<Vec<T>>
where Self: MultiValuesGetter<T>,

Generic getter method for multiple values

Automatically selects the correct getter method based on the target type, performing strict type checking.

§Type Parameters
  • T - The target element type to retrieve
§Returns

If types match, returns the list of values; otherwise returns an error

§Example
ⓘ
use crate::util::value::MultiValues;

let multi = MultiValues::Int32(vec![1, 2, 3]);

// Through type inference
let nums: Vec<i32> = multi.get().unwrap();
assert_eq!(nums, vec![1, 2, 3]);

// Explicitly specify type parameter
let nums = multi.get::<i32>().unwrap();
assert_eq!(nums, vec![1, 2, 3]);
Source

pub fn get_first<T>(&self) -> ValueResult<T>
where Self: MultiValuesFirstGetter<T>,

Generic getter method for the first value

Automatically selects the correct getter method based on the target type, performing strict type checking.

§Type Parameters
  • T - The target element type to retrieve
§Returns

If types match and a value exists, returns the first value; otherwise returns an error

§Example
ⓘ
use crate::util::value::MultiValues;

let multi = MultiValues::Int32(vec![42, 100, 200]);

// Through type inference
let first: i32 = multi.get_first().unwrap();
assert_eq!(first, 42);

// Explicitly specify type parameter
let first = multi.get_first::<i32>().unwrap();
assert_eq!(first, 42);

// String type
let multi = MultiValues::String(vec!["hello".to_string(), "world".to_string()]);
let first: String = multi.get_first().unwrap();
assert_eq!(first, "hello");
Source

pub fn set<'a, S>(&mut self, values: S) -> ValueResult<()>
where S: MultiValuesSetArg<'a>, Self: MultiValuesSetter<S::Item> + MultiValuesSetterSlice<S::Item> + MultiValuesSingleSetter<S::Item>,

Generic setter method

Automatically selects the optimal setter path based on the input type, replacing the entire list with strict type checking. Supports three input forms, all unified to this method via internal dispatch traits:

  • Vec<T>: Takes set_values(Vec<T>) path with zero additional allocation
  • &[T]: Takes set_values_slice(&[T]) path
  • T: Takes set_single_value(T) path
§Type Parameters
  • S - Input type, can be Vec<T>, &[T], or a single T
§Parameters
  • values - The value collection to set, can be Vec<T>, &[T], or a single T
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

§Example
ⓘ
use crate::lang::DataType;
use crate::util::value::MultiValues;

// 1) Vec<T>
let mut mv = MultiValues::Empty(DataType::Int32);
mv.set(vec![42, 100, 200]).unwrap();
assert_eq!(mv.get_int32s().unwrap(), &[42, 100, 200]);

// 2) &[T]
let mut mv = MultiValues::Empty(DataType::Int32);
let slice = &[7, 8, 9][..];
mv.set(slice).unwrap();
assert_eq!(mv.get_int32s().unwrap(), &[7, 8, 9]);

// 3) Single T
let mut mv = MultiValues::Empty(DataType::Int32);
mv.set(42).unwrap();
assert_eq!(mv.get_int32s().unwrap(), &[42]);

// String example
let mut mv = MultiValues::Empty(DataType::String);
mv.set(vec!["hello".to_string(), "world".to_string()]).unwrap();
assert_eq!(mv.get_strings().unwrap(), &["hello", "world"]);
Source

pub fn add<'a, S>(&mut self, values: S) -> ValueResult<()>
where S: MultiValuesAddArg<'a>, Self: MultiValuesAdder<S::Item> + MultiValuesMultiAdder<S::Item>,

Generic add method

Automatically selects the optimal add path based on the input type, appending elements to the existing list with strict type checking. Supports three input forms:

  • T: Takes add_value(T) path, appending a single element
  • Vec<T>: Takes add_values(Vec<T>) path, batch append (zero additional allocation)
  • &[T]: Takes add_values_slice(&[T]) path, batch append (using slice)
§Type Parameters
  • S - Input type, can be a single T, Vec<T>, or &[T]
§Example
ⓘ
use crate::lang::DataType;
use crate::util::value::MultiValues;

// 1) Single T
let mut mv = MultiValues::Int32(vec![42]);
mv.add(100).unwrap();
assert_eq!(mv.get_int32s().unwrap(), &[42, 100]);

// 2) Vec<T>
mv.add(vec![200, 300]).unwrap();
assert_eq!(mv.get_int32s().unwrap(), &[42, 100, 200, 300]);

// 3) &[T]
let slice = &[400, 500][..];
mv.add(slice).unwrap();
assert_eq!(mv.get_int32s().unwrap(), &[42, 100, 200, 300, 400, 500]);
Source

pub fn data_type(&self) -> DataType

Get the data type of the values

§Returns

Returns the data type corresponding to these multiple values

§Example
ⓘ
use crate::util::value::{MultiValues, DataType};

let values = MultiValues::Int32(vec![1, 2, 3]);
assert_eq!(values.data_type(), DataType::Int32);
Source

pub fn count(&self) -> usize

Get the number of values

§Returns

Returns the number of values contained in these multiple values

§Example
ⓘ
use crate::util::value::MultiValues;

let values = MultiValues::Int32(vec![1, 2, 3]);
assert_eq!(values.count(), 3);

let empty = MultiValues::Empty(DataType::String);
assert_eq!(empty.count(), 0);
Source

pub fn is_empty(&self) -> bool

Check if empty

§Returns

Returns true if these multiple values do not contain any values

§Example
ⓘ
use crate::util::value::{MultiValues, DataType};

let values = MultiValues::Int32(vec![]);
assert!(values.is_empty());

let empty = MultiValues::Empty(DataType::String);
assert!(empty.is_empty());
Source

pub fn clear(&mut self)

Clear all values while preserving the type

§Example
ⓘ
use crate::util::value::{MultiValues, DataType};

let mut values = MultiValues::Int32(vec![1, 2, 3]);
values.clear();
assert!(values.is_empty());
assert_eq!(values.data_type(), DataType::Int32);
Source

pub fn set_type(&mut self, data_type: DataType)

Set the data type

If the new type differs from the current type, clears all values and sets the new type.

§Parameters
  • data_type - The data type to set
§Example
ⓘ
use crate::util::value::{MultiValues, DataType};

let mut values = MultiValues::Int32(vec![1, 2, 3]);
values.set_type(DataType::String);
assert!(values.is_empty());
assert_eq!(values.data_type(), DataType::String);
Source

pub fn get_first_bool(&self) -> ValueResult<bool>

Get the first boolean value

§Returns

If types match and a value exists, returns the first boolean value; otherwise returns an error

§Example
ⓘ
use crate::util::value::MultiValues;

let values = MultiValues::Bool(vec![true, false]);
assert_eq!(values.get_first_bool().unwrap(), true);
Source

pub fn get_first_char(&self) -> ValueResult<char>

Get the first character value

§Returns

If types match and a value exists, returns the first character value; otherwise returns an error

Source

pub fn get_first_int8(&self) -> ValueResult<i8>

Get the first int8 value

§Returns

If types match and a value exists, returns the first int8 value; otherwise returns an error

Source

pub fn get_first_int16(&self) -> ValueResult<i16>

Get the first int16 value

§Returns

If types match and a value exists, returns the first int16 value; otherwise returns an error

Source

pub fn get_first_int32(&self) -> ValueResult<i32>

Get the first int32 value

§Returns

If types match and a value exists, returns the first int32 value; otherwise returns an error

Source

pub fn get_first_int64(&self) -> ValueResult<i64>

Get the first int64 value

§Returns

If types match and a value exists, returns the first int64 value; otherwise returns an error

Source

pub fn get_first_int128(&self) -> ValueResult<i128>

Get the first int128 value

§Returns

If types match and a value exists, returns the first int128 value; otherwise returns an error

Source

pub fn get_first_uint8(&self) -> ValueResult<u8>

Get the first uint8 value

§Returns

If types match and a value exists, returns the first uint8 value; otherwise returns an error

Source

pub fn get_first_uint16(&self) -> ValueResult<u16>

Get the first uint16 value

§Returns

If types match and a value exists, returns the first uint16 value; otherwise returns an error

Source

pub fn get_first_uint32(&self) -> ValueResult<u32>

Get the first uint32 value

§Returns

If types match and a value exists, returns the first uint32 value; otherwise returns an error

Source

pub fn get_first_uint64(&self) -> ValueResult<u64>

Get the first uint64 value

§Returns

If types match and a value exists, returns the first uint64 value; otherwise returns an error

Source

pub fn get_first_uint128(&self) -> ValueResult<u128>

Get the first uint128 value

§Returns

If types match and a value exists, returns the first uint128 value; otherwise returns an error

Source

pub fn get_first_float32(&self) -> ValueResult<f32>

Get the first float32 value

§Returns

If types match and a value exists, returns the first float32 value; otherwise returns an error

Source

pub fn get_first_float64(&self) -> ValueResult<f64>

Get the first float64 value

§Returns

If types match and a value exists, returns the first float64 value; otherwise returns an error

Source

pub fn get_first_string(&self) -> ValueResult<&str>

Get the first string reference

§Returns

If types match and a value exists, returns a reference to the first string; otherwise returns an error

Source

pub fn get_first_date(&self) -> ValueResult<NaiveDate>

Get the first date value

§Returns

If types match and a value exists, returns the first date value; otherwise returns an error

Source

pub fn get_first_time(&self) -> ValueResult<NaiveTime>

Get the first time value

§Returns

If types match and a value exists, returns the first time value; otherwise returns an error

Source

pub fn get_first_datetime(&self) -> ValueResult<NaiveDateTime>

Get the first datetime value

§Returns

If types match and a value exists, returns the first datetime value; otherwise returns an error

Source

pub fn get_first_instant(&self) -> ValueResult<DateTime<Utc>>

Get the first UTC instant value

§Returns

If types match and a value exists, returns the first UTC instant value; otherwise returns an error

Source

pub fn get_first_biginteger(&self) -> ValueResult<BigInt>

Get the first big integer value

§Returns

If types match and a value exists, returns the first big integer value; otherwise returns an error

Source

pub fn get_first_bigdecimal(&self) -> ValueResult<BigDecimal>

Get the first big decimal value

§Returns

If types match and a value exists, returns the first big decimal value; otherwise returns an error

Source

pub fn get_bools(&self) -> ValueResult<&[bool]>

Get reference to all boolean values

§Returns

If types match, returns a reference to the boolean value array; otherwise returns an error

§Example
ⓘ
use crate::util::value::MultiValues;

let values = MultiValues::Bool(vec![true, false, true]);
assert_eq!(values.get_bools().unwrap(), &[true, false, true]);
Source

pub fn get_chars(&self) -> ValueResult<&[char]>

Get reference to all character values

§Returns

If types match, returns a reference to the character value array; otherwise returns an error

Source

pub fn get_int8s(&self) -> ValueResult<&[i8]>

Get reference to all int8 values

§Returns

If types match, returns a reference to the int8 value array; otherwise returns an error

Source

pub fn get_int16s(&self) -> ValueResult<&[i16]>

Get reference to all int16 values

§Returns

If types match, returns a reference to the int16 value array; otherwise returns an error

Source

pub fn get_int32s(&self) -> ValueResult<&[i32]>

Get reference to all int32 values

§Returns

If types match, returns a reference to the int32 value array; otherwise returns an error

Source

pub fn get_int64s(&self) -> ValueResult<&[i64]>

Get reference to all int64 values

§Returns

If types match, returns a reference to the int64 value array; otherwise returns an error

Source

pub fn get_int128s(&self) -> ValueResult<&[i128]>

Get reference to all int128 values

§Returns

If types match, returns a reference to the int128 value array; otherwise returns an error

Source

pub fn get_uint8s(&self) -> ValueResult<&[u8]>

Get reference to all uint8 values

§Returns

If types match, returns a reference to the uint8 value array; otherwise returns an error

Source

pub fn get_uint16s(&self) -> ValueResult<&[u16]>

Get reference to all uint16 values

§Returns

If types match, returns a reference to the uint16 value array; otherwise returns an error

Source

pub fn get_uint32s(&self) -> ValueResult<&[u32]>

Get reference to all uint32 values

§Returns

If types match, returns a reference to the uint32 value array; otherwise returns an error

Source

pub fn get_uint64s(&self) -> ValueResult<&[u64]>

Get reference to all uint64 values

§Returns

If types match, returns a reference to the uint64 value array; otherwise returns an error

Source

pub fn get_uint128s(&self) -> ValueResult<&[u128]>

Get reference to all uint128 values

§Returns

If types match, returns a reference to the uint128 value array; otherwise returns an error

Source

pub fn get_float32s(&self) -> ValueResult<&[f32]>

Get reference to all float32 values

§Returns

If types match, returns a reference to the float32 value array; otherwise returns an error

Source

pub fn get_float64s(&self) -> ValueResult<&[f64]>

Get reference to all float64 values

§Returns

If types match, returns a reference to the float64 value array; otherwise returns an error

Source

pub fn get_strings(&self) -> ValueResult<&[String]>

Get reference to all strings

§Returns

If types match, returns a reference to the string array; otherwise returns an error

Source

pub fn get_dates(&self) -> ValueResult<&[NaiveDate]>

Get reference to all date values

§Returns

If types match, returns a reference to the date value array; otherwise returns an error

Source

pub fn get_times(&self) -> ValueResult<&[NaiveTime]>

Get reference to all time values

§Returns

If types match, returns a reference to the time value array; otherwise returns an error

Source

pub fn get_datetimes(&self) -> ValueResult<&[NaiveDateTime]>

Get reference to all datetime values

§Returns

If types match, returns a reference to the datetime value array; otherwise returns an error

Source

pub fn get_instants(&self) -> ValueResult<&[DateTime<Utc>]>

Get reference to all UTC instant values

§Returns

If types match, returns a reference to the UTC instant value array; otherwise returns an error

Source

pub fn get_bigintegers(&self) -> ValueResult<&[BigInt]>

Get reference to all big integers

§Returns

If types match, returns a reference to the big integer array; otherwise returns an error

Source

pub fn get_bigdecimals(&self) -> ValueResult<&[BigDecimal]>

Get reference to all big decimals

§Returns

If types match, returns a reference to the big decimal array; otherwise returns an error

Source

pub fn set_bools(&mut self, values: Vec<bool>) -> ValueResult<()>

Set all boolean values

§Parameters
  • values - The list of boolean values to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

§Example
ⓘ
use crate::util::value::MultiValues;

let mut values = MultiValues::Empty(DataType::Bool);
values.set_bools(vec![true, false, true]).unwrap();
assert_eq!(values.get_bools().unwrap(), &[true, false, true]);
Source

pub fn set_chars(&mut self, values: Vec<char>) -> ValueResult<()>

Set all character values

§Parameters
  • values - The list of character values to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_int8s(&mut self, values: Vec<i8>) -> ValueResult<()>

Set all int8 values

§Parameters
  • values - The list of int8 values to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_int16s(&mut self, values: Vec<i16>) -> ValueResult<()>

Set all int16 values

§Parameters
  • values - The list of int16 values to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_int32s(&mut self, values: Vec<i32>) -> ValueResult<()>

Set all int32 values

§Parameters
  • values - The list of int32 values to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_int64s(&mut self, values: Vec<i64>) -> ValueResult<()>

Set all int64 values

§Parameters
  • values - The list of int64 values to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_int128s(&mut self, values: Vec<i128>) -> ValueResult<()>

Set all int128 values

§Parameters
  • values - The list of int128 values to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_uint8s(&mut self, values: Vec<u8>) -> ValueResult<()>

Set all uint8 values

§Parameters
  • values - The list of uint8 values to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_uint16s(&mut self, values: Vec<u16>) -> ValueResult<()>

Set all uint16 values

§Parameters
  • values - The list of uint16 values to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_uint32s(&mut self, values: Vec<u32>) -> ValueResult<()>

Set all uint32 values

§Parameters
  • values - The list of uint32 values to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_uint64s(&mut self, values: Vec<u64>) -> ValueResult<()>

Set all uint64 values

§Parameters
  • values - The list of uint64 values to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_uint128s(&mut self, values: Vec<u128>) -> ValueResult<()>

Set all uint128 values

§Parameters
  • values - The list of uint128 values to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_float32s(&mut self, values: Vec<f32>) -> ValueResult<()>

Set all float32 values

§Parameters
  • values - The list of float32 values to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_float64s(&mut self, values: Vec<f64>) -> ValueResult<()>

Set all float64 values

§Parameters
  • values - The list of float64 values to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_strings(&mut self, values: Vec<String>) -> ValueResult<()>

Set all string values

§Parameters
  • values - The list of string values to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

§Example
ⓘ
use crate::util::value::MultiValues;

let mut values = MultiValues::Empty(DataType::String);
values.set_strings(vec!["hello".to_string(), "world".to_string()]).unwrap();
assert_eq!(values.get_strings().unwrap(), &["hello", "world"]);
Source

pub fn set_dates(&mut self, values: Vec<NaiveDate>) -> ValueResult<()>

Set all date values

§Parameters
  • values - The list of date values to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_times(&mut self, values: Vec<NaiveTime>) -> ValueResult<()>

Set all time values

§Parameters
  • values - The list of time values to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_datetimes(&mut self, values: Vec<NaiveDateTime>) -> ValueResult<()>

Set all datetime values

§Parameters
  • values - The list of datetime values to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_instants(&mut self, values: Vec<DateTime<Utc>>) -> ValueResult<()>

Set all UTC instant values

§Parameters
  • values - The list of UTC instant values to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_bigintegers(&mut self, values: Vec<BigInt>) -> ValueResult<()>

Set all big integer values

§Parameters
  • values - The list of big integer values to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_bigdecimals(&mut self, values: Vec<BigDecimal>) -> ValueResult<()>

Set all big decimal values

§Parameters
  • values - The list of big decimal values to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_bools_slice(&mut self, values: &[bool]) -> ValueResult<()>

Set all boolean values via slice

§Parameters
  • values - The boolean value slice to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_chars_slice(&mut self, values: &[char]) -> ValueResult<()>

Set all character values via slice

§Parameters
  • values - The character value slice to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_int8s_slice(&mut self, values: &[i8]) -> ValueResult<()>

Set all int8 values via slice

§Parameters
  • values - The int8 value slice to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_int16s_slice(&mut self, values: &[i16]) -> ValueResult<()>

Set all int16 values via slice

§Parameters
  • values - The int16 value slice to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_int32s_slice(&mut self, values: &[i32]) -> ValueResult<()>

Set all int32 values via slice

§Parameters
  • values - The int32 value slice to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_int64s_slice(&mut self, values: &[i64]) -> ValueResult<()>

Set all int64 values via slice

§Parameters
  • values - The int64 value slice to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_int128s_slice(&mut self, values: &[i128]) -> ValueResult<()>

Set all int128 values via slice

§Parameters
  • values - The int128 value slice to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_uint8s_slice(&mut self, values: &[u8]) -> ValueResult<()>

Set all uint8 values via slice

§Parameters
  • values - The uint8 value slice to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_uint16s_slice(&mut self, values: &[u16]) -> ValueResult<()>

Set all uint16 values via slice

§Parameters
  • values - The uint16 value slice to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_uint32s_slice(&mut self, values: &[u32]) -> ValueResult<()>

Set all uint32 values via slice

§Parameters
  • values - The uint32 value slice to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_uint64s_slice(&mut self, values: &[u64]) -> ValueResult<()>

Set all uint64 values via slice

§Parameters
  • values - The uint64 value slice to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_uint128s_slice(&mut self, values: &[u128]) -> ValueResult<()>

Set all uint128 values via slice

§Parameters
  • values - The uint128 value slice to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_float32s_slice(&mut self, values: &[f32]) -> ValueResult<()>

Set all float32 values via slice

§Parameters
  • values - The float32 value slice to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_float64s_slice(&mut self, values: &[f64]) -> ValueResult<()>

Set all float64 values via slice

§Parameters
  • values - The float64 value slice to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_strings_slice(&mut self, values: &[String]) -> ValueResult<()>

Set all string values via slice

§Parameters
  • values - The string value slice to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_dates_slice(&mut self, values: &[NaiveDate]) -> ValueResult<()>

Set all date values via slice

§Parameters
  • values - The date value slice to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_times_slice(&mut self, values: &[NaiveTime]) -> ValueResult<()>

Set all time values via slice

§Parameters
  • values - The time value slice to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_datetimes_slice( &mut self, values: &[NaiveDateTime], ) -> ValueResult<()>

Set all datetime values via slice

§Parameters
  • values - The datetime value slice to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_instants_slice( &mut self, values: &[DateTime<Utc>], ) -> ValueResult<()>

Set all UTC instant values via slice

§Parameters
  • values - The UTC instant value slice to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_bigintegers_slice(&mut self, values: &[BigInt]) -> ValueResult<()>

Set all big integer values via slice

§Parameters
  • values - The big integer value slice to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_bigdecimals_slice( &mut self, values: &[BigDecimal], ) -> ValueResult<()>

Set all big decimal values via slice

§Parameters
  • values - The big decimal value slice to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_bool(&mut self, value: bool) -> ValueResult<()>

Set single boolean value

§Parameters
  • value - The boolean value to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

§Example
ⓘ
use crate::util::value::MultiValues;

let mut values = MultiValues::Empty(DataType::Bool);
values.set_bool(true).unwrap();
assert_eq!(values.get_bools().unwrap(), &[true]);
Source

pub fn set_char(&mut self, value: char) -> ValueResult<()>

Set single character value

§Parameters
  • value - The character value to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_int8(&mut self, value: i8) -> ValueResult<()>

Set single int8 value

§Parameters
  • value - The int8 value to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_int16(&mut self, value: i16) -> ValueResult<()>

Set single int16 value

§Parameters
  • value - The int16 value to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_int32(&mut self, value: i32) -> ValueResult<()>

Set single int32 value

§Parameters
  • value - The int32 value to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_int64(&mut self, value: i64) -> ValueResult<()>

Set single int64 value

§Parameters
  • value - The int64 value to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_int128(&mut self, value: i128) -> ValueResult<()>

Set single int128 value

§Parameters
  • value - The int128 value to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_uint8(&mut self, value: u8) -> ValueResult<()>

Set single uint8 value

§Parameters
  • value - The uint8 value to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_uint16(&mut self, value: u16) -> ValueResult<()>

Set single uint16 value

§Parameters
  • value - The uint16 value to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_uint32(&mut self, value: u32) -> ValueResult<()>

Set single uint32 value

§Parameters
  • value - The uint32 value to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_uint64(&mut self, value: u64) -> ValueResult<()>

Set single uint64 value

§Parameters
  • value - The uint64 value to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_uint128(&mut self, value: u128) -> ValueResult<()>

Set single uint128 value

§Parameters
  • value - The uint128 value to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_float32(&mut self, value: f32) -> ValueResult<()>

Set single float32 value

§Parameters
  • value - The float32 value to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_float64(&mut self, value: f64) -> ValueResult<()>

Set single float64 value

§Parameters
  • value - The float64 value to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_string(&mut self, value: String) -> ValueResult<()>

Set single string value

§Parameters
  • value - The string value to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

§Example
ⓘ
use crate::util::value::MultiValues;

let mut values = MultiValues::Empty(DataType::String);
values.set_string("hello".to_string()).unwrap();
assert_eq!(values.get_strings().unwrap(), &["hello"]);
Source

pub fn set_date(&mut self, value: NaiveDate) -> ValueResult<()>

Set single date value

§Parameters
  • value - The date value to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_time(&mut self, value: NaiveTime) -> ValueResult<()>

Set single time value

§Parameters
  • value - The time value to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_datetime(&mut self, value: NaiveDateTime) -> ValueResult<()>

Set single datetime value

§Parameters
  • value - The datetime value to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_instant(&mut self, value: DateTime<Utc>) -> ValueResult<()>

Set single UTC instant value

§Parameters
  • value - The UTC instant value to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_biginteger(&mut self, value: BigInt) -> ValueResult<()>

Set single big integer value

§Parameters
  • value - The big integer value to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn set_bigdecimal(&mut self, value: BigDecimal) -> ValueResult<()>

Set single big decimal value

§Parameters
  • value - The big decimal value to set
§Returns

If setting succeeds, returns Ok(()); otherwise returns an error

Source

pub fn add_bool(&mut self, value: bool) -> ValueResult<()>

Add a boolean value

§Parameters
  • value - The boolean value to add
§Returns

If types match, returns Ok(()); otherwise returns an error

§Example
ⓘ
use crate::util::value::MultiValues;

let mut values = MultiValues::Bool(vec![true]);
values.add_bool(false).unwrap();
assert_eq!(values.count(), 2);
Source

pub fn add_char(&mut self, value: char) -> ValueResult<()>

Add a character value

§Parameters
  • value - The character value to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_int8(&mut self, value: i8) -> ValueResult<()>

Add an int8 value

§Parameters
  • value - The int8 value to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_int16(&mut self, value: i16) -> ValueResult<()>

Add an int16 value

§Parameters
  • value - The int16 value to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_int32(&mut self, value: i32) -> ValueResult<()>

Add an int32 value

§Parameters
  • value - The int32 value to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_int64(&mut self, value: i64) -> ValueResult<()>

Add an int64 value

§Parameters
  • value - The int64 value to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_int128(&mut self, value: i128) -> ValueResult<()>

Add an int128 value

§Parameters
  • value - The int128 value to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_uint8(&mut self, value: u8) -> ValueResult<()>

Add a uint8 value

§Parameters
  • value - The uint8 value to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_uint16(&mut self, value: u16) -> ValueResult<()>

Add a uint16 value

§Parameters
  • value - The uint16 value to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_uint32(&mut self, value: u32) -> ValueResult<()>

Add a uint32 value

§Parameters
  • value - The uint32 value to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_uint64(&mut self, value: u64) -> ValueResult<()>

Add a uint64 value

§Parameters
  • value - The uint64 value to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_uint128(&mut self, value: u128) -> ValueResult<()>

Add a uint128 value

§Parameters
  • value - The uint128 value to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_float32(&mut self, value: f32) -> ValueResult<()>

Add a float32 value

§Parameters
  • value - The float32 value to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_float64(&mut self, value: f64) -> ValueResult<()>

Add a float64 value

§Parameters
  • value - The float64 value to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_string(&mut self, value: String) -> ValueResult<()>

Add a string

§Parameters
  • value - The string to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_date(&mut self, value: NaiveDate) -> ValueResult<()>

Add a date value

§Parameters
  • value - The date value to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_time(&mut self, value: NaiveTime) -> ValueResult<()>

Add a time value

§Parameters
  • value - The time value to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_datetime(&mut self, value: NaiveDateTime) -> ValueResult<()>

Add a datetime value

§Parameters
  • value - The datetime value to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_instant(&mut self, value: DateTime<Utc>) -> ValueResult<()>

Add a UTC instant value

§Parameters
  • value - The UTC instant value to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_biginteger(&mut self, value: BigInt) -> ValueResult<()>

Add a big integer value

§Parameters
  • value - The big integer value to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_bigdecimal(&mut self, value: BigDecimal) -> ValueResult<()>

Add a big decimal value

§Parameters
  • value - The big decimal value to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_bools(&mut self, values: Vec<bool>) -> ValueResult<()>

Add multiple boolean values

§Parameters
  • values - The list of boolean values to add
§Returns

If types match, returns Ok(()); otherwise returns an error

§Example
ⓘ
use crate::util::value::MultiValues;

let mut values = MultiValues::Bool(vec![true]);
values.add_bools(vec![false, true]).unwrap();
assert_eq!(values.get_bools().unwrap(), &[true, false, true]);
Source

pub fn add_chars(&mut self, values: Vec<char>) -> ValueResult<()>

Add multiple character values

§Parameters
  • values - The list of character values to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_int8s(&mut self, values: Vec<i8>) -> ValueResult<()>

Add multiple int8 values

§Parameters
  • values - The list of int8 values to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_int16s(&mut self, values: Vec<i16>) -> ValueResult<()>

Add multiple int16 values

§Parameters
  • values - The list of int16 values to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_int32s(&mut self, values: Vec<i32>) -> ValueResult<()>

Add multiple int32 values

§Parameters
  • values - The list of int32 values to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_int64s(&mut self, values: Vec<i64>) -> ValueResult<()>

Add multiple int64 values

§Parameters
  • values - The list of int64 values to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_int128s(&mut self, values: Vec<i128>) -> ValueResult<()>

Add multiple int128 values

§Parameters
  • values - The list of int128 values to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_uint8s(&mut self, values: Vec<u8>) -> ValueResult<()>

Add multiple uint8 values

§Parameters
  • values - The list of uint8 values to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_uint16s(&mut self, values: Vec<u16>) -> ValueResult<()>

Add multiple uint16 values

§Parameters
  • values - The list of uint16 values to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_uint32s(&mut self, values: Vec<u32>) -> ValueResult<()>

Add multiple uint32 values

§Parameters
  • values - The list of uint32 values to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_uint64s(&mut self, values: Vec<u64>) -> ValueResult<()>

Add multiple uint64 values

§Parameters
  • values - The list of uint64 values to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_uint128s(&mut self, values: Vec<u128>) -> ValueResult<()>

Add multiple uint128 values

§Parameters
  • values - The list of uint128 values to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_float32s(&mut self, values: Vec<f32>) -> ValueResult<()>

Add multiple float32 values

§Parameters
  • values - The list of float32 values to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_float64s(&mut self, values: Vec<f64>) -> ValueResult<()>

Add multiple float64 values

§Parameters
  • values - The list of float64 values to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_strings(&mut self, values: Vec<String>) -> ValueResult<()>

Add multiple string values

§Parameters
  • values - The list of string values to add
§Returns

If types match, returns Ok(()); otherwise returns an error

§Example
ⓘ
use crate::util::value::MultiValues;

let mut values = MultiValues::String(vec!["hello".to_string()]);
values.add_strings(vec!["world".to_string(), "rust".to_string()]).unwrap();
assert_eq!(values.get_strings().unwrap(), &["hello", "world", "rust"]);
Source

pub fn add_dates(&mut self, values: Vec<NaiveDate>) -> ValueResult<()>

Add multiple date values

§Parameters
  • values - The list of date values to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_times(&mut self, values: Vec<NaiveTime>) -> ValueResult<()>

Add multiple time values

§Parameters
  • values - The list of time values to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_datetimes(&mut self, values: Vec<NaiveDateTime>) -> ValueResult<()>

Add multiple datetime values

§Parameters
  • values - The list of datetime values to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_instants(&mut self, values: Vec<DateTime<Utc>>) -> ValueResult<()>

Add multiple UTC instant values

§Parameters
  • values - The list of UTC instant values to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_bigintegers(&mut self, values: Vec<BigInt>) -> ValueResult<()>

Add multiple big integer values

§Parameters
  • values - The list of big integer values to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_bigdecimals(&mut self, values: Vec<BigDecimal>) -> ValueResult<()>

Add multiple big decimal values

§Parameters
  • values - The list of big decimal values to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_bools_slice(&mut self, values: &[bool]) -> ValueResult<()>

Add multiple boolean values via slice

§Parameters
  • values - The boolean value slice to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_chars_slice(&mut self, values: &[char]) -> ValueResult<()>

Add multiple character values via slice

§Parameters
  • values - The character value slice to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_int8s_slice(&mut self, values: &[i8]) -> ValueResult<()>

Add multiple int8 values via slice

§Parameters
  • values - The int8 value slice to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_int16s_slice(&mut self, values: &[i16]) -> ValueResult<()>

Add multiple int16 values via slice

§Parameters
  • values - The int16 value slice to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_int32s_slice(&mut self, values: &[i32]) -> ValueResult<()>

Add multiple int32 values via slice

§Parameters
  • values - The int32 value slice to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_int64s_slice(&mut self, values: &[i64]) -> ValueResult<()>

Add multiple int64 values via slice

§Parameters
  • values - The int64 value slice to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_int128s_slice(&mut self, values: &[i128]) -> ValueResult<()>

Add multiple int128 values via slice

§Parameters
  • values - The int128 value slice to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_uint8s_slice(&mut self, values: &[u8]) -> ValueResult<()>

Add multiple uint8 values via slice

§Parameters
  • values - The uint8 value slice to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_uint16s_slice(&mut self, values: &[u16]) -> ValueResult<()>

Add multiple uint16 values via slice

§Parameters
  • values - The uint16 value slice to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_uint32s_slice(&mut self, values: &[u32]) -> ValueResult<()>

Add multiple uint32 values via slice

§Parameters
  • values - The uint32 value slice to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_uint64s_slice(&mut self, values: &[u64]) -> ValueResult<()>

Add multiple uint64 values via slice

§Parameters
  • values - The uint64 value slice to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_uint128s_slice(&mut self, values: &[u128]) -> ValueResult<()>

Add multiple uint128 values via slice

§Parameters
  • values - The uint128 value slice to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_float32s_slice(&mut self, values: &[f32]) -> ValueResult<()>

Add multiple float32 values via slice

§Parameters
  • values - The float32 value slice to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_float64s_slice(&mut self, values: &[f64]) -> ValueResult<()>

Add multiple float64 values via slice

§Parameters
  • values - The float64 value slice to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_strings_slice(&mut self, values: &[String]) -> ValueResult<()>

Add multiple strings via slice

§Parameters
  • values - The string slice to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_dates_slice(&mut self, values: &[NaiveDate]) -> ValueResult<()>

Add multiple date values via slice

§Parameters
  • values - The date value slice to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_times_slice(&mut self, values: &[NaiveTime]) -> ValueResult<()>

Add multiple time values via slice

§Parameters
  • values - The time value slice to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_datetimes_slice( &mut self, values: &[NaiveDateTime], ) -> ValueResult<()>

Add multiple datetime values via slice

§Parameters
  • values - The datetime value slice to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_instants_slice( &mut self, values: &[DateTime<Utc>], ) -> ValueResult<()>

Add multiple UTC instant values via slice

§Parameters
  • values - The UTC instant value slice to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_bigintegers_slice(&mut self, values: &[BigInt]) -> ValueResult<()>

Add multiple big integer values via slice

§Parameters
  • values - The big integer value slice to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn add_bigdecimals_slice( &mut self, values: &[BigDecimal], ) -> ValueResult<()>

Add multiple big decimal values via slice

§Parameters
  • values - The big decimal value slice to add
§Returns

If types match, returns Ok(()); otherwise returns an error

Source

pub fn merge(&mut self, other: &MultiValues) -> ValueResult<()>

Merge another multiple values

Append all values from another multiple values to the current multiple values

§Parameters
  • other - The multiple values to merge
§Returns

If types match, returns Ok(()); otherwise returns an error

§Example
ⓘ
use crate::util::value::MultiValues;

let mut a = MultiValues::Int32(vec![1, 2]);
let b = MultiValues::Int32(vec![3, 4]);
a.merge(&b).unwrap();
assert_eq!(a.get_int32s().unwrap(), &[1, 2, 3, 4]);

Trait Implementations§

Source§

impl Clone for MultiValues

Source§

fn clone(&self) -> MultiValues

Returns a duplicate of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from source. Read more
Source§

impl Debug for MultiValues

Source§

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

Formats the value using the given formatter. Read more
Source§

impl Default for MultiValues

Source§

fn default() -> Self

Returns the “default value” for a type. Read more
Source§

impl<'de> Deserialize<'de> for MultiValues

Source§

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
Source§

impl From<Value> for MultiValues

Source§

fn from(value: Value) -> Self

Converts to this type from the input type.
Source§

impl PartialEq for MultiValues

Source§

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

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

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

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

impl Serialize for MultiValues

Source§

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

Serialize this value into the given Serde serializer. Read more
Source§

impl StructuralPartialEq for MultiValues

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<T> DeserializeOwned for T
where T: for<'de> Deserialize<'de>,