pbrs 0.2.0

Pure-Rust Protocol Buffers kernel with the Google protobuf v4 application API
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

#![allow(
    clippy::unimplemented,
    clippy::unwrap_used,
    clippy::expect_used,
    reason = "null MiniTable/MessagePtr is a rust_out kernel invariant, not a user Result"
)]

use crate::wire::UnknownFields;
use std::cell::RefCell;
use std::fmt::Debug;
use std::rc::Rc;

use super::{FieldKind, MiniTablePtr, MsgData, RawArrayInner, RawMapInner};

#[derive(Debug)]
pub struct ArenaInner {
    // Boxed so pointers handed to rust_out stay valid across Vec growth.
    #[expect(
        clippy::vec_box,
        reason = "upb-shaped repeated message slots are Box<Msg>"
    )]
    msgs: Vec<Box<MsgData>>,
    #[expect(
        clippy::vec_box,
        reason = "upb-shaped repeated message slots are Box<Msg>"
    )]
    arrays: Vec<Box<RawArrayInner>>,
    #[expect(
        clippy::vec_box,
        reason = "upb-shaped repeated message slots are Box<Msg>"
    )]
    maps: Vec<Box<RawMapInner>>,
    #[allow(
        clippy::vec_box,
        reason = "FieldKind::Bytes points to stable Vec headers owned across arena fusion"
    )]
    bytes: Vec<Box<Vec<u8>>>,
}

#[derive(Clone, Debug)]
pub struct Arena {
    pub(crate) inner: Rc<RefCell<ArenaInner>>,
}

impl Default for Arena {
    fn default() -> Self {
        Self::new()
    }
}

impl Arena {
    pub fn new() -> Self {
        Self {
            inner: Rc::new(RefCell::new(ArenaInner {
                msgs: Vec::new(),
                arrays: Vec::new(),
                maps: Vec::new(),
                bytes: Vec::new(),
            })),
        }
    }

    pub fn fuse(&self, other: &Arena) {
        if Rc::ptr_eq(&self.inner, &other.inner) {
            return;
        }
        let mut o = other.inner.borrow_mut();
        let mut s = self.inner.borrow_mut();
        let array_start = s.arrays.len();
        let map_start = s.maps.len();
        s.msgs.append(&mut o.msgs);
        s.arrays.append(&mut o.arrays);
        s.maps.append(&mut o.maps);
        s.bytes.append(&mut o.bytes);
        // Raw mutators must resolve the owner after a collection changes arenas.
        for array in &mut s.arrays[array_start..] {
            array.owner = Rc::downgrade(&self.inner);
        }
        for map in &mut s.maps[map_start..] {
            map.owner = Rc::downgrade(&self.inner);
        }
    }

    pub(crate) fn alloc_msg(&self, mt: MiniTablePtr) -> *mut MsgData {
        let n = unsafe { mt.0.as_ref().map(|t| t.fields.len()).unwrap_or(0) };
        let b = Box::new(MsgData {
            slots: vec![FieldKind::Empty; n],
            has: vec![false; n],
            strs: Vec::new(),
            unknown: UnknownFields::default(),
            mt,
        });
        let mut owner = self.inner.borrow_mut();
        owner.msgs.push(b);
        owner
            .msgs
            .last_mut()
            .expect("message was just inserted")
            .as_mut() as *mut MsgData
    }

    pub(crate) fn alloc_array(&self) -> *const RawArrayInner {
        let b = Box::new(RawArrayInner {
            items: RefCell::new(Vec::new()),
            strs: RefCell::new(Vec::new()),
            owner: Rc::downgrade(&self.inner),
        });
        let mut owner = self.inner.borrow_mut();
        owner.arrays.push(b);
        owner
            .arrays
            .last()
            .expect("array was just inserted")
            .as_ref() as *const RawArrayInner
    }

    pub(crate) fn alloc_map(&self) -> *const RawMapInner {
        let b = Box::new(RawMapInner {
            entries: RefCell::new(Vec::new()),
            strs: RefCell::new(Vec::new()),
            owner: Rc::downgrade(&self.inner),
        });
        let mut owner = self.inner.borrow_mut();
        owner.maps.push(b);
        owner.maps.last().expect("map was just inserted").as_ref() as *const RawMapInner
    }

    pub(crate) fn alloc_bytes(&self, bytes: Vec<u8>) -> *const Vec<u8> {
        let mut owner = self.inner.borrow_mut();
        owner.bytes.push(Box::new(bytes));
        // Taking the pointer before moving the Box here would invalidate its provenance.
        owner
            .bytes
            .last()
            .expect("bytes were just inserted")
            .as_ref() as *const Vec<u8>
    }
}