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
pub mod register;
pub mod utils;
mod chunk;
mod errors;
mod keys;
mod map;
mod section;
mod sequence;
mod token;
pub use chunk::{
Address as ChunkAddress, Chunk, Kind as ChunkKind, PrivateChunk, PublicChunk,
MAX_CHUNK_SIZE_IN_BYTES,
};
pub use errors::{Error, Result};
pub use keys::{
keypair::{BlsKeypairShare, Keypair, OwnerType, Signing},
node_keypairs::NodeKeypairs,
public_key::PublicKey,
secret_key::SecretKey,
signature::{Signature, SignatureShare},
};
pub use map::{
Action as MapAction, Address as MapAddress, Entries as MapEntries,
EntryAction as MapEntryAction, EntryActions as MapEntryActions, Kind as MapKind, Map,
PermissionSet as MapPermissionSet, Value as MapValue, Values as MapValues,
};
pub use register::Address as RegisterAddress;
pub use section::SectionElders;
pub use sequence::{
metadata::{
Action as SequenceAction, Address as SequenceAddress, Entries as SequenceEntries,
Entry as SequenceEntry, Index as SequenceIndex, Kind as SequenceKind,
Permissions as SequencePermissions, Policy as SequencePolicy,
PrivatePermissions as SequencePrivatePermissions, PrivatePolicy as SequencePrivatePolicy,
PublicPermissions as SequencePublicPermissions, PublicPolicy as SequencePublicPolicy,
User as SequenceUser,
},
Data as Sequence, DataOp as SequenceOp, PrivateSeqData, PublicSeqData,
};
pub use token::Token;
use register::Register;
use serde::{Deserialize, Serialize};
use xor_name::XorName;
#[allow(clippy::large_enum_variant)]
#[derive(Clone, Eq, PartialEq, Hash, Serialize, Deserialize, Debug)]
pub enum Data {
Chunk(Chunk),
Map(Map),
Sequence(Sequence),
Register(Register),
}
#[derive(Clone, Eq, PartialEq, Hash, Serialize, Deserialize, Debug, PartialOrd, Ord)]
pub enum DataAddress {
Chunk(ChunkAddress),
Map(MapAddress),
Sequence(SequenceAddress),
Register(RegisterAddress),
}
impl Data {
pub fn is_public(&self) -> bool {
match *self {
Self::Chunk(ref chunk) => chunk.is_public(),
Self::Map(_) => false,
Self::Sequence(ref sequence) => sequence.is_public(),
Self::Register(ref register) => register.is_public(),
}
}
pub fn is_private(&self) -> bool {
!self.is_public()
}
}
impl From<Chunk> for Data {
fn from(chunk: Chunk) -> Self {
Self::Chunk(chunk)
}
}
impl From<Map> for Data {
fn from(data: Map) -> Self {
Self::Map(data)
}
}
impl From<Sequence> for Data {
fn from(data: Sequence) -> Self {
Self::Sequence(data)
}
}
impl From<Register> for Data {
fn from(data: Register) -> Self {
Self::Register(data)
}
}