Struct NamedMultiValues

Source

pub struct NamedMultiValues { /* private fields */ }

Expand description

Named multiple values

A container that associates a readable name with a set of MultiValues, suitable for organizing data in key-value (name-multiple values) scenarios, such as configuration items, command-line parameter aggregation, structured log fields, etc.

§Features

Provides clear name identification for multiple value collections
Transparently reuses all capabilities of MultiValues through Deref/DerefMut
Supports serde serialization and deserialization

§Use Cases

Aggregating a set of ports, hostnames, etc., as semantically meaningful fields
Outputting named multiple value lists in configurations/logs

§Example

use common_rs::util::value::{NamedMultiValues, MultiValues};

// Identify a group of ports with the name "ports"
let named = NamedMultiValues::new(
    "ports",
    MultiValues::Int32(vec![8080, 8081, 8082])
);

assert_eq!(named.name(), "ports");
assert_eq!(named.count(), 3);

§Author

Haixing Hu

Implementations§

Source §

impl NamedMultiValues

Source

pub fn new(name: impl Into<String>, value: MultiValues) -> Self

Create a new named multiple values

Associates a given name with MultiValues, generating a container that can be referenced by name.

§Use Cases

Building configuration fields (e.g., servers, ports, etc.)
Binding parsed multiple value results to semantic names

§Parameters

name - Name of the multiple values
value - Content of the multiple values

§Returns

Returns a newly created named multiple values

§Example

use common_rs::util::value::{NamedMultiValues, MultiValues};

let named = NamedMultiValues::new(
    "servers",
    MultiValues::String(vec!["s1".to_string(), "s2".to_string()])
);
assert_eq!(named.name(), "servers");

Source

pub fn name(&self) -> &str

Get a reference to the name

§Returns

Returns a string slice of the name

§Example

use common_rs::util::value::{NamedMultiValues, MultiValues};

let named = NamedMultiValues::new("items", MultiValues::Int32(vec![1, 2, 3]));
assert_eq!(named.name(), "items");

Source

pub fn set_name(&mut self, name: impl Into<String>)

Set a new name

§Parameters

name - The new name

§Returns

No return value

§Example

use common_rs::util::value::{NamedMultiValues, MultiValues};

let mut named = NamedMultiValues::new("old", MultiValues::Bool(vec![true]));
named.set_name("new");
assert_eq!(named.name(), "new");

Methods from Deref<Target = MultiValues>§

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]);