Trait NumericArgument

Source

pub trait NumericArgument: Sized {
Show 14 methods    // Required methods
    fn require_zero(self, name: &str) -> ArgumentResult<Self>;
    fn require_non_zero(self, name: &str) -> ArgumentResult<Self>;
    fn require_positive(self, name: &str) -> ArgumentResult<Self>;
    fn require_non_negative(self, name: &str) -> ArgumentResult<Self>;
    fn require_negative(self, name: &str) -> ArgumentResult<Self>;
    fn require_non_positive(self, name: &str) -> ArgumentResult<Self>;
    fn require_in_closed_range(
        self,
        name: &str,
        min: Self,
        max: Self,
    ) -> ArgumentResult<Self>;
    fn require_in_open_range(
        self,
        name: &str,
        min: Self,
        max: Self,
    ) -> ArgumentResult<Self>;
    fn require_in_left_open_range(
        self,
        name: &str,
        min: Self,
        max: Self,
    ) -> ArgumentResult<Self>;
    fn require_in_right_open_range(
        self,
        name: &str,
        min: Self,
        max: Self,
    ) -> ArgumentResult<Self>;
    fn require_less(self, name: &str, max: Self) -> ArgumentResult<Self>;
    fn require_less_equal(self, name: &str, max: Self) -> ArgumentResult<Self>;
    fn require_greater(self, name: &str, min: Self) -> ArgumentResult<Self>;
    fn require_greater_equal(
        self,
        name: &str,
        min: Self,
    ) -> ArgumentResult<Self>;
}

Expand description

Numeric argument validation trait

Provides validation methods for all sortable numeric types, supporting method chaining.

§Features

Zero-cost abstraction: Same performance as manual checks after compilation
Method chaining: Can perform multiple validations in sequence
Type safety: Leverages Rust’s type system to ensure correctness
Clear errors: Provides friendly error messages

§Use Cases

Validating function parameter validity
Configuration value range checking
User input numeric validation

§Examples

Basic usage (returns ArgumentResult):

use qubit_common::lang::argument::{NumericArgument, ArgumentResult};

fn set_volume(volume: i32) -> ArgumentResult<()> {
    let volume = volume.require_in_closed_range("volume", 0, 100)?;
    println!("Volume: {}", volume);
    Ok(())
}

Converting to other error types:

use qubit_common::lang::argument::NumericArgument;

fn set_volume(volume: i32) -> Result<(), String> {
    let volume = volume
        .require_non_negative("volume")
        .and_then(|v| v.require_in_closed_range("volume", 0, 100))
        .map_err(|e| e.to_string())?;
    println!("Volume: {}", volume);
    Ok(())
}

§Author

Haixing Hu

Required Methods§

Source

fn require_zero(self, name: &str) -> ArgumentResult<Self>

Validate that value is zero

§Parameters

name - Parameter name for error message generation

§Returns

Returns Ok(self) if value is zero, otherwise returns an error

§Examples

use qubit_common::lang::argument::NumericArgument;

let value: i32 = 0;
assert!(value.require_zero("value").is_ok());

let non_zero: i32 = 5;
assert!(non_zero.require_zero("value").is_err());

Source

fn require_non_zero(self, name: &str) -> ArgumentResult<Self>

Validate that value is non-zero

§Parameters

name - Parameter name

§Returns

Returns Ok(self) if value is non-zero, otherwise returns an error

§Examples

use qubit_common::lang::argument::NumericArgument;

let value: i32 = 10;
assert!(value.require_non_zero("value").is_ok());

let zero: i32 = 0;
assert!(zero.require_non_zero("value").is_err());

Source

fn require_positive(self, name: &str) -> ArgumentResult<Self>

Validate that value is positive

§Parameters

name - Parameter name

§Returns

Returns Ok(self) if value is greater than zero, otherwise returns an error

§Examples

use qubit_common::lang::argument::NumericArgument;

let value: i32 = 10;
assert!(value.require_positive("value").is_ok());

let zero: i32 = 0;
assert!(zero.require_positive("value").is_err());

Source

fn require_non_negative(self, name: &str) -> ArgumentResult<Self>

Validate that value is non-negative

§Parameters

name - Parameter name

§Returns

Returns Ok(self) if value is non-negative, otherwise returns an error

§Examples

use qubit_common::lang::argument::NumericArgument;

let value: i32 = 0;
assert!(value.require_non_negative("value").is_ok());

let negative: i32 = -5;
assert!(negative.require_non_negative("value").is_err());

Source

fn require_negative(self, name: &str) -> ArgumentResult<Self>

Validate that value is negative

§Parameters

name - Parameter name

§Returns

Returns Ok(self) if value is less than zero, otherwise returns an error

§Examples

use qubit_common::lang::argument::NumericArgument;

let value: i32 = -5;
assert!(value.require_negative("value").is_ok());

let positive: i32 = 5;
assert!(positive.require_negative("value").is_err());

Source

fn require_non_positive(self, name: &str) -> ArgumentResult<Self>

Validate that value is non-positive

§Parameters

name - Parameter name

§Returns

Returns Ok(self) if value is less than or equal to zero, otherwise returns an error

§Examples

use qubit_common::lang::argument::NumericArgument;

let value: i32 = 0;
assert!(value.require_non_positive("value").is_ok());

let negative: i32 = -5;
assert!(negative.require_non_positive("value").is_ok());

let positive: i32 = 5;
assert!(positive.require_non_positive("value").is_err());

Source

fn require_in_closed_range( self, name: &str, min: Self, max: Self, ) -> ArgumentResult<Self>

Validate that value is within closed interval

§Parameters

name - Parameter name
min - Minimum value (inclusive)
max - Maximum value (inclusive)

§Returns

Returns Ok(self) if value is within [min, max] range, otherwise returns an error

§Examples

use qubit_common::lang::argument::NumericArgument;

let value = 50;
assert!(value.require_in_closed_range("value", 0, 100).is_ok());

let out_of_range = 150;
assert!(out_of_range.require_in_closed_range("value", 0, 100).is_err());

Source

fn require_in_open_range( self, name: &str, min: Self, max: Self, ) -> ArgumentResult<Self>

Validate that value is within open interval

§Parameters

name - Parameter name
min - Minimum value (exclusive)
max - Maximum value (exclusive)

§Returns

Returns Ok(self) if value is within (min, max) range, otherwise returns an error

§Examples

use qubit_common::lang::argument::NumericArgument;

let value = 50;
assert!(value.require_in_open_range("value", 0, 100).is_ok());

let boundary = 0;
assert!(boundary.require_in_open_range("value", 0, 100).is_err());

Source

fn require_in_left_open_range( self, name: &str, min: Self, max: Self, ) -> ArgumentResult<Self>

Validate that value is within left-open right-closed interval

§Parameters

name - Parameter name
min - Minimum value (exclusive)
max - Maximum value (inclusive)

§Returns

Returns Ok(self) if value is within (min, max] range, otherwise returns an error

§Examples

use qubit_common::lang::argument::NumericArgument;

let value = 100;
assert!(value.require_in_left_open_range("value", 0, 100).is_ok());

let min_boundary = 0;
assert!(min_boundary.require_in_left_open_range("value", 0, 100).is_err());

Source

fn require_in_right_open_range( self, name: &str, min: Self, max: Self, ) -> ArgumentResult<Self>

Validate that value is within left-closed right-open interval

§Parameters

name - Parameter name
min - Minimum value (inclusive)
max - Maximum value (exclusive)

§Returns

Returns Ok(self) if value is within [min, max) range, otherwise returns an error

§Examples

use qubit_common::lang::argument::NumericArgument;

let value = 0;
assert!(value.require_in_right_open_range("value", 0, 100).is_ok());

let max_boundary = 100;
assert!(max_boundary.require_in_right_open_range("value", 0, 100).is_err());

Source

fn require_less(self, name: &str, max: Self) -> ArgumentResult<Self>

Validate that value is less than specified value

§Parameters

name - Parameter name
max - Maximum value (exclusive)

§Returns

Returns Ok(self) if value is less than max, otherwise returns an error

§Examples

use qubit_common::lang::argument::NumericArgument;

let value = 50;
assert!(value.require_less("value", 100).is_ok());

let boundary = 100;
assert!(boundary.require_less("value", 100).is_err());

Source

fn require_less_equal(self, name: &str, max: Self) -> ArgumentResult<Self>

Validate that value is less than or equal to specified value

§Parameters

name - Parameter name
max - Maximum value (inclusive)

§Returns

Returns Ok(self) if value is less than or equal to max, otherwise returns an error

§Examples

use qubit_common::lang::argument::NumericArgument;

let value = 100;
assert!(value.require_less_equal("value", 100).is_ok());

let over = 101;
assert!(over.require_less_equal("value", 100).is_err());

Source

fn require_greater(self, name: &str, min: Self) -> ArgumentResult<Self>

Validate that value is greater than specified value

§Parameters

name - Parameter name
min - Minimum value (exclusive)

§Returns

Returns Ok(self) if value is greater than min, otherwise returns an error

§Examples

use qubit_common::lang::argument::NumericArgument;

let value = 50;
assert!(value.require_greater("value", 0).is_ok());

let boundary = 0;
assert!(boundary.require_greater("value", 0).is_err());

Source

fn require_greater_equal(self, name: &str, min: Self) -> ArgumentResult<Self>

Validate that value is greater than or equal to specified value

§Parameters

name - Parameter name
min - Minimum value (inclusive)

§Returns

Returns Ok(self) if value is greater than or equal to min, otherwise returns an error

§Examples

use qubit_common::lang::argument::NumericArgument;

let value = 0;
assert!(value.require_greater_equal("value", 0).is_ok());

let under = -1;
assert!(under.require_greater_equal("value", 0).is_err());

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors§

Source §

impl<T> NumericArgument for T
where T: PartialOrd + Default + Display + Copy,

Implement numeric argument validation for all ordered displayable types

Automatically provides validation functionality for types that satisfy PartialOrd + Default + Display + Copy constraints. This includes all standard numeric types: i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, usize, f32, f64.

NumericArgument

Trait NumericArgument Copy item path

§Features

§Use Cases

§Examples

§Author

Required Methods§

fn require_zero(self, name: &str) -> ArgumentResult<Self>

§Parameters

§Returns

§Examples

fn require_non_zero(self, name: &str) -> ArgumentResult<Self>

§Parameters

§Returns

§Examples

fn require_positive(self, name: &str) -> ArgumentResult<Self>

§Parameters

§Returns

§Examples

fn require_non_negative(self, name: &str) -> ArgumentResult<Self>

§Parameters

§Returns

§Examples

fn require_negative(self, name: &str) -> ArgumentResult<Self>

§Parameters

§Returns

§Examples

fn require_non_positive(self, name: &str) -> ArgumentResult<Self>

§Parameters

§Returns

§Examples

fn require_in_closed_range( self, name: &str, min: Self, max: Self, ) -> ArgumentResult<Self>

§Parameters

§Returns

§Examples

fn require_in_open_range( self, name: &str, min: Self, max: Self, ) -> ArgumentResult<Self>

§Parameters

§Returns

§Examples

fn require_in_left_open_range( self, name: &str, min: Self, max: Self, ) -> ArgumentResult<Self>

§Parameters

§Returns

§Examples

fn require_in_right_open_range( self, name: &str, min: Self, max: Self, ) -> ArgumentResult<Self>

§Parameters

§Returns

§Examples

fn require_less(self, name: &str, max: Self) -> ArgumentResult<Self>

§Parameters

§Returns

§Examples

fn require_less_equal(self, name: &str, max: Self) -> ArgumentResult<Self>

§Parameters

§Returns

§Examples

fn require_greater(self, name: &str, min: Self) -> ArgumentResult<Self>

§Parameters

§Returns

§Examples

fn require_greater_equal(self, name: &str, min: Self) -> ArgumentResult<Self>

§Parameters

§Returns

§Examples

Dyn Compatibility§

Implementors§

impl<T> NumericArgument for Twhere T: PartialOrd + Default + Display + Copy,

Trait NumericArgument

impl<T> NumericArgument for T
where T: PartialOrd + Default + Display + Copy,