1use nanoid::nanoid;
2use crate::value::{Value, timestamp_ms};
3use std::collections::HashMap;
4use crate::error::BundError;
5use crate::types::*;
6
7impl Value {
8 pub fn from_float(value: f64) -> Self {
9 Self {
10 id: nanoid!(),
11 stamp: timestamp_ms(),
12 dt: FLOAT,
13 q: 100.0,
14 data: Val::F64(value),
15 attr: Vec::new(),
16 curr: -1,
17 tags: HashMap::new(),
18 }
19 }
20 pub fn from_float32(value: f32) -> Self {
21 Self {
22 id: nanoid!(),
23 stamp: timestamp_ms(),
24 dt: FLOAT,
25 q: 100.0,
26 data: Val::F64(value as f64),
27 attr: Vec::new(),
28 curr: -1,
29 tags: HashMap::new(),
30 }
31 }
32 pub fn from_int(value: i64) -> Self {
33 Self {
34 id: nanoid!(),
35 stamp: timestamp_ms(),
36 dt: INTEGER,
37 q: 100.0,
38 data: Val::I64(value),
39 attr: Vec::new(),
40 curr: -1,
41 tags: HashMap::new(),
42 }
43 }
44 pub fn from_int32(value: i32) -> Self {
45 Self {
46 id: nanoid!(),
47 stamp: timestamp_ms(),
48 dt: INTEGER,
49 q: 100.0,
50 data: Val::I64(value as i64),
51 attr: Vec::new(),
52 curr: -1,
53 tags: HashMap::new(),
54 }
55 }
56 pub fn from_bool(value: bool) -> Self {
57 Self {
58 id: nanoid!(),
59 stamp: timestamp_ms(),
60 dt: BOOL,
61 q: 100.0,
62 data: Val::Bool(value),
63 attr: Vec::new(),
64 curr: -1,
65 tags: HashMap::new(),
66 }
67 }
68 pub fn make_true() -> Self {
69 Self {
70 id: nanoid!(),
71 stamp: timestamp_ms(),
72 dt: BOOL,
73 q: 100.0,
74 data: Val::Bool(true),
75 attr: Vec::new(),
76 curr: -1,
77 tags: HashMap::new(),
78 }
79 }
80 pub fn make_false() -> Self {
81 Self {
82 id: nanoid!(),
83 stamp: timestamp_ms(),
84 dt: BOOL,
85 q: 100.0,
86 data: Val::Bool(false),
87 attr: Vec::new(),
88 curr: -1,
89 tags: HashMap::new(),
90 }
91 }
92 pub fn from_string<N: AsRef<str>>(value: N) -> Self {
93 Self {
94 id: nanoid!(),
95 stamp: timestamp_ms(),
96 dt: STRING,
97 q: 100.0,
98 data: Val::String(value.as_ref().to_string()),
99 attr: Vec::new(),
100 curr: -1,
101 tags: HashMap::new(),
102 }
103 }
104 pub fn from_str(value: &str) -> Self {
105 Self {
106 id: nanoid!(),
107 stamp: timestamp_ms(),
108 dt: STRING,
109 q: 100.0,
110 data: Val::String(value.to_string()),
111 attr: Vec::new(),
112 curr: -1,
113 tags: HashMap::new(),
114 }
115 }
116 pub fn from_bin(value: Vec<u8>) -> Self {
117 Self {
118 id: nanoid!(),
119 stamp: timestamp_ms(),
120 dt: BIN,
121 q: 100.0,
122 data: Val::Binary(value),
123 attr: Vec::new(),
124 curr: -1,
125 tags: HashMap::new(),
126 }
127 }
128 pub fn make_envelope(value: Vec<u8>) -> Self {
129 Self {
130 id: nanoid!(),
131 stamp: timestamp_ms(),
132 dt: ENVELOPE,
133 q: 100.0,
134 data: Val::Binary(value),
135 attr: Vec::new(),
136 curr: -1,
137 tags: HashMap::new(),
138 }
139 }
140 pub fn binary() -> Self {
141 Self {
142 id: nanoid!(),
143 stamp: timestamp_ms(),
144 dt: BIN,
145 q: 100.0,
146 data: Val::Binary(Vec::new()),
147 attr: Vec::new(),
148 curr: -1,
149 tags: HashMap::new(),
150 }
151 }
152 pub fn from_error(value: BundError) -> Self {
153 Self {
154 id: nanoid!(),
155 stamp: timestamp_ms(),
156 dt: ERROR,
157 q: 100.0,
158 data: Val::Error(value),
159 attr: Vec::new(),
160 curr: -1,
161 tags: HashMap::new(),
162 }
163 }
164 pub fn from_pair(value: (Value, Value)) -> Self {
165 let mut res = Value::from_list(vec![value.0, value.1]);
166 res.dt = PAIR;
167 res
168 }
169 pub fn from_timestamp(value: u128) -> Self {
170 Self {
171 id: nanoid!(),
172 stamp: timestamp_ms(),
173 dt: TIME,
174 q: 100.0,
175 data: Val::Time(value),
176 attr: Vec::new(),
177 curr: -1,
178 tags: HashMap::new(),
179 }
180 }
181 pub fn message(from: Value, to: Value, data: Value) -> Self {
182 let mut res = Value::dict();
183 let mut to_list = Value::list();
184 let mut payload = Value::list();
185
186 res.dt = MESSAGE;
187 res = res.set("from", from);
188 to_list = to_list.push(to);
189 res = res.set("to", to_list);
190 payload = payload.push(data);
191 res = res.set("payload", payload);
192 res
193 }
194}