sqrid 0.0.35

Square coordinates and grid-like arrays, with zero dependencies, in a single file
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

// Copyright (C) 2021 Leandro Lisboa Penz <lpenz@lpenz.org>
// This file is subject to the terms and conditions defined in
// file 'LICENSE', which is part of this source code package.

use sqrid;

use anyhow::Result;
use std::convert::TryFrom;

type Pos = sqrid::Pos<2, 2>;
type Sqrid = sqrid::sqrid_create!(Pos, false);
type Pos2 = sqrid::Pos<255, 255>;
type Sqrid2 = sqrid::sqrid_create!(Pos2, false);

fn sumfunc(pos: Pos, dir: sqrid::Dir) -> Option<Pos> {
    (pos + dir).ok()
}

#[test]
fn test_basic() -> Result<()> {
    let center = Pos::try_from((1, 1))?;
    let bfiterator = Sqrid::bf_iter(sumfunc, &center);
    let bfiterator2 = bfiterator.clone();
    let v = bfiterator2
        .flatten()
        .map(|(pos, _)| pos.tuple())
        .collect::<Vec<_>>();
    assert_eq!(
        v,
        vec![
            (1, 0),
            (2, 1),
            (1, 2),
            (0, 1),
            (2, 0),
            (0, 0),
            (2, 2),
            (0, 2)
        ],
    );
    Ok(())
}

#[test]
fn test_walls() -> Result<()> {
    let center = Pos::try_from((1, 1))?;
    let v = Sqrid::bf_iter(
        |pos, dir| {
            (pos + dir).ok().and_then(|pos| {
                let t = pos.tuple();
                if t != (0, 1) && t != (2, 1) {
                    Some(pos)
                } else {
                    None
                }
            })
        },
        &center,
    )
    .flatten()
    .map(|(pos, _)| pos.tuple())
    .collect::<Vec<_>>();
    assert_eq!(v, vec![(1, 0), (1, 2), (2, 0), (0, 0), (2, 2), (0, 2)],);
    Ok(())
}

#[test]
fn test_scale() -> Result<()> {
    let v = Sqrid2::bf_iter(|pos, dir| (pos + dir).ok(), &Pos2::TOP_LEFT)
        .flatten()
        .map(|(pos, _)| pos)
        .collect::<Vec<_>>();
    assert_eq!(v.len(), 256 * 256 - 1);
    Ok(())
}