1use std::convert::{TryFrom, TryInto};
10
11#[repr(u16)]
13#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
14pub enum BinlogVersion {
15 Version1 = 1,
17 Version2,
19 Version3,
21 Version4,
23}
24
25impl From<BinlogVersion> for u16 {
26 fn from(x: BinlogVersion) -> Self {
27 x as u16
28 }
29}
30
31#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, thiserror::Error)]
32#[error("Unknown binlog version {0}")]
33#[repr(transparent)]
34pub struct UnknownBinlogVersion(pub u16);
35
36impl From<UnknownBinlogVersion> for u16 {
37 fn from(x: UnknownBinlogVersion) -> Self {
38 x.0
39 }
40}
41
42impl TryFrom<u16> for BinlogVersion {
43 type Error = UnknownBinlogVersion;
44
45 fn try_from(value: u16) -> Result<Self, Self::Error> {
46 match value {
47 1 => Ok(Self::Version1),
48 2 => Ok(Self::Version2),
49 3 => Ok(Self::Version3),
50 4 => Ok(Self::Version4),
51 x => Err(UnknownBinlogVersion(x)),
52 }
53 }
54}
55
56#[allow(non_camel_case_types)]
58#[repr(u8)]
59#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
60pub enum EventType {
61 UNKNOWN_EVENT = 0x00,
63 START_EVENT_V3 = 0x01,
67 QUERY_EVENT = 0x02,
70 STOP_EVENT = 0x03,
72 ROTATE_EVENT = 0x04,
75 INTVAR_EVENT = 0x05,
76 LOAD_EVENT = 0x06,
77 SLAVE_EVENT = 0x07,
79 CREATE_FILE_EVENT = 0x08,
80 APPEND_BLOCK_EVENT = 0x09,
81 EXEC_LOAD_EVENT = 0x0a,
82 DELETE_FILE_EVENT = 0x0b,
83 NEW_LOAD_EVENT = 0x0c,
84 RAND_EVENT = 0x0d,
85 USER_VAR_EVENT = 0x0e,
86 FORMAT_DESCRIPTION_EVENT = 0x0f,
92 XID_EVENT = 0x10,
93 BEGIN_LOAD_QUERY_EVENT = 0x11,
94 EXECUTE_LOAD_QUERY_EVENT = 0x12,
95 TABLE_MAP_EVENT = 0x13,
96 PRE_GA_WRITE_ROWS_EVENT = 0x14,
97 PRE_GA_UPDATE_ROWS_EVENT = 0x15,
98 PRE_GA_DELETE_ROWS_EVENT = 0x16,
99 WRITE_ROWS_EVENT_V1 = 0x17,
100 UPDATE_ROWS_EVENT_V1 = 0x18,
101 DELETE_ROWS_EVENT_V1 = 0x19,
102 INCIDENT_EVENT = 0x1a,
103 HEARTBEAT_EVENT = 0x1b,
104 IGNORABLE_EVENT = 0x1c,
105 ROWS_QUERY_EVENT = 0x1d,
106 WRITE_ROWS_EVENT = 0x1e,
107 UPDATE_ROWS_EVENT = 0x1f,
108 DELETE_ROWS_EVENT = 0x20,
109 GTID_EVENT = 0x21,
110 ANONYMOUS_GTID_EVENT = 0x22,
111 PREVIOUS_GTIDS_EVENT = 0x23,
112 TRANSACTION_CONTEXT_EVENT = 0x24,
113 VIEW_CHANGE_EVENT = 0x25,
114 XA_PREPARE_LOG_EVENT = 0x26,
116 PARTIAL_UPDATE_ROWS_EVENT = 0x27,
119 TRANSACTION_PAYLOAD_EVENT = 0x28,
120 ENUM_END_EVENT,
122}
123
124#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, thiserror::Error)]
125#[error("Unknown event type {0}")]
126#[repr(transparent)]
127pub struct UnknownEventType(pub u8);
128
129impl From<UnknownEventType> for u8 {
130 fn from(x: UnknownEventType) -> Self {
131 x.0
132 }
133}
134
135impl TryFrom<u8> for EventType {
136 type Error = UnknownEventType;
137
138 fn try_from(byte: u8) -> Result<Self, UnknownEventType> {
139 match byte {
140 0x00 => Ok(Self::UNKNOWN_EVENT),
141 0x01 => Ok(Self::START_EVENT_V3),
142 0x02 => Ok(Self::QUERY_EVENT),
143 0x03 => Ok(Self::STOP_EVENT),
144 0x04 => Ok(Self::ROTATE_EVENT),
145 0x05 => Ok(Self::INTVAR_EVENT),
146 0x06 => Ok(Self::LOAD_EVENT),
147 0x07 => Ok(Self::SLAVE_EVENT),
148 0x08 => Ok(Self::CREATE_FILE_EVENT),
149 0x09 => Ok(Self::APPEND_BLOCK_EVENT),
150 0x0a => Ok(Self::EXEC_LOAD_EVENT),
151 0x0b => Ok(Self::DELETE_FILE_EVENT),
152 0x0c => Ok(Self::NEW_LOAD_EVENT),
153 0x0d => Ok(Self::RAND_EVENT),
154 0x0e => Ok(Self::USER_VAR_EVENT),
155 0x0f => Ok(Self::FORMAT_DESCRIPTION_EVENT),
156 0x10 => Ok(Self::XID_EVENT),
157 0x11 => Ok(Self::BEGIN_LOAD_QUERY_EVENT),
158 0x12 => Ok(Self::EXECUTE_LOAD_QUERY_EVENT),
159 0x13 => Ok(Self::TABLE_MAP_EVENT),
160 0x14 => Ok(Self::PRE_GA_WRITE_ROWS_EVENT),
161 0x15 => Ok(Self::PRE_GA_UPDATE_ROWS_EVENT),
162 0x16 => Ok(Self::PRE_GA_DELETE_ROWS_EVENT),
163 0x17 => Ok(Self::WRITE_ROWS_EVENT_V1),
164 0x18 => Ok(Self::UPDATE_ROWS_EVENT_V1),
165 0x19 => Ok(Self::DELETE_ROWS_EVENT_V1),
166 0x1a => Ok(Self::INCIDENT_EVENT),
167 0x1b => Ok(Self::HEARTBEAT_EVENT),
168 0x1c => Ok(Self::IGNORABLE_EVENT),
169 0x1d => Ok(Self::ROWS_QUERY_EVENT),
170 0x1e => Ok(Self::WRITE_ROWS_EVENT),
171 0x1f => Ok(Self::UPDATE_ROWS_EVENT),
172 0x20 => Ok(Self::DELETE_ROWS_EVENT),
173 0x21 => Ok(Self::GTID_EVENT),
174 0x22 => Ok(Self::ANONYMOUS_GTID_EVENT),
175 0x23 => Ok(Self::PREVIOUS_GTIDS_EVENT),
176 0x24 => Ok(Self::TRANSACTION_CONTEXT_EVENT),
177 0x25 => Ok(Self::VIEW_CHANGE_EVENT),
178 0x26 => Ok(Self::XA_PREPARE_LOG_EVENT),
179 0x27 => Ok(Self::PARTIAL_UPDATE_ROWS_EVENT),
180 0x28 => Ok(Self::TRANSACTION_PAYLOAD_EVENT),
181 x => Err(UnknownEventType(x)),
182 }
183 }
184}
185
186my_bitflags! {
187 EventFlags,
188 #[error("Unknown flags in the raw value of EventFlags (raw={0:b})")]
189 UnknownEventFlags,
190 u16,
191
192 #[derive(PartialEq, Eq, Hash, Debug, Clone, Copy)]
194 pub struct EventFlags: u16 {
195 const LOG_EVENT_BINLOG_IN_USE_F = 0x0001;
198
199 const LOG_EVENT_FORCED_ROTATE_F = 0x0002;
201
202 const LOG_EVENT_THREAD_SPECIFIC_F = 0x0004;
204
205 const LOG_EVENT_SUPPRESS_USE_F = 0x0008;
207
208 const LOG_EVENT_UPDATE_TABLE_MAP_VERSION_F = 0x0010;
210
211 const LOG_EVENT_ARTIFICIAL_F = 0x0020;
213
214 const LOG_EVENT_RELAY_LOG_F = 0x0040;
216
217 const LOG_EVENT_IGNORABLE_F = 0x0080;
219
220 const LOG_EVENT_NO_FILTER_F = 0x0100;
224
225 const LOG_EVENT_MTS_ISOLATE_F = 0x0200;
228 }
229}
230
231#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
233#[allow(non_camel_case_types)]
234#[repr(u8)]
235pub enum BinlogChecksumAlg {
236 BINLOG_CHECKSUM_ALG_OFF = 0,
238 BINLOG_CHECKSUM_ALG_CRC32 = 1,
240}
241
242#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, thiserror::Error)]
243#[error("Unknown checksum algorithm {0}")]
244#[repr(transparent)]
245pub struct UnknownChecksumAlg(pub u8);
246
247impl From<UnknownChecksumAlg> for u8 {
248 fn from(x: UnknownChecksumAlg) -> Self {
249 x.0
250 }
251}
252
253impl TryFrom<u8> for BinlogChecksumAlg {
254 type Error = UnknownChecksumAlg;
255
256 fn try_from(value: u8) -> Result<Self, Self::Error> {
257 match value {
258 0 => Ok(Self::BINLOG_CHECKSUM_ALG_OFF),
259 1 => Ok(Self::BINLOG_CHECKSUM_ALG_CRC32),
260 x => Err(UnknownChecksumAlg(x)),
261 }
262 }
263}
264
265#[repr(u8)]
267#[allow(non_camel_case_types)]
268#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
269pub enum StatusVarKey {
270 Flags2 = 0,
272 SqlMode,
274 Catalog,
282 AutoIncrement,
289 Charset,
297 TimeZone,
304 CatalogNz,
311 LcTimeNames,
315 CharsetDatabase,
317 TableMapForUpdate,
320 MasterDataWritten,
322 Invoker,
331 UpdatedDbNames,
339 Microseconds,
341 CommitTs,
342 CommitTs2,
343 ExplicitDefaultsForTimestamp,
345 DdlLoggedWithXid,
348 DefaultCollationForUtf8mb4,
351 SqlRequirePrimaryKey,
353 DefaultTableEncryption,
355}
356
357#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, thiserror::Error)]
358#[error("Unknown status var key {0}")]
359#[repr(transparent)]
360pub struct UnknownStatusVarKey(pub u8);
361
362impl TryFrom<u8> for StatusVarKey {
363 type Error = UnknownStatusVarKey;
364 fn try_from(value: u8) -> Result<Self, Self::Error> {
365 match value {
366 0 => Ok(StatusVarKey::Flags2),
367 1 => Ok(StatusVarKey::SqlMode),
368 2 => Ok(StatusVarKey::Catalog),
369 3 => Ok(StatusVarKey::AutoIncrement),
370 4 => Ok(StatusVarKey::Charset),
371 5 => Ok(StatusVarKey::TimeZone),
372 6 => Ok(StatusVarKey::CatalogNz),
373 7 => Ok(StatusVarKey::LcTimeNames),
374 8 => Ok(StatusVarKey::CharsetDatabase),
375 9 => Ok(StatusVarKey::TableMapForUpdate),
376 10 => Ok(StatusVarKey::MasterDataWritten),
377 11 => Ok(StatusVarKey::Invoker),
378 12 => Ok(StatusVarKey::UpdatedDbNames),
379 13 => Ok(StatusVarKey::Microseconds),
380 14 => Ok(StatusVarKey::CommitTs),
381 15 => Ok(StatusVarKey::CommitTs2),
382 16 => Ok(StatusVarKey::ExplicitDefaultsForTimestamp),
383 17 => Ok(StatusVarKey::DdlLoggedWithXid),
384 18 => Ok(StatusVarKey::DefaultCollationForUtf8mb4),
385 19 => Ok(StatusVarKey::SqlRequirePrimaryKey),
386 20 => Ok(StatusVarKey::DefaultTableEncryption),
387 x => Err(UnknownStatusVarKey(x)),
388 }
389 }
390}
391
392my_bitflags! {
393 SemiSyncFlags,
394 #[error("Unknown flags in the raw value of SemiSyncFlags (raw={0:b})")]
395 UnknownSemiSyncFlags,
396 u8,
397
398 #[derive(PartialEq, Eq, Hash, Debug, Clone, Copy)]
400 pub struct SemiSyncFlags: u8 {
401 const SEMI_SYNC_ACK_REQ = 0x01;
404 }
405}
406
407#[repr(u8)]
409#[allow(non_camel_case_types)]
410#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
411pub enum LoadDuplicateHandling {
412 LOAD_DUP_ERROR = 0,
413 LOAD_DUP_IGNORE,
414 LOAD_DUP_REPLACE,
415}
416
417impl From<LoadDuplicateHandling> for u8 {
418 fn from(x: LoadDuplicateHandling) -> Self {
419 x as u8
420 }
421}
422
423#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, thiserror::Error)]
424#[error("Unknown duplicate handling variant {0}")]
425#[repr(transparent)]
426pub struct UnknownDuplicateHandling(pub u8);
427
428impl From<UnknownDuplicateHandling> for u8 {
429 fn from(x: UnknownDuplicateHandling) -> Self {
430 x.0
431 }
432}
433
434impl TryFrom<u8> for LoadDuplicateHandling {
435 type Error = UnknownDuplicateHandling;
436
437 fn try_from(value: u8) -> Result<Self, Self::Error> {
438 match value {
439 0 => Ok(Self::LOAD_DUP_ERROR),
440 1 => Ok(Self::LOAD_DUP_IGNORE),
441 2 => Ok(Self::LOAD_DUP_REPLACE),
442 x => Err(UnknownDuplicateHandling(x)),
443 }
444 }
445}
446
447#[repr(u8)]
449#[allow(non_camel_case_types)]
450#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
451pub enum OptionalMetadataFieldType {
452 SIGNEDNESS = 1,
460 DEFAULT_CHARSET,
473 COLUMN_CHARSET,
484 COLUMN_NAME,
493 SET_STR_VALUE,
504 ENUM_STR_VALUE,
515 GEOMETRY_TYPE,
524 SIMPLE_PRIMARY_KEY,
535 PRIMARY_KEY_WITH_PREFIX,
553 ENUM_AND_SET_DEFAULT_CHARSET,
566 ENUM_AND_SET_COLUMN_CHARSET,
577 COLUMN_VISIBILITY,
579 VECTOR_DIMENSIONALITY,
581}
582
583#[derive(Debug, Clone, Copy, PartialEq, Eq, thiserror::Error)]
584#[error("Unknown optional metadata field type {0}")]
585pub struct UnknownOptionalMetadataFieldType(pub u8);
586
587impl From<UnknownOptionalMetadataFieldType> for u8 {
588 fn from(x: UnknownOptionalMetadataFieldType) -> Self {
589 x.0
590 }
591}
592
593impl TryFrom<u8> for OptionalMetadataFieldType {
594 type Error = UnknownOptionalMetadataFieldType;
595
596 fn try_from(value: u8) -> Result<Self, Self::Error> {
597 match value {
598 1 => Ok(Self::SIGNEDNESS),
599 2 => Ok(Self::DEFAULT_CHARSET),
600 3 => Ok(Self::COLUMN_CHARSET),
601 4 => Ok(Self::COLUMN_NAME),
602 5 => Ok(Self::SET_STR_VALUE),
603 6 => Ok(Self::ENUM_STR_VALUE),
604 7 => Ok(Self::GEOMETRY_TYPE),
605 8 => Ok(Self::SIMPLE_PRIMARY_KEY),
606 9 => Ok(Self::PRIMARY_KEY_WITH_PREFIX),
607 10 => Ok(Self::ENUM_AND_SET_DEFAULT_CHARSET),
608 11 => Ok(Self::ENUM_AND_SET_COLUMN_CHARSET),
609 12 => Ok(Self::COLUMN_VISIBILITY),
610 13 => Ok(Self::VECTOR_DIMENSIONALITY),
611 x => Err(UnknownOptionalMetadataFieldType(x)),
612 }
613 }
614}
615
616#[repr(u16)]
618#[allow(non_camel_case_types)]
619#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
620pub enum IncidentType {
621 INCIDENT_NONE = 0,
623 INCIDENT_LOST_EVENTS = 1,
625}
626
627impl From<IncidentType> for u16 {
628 fn from(x: IncidentType) -> Self {
629 x as u16
630 }
631}
632
633#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, thiserror::Error)]
634#[error("Unknown item incident type {0}")]
635#[repr(transparent)]
636pub struct UnknownIncidentType(pub u16);
637
638impl From<UnknownIncidentType> for u16 {
639 fn from(x: UnknownIncidentType) -> Self {
640 x.0
641 }
642}
643
644impl TryFrom<u16> for IncidentType {
645 type Error = UnknownIncidentType;
646
647 fn try_from(value: u16) -> Result<Self, Self::Error> {
648 match value {
649 0 => Ok(Self::INCIDENT_NONE),
650 1 => Ok(Self::INCIDENT_LOST_EVENTS),
651 x => Err(UnknownIncidentType(x)),
652 }
653 }
654}
655
656#[repr(u8)]
658#[allow(non_camel_case_types)]
659#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
660pub enum IntvarEventType {
661 INVALID_INT_EVENT,
662 LAST_INSERT_ID_EVENT,
664 INSERT_ID_EVENT,
666}
667
668impl From<IntvarEventType> for u8 {
669 fn from(x: IntvarEventType) -> Self {
670 x as u8
671 }
672}
673
674#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, thiserror::Error)]
675#[error("Unknown intvar event type {0}")]
676#[repr(transparent)]
677pub struct UnknownIntvarEventType(pub u8);
678
679impl From<UnknownIntvarEventType> for u8 {
680 fn from(x: UnknownIntvarEventType) -> Self {
681 x.0
682 }
683}
684
685impl TryFrom<u8> for IntvarEventType {
686 type Error = UnknownIntvarEventType;
687
688 fn try_from(value: u8) -> Result<Self, Self::Error> {
689 match value {
690 0 => Ok(Self::INVALID_INT_EVENT),
691 1 => Ok(Self::LAST_INSERT_ID_EVENT),
692 2 => Ok(Self::INSERT_ID_EVENT),
693 x => Err(UnknownIntvarEventType(x)),
694 }
695 }
696}
697
698my_bitflags! {
699 GtidFlags,
700 #[error("Unknown flags in the raw value of GtidFlags (raw={0:b})")]
701 UnknownGtidFlags,
702 u8,
703
704 #[derive(PartialEq, Eq, Hash, Debug, Clone, Copy)]
706 pub struct GtidFlags: u8 {
707 const MAY_HAVE_SBR = 0x01;
714 }
715}
716
717#[repr(transparent)]
721#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
722pub struct Gno(u64);
723
724impl Gno {
725 pub const MIN_GNO: u64 = 1;
726 pub const MAX_GNO: u64 = i64::MAX as u64;
727}
728
729#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, thiserror::Error)]
730#[error("Group number {0} is out of range [{min}, {max}]", min = Gno::MIN_GNO, max = Gno::MAX_GNO)]
731#[repr(transparent)]
732pub struct InvalidGno(pub u64);
733
734impl From<InvalidGno> for u64 {
735 fn from(x: InvalidGno) -> Self {
736 x.0
737 }
738}
739
740impl TryFrom<u64> for Gno {
741 type Error = InvalidGno;
742
743 fn try_from(value: u64) -> Result<Self, Self::Error> {
744 if value == 0 || (Self::MIN_GNO..Self::MAX_GNO).contains(&value) {
745 Ok(Self(value))
746 } else {
747 Err(InvalidGno(value))
748 }
749 }
750}
751
752my_bitflags! {
753 RowsEventFlags,
754 #[error("Unknown flags in the raw value of RowsEventFlags (raw={0:b})")]
755 UnknownRowsEventFlags,
756 u16,
757
758 #[derive(PartialEq, Eq, Hash, Debug, Clone, Copy)]
760 pub struct RowsEventFlags: u16 {
761 const STMT_END = 0x0001;
763 const NO_FOREIGN_KEY_CHECKS = 0x0002;
765 const RELAXED_UNIQUE_CHECKS = 0x0004;
767 const COMPLETE_ROWS = 0x0008;
770 }
771}
772
773my_bitflags! {
774 UserVarFlags,
775 #[error("Unknown flags in the raw value of UserVarFlags (raw={0:b})")]
776 UnknownUserVarFlags,
777 u8,
778
779 #[derive(PartialEq, Eq, Hash, Debug, Clone, Copy)]
781 pub struct UserVarFlags: u8 {
782 const UNSIGNED = 0x01;
783 }
784}
785
786#[allow(non_camel_case_types)]
788#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
789#[repr(u8)]
790pub enum TransactionPayloadFields {
791 OTW_PAYLOAD_HEADER_END_MARK = 0,
793
794 OTW_PAYLOAD_SIZE_FIELD = 1,
796
797 OTW_PAYLOAD_COMPRESSION_TYPE_FIELD = 2,
799
800 OTW_PAYLOAD_UNCOMPRESSED_SIZE_FIELD = 3,
802 }
804
805#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, thiserror::Error)]
806#[error("Unknown TransactionPayloadFields operation {}", _0)]
807#[repr(transparent)]
808pub struct UnknownTransactionPayloadFields(pub u8);
809
810impl TryFrom<u8> for TransactionPayloadFields {
811 type Error = UnknownTransactionPayloadFields;
812
813 fn try_from(value: u8) -> Result<Self, Self::Error> {
814 match value {
815 0 => Ok(Self::OTW_PAYLOAD_HEADER_END_MARK),
816 1 => Ok(Self::OTW_PAYLOAD_SIZE_FIELD),
817 2 => Ok(Self::OTW_PAYLOAD_COMPRESSION_TYPE_FIELD),
818 3 => Ok(Self::OTW_PAYLOAD_UNCOMPRESSED_SIZE_FIELD),
819 x => Err(UnknownTransactionPayloadFields(x)),
820 }
821 }
822}
823
824impl From<TransactionPayloadFields> for u8 {
825 fn from(x: TransactionPayloadFields) -> Self {
826 x as u8
827 }
828}
829
830impl From<TransactionPayloadFields> for u64 {
831 fn from(x: TransactionPayloadFields) -> Self {
832 x as u64
833 }
834}
835
836impl TryFrom<u64> for TransactionPayloadFields {
837 type Error = UnknownTransactionPayloadFields;
838
839 fn try_from(value: u64) -> Result<Self, Self::Error> {
840 match value {
841 0 => Ok(Self::OTW_PAYLOAD_HEADER_END_MARK),
842 1 => Ok(Self::OTW_PAYLOAD_SIZE_FIELD),
843 2 => Ok(Self::OTW_PAYLOAD_COMPRESSION_TYPE_FIELD),
844 3 => Ok(Self::OTW_PAYLOAD_UNCOMPRESSED_SIZE_FIELD),
845 x => Err(UnknownTransactionPayloadFields(x.try_into().unwrap())),
846 }
847 }
848}
849#[allow(non_camel_case_types)]
851#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
852#[repr(u8)]
853pub enum TransactionPayloadCompressionType {
854 ZSTD = 0,
856
857 NONE = 255,
859}
860
861#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, thiserror::Error)]
862#[error("Unknown TransactionPayloadCompressionType {}", _0)]
863#[repr(transparent)]
864pub struct UnknownTransactionPayloadCompressionType(pub u8);
865
866impl TryFrom<u8> for TransactionPayloadCompressionType {
867 type Error = UnknownTransactionPayloadCompressionType;
868
869 fn try_from(value: u8) -> Result<Self, Self::Error> {
870 match value {
871 0 => Ok(Self::ZSTD),
872 255 => Ok(Self::NONE),
873 x => Err(UnknownTransactionPayloadCompressionType(x)),
874 }
875 }
876}
877
878impl TryFrom<u64> for TransactionPayloadCompressionType {
879 type Error = UnknownTransactionPayloadCompressionType;
880
881 fn try_from(value: u64) -> Result<Self, Self::Error> {
882 match value {
883 0 => Ok(Self::ZSTD),
884 255 => Ok(Self::NONE),
885 x => Err(UnknownTransactionPayloadCompressionType(
886 x.try_into().unwrap(),
887 )),
888 }
889 }
890}