svgdom 0.1.0

Library to represent an SVG as an DOM.
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

use std::io::Write;

use {WriteOptions, WriteBuffer};

/// The trait for comparing f64 numbers.
pub trait FuzzyEq {
    /// Returns `true` if numbers are equal.
    fn fuzzy_eq(&self, other: &f64) -> bool;
    /// Returns `true` if numbers are not equal.
    fn fuzzy_ne(&self, other: &f64) -> bool {
        !self.fuzzy_eq(other)
    }
}

impl FuzzyEq for f64 {
    #[inline]
    fn fuzzy_eq(&self, other: &f64) -> bool {
        // we don't use EPSILON, because we only care about 8 digits in a fractional part
        (*self - *other).abs() < 0.000000001
    }
}

pub fn write_num(num: f64, rm_leading_zero: bool, buf: &mut Vec<u8>) {
    // We always round a number to 8 digits.
    // f64 can handle up to 15 numbers, but we still round to 8 top.
    // It's not really good, but smaller numbers are mostly useless in the SVG.
    let v = (num * 100000000.0f64).round() / 100000000.0f64;

    let start_pos = buf.len();

    write!(buf, "{}", v).unwrap();

    if rm_leading_zero {
        let mut has_dot = false;
        let mut pos = 0;
        for c in buf.iter().skip(start_pos) {
            if *c == b'.' {
                has_dot = true;
                break;
            }
            pos += 1;
        }

        if has_dot && buf[start_pos + pos - 1] == b'0' {
            if pos == 2 && v.is_sign_negative() {
                // -0.1 -> -.1
                buf.remove(start_pos + 1);
            } else if pos == 1 && v.is_sign_positive() {
                // 0.1 -> .1
                buf.remove(start_pos);
            }
        }
    }
}

impl WriteBuffer for f64 {
    fn write_buf_opt(&self, opt: &WriteOptions, buf: &mut Vec<u8>) {
        write_num(*self, opt.remove_leading_zero, buf);
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    macro_rules! test_number {
        ($name:ident, $num:expr, $rm_zero:expr, $result:expr) => (
            #[test]
            fn $name() {
                let mut v = Vec::new();
                write_num($num, $rm_zero, &mut v);
                assert_eq!(String::from_utf8(v).unwrap(), $result);
            }
        )
    }

    test_number!(gen_number_1, 1.0,                 false, "1");
    test_number!(gen_number_2, 0.0,                 false, "0");
    test_number!(gen_number_3, -0.0,                false, "0");
    test_number!(gen_number_4, -1.0,                false, "-1");
    test_number!(gen_number_5, 12345678.12345678,   false, "12345678.12345678");
    test_number!(gen_number_6, -0.1,                true,  "-.1");
    test_number!(gen_number_7, 0.1,                 true,  ".1");
    test_number!(gen_number_8, 1.0,                 true,  "1");
    test_number!(gen_number_9, -1.0,                true,  "-1");
    test_number!(gen_number_10, 1.5,                false, "1.5");
    test_number!(gen_number_11, 0.14186,            false, "0.14186");
    test_number!(gen_number_12, 0.4621799999999894, false, "0.46218");
    test_number!(gen_number_13, 0.0338000000000136, false, "0.0338");
}