hypercore/oplog/
entry.rs

1use crate::encoding::{CompactEncoding, EncodingError, HypercoreState};
2use crate::{common::BitfieldUpdate, Node};
3
4/// Entry tree upgrade
5#[derive(Debug)]
6pub(crate) struct EntryTreeUpgrade {
7    pub(crate) fork: u64,
8    pub(crate) ancestors: u64,
9    pub(crate) length: u64,
10    pub(crate) signature: Box<[u8]>,
11}
12
13impl CompactEncoding<EntryTreeUpgrade> for HypercoreState {
14    fn preencode(&mut self, value: &EntryTreeUpgrade) -> Result<usize, EncodingError> {
15        self.0.preencode(&value.fork)?;
16        self.0.preencode(&value.ancestors)?;
17        self.0.preencode(&value.length)?;
18        self.0.preencode(&value.signature)
19    }
20
21    fn encode(
22        &mut self,
23        value: &EntryTreeUpgrade,
24        buffer: &mut [u8],
25    ) -> Result<usize, EncodingError> {
26        self.0.encode(&value.fork, buffer)?;
27        self.0.encode(&value.ancestors, buffer)?;
28        self.0.encode(&value.length, buffer)?;
29        self.0.encode(&value.signature, buffer)
30    }
31
32    fn decode(&mut self, buffer: &[u8]) -> Result<EntryTreeUpgrade, EncodingError> {
33        let fork: u64 = self.0.decode(buffer)?;
34        let ancestors: u64 = self.0.decode(buffer)?;
35        let length: u64 = self.0.decode(buffer)?;
36        let signature: Box<[u8]> = self.0.decode(buffer)?;
37        Ok(EntryTreeUpgrade {
38            fork,
39            ancestors,
40            length,
41            signature,
42        })
43    }
44}
45
46impl CompactEncoding<BitfieldUpdate> for HypercoreState {
47    fn preencode(&mut self, value: &BitfieldUpdate) -> Result<usize, EncodingError> {
48        self.0.add_end(1)?;
49        self.0.preencode(&value.start)?;
50        self.0.preencode(&value.length)
51    }
52
53    fn encode(
54        &mut self,
55        value: &BitfieldUpdate,
56        buffer: &mut [u8],
57    ) -> Result<usize, EncodingError> {
58        let flags: u8 = if value.drop { 1 } else { 0 };
59        self.0.set_byte_to_buffer(flags, buffer)?;
60        self.0.encode(&value.start, buffer)?;
61        self.0.encode(&value.length, buffer)
62    }
63
64    fn decode(&mut self, buffer: &[u8]) -> Result<BitfieldUpdate, EncodingError> {
65        let flags = self.0.decode_u8(buffer)?;
66        let start: u64 = self.0.decode(buffer)?;
67        let length: u64 = self.0.decode(buffer)?;
68        Ok(BitfieldUpdate {
69            drop: flags == 1,
70            start,
71            length,
72        })
73    }
74}
75
76/// Oplog Entry
77#[derive(Debug)]
78pub struct Entry {
79    // TODO: This is a keyValueArray in JS
80    pub(crate) user_data: Vec<String>,
81    pub(crate) tree_nodes: Vec<Node>,
82    pub(crate) tree_upgrade: Option<EntryTreeUpgrade>,
83    pub(crate) bitfield: Option<BitfieldUpdate>,
84}
85
86impl CompactEncoding<Entry> for HypercoreState {
87    fn preencode(&mut self, value: &Entry) -> Result<usize, EncodingError> {
88        self.0.add_end(1)?; // flags
89        if !value.user_data.is_empty() {
90            self.0.preencode(&value.user_data)?;
91        }
92        if !value.tree_nodes.is_empty() {
93            self.preencode(&value.tree_nodes)?;
94        }
95        if let Some(tree_upgrade) = &value.tree_upgrade {
96            self.preencode(tree_upgrade)?;
97        }
98        if let Some(bitfield) = &value.bitfield {
99            self.preencode(bitfield)?;
100        }
101        Ok(self.end())
102    }
103
104    fn encode(&mut self, value: &Entry, buffer: &mut [u8]) -> Result<usize, EncodingError> {
105        let start = self.0.start();
106        self.0.add_start(1)?;
107        let mut flags: u8 = 0;
108        if !value.user_data.is_empty() {
109            flags |= 1;
110            self.0.encode(&value.user_data, buffer)?;
111        }
112        if !value.tree_nodes.is_empty() {
113            flags |= 2;
114            self.encode(&value.tree_nodes, buffer)?;
115        }
116        if let Some(tree_upgrade) = &value.tree_upgrade {
117            flags |= 4;
118            self.encode(tree_upgrade, buffer)?;
119        }
120        if let Some(bitfield) = &value.bitfield {
121            flags |= 8;
122            self.encode(bitfield, buffer)?;
123        }
124
125        buffer[start] = flags;
126        Ok(self.0.start())
127    }
128
129    fn decode(&mut self, buffer: &[u8]) -> Result<Entry, EncodingError> {
130        let flags = self.0.decode_u8(buffer)?;
131        let user_data: Vec<String> = if flags & 1 != 0 {
132            self.0.decode(buffer)?
133        } else {
134            vec![]
135        };
136
137        let tree_nodes: Vec<Node> = if flags & 2 != 0 {
138            self.decode(buffer)?
139        } else {
140            vec![]
141        };
142
143        let tree_upgrade: Option<EntryTreeUpgrade> = if flags & 4 != 0 {
144            let value: EntryTreeUpgrade = self.decode(buffer)?;
145            Some(value)
146        } else {
147            None
148        };
149
150        let bitfield: Option<BitfieldUpdate> = if flags & 8 != 0 {
151            let value: BitfieldUpdate = self.decode(buffer)?;
152            Some(value)
153        } else {
154            None
155        };
156
157        Ok(Entry {
158            user_data,
159            tree_nodes,
160            tree_upgrade,
161            bitfield,
162        })
163    }
164}
hypercore/oplog/entry.rs

hypercore/oplog/
entry.rs
