flatbuffers_rust/flatbuffers/
flatbuffer_handler.rs

1use flatbuffers::flatbuffer_manager::FlatBufferManager;
2
3static SEPARATOR: u8 = 0xff;
4#[derive(Debug)]
5// 在handler中做限制，防止人为访问内存出错
6pub struct FlatBufferHandler {}
7
8impl FlatBufferHandler {
9    pub fn get_field_bytes_pivot(&self, type_name: &str, field_name: &str, manager: &FlatBufferManager, data: &mut Vec<u8>, pivot: usize) -> Result<(Option<Vec<u8>>, usize), String> {
10        let mut vec = manager.to_local_vec(field_name, type_name).unwrap();
11        let mut position = manager.field_position(&mut vec).unwrap();
12        self.get_part_data_level(&mut position, pivot, &data)
13    }
14    // 方法名不舒服
15    // 从某一层获取到任意深层的任一数据
16    // level = vec[4,2,3,1] 
17    // 表示 当前“struct” 的第一个字段的 第3个字段的 第2个字段的 第4个字段
18    pub fn get_part_data_level(&self, level:&mut Vec<usize>, root: usize, data: &Vec<u8>) -> Result<(Option<Vec<u8>>, usize), String> {
19        // println!("data is {:?}", data);
20        let l = level.len();
21        let mut want_vec = Vec::new();
22        let mut want_root = 0;
23        let part = level.pop().unwrap();
24        let (child_data, child_root) = match self.get_part_data(part, root, &data) {
25            Ok((child_data, child_root)) => (child_data, child_root),
26            Err(e) => return Err(e),
27        };
28        match child_data {
29            Some(d) => { want_vec = d; want_root = child_root; },
30            None => {
31                if 1 == l {
32                    return Ok((None, 0)); // 访问的部分是None
33                } else {
34                    return Err(format!("访问层次有误"));
35                }
36            },
37        };
38
39        for i in 0..l-1 {
40            let part = level.pop().unwrap();
41            let (child_data, child_root) = match self.get_part_data(part, want_root, &want_vec) {
42                Ok((child_data, child_root)) => (child_data, child_root),
43                Err(e) => return Err(e),
44            };
45            match child_data {
46                Some(d) => { want_vec = d; want_root = child_root; },
47                None => {
48                    if i == l {
49                        return Ok((None, 0)); // 访问的部分是None
50                    } else {
51                        return Err(format!("访问层次有误"));
52                    }
53                },
54            };
55        }
56        Ok((Some(want_vec), want_root))
57    }
58    pub fn get_part_data(&self, part: usize, root: usize, data: &Vec<u8>) -> Result<(Option<Vec<u8>>, usize), String> {
59        // 先通过 root 的值 获取字段总数
60        if part == 0 {
61            return Err(format!("part is {}", part));
62        }
63        if root == 1 {
64            // 这是个基本数据
65            return Err(format!("{:?} is a primitive type", data));
66        }
67        // println!("root is {:?}", root);
68        let slot_num = data[root] as usize;
69        if part > slot_num {
70            // 越界
71            return Err(format!("slot's num is {}, {} > slot's", slot_num, part));
72        }
73        // println!("root is {}, root's value is {}", root, data[root]);
74        // 得到偏移量 [root-(slot_num-part+1)*size, root-(slot_num-part)*size]
75        let (start, child_root) = self.get_start(part, slot_num, root, data);
76        
77        // println!("part2 start:{}, child root value is {}", start, data[child_root]);
78        if start == 0 {
79            // 该项数据为空
80            return Ok((None, 0));
81        }
82        // 计算 end 
83        let end = self.get_end(part, slot_num, root, data);
84        
85        // println!("end is {}", end);
86        Ok((Some(data[start..end].to_vec()), child_root-start))
87    }
88    fn get_end(&self, part: usize, slot_num: usize, root: usize, data: &Vec<u8>) -> usize {
89        let mut part = part;
90        // println!("part :{}", part);
91        if slot_num == part {
92            return data.len();
93        } else {
94            loop {
95                part += 1;
96                if slot_num == part && data[root - 4] == 0u8 {
97                    // 这里肯定还有问题
98                    return data.len();
99                }
100                let (end, pivot) = self.get_start(part, slot_num, root, data);
101                
102                // println!("第8字段开始值可能为{}", end);
103                if end != 0 {
104                    return end;
105                }
106            }
107        }
108    }
109    fn get_start(&self, part: usize, slot_num: usize, root: usize, data: &Vec<u8>) -> (usize, usize) {
110        let size = 4;
111        let mut offset = 0;
112        let mut scale = 1;
113        // println!("slot_num is {:?}", slot_num);
114        // println!("end = root-(slot_num-part)*size :{:?}, data.len is {}", root-(slot_num-part+1)*size, data.len());
115        let offset_vec = data[root-(slot_num-part+1)*size..root-(slot_num-part)*size].to_vec();
116        // println!("offset_vec is {:?}", offset_vec);
117        for i in 0..size {
118            // println!("{:?}", offset_vec[i]);
119            offset += (offset_vec[i] as usize) *scale;
120            scale *= 256;
121        }
122        // println!("offset is {:?}", offset);
123        if offset == 0 {
124            // 偏移为0 表示 None
125            // println!("进入 0, 0");
126            return (0, 0);
127        }
128        let child_root = offset as usize + root;
129        // println!("root is {}, offset is {}, child_root is {}", root, offset, child_root);
130        // println!("root's value is {}, child_root's value is {}", data[root], data[child_root]);
131        let mut start = 0;
132        // 判断是否有 vtable
133        if data[child_root - 1] == SEPARATOR {
134            // 表示child_root是start
135            start = child_root - 1;
136        } else {
137            // 获取到 child_vtable 大小
138            let child_slot_num = data[child_root];
139            start = child_root - size*child_slot_num as usize -1; // SEPARATOR 也要包括进去
140        }
141        (start, child_root)
142    }
143}
flatbuffers_rust/flatbuffers/flatbuffer_handler.rs

flatbuffers_rust/flatbuffers/
flatbuffer_handler.rs
