bucky_objects/objects/
union_account.rs

1use crate::*;
2
3use std::convert::TryFrom;
4use bucky_error::{BuckyError, BuckyErrorCode};
5use serde::Serialize;
6
7#[derive(Clone, Debug, Serialize)]
8pub struct UnionAccountDescContent {
9    left: ObjectId,
10    right: ObjectId,
11    service_type: u8,
12}
13
14impl UnionAccountDescContent {
15    pub fn new(account1: ObjectId, account2: ObjectId, service_type: u8) -> Self {
16        let mut left = account1;
17        let mut right = account2;
18        if account1 > account2 {
19            left = account2;
20            right = account1;
21        }
22
23        Self {
24            left,
25            right,
26            service_type,
27        }
28    }
29
30    pub fn left(&self) -> &ObjectId {
31        &self.left
32    }
33
34    pub fn right(&self) -> &ObjectId {
35        &self.right
36    }
37
38    pub fn service_type(&self) -> u8 {
39        self.service_type
40    }
41}
42
43impl DescContent for UnionAccountDescContent {
44    fn obj_type() -> u16 {
45        ObjectTypeCode::UnionAccount.into()
46    }
47
48    type OwnerType = SubDescNone;
49    type AreaType = SubDescNone;
50    type AuthorType = SubDescNone;
51    type PublicKeyType = SubDescNone;
52}
53
54impl RawEncode for UnionAccountDescContent {
55    fn raw_measure(&self, purpose: &Option<RawEncodePurpose>) -> Result<usize, BuckyError> {
56        let size =
57            0 + self.left.raw_measure(purpose).map_err(|e| {
58                log::error!("UnionAccountDescContent::raw_measure/left error:{}", e);
59                e
60            })? + self.right.raw_measure(purpose).map_err(|e| {
61                log::error!("UnionAccountDescContent::raw_measure/right error:{}", e);
62                e
63            })? + u8::raw_bytes().unwrap();
64
65        Ok(size)
66    }
67
68    fn raw_encode<'a>(
69        &self,
70        buf: &'a mut [u8],
71        purpose: &Option<RawEncodePurpose>,
72    ) -> Result<&'a mut [u8], BuckyError> {
73        let size = self.raw_measure(purpose).unwrap();
74        if buf.len() < size {
75            return Err(BuckyError::new(
76                BuckyErrorCode::OutOfLimit,
77                "[raw_encode] not enough buffer for UnionAccountDescContent",
78            ));
79        }
80
81        let buf = self.left.raw_encode(buf, purpose).map_err(|e| {
82            log::error!("UnionAccountDescContent::raw_encode/left error:{}", e);
83            e
84        })?;
85
86        let buf = self.right.raw_encode(buf, purpose).map_err(|e| {
87            log::error!("UnionAccountDescContent::raw_encode/right error:{}", e);
88            e
89        })?;
90
91        let buf = self.service_type.raw_encode(buf, purpose).map_err(|e| {
92            log::error!(
93                "UnionAccountDescContent::raw_encode/service_type error:{}",
94                e
95            );
96            e
97        })?;
98
99        Ok(buf)
100    }
101}
102
103impl<'de> RawDecode<'de> for UnionAccountDescContent {
104    fn raw_decode(buf: &'de [u8]) -> BuckyResult<(Self, &'de [u8])> {
105        let (left, buf) = ObjectId::raw_decode(buf).map_err(|e| {
106            log::error!("UnionAccountDescContent::raw_decode/left error:{}", e);
107            e
108        })?;
109
110        let (right, buf) = ObjectId::raw_decode(buf).map_err(|e| {
111            log::error!("UnionAccountDescContent::raw_decode/right error:{}", e);
112            e
113        })?;
114
115        let (service_type, buf) = u8::raw_decode(buf).map_err(|e| {
116            log::error!(
117                "UnionAccountDescContent::raw_decode/service_type error:{}",
118                e
119            );
120            e
121        })?;
122
123        Ok((
124            Self {
125                left,
126                right,
127                service_type,
128            },
129            buf,
130        ))
131    }
132}
133
134#[derive(Clone, Debug, RawEncode, RawDecode)]
135pub struct UnionAccountBodyContent {}
136
137impl BodyContent for UnionAccountBodyContent {}
138
139impl UnionAccountBodyContent {
140    pub fn new() -> Self {
141        Self {}
142    }
143}
144
145pub type UnionAccountType = NamedObjType<UnionAccountDescContent, UnionAccountBodyContent>;
146pub type UnionAccountBuilder = NamedObjectBuilder<UnionAccountDescContent, UnionAccountBodyContent>;
147
148pub type UnionAccountDesc = NamedObjectDesc<UnionAccountDescContent>;
149pub type UnionAccountId = NamedObjectId<UnionAccountType>;
150pub type UnionAccount = NamedObjectBase<UnionAccountType>;
151
152impl UnionAccountDesc {
153    pub fn tx_id(&self) -> UnionAccountId {
154        UnionAccountId::try_from(self.calculate_id()).unwrap()
155    }
156}
157
158impl NamedObjectBase<UnionAccountType> {
159    pub fn new(account1: ObjectId, account2: ObjectId, service_type: u8) -> UnionAccountBuilder {
160        let desc_content = UnionAccountDescContent::new(account1, account2, service_type);
161
162        let body_content = UnionAccountBodyContent::new();
163
164        UnionAccountBuilder::new(desc_content, body_content)
165    }
166}
167
168#[cfg(test)]
169mod test {
170    use crate::{ObjectId, RawConvertTo, RawFrom, UnionAccount};
171    //use std::path::Path;
172
173    #[test]
174    fn union_account() {
175        let account1 = ObjectId::default();
176
177        let account2 = ObjectId::default();
178
179        let service_type = 0; // TODO: 常量定义
180
181        let obj = UnionAccount::new(account1, account2, service_type).build();
182
183        // let p = Path::new("f:\\temp\\union_account.obj");
184        // if p.parent().unwrap().exists() {
185        //     obj.clone().encode_to_file(p, false);
186        // }
187
188        let buf = obj.to_vec().unwrap();
189
190        let _new_obj = UnionAccount::clone_from_slice(&buf).unwrap();
191    }
192}
bucky_objects/objects/union_account.rs

bucky_objects/objects/
union_account.rs
