font-index 0.1.2

Static index for system fonts
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
102
103
104
105
106
107
108
109
110

//! Shared font data.

use std::io;
use std::path::Path;
use std::sync::{Arc, Weak};
use std::time::SystemTime;

#[derive(Debug)]
enum Inner {
    Mapped(memmap2::Mmap),
    Memory(Vec<u8>),
}

impl Inner {
    fn data(&self) -> &[u8] {
        match self {
            Self::Mapped(mmap) => &*mmap,
            Self::Memory(vec) => &vec,
        }
    }
}

/// Atomically reference counted, heap allocated or memory mapped buffer.
#[derive(Clone, Debug)]
#[repr(transparent)]
pub struct SharedData {
    inner: Arc<Inner>,
}

/// Weak reference to shared data.
#[derive(Clone, Debug)]
#[repr(transparent)]
pub struct WeakSharedData {
    inner: Weak<Inner>,
}

impl WeakSharedData {
    /// Upgrades the weak reference.
    pub fn upgrade(&self) -> Option<SharedData> {
        Some(SharedData {
            inner: self.inner.upgrade()?,
        })
    }
}

impl SharedData {
    /// Creates shared data from the specified bytes.
    pub fn new(data: Vec<u8>) -> Self {
        Self {
            inner: Arc::new(Inner::Memory(data)),
        }
    }

    /// Creates shared data from the specified path.
    pub fn from_file(
        path: impl AsRef<Path>,
        mmap: bool,
        timestamp: Option<SystemTime>,
    ) -> Result<Self, io::Error> {
        let path = path.as_ref();
        if let Some(timestamp) = timestamp {
            let metadata = path.metadata()?;
            let current_timestamp = metadata.modified()?;
            if timestamp != current_timestamp {
                // Close enough
                return Err(io::Error::from(io::ErrorKind::InvalidData));
            }
        }
        let inner = Arc::new(if mmap {
            let file = std::fs::File::open(path)?;
            let map = unsafe { memmap2::Mmap::map(&file)? };
            Inner::Mapped(map)
        } else {
            let data = std::fs::read(path)?;
            Inner::Memory(data)
        });
        Ok(Self { inner })
    }

    /// Creates a new weak reference to the data.
    pub fn downgrade(&self) -> WeakSharedData {
        WeakSharedData {
            inner: Arc::downgrade(&self.inner),
        }
    }

    /// Returns the underlying bytes of the data.
    pub fn as_bytes(&self) -> &[u8] {
        self.inner.data()
    }

    /// Returns the number of strong references to the data.
    pub fn strong_count(&self) -> usize {
        Arc::strong_count(&self.inner)
    }
}

impl std::ops::Deref for SharedData {
    type Target = [u8];

    fn deref(&self) -> &Self::Target {
        self.inner.data()
    }
}

impl AsRef<[u8]> for SharedData {
    fn as_ref(&self) -> &[u8] {
        self.inner.data()
    }
}