smallvec 2.0.0-beta.5

'Small vector' optimization: store up to a small number of items on the stack
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

use {
    super::SmallVec,
    alloc::{
        alloc::{
            Allocator,
            Global
        },
        collections::BTreeMap as Map,
        format
    },
    borsh::{
        BorshDeserialize,
        BorshSchema,
        BorshSerialize,
        io::{
            Error,
            ErrorKind,
            Read,
            Result as Serial,
            Write
        },
        schema::{
            Declaration,
            Definition
        }
    },
    core::iter::repeat_with
};

impl<Item: BorshSerialize, const INLINE: usize, Heap: Allocator> BorshSerialize
    for SmallVec<Item, INLINE, Heap>
{
    fn serialize<Writer: Write>(&self, writer: &mut Writer) -> Serial<()> {
        (self.len() as u64).serialize(writer)?;
        for element in self {
            element.serialize(writer)?;
        }

        Ok(())
    }
}

impl<Item: BorshDeserialize, const INLINE: usize> BorshDeserialize
    for SmallVec<Item, INLINE, Global>
{
    fn deserialize_reader<R: Read>(reader: &mut R) -> Serial<Self> {
        let length = u64::deserialize_reader(reader)?;
        repeat_with(|| Item::deserialize_reader(reader))
            .take(length.try_into().map_err(|_| Error::new(
                ErrorKind::OutOfMemory,
                "Cannot deserialize a sequence with more than usize::MAX elements in this machine"
            ))?)
            .collect()
    }
}

impl<Item: BorshSchema, const INLINE: usize, Heap: Allocator> BorshSchema
    for SmallVec<Item, INLINE, Heap>
{
    fn declaration() -> Declaration { format!("Vec<{}>", Item::declaration()) }

    fn add_definitions_recursively(definitions: &mut Map<Declaration, Definition>) {
        let declaration = Self::declaration();
        if definitions.contains_key(&declaration) {
            return;
        }
        Item::add_definitions_recursively(definitions);
        definitions.insert(
            declaration,
            Definition::Sequence {
                length_width: 8,
                length_range: 0..=u64::MAX,
                elements: Item::declaration()
            }
        );
    }
}