Struct NumberIncDecCpCmp 

pub struct NumberIncDecCpCmp<T>
where
    T: Copy + Clone,
{ /* private fields */ }

The Number Implementation of IncDecCpCmp.

Acts as the general proxy layer for safly working with primitive number types inside crate. Note: unlike AnyIncDecCpCmp, the self.inc(a,b) and self.dec(a,b) are checked.

The following types are implemented for NumberIncDecCpCmp

• u8, u16, u32, u64, u128, usize
• i8, i16, i32, i64, i128, isize
• f32, f64

Implementations

impl<T> NumberIncDecCpCmp<T>

where T: Clone + Copy, NumberIncDecCpCmp<T>: DefaultValues<T, T>,

pub fn defaults() -> Self

Examples found in repository

examples/getbeginend.rs (line 45)

fn main() {
    for r in OverlapIter::new(
        vec![
            MyRange { a: 1, b: 4 },
            MyRange { a: 3, b: 5 },
            MyRange { a: 4, b: 6 },
        ],
        1,
        NumberIncDecCpCmp::defaults(),
        MyFactory {},
    ) {
        println!("{:?}", r);
    }
}

examples/floats.rs (line 4)

fn main() {
    let l = NumberIncDecCpCmp::defaults();
    // f32 Increment examples
    assert_eq!(l.inc(&0.2, &0.5), Some(0.7));
    assert_eq!(l.inc(&1.7, &-0.5), None);
    assert_eq!(l.inc(&f32::INFINITY, &0.5), None);
    assert_eq!(l.inc(&f32::INFINITY, &f32::INFINITY), None);
    assert_eq!(l.inc(&1.0, &f32::INFINITY), Some(f32::INFINITY));
    assert_eq!(l.inc(&1.0, &f32::NEG_INFINITY), None);

    // f32 Decrement examples
    assert_eq!(l.dec(&0.5, &0.5), Some(-0.0));
    assert_eq!(l.dec(&1.7, &-0.5), None);
    assert_eq!(l.dec(&f32::INFINITY, &0.5), None);
    assert_eq!(l.dec(&f32::INFINITY, &f32::INFINITY), None);
    assert_eq!(l.dec(&1.0, &f32::INFINITY), Some(f32::NEG_INFINITY));
    assert_eq!(l.dec(&1.0, &f32::NEG_INFINITY), None);

    // This sets the step and rebound value to 0.1
    for r in Intersector::num_sr_from(0.1, &[1.0..=3.1, 2.5..=4.1, 1.9..=7.64]) {
        print!("Common Range: {}->{}\n", r.start(), r.end());
    }

    // The resulting output will be:
    //  Common Range: 1->1.7999999999999998
    //  Common Range: 1.9->2.4
    //  Common Range: 2.5->3.1
    //  Common Range: 3.2->4.1
    //  Common Range: 4.199999999999999->7.64
}

examples/columns.rs (line 11)

fn main() {
    // We create all of our column data unsorted
    let mut col_a = vec![0..=11, 2..=3, 7..=9, 22..=33, 34..=39];
    let mut col_b = vec![6..=9, 6..=9, 6..=7, 11..=22, 7..=11, 9..=9];
    let mut col_c = vec![3..=4, 3..=9, 4..=6, 30..=41];

    // ** Full Sort Example here! **
    // We will use this to drive the internals of the sort function
    let t = NumberIncDecCpCmp::defaults();

    // We create our sort function here
    let sort_by = |a: &std::ops::RangeInclusive<i32>, b: &std::ops::RangeInclusive<i32>| {
        sort_forward(a, b, &t.default_rebound(), &t)
    };

    // Sort all of our rows and force them to exist in the correct order!
    col_a.sort_by(sort_by);
    col_b.sort_by(sort_by);
    col_c.sort_by(sort_by);
    // ** End Full Sort Example **

    // Create our Columns instance using number defaults.
    let cols = Columns::num_defaults();

    // give up if we fail to add a column!
    assert!(cols.add_column(col_a.into_iter()).is_ok());
    assert!(cols.add_column(col_b.into_iter()).is_ok());
    assert!(cols.add_column(col_c.into_iter()).is_ok());

    // Just pretty printing our text table border
    println!(
        "+---------+-----------+{:-<35}+{:-<61}+{:-<35}+",
        "", "", ""
    );

    // Pretty preint our text table header
    println!(
        "| Overlap | State(id) |{:^35}|{:^61}|{:^35}|",
        "Column(A)", "Column(B)", "Column(C)"
    );

    // In order to access the iter.get_column(column_id) method, the iter instance must remain in scope.
    // If access to the causal ranges is not required, then a standard for lopp iterator will work.
    let mut iter = cols.into_iter();
    let mut id = 0;
    loop {
        let next = iter.next();
        if next.is_none() {
            // print out the last text bumper.
            println!(
                "+---------+-----------+{:-<35}+{:-<61}+{:-<35}+",
                "", "", ""
            );
            return;
        }
        let (overlap, res, columns) = next.unwrap();
        // print a bumper text row.
        println!(
            "+---------+-----------+{:-<35}+{:-<61}+{:-<35}+",
            "", "", ""
        );

        // Print out the common intersecting range!
        print!("|  {:^2}->{:^2} |", overlap.get_begin(), overlap.get_end());
        let mut stop = false;
        if res.is_err() {
            print!("   Err({})  |", id);
            // We still want to access the column or columns that error out before we stop
            stop = true;
        } else {
            print!("   Ok({})   |", id);
        }
        for (column_id, col) in columns.iter().enumerate() {
            let mut txt = Vec::new();
            match col {
                Ok(src) => {
                    for row in src {
                        // This range contains all of the ranges that were used to create it!
                        let container = row.as_ref();
                        txt.push(format!(
                            "[{}->{}](",
                            container.get_begin(),
                            container.get_end()
                        ));
                        let mut r = Vec::new();

                        // walk our raw source ranges that caused this larger range
                        for (row_id, range) in container.src().iter() {
                            r.push(format!("{}({}->{})", row_id, range.start(), range.end()));
                        }
                        txt.push(r.join(","));
                        txt.push(String::from(")"));
                    }
                }
                Err(msg) => {
                    // This code exists but does not execute in this example.
                    // The Err code block, exists to demonstrate how to gain access to the ranges that
                    // caused a given error.

                    // Save our error for output
                    txt.push(String::from(*msg));

                    // get our raw column and the original rows that caused the error!
                    let col = iter.get_column(column_id).unwrap();

                    // This Vec contains the rows that caused the error!
                    let rows = col.get_rows();
                    for row in rows {
                        let result_range = row.as_ref();
                        // The range that was generated from the raw ranges
                        txt.push(format!(
                            "Invalid Range: ({}->{})",
                            result_range.get_begin(),
                            result_range.get_end()
                        ));
                        for (row_id, range) in result_range.src().iter() {
                            // One ore more of these ranges caused the error!
                            txt.push(format!("({}){}->{}", row_id, range.start(), range.end()))
                        }
                    }
                }
            }
            match column_id {
                0 => print!("{:^35}|", txt.join("")),
                1 => print!("{:^61}|", txt.join("")),
                2 => print!("{:^35}|", txt.join("")),
                _ => (),
            }
        }

        println!();
        if stop {
            // stop here if we ran into an error processing an iterator.
            break;
        }
        id += 1;
    }
}

pub fn new(min: T, max: T) -> Self

pub fn set_min(&mut self, v: T)

Sets the values returned by self.min() and self.min_ref(). Changing this value from the default will further constrain what ranges are considered invalid.

pub fn set_max(&mut self, v: T)

Sets the values returned by self.max() and self.max_ref(). Changing this value from the default will further constrain what ranges are considered invalid.

Trait Implementations

impl<T> Clone for NumberIncDecCpCmp<T>

where T: Copy + Clone + Clone,

fn clone(&self) -> NumberIncDecCpCmp<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Copy for NumberIncDecCpCmp<T>

where T: Copy + Clone + Copy,

impl CpCmp<f32> for NumberIncDecCpCmp<f32>

fn min(&self) -> f32

Returns the minimum begin value we will accept when converting from std::ops::Bound::Unbounded.

fn max(&self) -> f32

Returns the maximum end value we will accept when converting from std::ops::Bound::Unbounded.

fn min_ref(&self) -> &f32

fn max_ref(&self) -> &f32

fn cp(&self, v: &f32) -> f32

fn lt(&self, a: &f32, b: &f32) -> bool

Returns true if a < b.

fn gt(&self, a: &T, b: &T) -> bool

Returns true if a gt b.

fn eq(&self, a: &T, b: &T) -> bool

Returns true if a eq b.

fn ne(&self, a: &T, b: &T) -> bool

Returns true if a ne b.

fn le(&self, a: &T, b: &T) -> bool

Returns true if a le b.

fn ge(&self, a: &T, b: &T) -> bool

Returns true if a ge b.

fn contains(&self, a: &T, b: &T, c: &T) -> bool

Returns true if a and b contain c.

fn cp_tpl_ref(&self, src: (&T, &T)) -> (T, T)

Returns a new owned copy of the input ref tuple.

fn overlap(&self, a: &T, b: &T, c: &T, d: &T) -> bool

Returns true if any of the following are true

fn is_invalid_set(&self, a: &T, b: &T) -> bool

Returns true if b lt a or a lt self.min_ref() or self.max_ref() lt b.

impl CpCmp<f64> for NumberIncDecCpCmp<f64>

fn min(&self) -> f64

Returns the minimum begin value we will accept when converting from std::ops::Bound::Unbounded.

fn max(&self) -> f64

Returns the maximum end value we will accept when converting from std::ops::Bound::Unbounded.

fn min_ref(&self) -> &f64

fn max_ref(&self) -> &f64

fn cp(&self, v: &f64) -> f64

fn lt(&self, a: &f64, b: &f64) -> bool

Returns true if a < b.

fn gt(&self, a: &T, b: &T) -> bool

Returns true if a gt b.

fn eq(&self, a: &T, b: &T) -> bool

Returns true if a eq b.

fn ne(&self, a: &T, b: &T) -> bool

Returns true if a ne b.

fn le(&self, a: &T, b: &T) -> bool

Returns true if a le b.

fn ge(&self, a: &T, b: &T) -> bool

Returns true if a ge b.

fn contains(&self, a: &T, b: &T, c: &T) -> bool

Returns true if a and b contain c.

fn cp_tpl_ref(&self, src: (&T, &T)) -> (T, T)

Returns a new owned copy of the input ref tuple.

fn overlap(&self, a: &T, b: &T, c: &T, d: &T) -> bool

Returns true if any of the following are true

fn is_invalid_set(&self, a: &T, b: &T) -> bool

Returns true if b lt a or a lt self.min_ref() or self.max_ref() lt b.

impl CpCmp<i8> for NumberIncDecCpCmp<i8>

fn min(&self) -> i8

Returns the minimum begin value we will accept when converting from std::ops::Bound::Unbounded.

fn max(&self) -> i8

Returns the maximum end value we will accept when converting from std::ops::Bound::Unbounded.

fn min_ref(&self) -> &i8

fn max_ref(&self) -> &i8

fn cp(&self, v: &i8) -> i8

fn lt(&self, a: &i8, b: &i8) -> bool

Returns true if a < b.

fn gt(&self, a: &T, b: &T) -> bool

Returns true if a gt b.

fn eq(&self, a: &T, b: &T) -> bool

Returns true if a eq b.

fn ne(&self, a: &T, b: &T) -> bool

Returns true if a ne b.

fn le(&self, a: &T, b: &T) -> bool

Returns true if a le b.

fn ge(&self, a: &T, b: &T) -> bool

Returns true if a ge b.

fn contains(&self, a: &T, b: &T, c: &T) -> bool

Returns true if a and b contain c.

fn cp_tpl_ref(&self, src: (&T, &T)) -> (T, T)

Returns a new owned copy of the input ref tuple.

fn overlap(&self, a: &T, b: &T, c: &T, d: &T) -> bool

Returns true if any of the following are true

fn is_invalid_set(&self, a: &T, b: &T) -> bool

Returns true if b lt a or a lt self.min_ref() or self.max_ref() lt b.

impl CpCmp<i16> for NumberIncDecCpCmp<i16>

fn min(&self) -> i16

Returns the minimum begin value we will accept when converting from std::ops::Bound::Unbounded.

fn max(&self) -> i16

Returns the maximum end value we will accept when converting from std::ops::Bound::Unbounded.

fn min_ref(&self) -> &i16

fn max_ref(&self) -> &i16

fn cp(&self, v: &i16) -> i16

fn lt(&self, a: &i16, b: &i16) -> bool

Returns true if a < b.

fn gt(&self, a: &T, b: &T) -> bool

Returns true if a gt b.

fn eq(&self, a: &T, b: &T) -> bool

Returns true if a eq b.

fn ne(&self, a: &T, b: &T) -> bool

Returns true if a ne b.

fn le(&self, a: &T, b: &T) -> bool

Returns true if a le b.

fn ge(&self, a: &T, b: &T) -> bool

Returns true if a ge b.

fn contains(&self, a: &T, b: &T, c: &T) -> bool

Returns true if a and b contain c.

fn cp_tpl_ref(&self, src: (&T, &T)) -> (T, T)

Returns a new owned copy of the input ref tuple.

fn overlap(&self, a: &T, b: &T, c: &T, d: &T) -> bool

Returns true if any of the following are true

fn is_invalid_set(&self, a: &T, b: &T) -> bool

Returns true if b lt a or a lt self.min_ref() or self.max_ref() lt b.

impl CpCmp<i32> for NumberIncDecCpCmp<i32>

fn min(&self) -> i32

Returns the minimum begin value we will accept when converting from std::ops::Bound::Unbounded.

fn max(&self) -> i32

Returns the maximum end value we will accept when converting from std::ops::Bound::Unbounded.

fn min_ref(&self) -> &i32

fn max_ref(&self) -> &i32

fn cp(&self, v: &i32) -> i32

fn lt(&self, a: &i32, b: &i32) -> bool

Returns true if a < b.

fn gt(&self, a: &T, b: &T) -> bool

Returns true if a gt b.

fn eq(&self, a: &T, b: &T) -> bool

Returns true if a eq b.

fn ne(&self, a: &T, b: &T) -> bool

Returns true if a ne b.

fn le(&self, a: &T, b: &T) -> bool

Returns true if a le b.

fn ge(&self, a: &T, b: &T) -> bool

Returns true if a ge b.

fn contains(&self, a: &T, b: &T, c: &T) -> bool

Returns true if a and b contain c.

fn cp_tpl_ref(&self, src: (&T, &T)) -> (T, T)

Returns a new owned copy of the input ref tuple.

fn overlap(&self, a: &T, b: &T, c: &T, d: &T) -> bool

Returns true if any of the following are true

fn is_invalid_set(&self, a: &T, b: &T) -> bool

Returns true if b lt a or a lt self.min_ref() or self.max_ref() lt b.

impl CpCmp<i64> for NumberIncDecCpCmp<i64>

fn min(&self) -> i64

Returns the minimum begin value we will accept when converting from std::ops::Bound::Unbounded.

fn max(&self) -> i64

Returns the maximum end value we will accept when converting from std::ops::Bound::Unbounded.

fn min_ref(&self) -> &i64

fn max_ref(&self) -> &i64

fn cp(&self, v: &i64) -> i64

fn lt(&self, a: &i64, b: &i64) -> bool

Returns true if a < b.

fn gt(&self, a: &T, b: &T) -> bool

Returns true if a gt b.

fn eq(&self, a: &T, b: &T) -> bool

Returns true if a eq b.

fn ne(&self, a: &T, b: &T) -> bool

Returns true if a ne b.

fn le(&self, a: &T, b: &T) -> bool

Returns true if a le b.

fn ge(&self, a: &T, b: &T) -> bool

Returns true if a ge b.

fn contains(&self, a: &T, b: &T, c: &T) -> bool

Returns true if a and b contain c.

fn cp_tpl_ref(&self, src: (&T, &T)) -> (T, T)

Returns a new owned copy of the input ref tuple.

fn overlap(&self, a: &T, b: &T, c: &T, d: &T) -> bool

Returns true if any of the following are true

fn is_invalid_set(&self, a: &T, b: &T) -> bool

Returns true if b lt a or a lt self.min_ref() or self.max_ref() lt b.

impl CpCmp<i128> for NumberIncDecCpCmp<i128>

fn min(&self) -> i128

Returns the minimum begin value we will accept when converting from std::ops::Bound::Unbounded.

fn max(&self) -> i128

Returns the maximum end value we will accept when converting from std::ops::Bound::Unbounded.

fn min_ref(&self) -> &i128

fn max_ref(&self) -> &i128

fn cp(&self, v: &i128) -> i128

fn lt(&self, a: &i128, b: &i128) -> bool

Returns true if a < b.

fn gt(&self, a: &T, b: &T) -> bool

Returns true if a gt b.

fn eq(&self, a: &T, b: &T) -> bool

Returns true if a eq b.

fn ne(&self, a: &T, b: &T) -> bool

Returns true if a ne b.

fn le(&self, a: &T, b: &T) -> bool

Returns true if a le b.

fn ge(&self, a: &T, b: &T) -> bool

Returns true if a ge b.

fn contains(&self, a: &T, b: &T, c: &T) -> bool

Returns true if a and b contain c.

fn cp_tpl_ref(&self, src: (&T, &T)) -> (T, T)

Returns a new owned copy of the input ref tuple.

fn overlap(&self, a: &T, b: &T, c: &T, d: &T) -> bool

Returns true if any of the following are true

fn is_invalid_set(&self, a: &T, b: &T) -> bool

Returns true if b lt a or a lt self.min_ref() or self.max_ref() lt b.

impl CpCmp<isize> for NumberIncDecCpCmp<isize>

fn min(&self) -> isize

Returns the minimum begin value we will accept when converting from std::ops::Bound::Unbounded.

fn max(&self) -> isize

Returns the maximum end value we will accept when converting from std::ops::Bound::Unbounded.

fn min_ref(&self) -> &isize

fn max_ref(&self) -> &isize

fn cp(&self, v: &isize) -> isize

fn lt(&self, a: &isize, b: &isize) -> bool

Returns true if a < b.

fn gt(&self, a: &T, b: &T) -> bool

Returns true if a gt b.

fn eq(&self, a: &T, b: &T) -> bool

Returns true if a eq b.

fn ne(&self, a: &T, b: &T) -> bool

Returns true if a ne b.

fn le(&self, a: &T, b: &T) -> bool

Returns true if a le b.

fn ge(&self, a: &T, b: &T) -> bool

Returns true if a ge b.

fn contains(&self, a: &T, b: &T, c: &T) -> bool

Returns true if a and b contain c.

fn cp_tpl_ref(&self, src: (&T, &T)) -> (T, T)

Returns a new owned copy of the input ref tuple.

fn overlap(&self, a: &T, b: &T, c: &T, d: &T) -> bool

Returns true if any of the following are true

fn is_invalid_set(&self, a: &T, b: &T) -> bool

Returns true if b lt a or a lt self.min_ref() or self.max_ref() lt b.

impl CpCmp<u8> for NumberIncDecCpCmp<u8>

fn min(&self) -> u8

Returns the minimum begin value we will accept when converting from std::ops::Bound::Unbounded.

fn max(&self) -> u8

Returns the maximum end value we will accept when converting from std::ops::Bound::Unbounded.

fn min_ref(&self) -> &u8

fn max_ref(&self) -> &u8

fn cp(&self, v: &u8) -> u8

fn lt(&self, a: &u8, b: &u8) -> bool

Returns true if a < b.

fn gt(&self, a: &T, b: &T) -> bool

Returns true if a gt b.

fn eq(&self, a: &T, b: &T) -> bool

Returns true if a eq b.

fn ne(&self, a: &T, b: &T) -> bool

Returns true if a ne b.

fn le(&self, a: &T, b: &T) -> bool

Returns true if a le b.

fn ge(&self, a: &T, b: &T) -> bool

Returns true if a ge b.

fn contains(&self, a: &T, b: &T, c: &T) -> bool

Returns true if a and b contain c.

fn cp_tpl_ref(&self, src: (&T, &T)) -> (T, T)

Returns a new owned copy of the input ref tuple.

fn overlap(&self, a: &T, b: &T, c: &T, d: &T) -> bool

Returns true if any of the following are true

fn is_invalid_set(&self, a: &T, b: &T) -> bool

Returns true if b lt a or a lt self.min_ref() or self.max_ref() lt b.

impl CpCmp<u16> for NumberIncDecCpCmp<u16>

fn min(&self) -> u16

Returns the minimum begin value we will accept when converting from std::ops::Bound::Unbounded.

fn max(&self) -> u16

Returns the maximum end value we will accept when converting from std::ops::Bound::Unbounded.

fn min_ref(&self) -> &u16

fn max_ref(&self) -> &u16

fn cp(&self, v: &u16) -> u16

fn lt(&self, a: &u16, b: &u16) -> bool

Returns true if a < b.

fn gt(&self, a: &T, b: &T) -> bool

Returns true if a gt b.

fn eq(&self, a: &T, b: &T) -> bool

Returns true if a eq b.

fn ne(&self, a: &T, b: &T) -> bool

Returns true if a ne b.

fn le(&self, a: &T, b: &T) -> bool

Returns true if a le b.

fn ge(&self, a: &T, b: &T) -> bool

Returns true if a ge b.

fn contains(&self, a: &T, b: &T, c: &T) -> bool

Returns true if a and b contain c.

fn cp_tpl_ref(&self, src: (&T, &T)) -> (T, T)

Returns a new owned copy of the input ref tuple.

fn overlap(&self, a: &T, b: &T, c: &T, d: &T) -> bool

Returns true if any of the following are true

fn is_invalid_set(&self, a: &T, b: &T) -> bool

Returns true if b lt a or a lt self.min_ref() or self.max_ref() lt b.

impl CpCmp<u32> for NumberIncDecCpCmp<u32>

fn min(&self) -> u32

Returns the minimum begin value we will accept when converting from std::ops::Bound::Unbounded.

fn max(&self) -> u32

Returns the maximum end value we will accept when converting from std::ops::Bound::Unbounded.

fn min_ref(&self) -> &u32

fn max_ref(&self) -> &u32

fn cp(&self, v: &u32) -> u32

fn lt(&self, a: &u32, b: &u32) -> bool

Returns true if a < b.

fn gt(&self, a: &T, b: &T) -> bool

Returns true if a gt b.

fn eq(&self, a: &T, b: &T) -> bool

Returns true if a eq b.

fn ne(&self, a: &T, b: &T) -> bool

Returns true if a ne b.

fn le(&self, a: &T, b: &T) -> bool

Returns true if a le b.

fn ge(&self, a: &T, b: &T) -> bool

Returns true if a ge b.

fn contains(&self, a: &T, b: &T, c: &T) -> bool

Returns true if a and b contain c.

fn cp_tpl_ref(&self, src: (&T, &T)) -> (T, T)

Returns a new owned copy of the input ref tuple.

fn overlap(&self, a: &T, b: &T, c: &T, d: &T) -> bool

Returns true if any of the following are true

fn is_invalid_set(&self, a: &T, b: &T) -> bool

Returns true if b lt a or a lt self.min_ref() or self.max_ref() lt b.

impl CpCmp<u64> for NumberIncDecCpCmp<u64>

fn min(&self) -> u64

Returns the minimum begin value we will accept when converting from std::ops::Bound::Unbounded.

fn max(&self) -> u64

Returns the maximum end value we will accept when converting from std::ops::Bound::Unbounded.

fn min_ref(&self) -> &u64

fn max_ref(&self) -> &u64

fn cp(&self, v: &u64) -> u64

fn lt(&self, a: &u64, b: &u64) -> bool

Returns true if a < b.

fn gt(&self, a: &T, b: &T) -> bool

Returns true if a gt b.

fn eq(&self, a: &T, b: &T) -> bool

Returns true if a eq b.

fn ne(&self, a: &T, b: &T) -> bool

Returns true if a ne b.

fn le(&self, a: &T, b: &T) -> bool

Returns true if a le b.

fn ge(&self, a: &T, b: &T) -> bool

Returns true if a ge b.

fn contains(&self, a: &T, b: &T, c: &T) -> bool

Returns true if a and b contain c.

fn cp_tpl_ref(&self, src: (&T, &T)) -> (T, T)

Returns a new owned copy of the input ref tuple.

fn overlap(&self, a: &T, b: &T, c: &T, d: &T) -> bool

Returns true if any of the following are true

fn is_invalid_set(&self, a: &T, b: &T) -> bool

Returns true if b lt a or a lt self.min_ref() or self.max_ref() lt b.

impl CpCmp<u128> for NumberIncDecCpCmp<u128>

fn min(&self) -> u128

Returns the minimum begin value we will accept when converting from std::ops::Bound::Unbounded.

fn max(&self) -> u128

Returns the maximum end value we will accept when converting from std::ops::Bound::Unbounded.

fn min_ref(&self) -> &u128

fn max_ref(&self) -> &u128

fn cp(&self, v: &u128) -> u128

fn lt(&self, a: &u128, b: &u128) -> bool

Returns true if a < b.

fn gt(&self, a: &T, b: &T) -> bool

Returns true if a gt b.

fn eq(&self, a: &T, b: &T) -> bool

Returns true if a eq b.

fn ne(&self, a: &T, b: &T) -> bool

Returns true if a ne b.

fn le(&self, a: &T, b: &T) -> bool

Returns true if a le b.

fn ge(&self, a: &T, b: &T) -> bool

Returns true if a ge b.

fn contains(&self, a: &T, b: &T, c: &T) -> bool

Returns true if a and b contain c.

fn cp_tpl_ref(&self, src: (&T, &T)) -> (T, T)

Returns a new owned copy of the input ref tuple.

fn overlap(&self, a: &T, b: &T, c: &T, d: &T) -> bool

Returns true if any of the following are true

fn is_invalid_set(&self, a: &T, b: &T) -> bool

Returns true if b lt a or a lt self.min_ref() or self.max_ref() lt b.

impl CpCmp<usize> for NumberIncDecCpCmp<usize>

fn min(&self) -> usize

Returns the minimum begin value we will accept when converting from std::ops::Bound::Unbounded.

fn max(&self) -> usize

Returns the maximum end value we will accept when converting from std::ops::Bound::Unbounded.

fn min_ref(&self) -> &usize

fn max_ref(&self) -> &usize

fn cp(&self, v: &usize) -> usize

fn lt(&self, a: &usize, b: &usize) -> bool

Returns true if a < b.

fn gt(&self, a: &T, b: &T) -> bool

Returns true if a gt b.

fn eq(&self, a: &T, b: &T) -> bool

Returns true if a eq b.

fn ne(&self, a: &T, b: &T) -> bool

Returns true if a ne b.

fn le(&self, a: &T, b: &T) -> bool

Returns true if a le b.

fn ge(&self, a: &T, b: &T) -> bool

Returns true if a ge b.

fn contains(&self, a: &T, b: &T, c: &T) -> bool

Returns true if a and b contain c.

fn cp_tpl_ref(&self, src: (&T, &T)) -> (T, T)

Returns a new owned copy of the input ref tuple.

fn overlap(&self, a: &T, b: &T, c: &T, d: &T) -> bool

Returns true if any of the following are true

fn is_invalid_set(&self, a: &T, b: &T) -> bool

Returns true if b lt a or a lt self.min_ref() or self.max_ref() lt b.

impl<T> Debug for NumberIncDecCpCmp<T>

where T: Copy + Clone + Debug,

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

Formats the value using the given formatter.

impl DefaultValues<f32, f32> for NumberIncDecCpCmp<f32>

fn default_step(&self) -> f32

Returns the default value use for progressing a begin or end value of a range.

fn default_rebound(&self) -> f32

Returns the value used to adjust a start or end value in the context of std::ops::Bound.

fn default_min() -> f32

Returns the default minimum value.

fn default_max() -> f32

Returns the default maximum value.

impl DefaultValues<f64, f64> for NumberIncDecCpCmp<f64>

fn default_step(&self) -> f64

Returns the default value use for progressing a begin or end value of a range.

fn default_rebound(&self) -> f64

Returns the value used to adjust a start or end value in the context of std::ops::Bound.

fn default_min() -> f64

Returns the default minimum value.

fn default_max() -> f64

Returns the default maximum value.

impl DefaultValues<i8, i8> for NumberIncDecCpCmp<i8>

fn default_step(&self) -> i8

Returns the default value use for progressing a begin or end value of a range.

fn default_rebound(&self) -> i8

Returns the value used to adjust a start or end value in the context of std::ops::Bound.

fn default_min() -> i8

Returns the default minimum value.

fn default_max() -> i8

Returns the default maximum value.

impl DefaultValues<i16, i16> for NumberIncDecCpCmp<i16>

fn default_step(&self) -> i16

Returns the default value use for progressing a begin or end value of a range.

fn default_rebound(&self) -> i16

Returns the value used to adjust a start or end value in the context of std::ops::Bound.

fn default_min() -> i16

Returns the default minimum value.

fn default_max() -> i16

Returns the default maximum value.

impl DefaultValues<i32, i32> for NumberIncDecCpCmp<i32>

fn default_step(&self) -> i32

Returns the default value use for progressing a begin or end value of a range.

fn default_rebound(&self) -> i32

Returns the value used to adjust a start or end value in the context of std::ops::Bound.

fn default_min() -> i32

Returns the default minimum value.

fn default_max() -> i32

Returns the default maximum value.

impl DefaultValues<i64, i64> for NumberIncDecCpCmp<i64>

fn default_step(&self) -> i64

Returns the default value use for progressing a begin or end value of a range.

fn default_rebound(&self) -> i64

Returns the value used to adjust a start or end value in the context of std::ops::Bound.

fn default_min() -> i64

Returns the default minimum value.

fn default_max() -> i64

Returns the default maximum value.

impl DefaultValues<i128, i128> for NumberIncDecCpCmp<i128>

fn default_step(&self) -> i128

Returns the default value use for progressing a begin or end value of a range.

fn default_rebound(&self) -> i128

Returns the value used to adjust a start or end value in the context of std::ops::Bound.

fn default_min() -> i128

Returns the default minimum value.

fn default_max() -> i128

Returns the default maximum value.

impl DefaultValues<isize, isize> for NumberIncDecCpCmp<isize>

fn default_step(&self) -> isize

Returns the default value use for progressing a begin or end value of a range.

fn default_rebound(&self) -> isize

Returns the value used to adjust a start or end value in the context of std::ops::Bound.

fn default_min() -> isize

Returns the default minimum value.

fn default_max() -> isize

Returns the default maximum value.

impl DefaultValues<u8, u8> for NumberIncDecCpCmp<u8>

fn default_step(&self) -> u8

Returns the default value use for progressing a begin or end value of a range.

fn default_rebound(&self) -> u8

Returns the value used to adjust a start or end value in the context of std::ops::Bound.

fn default_min() -> u8

Returns the default minimum value.

fn default_max() -> u8

Returns the default maximum value.

impl DefaultValues<u16, u16> for NumberIncDecCpCmp<u16>

fn default_step(&self) -> u16

Returns the default value use for progressing a begin or end value of a range.

fn default_rebound(&self) -> u16

Returns the value used to adjust a start or end value in the context of std::ops::Bound.

fn default_min() -> u16

Returns the default minimum value.

fn default_max() -> u16

Returns the default maximum value.

impl DefaultValues<u32, u32> for NumberIncDecCpCmp<u32>

fn default_step(&self) -> u32

Returns the default value use for progressing a begin or end value of a range.

fn default_rebound(&self) -> u32

Returns the value used to adjust a start or end value in the context of std::ops::Bound.

fn default_min() -> u32

Returns the default minimum value.

fn default_max() -> u32

Returns the default maximum value.

impl DefaultValues<u64, u64> for NumberIncDecCpCmp<u64>

fn default_step(&self) -> u64

Returns the default value use for progressing a begin or end value of a range.

fn default_rebound(&self) -> u64

Returns the value used to adjust a start or end value in the context of std::ops::Bound.

fn default_min() -> u64

Returns the default minimum value.

fn default_max() -> u64

Returns the default maximum value.

impl DefaultValues<u128, u128> for NumberIncDecCpCmp<u128>

fn default_step(&self) -> u128

Returns the default value use for progressing a begin or end value of a range.

fn default_rebound(&self) -> u128

Returns the value used to adjust a start or end value in the context of std::ops::Bound.

fn default_min() -> u128

Returns the default minimum value.

fn default_max() -> u128

Returns the default maximum value.

impl DefaultValues<usize, usize> for NumberIncDecCpCmp<usize>

fn default_step(&self) -> usize

Returns the default value use for progressing a begin or end value of a range.

fn default_rebound(&self) -> usize

Returns the value used to adjust a start or end value in the context of std::ops::Bound.

fn default_min() -> usize

Returns the default minimum value.

fn default_max() -> usize

Returns the default maximum value.

impl IncDecCpCmp<f32, f32> for NumberIncDecCpCmp<f32>

fn dec(&self, a: &f32, b: &f32) -> Option<f32>

Should safely decrement a by b. The value should always go down… if not then it should return None.

fn inc(&self, a: &f32, b: &f32) -> Option<f32>

Should safely increment a by b. The value should always go up.. if not then it should return None.

fn cp_v(&self, v: &f32) -> f32

fn rebound_start(&self, start: Bound<&T>, rebound: &V) -> Option<T>

Returns the raw adjusted start value.

fn rebound_end(&self, end: Bound<&T>, rebound: &V) -> Option<T>

Returns the raw adjusted end value.

impl IncDecCpCmp<f64, f64> for NumberIncDecCpCmp<f64>

fn dec(&self, a: &f64, b: &f64) -> Option<f64>

Should safely decrement a by b. The value should always go down… if not then it should return None.

fn inc(&self, a: &f64, b: &f64) -> Option<f64>

Should safely increment a by b. The value should always go up.. if not then it should return None.

fn cp_v(&self, v: &f64) -> f64

fn rebound_start(&self, start: Bound<&T>, rebound: &V) -> Option<T>

Returns the raw adjusted start value.

fn rebound_end(&self, end: Bound<&T>, rebound: &V) -> Option<T>

Returns the raw adjusted end value.

impl IncDecCpCmp<i8, i8> for NumberIncDecCpCmp<i8>

fn dec(&self, a: &i8, b: &i8) -> Option<i8>

Should safely decrement a by b. The value should always go down… if not then it should return None.

fn inc(&self, a: &i8, b: &i8) -> Option<i8>

Should safely increment a by b. The value should always go up.. if not then it should return None.

fn cp_v(&self, v: &i8) -> i8

fn rebound_start(&self, start: Bound<&T>, rebound: &V) -> Option<T>

Returns the raw adjusted start value.

fn rebound_end(&self, end: Bound<&T>, rebound: &V) -> Option<T>

Returns the raw adjusted end value.

impl IncDecCpCmp<i16, i16> for NumberIncDecCpCmp<i16>

fn dec(&self, a: &i16, b: &i16) -> Option<i16>

Should safely decrement a by b. The value should always go down… if not then it should return None.

fn inc(&self, a: &i16, b: &i16) -> Option<i16>

Should safely increment a by b. The value should always go up.. if not then it should return None.

fn cp_v(&self, v: &i16) -> i16

fn rebound_start(&self, start: Bound<&T>, rebound: &V) -> Option<T>

Returns the raw adjusted start value.

fn rebound_end(&self, end: Bound<&T>, rebound: &V) -> Option<T>

Returns the raw adjusted end value.

impl IncDecCpCmp<i32, i32> for NumberIncDecCpCmp<i32>

fn dec(&self, a: &i32, b: &i32) -> Option<i32>

Should safely decrement a by b. The value should always go down… if not then it should return None.

fn inc(&self, a: &i32, b: &i32) -> Option<i32>

Should safely increment a by b. The value should always go up.. if not then it should return None.

fn cp_v(&self, v: &i32) -> i32

fn rebound_start(&self, start: Bound<&T>, rebound: &V) -> Option<T>

Returns the raw adjusted start value.

fn rebound_end(&self, end: Bound<&T>, rebound: &V) -> Option<T>

Returns the raw adjusted end value.

impl IncDecCpCmp<i64, i64> for NumberIncDecCpCmp<i64>

fn dec(&self, a: &i64, b: &i64) -> Option<i64>

Should safely decrement a by b. The value should always go down… if not then it should return None.

fn inc(&self, a: &i64, b: &i64) -> Option<i64>

Should safely increment a by b. The value should always go up.. if not then it should return None.

fn cp_v(&self, v: &i64) -> i64

fn rebound_start(&self, start: Bound<&T>, rebound: &V) -> Option<T>

Returns the raw adjusted start value.

fn rebound_end(&self, end: Bound<&T>, rebound: &V) -> Option<T>

Returns the raw adjusted end value.

impl IncDecCpCmp<i128, i128> for NumberIncDecCpCmp<i128>

fn dec(&self, a: &i128, b: &i128) -> Option<i128>

Should safely decrement a by b. The value should always go down… if not then it should return None.

fn inc(&self, a: &i128, b: &i128) -> Option<i128>

Should safely increment a by b. The value should always go up.. if not then it should return None.

fn cp_v(&self, v: &i128) -> i128

fn rebound_start(&self, start: Bound<&T>, rebound: &V) -> Option<T>

Returns the raw adjusted start value.

fn rebound_end(&self, end: Bound<&T>, rebound: &V) -> Option<T>

Returns the raw adjusted end value.

impl IncDecCpCmp<isize, isize> for NumberIncDecCpCmp<isize>

fn dec(&self, a: &isize, b: &isize) -> Option<isize>

Should safely decrement a by b. The value should always go down… if not then it should return None.

fn inc(&self, a: &isize, b: &isize) -> Option<isize>

Should safely increment a by b. The value should always go up.. if not then it should return None.

fn cp_v(&self, v: &isize) -> isize

fn rebound_start(&self, start: Bound<&T>, rebound: &V) -> Option<T>

Returns the raw adjusted start value.

fn rebound_end(&self, end: Bound<&T>, rebound: &V) -> Option<T>

Returns the raw adjusted end value.

impl IncDecCpCmp<u8, u8> for NumberIncDecCpCmp<u8>

fn dec(&self, a: &u8, b: &u8) -> Option<u8>

Should safely decrement a by b. The value should always go down… if not then it should return None.

fn inc(&self, a: &u8, b: &u8) -> Option<u8>

Should safely increment a by b. The value should always go up.. if not then it should return None.

fn cp_v(&self, v: &u8) -> u8

fn rebound_start(&self, start: Bound<&T>, rebound: &V) -> Option<T>

Returns the raw adjusted start value.

fn rebound_end(&self, end: Bound<&T>, rebound: &V) -> Option<T>

Returns the raw adjusted end value.

impl IncDecCpCmp<u16, u16> for NumberIncDecCpCmp<u16>

fn dec(&self, a: &u16, b: &u16) -> Option<u16>

Should safely decrement a by b. The value should always go down… if not then it should return None.

fn inc(&self, a: &u16, b: &u16) -> Option<u16>

Should safely increment a by b. The value should always go up.. if not then it should return None.

fn cp_v(&self, v: &u16) -> u16

fn rebound_start(&self, start: Bound<&T>, rebound: &V) -> Option<T>

Returns the raw adjusted start value.

fn rebound_end(&self, end: Bound<&T>, rebound: &V) -> Option<T>

Returns the raw adjusted end value.

impl IncDecCpCmp<u32, u32> for NumberIncDecCpCmp<u32>

fn dec(&self, a: &u32, b: &u32) -> Option<u32>

Should safely decrement a by b. The value should always go down… if not then it should return None.

fn inc(&self, a: &u32, b: &u32) -> Option<u32>

Should safely increment a by b. The value should always go up.. if not then it should return None.

fn cp_v(&self, v: &u32) -> u32

fn rebound_start(&self, start: Bound<&T>, rebound: &V) -> Option<T>

Returns the raw adjusted start value.

fn rebound_end(&self, end: Bound<&T>, rebound: &V) -> Option<T>

Returns the raw adjusted end value.

impl IncDecCpCmp<u64, u64> for NumberIncDecCpCmp<u64>

fn dec(&self, a: &u64, b: &u64) -> Option<u64>

Should safely decrement a by b. The value should always go down… if not then it should return None.

fn inc(&self, a: &u64, b: &u64) -> Option<u64>

Should safely increment a by b. The value should always go up.. if not then it should return None.

fn cp_v(&self, v: &u64) -> u64

fn rebound_start(&self, start: Bound<&T>, rebound: &V) -> Option<T>

Returns the raw adjusted start value.

fn rebound_end(&self, end: Bound<&T>, rebound: &V) -> Option<T>

Returns the raw adjusted end value.

impl IncDecCpCmp<u128, u128> for NumberIncDecCpCmp<u128>

fn dec(&self, a: &u128, b: &u128) -> Option<u128>

Should safely decrement a by b. The value should always go down… if not then it should return None.

fn inc(&self, a: &u128, b: &u128) -> Option<u128>

Should safely increment a by b. The value should always go up.. if not then it should return None.

fn cp_v(&self, v: &u128) -> u128

fn rebound_start(&self, start: Bound<&T>, rebound: &V) -> Option<T>

Returns the raw adjusted start value.

fn rebound_end(&self, end: Bound<&T>, rebound: &V) -> Option<T>

Returns the raw adjusted end value.

impl IncDecCpCmp<usize, usize> for NumberIncDecCpCmp<usize>

fn dec(&self, a: &usize, b: &usize) -> Option<usize>

Should safely decrement a by b. The value should always go down… if not then it should return None.

fn inc(&self, a: &usize, b: &usize) -> Option<usize>

Should safely increment a by b. The value should always go up.. if not then it should return None.

fn cp_v(&self, v: &usize) -> usize

fn rebound_start(&self, start: Bound<&T>, rebound: &V) -> Option<T>

Returns the raw adjusted start value.

fn rebound_end(&self, end: Bound<&T>, rebound: &V) -> Option<T>

Returns the raw adjusted end value.