sudoku-rust/sudoku/src/bits.rs

/*
Or MAYBE, just use Vec<bool> ?!
While that would use more memory, it would certainly be faster!
Is saving a few bytes (these days) worth it, really?

The iterator would ... already be written for Vec<T>. :P
(Buuut, not quite. I only want true values...)

fn main() {
    let vector = vec![true, false, false, true];

    for z in vector.iter().enumerate().filter(|x| *x.1) {
        println!("{:?}", z);
    }
    for z in vector.iter().enumerate().filter(|x| *x.1) {
        println!("{:?}", z);
    }
}

This returns (0, true), (3, true)

fn main() {
    let vector = vec![true, false, false, true];

    let d : Vec<usize> = vector.iter().enumerate().filter(|x| *x.1).map(|x| x.0).collect();
    println!("{:?}", &d);
}

This returns (0,3) !  This is what I was looking for!
I'd rather have an iterator (like I have below), but I might
have to compromise here.

    let d = vector.iter().enumerate().filter(|x| *x.1).map(|x| x.0);
    for dv in d {
        println!(" {}", dv);
    }

There we go, map returns iterator. :D
Enumerate creates (index, value),
filter finds "true" items,
map returns iterator (with index)!

And we could handle any crazy size as well... :O

 */

use std::ops::RangeBounds;
use std::fmt;
// use std::iter::{Map, Filter, Enumerate};

#[derive(Clone)]
pub struct GenBits(pub Vec<bool>);

impl GenBits {
    pub fn new(size: usize) -> Self {
        GenBits(vec![false; size])
    }

    pub fn clear(&mut self) {
        for i in 0..self.0.len() {
            self.0[i] = false;
        }
    }

    pub fn fill(&mut self, value: bool) {
        for i in 0..self.0.len() {
            self.0[i] = value;
        }
    }

    pub fn set(&mut self, bit: usize, state: bool) {
        self.0[bit] = state;
    }

    pub fn get(&self, bit: usize) -> bool {
        self.0[bit]
    }

    pub fn set_bits<R: RangeBounds<usize> + IntoIterator<Item = usize>>(&mut self, bits: R) {
        for i in bits {
            self.0[i as usize] = true;
        }
    }

    pub fn count_set(&self) -> usize {
        self.0.iter().filter(|&x| *x).count()
    }

    // https://depth-first.com/articles/2020/06/22/returning-rust-iterators/

    #[deprecated = "Use iter() instead."]
    /// Returns the indexes of items that are true
    pub fn indexes(&self) -> impl Iterator<Item = usize> + '_ {
        self.0.iter().enumerate().filter(|x| *x.1).map(|x| x.0)
    }

    /// The "default" iterator for GenBits returns this.
    pub fn iter(&self) -> impl Iterator<Item = usize> + '_ {
        self.0.iter().enumerate().filter(|x| *x.1).map(|x| x.0)
    }

    /*
    pub fn iter(&self) -> std::slice::Iter<'_, bool> {
        self.0.iter()
    }
    */

    /// Display bits that are set.
    /// +1 is added to the display, so it matches the cell values (1..N)
    pub fn display(&self) -> String {
        self.0
            .iter()
            .enumerate()
            .filter(|x| *x.1)
            .map(|x| x.0)
            .map(|i| (i + 1).to_string())
            // .map(|i| i.to_string())
            .collect::<Vec<_>>()
            .join(",")
    }
}

impl fmt::Debug for GenBits {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            write!(f, "({})", self.0.iter().enumerate().filter(|x| *x.1).map(|x| x.0.to_string()).collect::<Vec<_>>().join(","))
        }
}

impl fmt::Display for GenBits {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "({})", self.0.iter().enumerate().filter(|x| *x.1).map(|x| x.0.to_string()).collect::<Vec<_>>().join(","))
    }
}

impl PartialEq for GenBits {
    fn eq(&self, other: &Self) -> bool {
        if self.0.len() != other.0.len() {
            return false;
        }
        for i in 0..self.0.len() {
            if self.0[i] != other.0[i] {
                return false;
            }
        }
        true
    }
}

#[cfg(test)]
mod tests {
    // use crate::sudoku::*;
    use crate::bits::*;

    #[test]
    fn check_u16() {
        const SIZE: usize = 9;
        let mut p = GenBits::new(SIZE);

        p.clear();

        for i in 0..9 {
            let mut result = p.get(i);
            assert_eq!(result, false);
            p.set(i, true);
            result = p.get(i);
            assert_eq!(result, true);
        }

        p = GenBits::new(SIZE);
        p.set(3, true);
        p.set(5, true);
        p.set(6, true);
        assert_eq!(3, p.count_set());
        let values: Vec<usize> = p.iter().collect();
        assert_eq!(values, vec!(3, 5, 6));
        assert_eq!(3, p.count_set());
        p.set(0, true);
        assert_eq!(4, p.count_set());

        p = GenBits::new(SIZE);
        p.set_bits(0..6);

        for i in 0..6 {
            let result = p.get(i);
            assert_eq!(result, true);
        }
        assert_eq!(p.get(6), false);
    }

    #[test]
    fn check_u32() {
        const SIZE: usize = 29;
        let mut p = GenBits::new(SIZE);

        p.clear();

        for i in 0..29 {
            let mut result = p.get(i);
            assert_eq!(result, false);
            p.set(i, true);
            result = p.get(i);
            assert_eq!(result, true);
        }

        p = GenBits::new(SIZE);
        p.set(13, true);
        p.set(15, true);
        p.set(26, true);
        assert_eq!(3, p.count_set());
        let values: Vec<usize> = p.iter().collect();
        assert_eq!(values, vec!(13, 15, 26));
        assert_eq!(3, p.count_set());
        p.set(0, true);
        assert_eq!(4, p.count_set());

        p = GenBits::new(SIZE);
        p.set_bits(10..26);

        for i in 10..26 {
            let result = p.get(i);
            assert_eq!(result, true);
        }
        assert_eq!(p.get(9), false);
        assert_eq!(p.get(27), false);
    }
}

/*
    // -> Map<Filter<Enumerate<std::slice::Iter<'_, bool>>>>
    pub fn indexes(&self) -> std::slice::Iter<usize>  {
        self.data.iter().enumerate().filter(|x| *x.1).map(|x| x.0)
    }
*/

/*
use bit_field::BitField;

// If I wanted to do 4x4 or 5x5, I would need more bits. (u32).

use num::Integer;
use std::ops::RangeBounds;
use std::fmt;

#[derive(Copy, Clone, PartialEq)]
pub struct GenBits<T: Integer + BitField>(pub T);

impl<T: Integer + BitField> GenBits<T> {
    pub fn clear(&mut self) {
        self.0 = T::zero();
    }

    pub fn set(&mut self, bit: usize, value: bool) {
        self.0.set_bit(bit, value);
    }

    #[must_use]
    pub fn get(&self, bit: usize) -> bool {
        self.0.get_bit(bit)
    }

    pub fn set_bits<R: RangeBounds<u8> + IntoIterator<Item = u8>>(&mut self, bits: R) {
        for i in bits {
            self.set(i as usize, true);
        }
    }

    #[must_use]
    pub fn count_set(&self) -> u8 {
        let mut count: u8 = 0;
        for i in 0..T::BIT_LENGTH {
            if self.get(i) {
                count += 1;
            }
        }
        count
    }

    /// Display bits that are set.
    /// +1 is added to the display, so it matches the cell values (1..N)
    pub fn display(&self) -> String {
        self.iter()
            .map(|i| (i+1).to_string())
            // .map(|i| i.to_string())
            .collect::<Vec<_>>().join(",")
    }

}

impl<T: Integer + BitField + ToString> fmt::Debug for GenBits<T> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let result = self.iter()
        // .map(|i| (i+1).to_string())
        .map(|i| i.to_string())
        .collect::<Vec<_>>().join(",");
        if result.is_empty() {
            return write!(f, "{{}}")
        } else {
        return write!(f, "<{}>", result)
        }
    }
}

pub struct GenBitsIterator<'a, T: Integer + BitField> {
    pub possible: &'a GenBits<T>,
    pub index: usize,
}

impl<T: Integer + BitField> GenBits<T> {
    pub fn iter(&self) -> GenBitsIterator<T> {
        GenBitsIterator {
            possible: self,
            index: 0,
        }
    }
}

impl<'a, T: Integer + BitField> Iterator for GenBitsIterator<'a, T> {
    type Item = u8;

    fn next(&mut self) -> Option<u8> {
        while (self.index < T::BIT_LENGTH) && (!self.possible.get(self.index as usize)) {
            self.index += 1;
        }
        if self.index == T::BIT_LENGTH {
            None
        } else {
            self.index += 1;
            Some((self.index - 1) as u8)
        }
    }
}

#[cfg(test)]
mod tests {
    // use crate::sudoku::*;
    use crate::bits::*;

    #[test]
    fn check_u16() {
        let mut p = GenBits::<u16>(0);

        p.clear();

        for i in 0..9 {
            let mut result = p.get(i);
            assert_eq!(result, false);
            p.set(i, true);
            result = p.get(i);
            assert_eq!(result, true);
        }

        p = GenBits::<u16>(0);
        p.set(3, true);
        p.set(5, true);
        p.set(6, true);
        assert_eq!(3, p.count_set());
        let values: Vec<u8> = p.iter().collect();
        assert_eq!(values, vec!(3, 5, 6));
        assert_eq!(3, p.count_set());
        p.set(0, true);
        assert_eq!(4, p.count_set());

        p = GenBits::<u16>(0);
        p.set_bits(0..6);

        for i in 0..6 {
            let result = p.get(i);
            assert_eq!(result, true);
        }
        assert_eq!(p.get(6), false);
    }

    #[test]
    fn check_u32() {
        let mut p = GenBits::<u32>(0);

        p.clear();

        for i in 0..29 {
            let mut result = p.get(i);
            assert_eq!(result, false);
            p.set(i, true);
            result = p.get(i);
            assert_eq!(result, true);
        }

        p = GenBits::<u32>(0);
        p.set(13, true);
        p.set(15, true);
        p.set(26, true);
        assert_eq!(3, p.count_set());
        let values: Vec<u8> = p.iter().collect();
        assert_eq!(values, vec!(13, 15, 26));
        assert_eq!(3, p.count_set());
        p.set(0, true);
        assert_eq!(4, p.count_set());

        p = GenBits::<u32>(0);
        p.set_bits(10..26);

        for i in 10..26 {
            let result = p.get(i);
            assert_eq!(result, true);
        }
        assert_eq!(p.get(9), false);
        assert_eq!(p.get(27), false);
    }
}

*/