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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
/*
* Copyright (C) 2024 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
//! flag value module defines the flag value file format and methods for serialization
//! and deserialization
use crate::{read_str_from_bytes, read_u32_from_bytes, read_u8_from_bytes};
use crate::{AconfigStorageError, StorageFileType};
use anyhow::anyhow;
use std::fmt;
/// Flag value header struct
#[derive(PartialEq)]
pub struct FlagValueHeader {
pub version: u32,
pub container: String,
pub file_type: u8,
pub file_size: u32,
pub num_flags: u32,
pub boolean_value_offset: u32,
}
/// Implement debug print trait for header
impl fmt::Debug for FlagValueHeader {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
writeln!(
f,
"Version: {}, Container: {}, File Type: {:?}, File Size: {}",
self.version,
self.container,
StorageFileType::try_from(self.file_type),
self.file_size
)?;
writeln!(
f,
"Num of Flags: {}, Value Offset:{}",
self.num_flags, self.boolean_value_offset
)?;
Ok(())
}
}
impl FlagValueHeader {
/// Serialize to bytes
pub fn as_bytes(&self) -> Vec<u8> {
let mut result = Vec::new();
result.extend_from_slice(&self.version.to_le_bytes());
let container_bytes = self.container.as_bytes();
result.extend_from_slice(&(container_bytes.len() as u32).to_le_bytes());
result.extend_from_slice(container_bytes);
result.extend_from_slice(&self.file_type.to_le_bytes());
result.extend_from_slice(&self.file_size.to_le_bytes());
result.extend_from_slice(&self.num_flags.to_le_bytes());
result.extend_from_slice(&self.boolean_value_offset.to_le_bytes());
result
}
/// Deserialize from bytes
pub fn from_bytes(bytes: &[u8]) -> Result<Self, AconfigStorageError> {
let mut head = 0;
let list = Self {
version: read_u32_from_bytes(bytes, &mut head)?,
container: read_str_from_bytes(bytes, &mut head)?,
file_type: read_u8_from_bytes(bytes, &mut head)?,
file_size: read_u32_from_bytes(bytes, &mut head)?,
num_flags: read_u32_from_bytes(bytes, &mut head)?,
boolean_value_offset: read_u32_from_bytes(bytes, &mut head)?,
};
if list.file_type != StorageFileType::FlagVal as u8 {
return Err(AconfigStorageError::BytesParseFail(anyhow!(
"binary file is not a flag value file"
)));
}
Ok(list)
}
}
/// Flag value list struct
#[derive(PartialEq)]
pub struct FlagValueList {
pub header: FlagValueHeader,
pub booleans: Vec<bool>,
}
/// Implement debug print trait for flag value
impl fmt::Debug for FlagValueList {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
writeln!(f, "Header:")?;
write!(f, "{:?}", self.header)?;
writeln!(f, "Values:")?;
writeln!(f, "{:?}", self.booleans)?;
Ok(())
}
}
impl FlagValueList {
/// Serialize to bytes
pub fn as_bytes(&self) -> Vec<u8> {
[
self.header.as_bytes(),
self.booleans.iter().map(|&v| u8::from(v).to_le_bytes()).collect::<Vec<_>>().concat(),
]
.concat()
}
/// Deserialize from bytes
pub fn from_bytes(bytes: &[u8]) -> Result<Self, AconfigStorageError> {
let header = FlagValueHeader::from_bytes(bytes)?;
let num_flags = header.num_flags;
let mut head = header.as_bytes().len();
let booleans =
(0..num_flags).map(|_| read_u8_from_bytes(bytes, &mut head).unwrap() == 1).collect();
let list = Self { header, booleans };
Ok(list)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::test_utils::create_test_flag_value_list;
#[test]
// this test point locks down the value list serialization
fn test_serialization() {
let flag_value_list = create_test_flag_value_list();
let header: &FlagValueHeader = &flag_value_list.header;
let reinterpreted_header = FlagValueHeader::from_bytes(&header.as_bytes());
assert!(reinterpreted_header.is_ok());
assert_eq!(header, &reinterpreted_header.unwrap());
let flag_value_bytes = flag_value_list.as_bytes();
let reinterpreted_value_list = FlagValueList::from_bytes(&flag_value_bytes);
assert!(reinterpreted_value_list.is_ok());
assert_eq!(&flag_value_list, &reinterpreted_value_list.unwrap());
assert_eq!(flag_value_bytes.len() as u32, header.file_size);
}
#[test]
// this test point locks down that version number should be at the top of serialized
// bytes
fn test_version_number() {
let flag_value_list = create_test_flag_value_list();
let bytes = &flag_value_list.as_bytes();
let mut head = 0;
let version = read_u32_from_bytes(bytes, &mut head).unwrap();
assert_eq!(version, 1234)
}
#[test]
// this test point locks down file type check
fn test_file_type_check() {
let mut flag_value_list = create_test_flag_value_list();
flag_value_list.header.file_type = 123u8;
let error = FlagValueList::from_bytes(&flag_value_list.as_bytes()).unwrap_err();
assert_eq!(
format!("{:?}", error),
format!("BytesParseFail(binary file is not a flag value file)")
);
}
}
|
