path: root/svgbob/src/util.rs

use crate::Point;
use ncollide2d::shape::Triangle;
use ncollide2d::{bounding_volume::AABB, math::Isometry, query::PointQuery};
use std::cmp::Ordering;

pub fn opt_ord(f1: Option<f32>, f2: Option<f32>) -> Ordering {
    match (f1, f2) {
        (None, None) => Ordering::Equal,
        (Some(_), None) => Ordering::Greater,
        (None, Some(_)) => Ordering::Less,
        (Some(f1), Some(f2)) => ord(f1, f2),
    }
}

pub fn ord(f1: f32, f2: f32) -> Ordering {
    if f1 == f2 {
        Ordering::Equal
    } else if f1 > f2 {
        Ordering::Greater
    } else if f1 < f2 {
        Ordering::Less
    } else {
        println!("f1: {}, f2: {}", f1, f2);
        unreachable!("comparison should only be 3 possibilities")
    }
}

/// clips a line to the bounding box of this whole grid
/// and approximate each point to the closes intersection
fn clip_line_internal(
    aabb: &AABB,
    start: Point,
    end: Point,
) -> Option<(Point, Point)> {
    let start_v = start.to_vector();
    let end_v = end.to_vector() - start_v;
    let clipped = aabb.clip_line(&start, &end_v);
    if let Some(clipped) = clipped {
        let a = *clipped.a;
        let b = *clipped.b;
        Some((a.into(), b.into()))
    } else {
        None
    }
}

/// clip a line but do not extend the points
pub fn clip_line(
    aabb: &AABB,
    start: Point,
    end: Point,
) -> Option<(Point, Point)> {
    let clipped = clip_line_internal(aabb, start, end);
    let identity = &Isometry::identity();
    if let Some(clipped) = clipped {
        let mut clip_start = clipped.0;
        let mut clip_end = clipped.1;

        if aabb.contains_point(identity, &start) {
            clip_start = start;
        }
        if aabb.contains_point(identity, &end) {
            clip_end = end;
        }
        if clip_start == clip_end {
            None
        } else {
            Some((clip_start, clip_end))
        }
    } else {
        None
    }
}

/// the threshold are of 0.01 is used since
/// lines may not be very aligned.
pub fn is_collinear(a: &Point, b: &Point, c: &Point) -> bool {
    use std::ops::Deref;
    Triangle::new(*a.deref(), *b.deref(), *c.deref()).area() < 0.01
}

pub fn pad(v: f32) -> f32 {
    if v > 0.0 {
        v.ceil()
    } else {
        v.floor()
    }
}

/// this is parser module which provides parsing for identifier for
/// extracting the css tag of inside of a shape fragment
pub mod parser {

    use pom::parser::{is_a, list, none_of, one_of, sym, tag, Parser};
    use std::iter::FromIterator;

    /// Parses a list with the defined separator, but will fail early when one of the
    /// item can not be parsed
    pub fn list_fail<'a, I, O, U>(
        parser: Parser<'a, I, O>,
        separator: Parser<'a, I, U>,
    ) -> Parser<'a, I, Vec<O>>
    where
        O: 'a,
        U: 'a,
    {
        Parser::new(move |input: &'a [I], start: usize| {
            let mut items = vec![];
            let mut pos = start;
            match (parser.method)(input, pos) {
                Ok((first_item, first_pos)) => {
                    items.push(first_item);
                    pos = first_pos;
                    loop {
                        match (separator.method)(input, pos) {
                            Ok((_, sep_pos)) => {
                                match (parser.method)(input, sep_pos) {
                                    Ok((more_item, more_pos)) => {
                                        items.push(more_item);
                                        pos = more_pos;
                                    }
                                    Err(e) => {
                                        // return early when there is an
                                        // error matching the succeeding
                                        // items
                                        return Err(e);
                                    }
                                }
                            }
                            Err(_e) => {
                                // the separator does not match, just break
                                break;
                            }
                        }
                    }
                }
                Err(e) => {
                    // return early when there is an error matching the first item
                    return Err(e);
                }
            }
            Ok((items, pos))
        })
    }

    pub(super) fn alpha_or_underscore(ch: char) -> bool {
        pom::char_class::alpha(ch as u8) || underscore(ch)
    }

    pub(super) fn alphanum_or_underscore(ch: char) -> bool {
        pom::char_class::alphanum(ch as u8) || underscore(ch)
    }

    /// is this car is an underscore
    pub(super) fn underscore(ch: char) -> bool {
        ch == '_'
    }

    pub fn new_line<'a>() -> Parser<'a, char, ()> {
        one_of("\r\n").discard()
    }

    /// any whitespace character
    pub fn space<'a>() -> Parser<'a, char, ()> {
        one_of(" \t").repeat(0..).discard()
    }

    pub fn white_space<'a>() -> Parser<'a, char, ()> {
        one_of(" \t\r\n").repeat(0..).discard()
    }

    /// a valid identifier
    pub(crate) fn ident<'a>() -> Parser<'a, char, String> {
        (is_a(alpha_or_underscore) + is_a(alphanum_or_underscore).repeat(0..))
            .map(|(ch1, rest_ch)| {
                format!("{}{}", ch1, String::from_iter(rest_ch))
            })
    }

    fn classes<'a>() -> Parser<'a, char, Vec<String>> {
        list(ident(), sym(','))
    }

    fn tag_classes<'a>() -> Parser<'a, char, Vec<String>> {
        sym('{') * classes() - sym('}')
    }

    /// parse css tag in the format of '{', <identifier>, '}'
    pub(crate) fn parse_css_tag(
        input: &str,
    ) -> Result<Vec<String>, pom::Error> {
        let cell_text_chars: Vec<char> = input.chars().collect();
        parse_css_tag_chars(&cell_text_chars)
    }

    fn parse_css_tag_chars(input: &[char]) -> Result<Vec<String>, pom::Error> {