libkeri/cesr/indexing/
siger.rs1use crate::cesr::indexing::{idx_sig_dex, BaseIndexer, Indexer};
2use crate::cesr::verfer::Verfer;
3use crate::cesr::Parsable;
4use crate::errors::MatterError;
5use crate::Matter;
6use std::any::Any;
7
8#[derive(Debug, Clone)]
14pub struct Siger {
15 base: BaseIndexer,
16 verfer: Option<Verfer>,
17}
18
19impl Siger {
20 pub fn new(
21 raw: Option<&[u8]>,
22 code: Option<&str>,
23 index: Option<u32>,
24 ondex: Option<u32>,
25 verfer: Option<Verfer>,
26 ) -> Result<Self, MatterError> {
27 if !idx_sig_dex::TUPLE.contains(&(code.unwrap())) {
28 return Err(MatterError::UnsupportedCodeError(String::from(
29 code.unwrap(),
30 )));
31 }
32
33 let base = BaseIndexer::new(raw, code, index, ondex)?;
34 Ok(Siger { base, verfer })
35 }
36
37 pub fn from_raw(raw: Option<&[u8]>, verfer: Option<Verfer>) -> Result<Self, MatterError> {
38 let base = BaseIndexer::from_raw(raw)?;
39
40 Ok(Siger { base, verfer })
41 }
42
43 pub fn from_qb64(qb64: &str, verfer: Option<Verfer>) -> Result<Self, MatterError> {
44 let base = BaseIndexer::from_qb64(qb64)?;
45 if !idx_sig_dex::TUPLE.contains(&(base.code())) {
46 return Err(MatterError::UnsupportedCodeError(String::from(base.code())));
47 }
48
49 Ok(Siger { base, verfer })
50 }
51
52 pub fn verfer(&self) -> Option<Verfer> {
53 self.verfer.clone()
54 }
55
56 pub fn set_verfer(&mut self, verfer: Verfer) {
57 self.verfer = Some(verfer);
58 }
59}
60
61impl Parsable for Siger {
62 fn from_qb64b(data: &mut Vec<u8>, strip: Option<bool>) -> Result<Self, MatterError> {
63 let base = BaseIndexer::from_qb64b(data, strip)?;
64 if !idx_sig_dex::TUPLE.contains(&(base.code())) {
65 return Err(MatterError::UnsupportedCodeError(String::from(base.code())));
66 }
67
68 Ok(Siger { base, verfer: None })
69 }
70
71 fn from_qb2(data: &mut Vec<u8>, strip: Option<bool>) -> Result<Self, MatterError> {
72 let base = BaseIndexer::from_qb2(data, strip)?;
73 if !idx_sig_dex::TUPLE.contains(&(base.code())) {
74 return Err(MatterError::UnsupportedCodeError(String::from(base.code())));
75 }
76
77 Ok(Siger { base, verfer: None })
78 }
79}
80
81impl Indexer for Siger {
82 fn index(&self) -> u32 {
83 self.base.index()
84 }
85 fn ondex(&self) -> Option<u32> {
86 self.base.ondex()
87 }
88}
89
90impl Matter for Siger {
91 fn code(&self) -> &str {
92 self.base.code()
93 }
94
95 fn raw(&self) -> &[u8] {
96 self.base.raw()
97 }
98
99 fn qb64(&self) -> String {
100 self.base.qb64()
101 }
102
103 fn qb64b(&self) -> Vec<u8> {
104 self.base.qb64b()
105 }
106
107 fn qb2(&self) -> Vec<u8> {
108 self.base.qb2()
109 }
110
111 fn soft(&self) -> &str {
112 ""
113 }
114
115 fn full_size(&self) -> usize {
116 self.base.full_size() as usize
117 }
118
119 fn size(&self) -> usize {
120 0
121 }
122
123 fn is_transferable(&self) -> bool {
124 false
125 }
126
127 fn is_digestive(&self) -> bool {
128 false
129 }
130
131 fn is_prefixive(&self) -> bool {
132 false
133 }
134
135 fn is_special(&self) -> bool {
136 false
137 }
138
139 fn as_any(&self) -> &dyn Any {
140 self
141 }
142}