interns 1.2.0

Object interner
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

use core::borrow::Borrow;

use crate::backend::Internable;

use super::Backend;

/// Backend that stores elements inside a [Vec]
pub struct VecBackend<T> {
    buf: Vec<T>,
}

impl<T> Default for VecBackend<T> {
    fn default() -> Self {
        Self { buf: Default::default() }
    }
}

#[derive(Clone, Copy, Debug, Hash, Eq, PartialEq)]
#[repr(transparent)]
pub struct Symbol(usize);

impl<T> Backend<T> for VecBackend<T> {
    type Symbol = Symbol;

    fn get(&self, sym: Self::Symbol) -> Option<&T> {
        let val = self.buf.get(sym.0)?;
        Some(val)
    }
}

impl<T, Ref, Inter> Internable<T, VecBackend<T>> for Ref
where
    T: Borrow<Ref>,
    Ref: ToOwned<Owned = Inter> + ?Sized,
    Inter: Into<T>
{
    fn intern_into(&self, b: &mut VecBackend<T>) -> Symbol {
        let sym = Symbol(b.buf.len());
        b.buf.push(self.to_owned().into());
        sym
    }
}

#[derive(Clone, Copy, Debug, Hash, Eq, PartialEq)]
pub struct Span {
    start: usize,
    len: usize,
}

impl<T> Backend<[T]> for VecBackend<T> {
    type Symbol = Span;

    fn get(&self, sym: Self::Symbol) -> Option<&[T]> {
        let val = self.buf.get(sym.start..sym.start + sym.len)?;
        Some(val)
    }
}

impl<T: Clone> Internable<[T], VecBackend<T>> for [T] {
    fn intern_into(&self, b: &mut VecBackend<T>) -> Span {
        let start = b.buf.len();
        b.buf.extend_from_slice(self);
        let len = b.buf.len() - start;
        Span { start, len }
    }
}