bmfont_rs 0.4.0

Load/ save/ manipulate BMFont files
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
95
96
97
98
99
100
101

//! Binary packing/ unpacking traits.
//!
//! We define static (fixed length) and dynamic (variable length) packing and packing traits:
//! * Static: `PackLen`, `Pack` and `Unpack`
//! * Dynamic: `PackDynLen`, `PackDyn` and `UnpackDyn`
//!
//! These packing traits are generic over the encoding type.

pub trait PackLen<T = ()>: Sized {
    const PACK_LEN: usize;
}

pub trait Pack<T = ()>: PackLen<T> {
    fn pack(&self, dst: &mut Vec<u8>) -> crate::Result<usize>;
}

pub trait Unpack<T = ()>: PackLen<T> + Sized {
    fn unpack_next(src: &mut &[u8]) -> crate::Result<Self>;

    #[inline(always)]
    fn unpack(src: &mut &[u8]) -> crate::Result<Self> {
        let obj = Self::unpack_next(src)?;
        if src.is_empty() {
            Ok(obj)
        } else {
            overflow()
        }
    }

    #[inline(always)]
    fn unpack_all<F>(src: &mut &[u8], mut take: F) -> crate::Result<()>
    where
        F: FnMut(Self) -> crate::Result<()>,
    {
        while !src.is_empty() {
            take(Self::unpack_next(src)?)?;
        }
        Ok(())
    }
}

pub trait PackDynLen<T = ()>: Sized {
    const PACK_DYN_MIN: usize;

    fn dyn_len(&self) -> usize;
}

pub trait PackDyn<T = ()>: PackDynLen<T> {
    fn pack_dyn(&self, dst: &mut Vec<u8>) -> crate::Result<usize>;
}

pub trait UnpackDyn<T = ()>: PackDynLen<T> + Sized {
    fn unpack_dyn_next(src: &mut &[u8]) -> crate::Result<Self>;

    #[inline(always)]
    fn unpack_dyn(src: &mut &[u8]) -> crate::Result<Self> {
        let obj = Self::unpack_dyn_next(src)?;
        if src.is_empty() {
            Ok(obj)
        } else {
            overflow()
        }
    }

    #[inline(always)]
    fn unpack_dyn_all<F>(src: &mut &[u8], mut take: F) -> crate::Result<()>
    where
        F: FnMut(Self) -> crate::Result<()>,
    {
        while !src.is_empty() {
            take(Self::unpack_dyn_next(src)?)?;
        }
        Ok(())
    }
}

#[allow(dead_code)]
pub fn opt_len<T, U: PackLen<T>>(option: &Option<U>) -> Option<usize> {
    if option.is_some() {
        Some(U::PACK_LEN)
    } else {
        None
    }
}

#[allow(dead_code)]
pub fn opt_dyn_len<T, U: PackDynLen<T>>(option: &Option<U>) -> Option<usize> {
    option.as_ref().map(|u| u.dyn_len())
}

pub fn overflow<T>() -> crate::Result<T> {
    Err(crate::Error::Parse { line: None, entity: "buffer".to_owned(), err: "overflow".to_owned() })
}

pub fn underflow<T>() -> crate::Result<T> {
    Err(crate::Error::Parse {
        line: None,
        entity: "buffer".to_owned(),
        err: "underflow".to_owned(),
    })
}