forked from Orchid/orchid
98 lines
2.7 KiB
Rust
98 lines
2.7 KiB
Rust
//! Named left/right. I tried bools, I couldn't consistently remember which one
|
|
//! is left, so I made an enum. Rust should optimize this into a bool anyway.
|
|
|
|
use std::fmt;
|
|
use std::ops::Not;
|
|
|
|
use crate::boxed_iter::BoxedIter;
|
|
|
|
/// A primitive for encoding the two sides Left and Right. While booleans
|
|
/// are technically usable for this purpose, they're very easy to confuse
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
|
|
pub enum Side {
|
|
/// Left, low, or high-to-low in the case of sequences
|
|
Left,
|
|
/// Right, high, or low-to-high in the case of sequences
|
|
Right,
|
|
}
|
|
|
|
impl fmt::Display for Side {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
match self {
|
|
Self::Left => write!(f, "Left"),
|
|
Self::Right => write!(f, "Right"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Side {
|
|
/// Get the side that is not the current one
|
|
pub fn opposite(&self) -> Self {
|
|
match self {
|
|
Self::Left => Self::Right,
|
|
Self::Right => Self::Left,
|
|
}
|
|
}
|
|
/// Shorthand for opposite
|
|
pub fn inv(&self) -> Self { self.opposite() }
|
|
/// take N elements from this end of a slice
|
|
pub fn slice<'a, T>(&self, size: usize, slice: &'a [T]) -> &'a [T] {
|
|
match self {
|
|
Side::Left => &slice[..size],
|
|
Side::Right => &slice[slice.len() - size..],
|
|
}
|
|
}
|
|
/// ignore N elements from this end of a slice
|
|
pub fn crop<'a, T>(&self, margin: usize, slice: &'a [T]) -> &'a [T] {
|
|
self.opposite().slice(slice.len() - margin, slice)
|
|
}
|
|
/// ignore N elements from this end and M elements from the other end
|
|
/// of a slice
|
|
pub fn crop_both<'a, T>(&self, margin: usize, opposite: usize, slice: &'a [T]) -> &'a [T] {
|
|
self.crop(margin, self.opposite().crop(opposite, slice))
|
|
}
|
|
/// Pick this side from a pair of things
|
|
pub fn pick<T>(&self, pair: (T, T)) -> T {
|
|
match self {
|
|
Side::Left => pair.0,
|
|
Side::Right => pair.1,
|
|
}
|
|
}
|
|
/// Make a pair with the first element on this side
|
|
pub fn pair<T>(&self, this: T, opposite: T) -> (T, T) {
|
|
match self {
|
|
Side::Left => (this, opposite),
|
|
Side::Right => (opposite, this),
|
|
}
|
|
}
|
|
/// Walk a double ended iterator (assumed to be left-to-right) in this
|
|
/// direction
|
|
pub fn walk<'a, I: DoubleEndedIterator + 'a>(&self, iter: I) -> BoxedIter<'a, I::Item> {
|
|
match self {
|
|
Side::Right => Box::new(iter) as BoxedIter<I::Item>,
|
|
Side::Left => Box::new(iter.rev()),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Not for Side {
|
|
type Output = Side;
|
|
|
|
fn not(self) -> Self::Output { self.opposite() }
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use itertools::Itertools;
|
|
|
|
use super::*;
|
|
|
|
/// I apparently have a tendency to mix these up so it's best if
|
|
/// the sides are explicitly stated
|
|
#[test]
|
|
fn test_walk() {
|
|
assert_eq!(Side::Right.walk(0..4).collect_vec(), vec![0, 1, 2, 3], "can walk a range");
|
|
assert_eq!(Side::Left.walk(0..4).collect_vec(), vec![3, 2, 1, 0], "can walk a range backwards")
|
|
}
|
|
}
|