cyfs_base/objects/
object_type.rs1use crate::*;
2
3use std::str::FromStr;
4
5#[derive(Clone, Eq, PartialEq, Debug)]
6#[repr(u8)]
7pub enum ObjectTypeCode {
8 Device = 1,
9 People = 2,
10 SimpleGroup = 3,
11 Org = 4,
12 AppGroup = 5,
13 UnionAccount = 6,
14 Chunk = 7,
15 File = 8,
16 Dir = 9,
17 Diff = 10,
18 ProofOfService = 11,
19 Tx = 12,
20 Action = 13,
21 ObjectMap = 14,
22 Contract = 15,
23 Custom = 16,
24}
25
26impl From<u16> for ObjectTypeCode {
27 fn from(v: u16) -> Self {
28 match v {
29 1u16 => ObjectTypeCode::Device,
30 2u16 => ObjectTypeCode::People,
31 3u16 => ObjectTypeCode::SimpleGroup,
32 4u16 => ObjectTypeCode::Org,
33 5u16 => ObjectTypeCode::AppGroup,
34 6u16 => ObjectTypeCode::UnionAccount,
35 7u16 => ObjectTypeCode::Chunk,
36 8u16 => ObjectTypeCode::File,
37 9u16 => ObjectTypeCode::Dir,
38 10u16 => ObjectTypeCode::Diff,
39 11u16 => ObjectTypeCode::ProofOfService,
40 12u16 => ObjectTypeCode::Tx,
41 13u16 => ObjectTypeCode::Action,
42 14u16 => ObjectTypeCode::ObjectMap,
43 15u16 => ObjectTypeCode::Contract,
44 16u16 => ObjectTypeCode::Custom,
45 _ => ObjectTypeCode::Custom,
46 }
47 }
48}
49
50impl From<&ObjectTypeCode> for u16 {
51 fn from(v: &ObjectTypeCode) -> Self {
52 match v {
53 ObjectTypeCode::Device => 1u16,
54 ObjectTypeCode::People => 2u16,
55 ObjectTypeCode::SimpleGroup => 3u16,
56 ObjectTypeCode::Org => 4u16,
57 ObjectTypeCode::AppGroup => 5u16,
58 ObjectTypeCode::UnionAccount => 6u16,
59 ObjectTypeCode::Chunk => 7u16,
60 ObjectTypeCode::File => 8u16,
61 ObjectTypeCode::Dir => 9u16,
62 ObjectTypeCode::Diff => 10u16,
63 ObjectTypeCode::ProofOfService => 11u16,
64 ObjectTypeCode::Tx => 12u16,
65 ObjectTypeCode::Action => 13u16,
66 ObjectTypeCode::ObjectMap => 14u16,
67 ObjectTypeCode::Contract => 15u16,
68 _ => 16u16,
69 }
70 }
71}
72
73impl From<ObjectTypeCode> for u16 {
74 fn from(v: ObjectTypeCode) -> Self {
75 let r = &v;
76 r.into()
77 }
78}
79
80impl ObjectTypeCode {
81 pub fn raw_check_type_code(buf: &[u8]) -> Self {
82 let flag = buf[0];
83 if (flag >> 6) != 0b_00000001 {
84 ObjectTypeCode::Custom
85 } else {
86 let obj_type_code = (flag << 2 >> 4) as u16;
87 obj_type_code.into()
88 }
89 }
90
91 pub fn to_u16(&self) -> u16 {
92 self.into()
93 }
94
95 pub fn to_u8(&self) -> u8 {
96 self.to_u16() as u8
97 }
98}
99
100impl FromStr for ObjectTypeCode {
101 type Err = BuckyError;
102 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
103 let v: u16 = s.parse().map_err(|e| {
104 warn!("parse object type code error: {} {}", s, e);
105 BuckyError::from(BuckyErrorCode::InvalidFormat)
106 })?;
107
108 Ok(v.into())
109 }
110}
111
112impl ToString for ObjectTypeCode {
113 fn to_string(&self) -> String {
114 let v: u16 = self.into();
115 v.to_string()
116 }
117}
118
119impl RawEncode for ObjectTypeCode {
120 fn raw_measure(&self, _purpose: &Option<RawEncodePurpose>) -> BuckyResult<usize> {
121 Ok(u16::raw_bytes().unwrap())
122 }
123
124 fn raw_encode<'a>(
125 &self,
126 buf: &'a mut [u8],
127 purpose: &Option<RawEncodePurpose>,
128 ) -> BuckyResult<&'a mut [u8]> {
129 let v: u16 = self.into();
130 v.raw_encode(buf, purpose)
131 }
132}
133
134impl<'de> RawDecode<'de> for ObjectTypeCode {
135 fn raw_decode(buf: &'de [u8]) -> BuckyResult<(Self, &'de [u8])> {
136 let (v, buf) = u16::raw_decode(buf).map_err(|e| {
137 log::error!("ObjectTypeCode::raw_decode error:{}", e);
138 e
139 })?;
140 let v = v.into();
141
142 Ok((v, buf))
143 }
144}
145
146pub mod object_type_helper {
147 use super::*;
148
149 pub fn is_standard_object(object_type: u16) -> bool {
150 object_type >= OBJECT_TYPE_STANDARD_START && object_type <= OBJECT_TYPE_STANDARD_END
151 }
152
153 pub fn is_custom_object(object_type: u16) -> bool {
154 object_type >= OBJECT_TYPE_CORE_START
155 }
156
157 pub fn is_core_object(object_type: u16) -> bool {
158 object_type >= OBJECT_TYPE_CORE_START && object_type <= OBJECT_TYPE_CORE_END
159 }
160
161 pub fn is_dec_app_object(object_type: u16) -> bool {
162 object_type >= OBJECT_TYPE_DECAPP_START && object_type <= OBJECT_TYPE_DECAPP_END
163 }
164}
165
166pub trait ObjectType: Clone {
168 fn obj_type_code() -> ObjectTypeCode;
170
171 fn obj_type() -> u16;
175
176 fn is_standard_object() -> bool {
177 let c = Self::obj_type_code();
178 c != ObjectTypeCode::Custom
179 }
180
181 fn is_core_object() -> bool {
182 let t = Self::obj_type();
183 let c = Self::obj_type_code();
184 c == ObjectTypeCode::Custom && object_type_helper::is_core_object(t)
185 }
186
187 fn is_dec_app_object() -> bool {
188 let t = Self::obj_type();
189 let c = Self::obj_type_code();
190 c == ObjectTypeCode::Custom && object_type_helper::is_dec_app_object(t)
191 }
192
193 type DescType: ObjectDesc + Sync + Send;
194 type ContentType: Sync + Send;
195}