forked from Orchid/orchid
58 lines
1.7 KiB
Rust
58 lines
1.7 KiB
Rust
use std::fmt::Display;
|
|
|
|
/// A primitive for encoding the two sides Left and Right. While booleans
|
|
/// are technically usable for this purpose, they're less descriptive.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
|
|
pub enum Side {Left, Right}
|
|
|
|
impl Display for Side {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
match self {
|
|
Self::Left => write!(f, "Left"),
|
|
Self::Right => write!(f, "Right"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Side {
|
|
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)
|
|
}
|
|
}
|
|
} |