Struct Bint 

pub struct Bint {
    pub value: u8,
    pub boundary: u8,
}

Bint: A bounded integer.

Returns a struct that represents an unsigned integer and a boundary that represents when the value will be reset to 0.

Usage:

use bint::Bint;

let b = Bint {value: 5, boundary: 6 };
let c: Bint = b.up();
let d: Bint = c.up();

assert_eq!(5, b.value);
assert_eq!(0, c.value);
assert_eq!(1, d.value);

Fields

value: u8

boundary: u8

Implementations

impl Bint

pub fn new(boundary: u8) -> Bint

use bint::Bint;

let b: Bint = Bint::new(6);
let c: Bint = b.down();
let d: Bint = c.up();
let e: Bint = d.up();

assert_eq!(0, b.value);
assert_eq!(5, c.value);
assert_eq!(0, d.value);
assert_eq!(1, e.value);

Examples found in repository

examples/double.rs (line 8)

fn main() {
    let mut bint = Bint::new(30);
    for _ in 0..60 {
        let (x, y) = perms(bint.value);
        bint = bint.up();
        println!("{} {}", x, y);
    }
}

pub fn new_with_value(boundary: u8, value: u8) -> Bint

use bint::Bint;

let bint = Bint::new_with_value(10, 7);
assert_eq!(10, bint.boundary);
assert_eq!(7, bint.value);

let bint_out_of_range = Bint::new_with_value(10, 23);
assert_eq!(10, bint_out_of_range.boundary);
assert_eq!(0, bint_out_of_range.value);

pub fn up(&self) -> Bint

use bint::Bint;

let b: Bint = Bint {
    value: 4,
    boundary: 6,
};

let b: Bint = b.up();
assert_eq!(5, b.value);

let b: Bint = b.up();
assert_eq!(0, b.value);

Examples found in repository

examples/double.rs (line 11)

fn main() {
    let mut bint = Bint::new(30);
    for _ in 0..60 {
        let (x, y) = perms(bint.value);
        bint = bint.up();
        println!("{} {}", x, y);
    }
}

pub fn up_x(self, x: u8) -> Bint

use bint::Bint;

let b: Bint = Bint {
    value: 4,
    boundary: 6,
};

let b: Bint = b.up_x(3);
assert_eq!(1, b.value);

pub fn down(&self) -> Bint

use bint::Bint;

let b: Bint = Bint {
    value: 1,
    boundary: 6,
};

let b: Bint = b.down();
assert_eq!(0, b.value);

let b: Bint = b.down();
assert_eq!(5, b.value);

pub fn down_x(self, x: u8) -> Bint

use bint::Bint;

let b: Bint = Bint {
    value: 4,
    boundary: 6,
};

let b: Bint = b.down_x(6);
assert_eq!(4, b.value);

let b: Bint = b.down_x(3);
assert_eq!(1, b.value);

Trait Implementations

impl Clone for Bint

fn clone(&self) -> Bint

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Bint

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

Formats the value using the given formatter.

impl Default for Bint

fn default() -> Self

Defaults to the maximum value of an unsigned 8 integer.

use bint::Bint;

let mut b = Bint::default();

for _ in 0..u8::MAX {
    b = b.down()
}

for _ in 0..u8::MAX {
    b = b.down()
}

assert_eq!(b.value, 0)

impl Display for Bint

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

Formats the value using the given formatter.

impl From<&Bint> for BintCell

fn from(cell: &Bint) -> Self

use bint::{Bint, BintCell};

let bint = Bint::new_with_value(8, 3);
let expected = BintCell::new_with_value(8, 3);

assert_eq!(expected, BintCell::from(&bint));

impl From<&BintCell> for Bint

fn from(cell: &BintCell) -> Self

use bint::{Bint, BintCell};

let cell = BintCell::new_with_value(8, 3);
let expected = Bint {
    value: cell.value(),
    boundary: cell.boundary,
};

assert_eq!(expected, Bint::from(cell));

impl From<&DrainableBintCell> for Bint

fn from(cell: &DrainableBintCell) -> Self

use bint::{Bint, DrainableBintCell};

let bint_cell = DrainableBintCell::new_with_value(8, 8, 3);
let expected = Bint::new_with_value(8, 3);

assert_eq!(expected, Bint::from(&bint_cell));

impl From<Bint> for BintCell

fn from(cell: Bint) -> Self

use bint::{Bint, BintCell};

let bint = Bint::new_with_value(8, 3);
let expected = BintCell::new_with_value(8, 3);

assert_eq!(expected, BintCell::from(bint));

impl From<BintCell> for Bint

fn from(cell: BintCell) -> Self

use bint::{Bint, BintCell};

let cell = BintCell::new_with_value(8, 3);
let expected = Bint {
    value: cell.value(),
    boundary: cell.boundary,
};

assert_eq!(expected, Bint::from(cell));

impl From<DrainableBintCell> for Bint

fn from(cell: DrainableBintCell) -> Self

use bint::{Bint, DrainableBintCell};

let bint_cell = DrainableBintCell::new_with_value(8, 8, 3);
let expected = Bint::new_with_value(8, 3);

assert_eq!(expected, Bint::from(bint_cell));

impl Hash for Bint

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Bint

fn cmp(&self, other: &Bint) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Bint

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for Bint

fn partial_cmp(&self, other: &Bint) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for Bint

impl Eq for Bint

impl StructuralPartialEq for Bint