1pub static ALPHABET16_ENCODE:&[u8;16]=&[48,49,50,51,52,53,54,55,56,57,65,66,67,68,69,70];
2
3#[allow(non_upper_case_globals)]
4#[cfg(target_pointer_width="32")]
5pub static encode_8:unsafe fn(*const u64,usize,*const u8,*mut u8)=encode_8_32;
6
7#[allow(non_upper_case_globals)]
8#[cfg(target_pointer_width="64")]
9pub static encode_8:unsafe fn(*const u64,usize,*const u8,*mut u8)=encode_8_64;
10
11pub trait B16Encode<I,O,E>{
12 fn encode(input:I)->Result<O,E>;
13}
14
15#[derive(Debug)]
16pub enum B16EncodeError{
17 Null,
18 Undefined,
19 IOError(io::Error)
20}
21
22pub unsafe fn encode_8_64(ptr_input:*const u64,len_input:usize,ptr_alphabet:*const u8,ptr_output:*mut u8){
23 let mut ptr_in=ptr_input;
24 let mut ptr_out=ptr_output;
25 let mut back_index = len_input as isize;
26 let mut n64:u64;
27 while back_index>1{
28 n64=*ptr_in;
29 *ptr_out.offset(00)=*ptr_alphabet.offset(((n64>>60)&0b1111) as isize);
30 *ptr_out.offset(01)=*ptr_alphabet.offset(((n64>>56)&0b1111) as isize);
31 *ptr_out.offset(02)=*ptr_alphabet.offset(((n64>>52)&0b1111) as isize);
32 *ptr_out.offset(03)=*ptr_alphabet.offset(((n64>>48)&0b1111) as isize);
33 *ptr_out.offset(04)=*ptr_alphabet.offset(((n64>>44)&0b1111) as isize);
34 *ptr_out.offset(05)=*ptr_alphabet.offset(((n64>>40)&0b1111) as isize);
35 *ptr_out.offset(06)=*ptr_alphabet.offset(((n64>>36)&0b1111) as isize);
36 *ptr_out.offset(07)=*ptr_alphabet.offset(((n64>>32)&0b1111) as isize);
37 *ptr_out.offset(08)=*ptr_alphabet.offset(((n64>>28)&0b1111) as isize);
38 *ptr_out.offset(09)=*ptr_alphabet.offset(((n64>>24)&0b1111) as isize);
39 *ptr_out.offset(10)=*ptr_alphabet.offset(((n64>>20)&0b1111) as isize);
40 *ptr_out.offset(11)=*ptr_alphabet.offset(((n64>>16)&0b1111) as isize);
41 *ptr_out.offset(12)=*ptr_alphabet.offset(((n64>>12)&0b1111) as isize);
42 *ptr_out.offset(13)=*ptr_alphabet.offset(((n64>>08)&0b1111) as isize);
43 *ptr_out.offset(14)=*ptr_alphabet.offset(((n64>>04)&0b1111) as isize);
44 *ptr_out.offset(15)=*ptr_alphabet.offset(((n64>>00)&0b1111) as isize);
45 ptr_out=ptr_out.offset(16);
46 ptr_in=ptr_in.offset(1);
47 back_index-=1;
48 }
49 if back_index==1{
50 n64=*ptr_in;
51 *ptr_out.offset(00)=*ptr_alphabet.offset(((n64>>60)&0b1111) as isize);
52 *ptr_out.offset(01)=*ptr_alphabet.offset(((n64>>56)&0b1111) as isize);
53 *ptr_out.offset(02)=*ptr_alphabet.offset(((n64>>52)&0b1111) as isize);
54 *ptr_out.offset(03)=*ptr_alphabet.offset(((n64>>48)&0b1111) as isize);
55 *ptr_out.offset(04)=*ptr_alphabet.offset(((n64>>44)&0b1111) as isize);
56 *ptr_out.offset(05)=*ptr_alphabet.offset(((n64>>40)&0b1111) as isize);
57 *ptr_out.offset(06)=*ptr_alphabet.offset(((n64>>36)&0b1111) as isize);
58 *ptr_out.offset(07)=*ptr_alphabet.offset(((n64>>32)&0b1111) as isize);
59 *ptr_out.offset(08)=*ptr_alphabet.offset(((n64>>28)&0b1111) as isize);
60 *ptr_out.offset(09)=*ptr_alphabet.offset(((n64>>24)&0b1111) as isize);
61 *ptr_out.offset(10)=*ptr_alphabet.offset(((n64>>20)&0b1111) as isize);
62 *ptr_out.offset(11)=*ptr_alphabet.offset(((n64>>16)&0b1111) as isize);
63 *ptr_out.offset(12)=*ptr_alphabet.offset(((n64>>12)&0b1111) as isize);
64 *ptr_out.offset(13)=*ptr_alphabet.offset(((n64>>08)&0b1111) as isize);
65 *ptr_out.offset(14)=*ptr_alphabet.offset(((n64>>04)&0b1111) as isize);
66 *ptr_out.offset(15)=*ptr_alphabet.offset(((n64>>00)&0b1111) as isize);
67 }
68}
69
70pub unsafe fn encode_8_32(ptr_input:*const u64,len_input:usize,ptr_alphabet:*const u8,ptr_output:*mut u8){
71 let mut ptr_in=ptr_input;
72 let mut ptr_out=ptr_output;
73 let mut back_index = len_input as isize;
74 let mut n32:u32;
75 while back_index>1{
76 n32=((*ptr_in)>>32) as u32;
77 *ptr_out.offset(0)=*ptr_alphabet.offset(((n32>>28)&0b1111) as isize);
78 *ptr_out.offset(1)=*ptr_alphabet.offset(((n32>>24)&0b1111) as isize);
79 *ptr_out.offset(2)=*ptr_alphabet.offset(((n32>>20)&0b1111) as isize);
80 *ptr_out.offset(3)=*ptr_alphabet.offset(((n32>>16)&0b1111) as isize);
81 *ptr_out.offset(4)=*ptr_alphabet.offset(((n32>>12)&0b1111) as isize);
82 *ptr_out.offset(5)=*ptr_alphabet.offset(((n32>>08)&0b1111) as isize);
83 *ptr_out.offset(6)=*ptr_alphabet.offset(((n32>>04)&0b1111) as isize);
84 *ptr_out.offset(7)=*ptr_alphabet.offset(((n32>>00)&0b1111) as isize);
85 ptr_out=ptr_out.offset(8);
86 n32=((*ptr_in)&0xffff_ffff) as u32;
87 *ptr_out.offset(0)=*ptr_alphabet.offset(((n32>>28)&0b1111) as isize);
88 *ptr_out.offset(1)=*ptr_alphabet.offset(((n32>>24)&0b1111) as isize);
89 *ptr_out.offset(2)=*ptr_alphabet.offset(((n32>>20)&0b1111) as isize);
90 *ptr_out.offset(3)=*ptr_alphabet.offset(((n32>>16)&0b1111) as isize);
91 *ptr_out.offset(4)=*ptr_alphabet.offset(((n32>>12)&0b1111) as isize);
92 *ptr_out.offset(5)=*ptr_alphabet.offset(((n32>>08)&0b1111) as isize);
93 *ptr_out.offset(6)=*ptr_alphabet.offset(((n32>>04)&0b1111) as isize);
94 *ptr_out.offset(7)=*ptr_alphabet.offset(((n32>>00)&0b1111) as isize);
95 ptr_out=ptr_out.offset(8);
96 ptr_in=ptr_in.offset(1);
97 back_index-=1;
98 }
99 if back_index==1{
100 n32=((*ptr_in)>>32) as u32;
101 *ptr_out.offset(0)=*ptr_alphabet.offset(((n32>>28)&0b1111) as isize);
102 *ptr_out.offset(1)=*ptr_alphabet.offset(((n32>>24)&0b1111) as isize);
103 *ptr_out.offset(2)=*ptr_alphabet.offset(((n32>>20)&0b1111) as isize);
104 *ptr_out.offset(3)=*ptr_alphabet.offset(((n32>>16)&0b1111) as isize);
105 *ptr_out.offset(4)=*ptr_alphabet.offset(((n32>>12)&0b1111) as isize);
106 *ptr_out.offset(5)=*ptr_alphabet.offset(((n32>>08)&0b1111) as isize);
107 *ptr_out.offset(6)=*ptr_alphabet.offset(((n32>>04)&0b1111) as isize);
108 *ptr_out.offset(7)=*ptr_alphabet.offset(((n32>>00)&0b1111) as isize);
109 ptr_out=ptr_out.offset(8);
110 n32=((*ptr_in)&0xffff_ffff) as u32;
111 *ptr_out.offset(0)=*ptr_alphabet.offset(((n32>>28)&0b1111) as isize);
112 *ptr_out.offset(1)=*ptr_alphabet.offset(((n32>>24)&0b1111) as isize);
113 *ptr_out.offset(2)=*ptr_alphabet.offset(((n32>>20)&0b1111) as isize);
114 *ptr_out.offset(3)=*ptr_alphabet.offset(((n32>>16)&0b1111) as isize);
115 *ptr_out.offset(4)=*ptr_alphabet.offset(((n32>>12)&0b1111) as isize);
116 *ptr_out.offset(5)=*ptr_alphabet.offset(((n32>>08)&0b1111) as isize);
117 *ptr_out.offset(6)=*ptr_alphabet.offset(((n32>>04)&0b1111) as isize);
118 *ptr_out.offset(7)=*ptr_alphabet.offset(((n32>>00)&0b1111) as isize);
119 }
120}
121
122pub unsafe fn encode_4(ptr_input:*const u32,len_input:usize,ptr_alphabet:*const u8,ptr_output:*mut u8){
123 let mut ptr_in=ptr_input;
124 let mut ptr_out=ptr_output;
125 let mut back_index = len_input as isize;
126 let mut n32:u32;
127 while back_index>1{
128 n32=*ptr_in;
129 *ptr_out.offset(0)=*ptr_alphabet.offset(((n32>>28)&0b1111) as isize);
130 *ptr_out.offset(1)=*ptr_alphabet.offset(((n32>>24)&0b1111) as isize);
131 *ptr_out.offset(2)=*ptr_alphabet.offset(((n32>>20)&0b1111) as isize);
132 *ptr_out.offset(3)=*ptr_alphabet.offset(((n32>>16)&0b1111) as isize);
133 *ptr_out.offset(4)=*ptr_alphabet.offset(((n32>>12)&0b1111) as isize);
134 *ptr_out.offset(5)=*ptr_alphabet.offset(((n32>>08)&0b1111) as isize);
135 *ptr_out.offset(6)=*ptr_alphabet.offset(((n32>>04)&0b1111) as isize);
136 *ptr_out.offset(7)=*ptr_alphabet.offset(((n32>>00)&0b1111) as isize);
137 ptr_out=ptr_out.offset(8);
138 ptr_in=ptr_in.offset(1);
139 back_index-=1;
140 }
141 if back_index==1{
142 n32=*ptr_in.offset(0);
143 *ptr_out.offset(0)=*ptr_alphabet.offset(((n32>>28)&0b1111) as isize);
144 *ptr_out.offset(1)=*ptr_alphabet.offset(((n32>>24)&0b1111) as isize);
145 *ptr_out.offset(2)=*ptr_alphabet.offset(((n32>>20)&0b1111) as isize);
146 *ptr_out.offset(3)=*ptr_alphabet.offset(((n32>>16)&0b1111) as isize);
147 *ptr_out.offset(4)=*ptr_alphabet.offset(((n32>>12)&0b1111) as isize);
148 *ptr_out.offset(5)=*ptr_alphabet.offset(((n32>>08)&0b1111) as isize);
149 *ptr_out.offset(6)=*ptr_alphabet.offset(((n32>>04)&0b1111) as isize);
150 *ptr_out.offset(7)=*ptr_alphabet.offset(((n32>>00)&0b1111) as isize);
151 }
152}
153
154pub unsafe fn encode_2(ptr_input:*const u16,len_input:usize,ptr_alphabet:*const u8,ptr_output:*mut u8){
155 let mut ptr_in=ptr_input;
156 let mut ptr_out=ptr_output;
157 let mut back_index = len_input as isize;
158 let mut n16:u16;
159 while back_index>1{
160 n16=*ptr_in;
161 *ptr_out.offset(0)=*ptr_alphabet.offset(((n16>>12)&0b1111) as isize);
162 *ptr_out.offset(1)=*ptr_alphabet.offset(((n16>>08)&0b1111) as isize);
163 *ptr_out.offset(2)=*ptr_alphabet.offset(((n16>>04)&0b1111) as isize);
164 *ptr_out.offset(3)=*ptr_alphabet.offset(((n16>>00)&0b1111) as isize);
165 ptr_out=ptr_out.offset(4);
166 ptr_in=ptr_in.offset(1);
167 back_index-=1;
168 }
169 if back_index==1{
170 n16=*ptr_in;
171 *ptr_out.offset(0)=*ptr_alphabet.offset(((n16>>12)&0b1111) as isize);
172 *ptr_out.offset(1)=*ptr_alphabet.offset(((n16>>08)&0b1111) as isize);
173 *ptr_out.offset(2)=*ptr_alphabet.offset(((n16>>04)&0b1111) as isize);
174 *ptr_out.offset(3)=*ptr_alphabet.offset(((n16>>00)&0b1111) as isize);
175 }
176}
177
178pub unsafe fn encode_1(ptr_input:*const u8,len_input:usize,ptr_alphabet:*const u8,ptr_output:*mut u8){
179 let mut ptr_in=ptr_input;
180 let mut ptr_out=ptr_output;
181 let mut back_index = len_input as isize;
182 let mut n8:u8;
183 while back_index>1{
184 n8=*ptr_in;
185 *ptr_out.offset(0)=*ptr_alphabet.offset(((n8>>04)&0b1111) as isize);
186 *ptr_out.offset(1)=*ptr_alphabet.offset(((n8>>00)&0b1111) as isize);
187 ptr_out=ptr_out.offset(2);
188 ptr_in=ptr_in.offset(1);
189 back_index-=1;
190 }
191 if back_index==1{
192 n8=*ptr_in;
193 *ptr_out.offset(0)=*ptr_alphabet.offset(((n8>>04)&0b1111) as isize);
194 *ptr_out.offset(1)=*ptr_alphabet.offset(((n8>>00)&0b1111) as isize);
195 }
196}
197
198impl B16Encode<Vec<u64>,String,B16EncodeError> for B16<String>{
199 fn encode(input:Vec<u64>)->Result<String,B16EncodeError>{
200 let length_input=input.len();
201 let mut string=String::with_capacity(length_input<<3);
202 unsafe{
203 let vector=&mut string.as_mut_vec();
204 vector.set_len(length_input<<3);
205 encode_8(input.as_ptr(),length_input,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
206 }
207 return Ok(string);
208 }
209}
210
211impl B16Encode<Vec<u64>,Vec<u8>,B16EncodeError> for B16<Vec<u8>>{
212 fn encode(input:Vec<u64>)->Result<Vec<u8>,B16EncodeError>{
213 let length_input=input.len();
214 let mut vector=Vec::<u8>::with_capacity(length_input<<3);
215 unsafe{
216 vector.set_len(length_input<<3);
217 encode_8(input.as_ptr(),length_input,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
218 }
219 return Ok(vector);
220 }
221}
222
223impl B16Encode<Vec<i64>,String,B16EncodeError> for B16<String>{
224 fn encode(input:Vec<i64>)->Result<String,B16EncodeError>{
225 let length_input=input.len();
226 let mut string=String::with_capacity(length_input<<3);
227 unsafe{
228 let vector=&mut string.as_mut_vec();
229 vector.set_len(length_input<<3);
230 encode_8(input.as_ptr() as * const u64,length_input,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
231 }
232 return Ok(string);
233 }
234}
235
236impl B16Encode<Vec<i64>,Vec<u8>,B16EncodeError> for B16<Vec<u8>>{
237 fn encode(input:Vec<i64>)->Result<Vec<u8>,B16EncodeError>{
238 let length_input=input.len();
239 let mut vector=Vec::<u8>::with_capacity(length_input<<3);
240 unsafe{
241 vector.set_len(length_input<<3);
242 encode_8(input.as_ptr() as * const u64,length_input,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
243 }
244 return Ok(vector);
245 }
246}
247
248impl B16Encode<Vec<u32>,String,B16EncodeError> for B16<String>{
249 fn encode(input:Vec<u32>)->Result<String,B16EncodeError>{
250 let length_input=input.len();
251 let mut string=String::with_capacity(length_input<<3);
252 unsafe{
253 let vector=&mut string.as_mut_vec();
254 vector.set_len(length_input<<3);
255 encode_4(input.as_ptr(),length_input,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
256 }
257 return Ok(string);
258 }
259}
260
261impl B16Encode<Vec<u32>,Vec<u8>,B16EncodeError> for B16<Vec<u8>>{
262 fn encode(input:Vec<u32>)->Result<Vec<u8>,B16EncodeError>{
263 let length_input=input.len();
264 let mut vector=Vec::<u8>::with_capacity(length_input<<3);
265 unsafe{
266 vector.set_len(length_input<<3);
267 encode_4(input.as_ptr(),length_input,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
268 }
269 return Ok(vector);
270 }
271}
272
273impl B16Encode<Vec<i32>,String,B16EncodeError> for B16<String>{
274 fn encode(input:Vec<i32>)->Result<String,B16EncodeError>{
275 let length_input=input.len();
276 let mut string=String::with_capacity(length_input<<3);
277 unsafe{
278 let vector=&mut string.as_mut_vec();
279 vector.set_len(length_input<<3);
280 encode_4(input.as_ptr() as *const u32,length_input,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
281 }
282 return Ok(string);
283 }
284}
285
286impl B16Encode<Vec<i32>,Vec<u8>,B16EncodeError> for B16<Vec<u8>>{
287 fn encode(input:Vec<i32>)->Result<Vec<u8>,B16EncodeError>{
288 let length_input=input.len();
289 let mut vector=Vec::<u8>::with_capacity(length_input<<3);
290 unsafe{
291 vector.set_len(length_input<<3);
292 encode_4(input.as_ptr() as *const u32,length_input,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
293 }
294 return Ok(vector);
295 }
296}
297
298impl B16Encode<Vec<u16>,String,B16EncodeError> for B16<String>{
299 fn encode(input:Vec<u16>)->Result<String,B16EncodeError>{
300 let length_input=input.len();
301 let mut string=String::with_capacity(length_input<<2);
302 unsafe{
303 let vector=&mut string.as_mut_vec();
304 vector.set_len(length_input<<2);
305 encode_2(input.as_ptr(),length_input,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
306 }
307 return Ok(string);
308 }
309}
310
311impl B16Encode<Vec<u16>,Vec<u8>,B16EncodeError> for B16<Vec<u8>>{
312 fn encode(input:Vec<u16>)->Result<Vec<u8>,B16EncodeError>{
313 let length_input=input.len();
314 let mut vector=Vec::<u8>::with_capacity(length_input<<2);
315 unsafe{
316 vector.set_len(length_input<<2);
317 encode_2(input.as_ptr(),length_input,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
318 }
319 return Ok(vector);
320 }
321}
322
323impl B16Encode<Vec<i16>,String,B16EncodeError> for B16<String>{
324 fn encode(input:Vec<i16>)->Result<String,B16EncodeError>{
325 let length_input=input.len();
326 let mut string=String::with_capacity(length_input<<2);
327 unsafe{
328 let vector=&mut string.as_mut_vec();
329 vector.set_len(length_input<<2);
330 encode_2(input.as_ptr() as *const u16,length_input,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
331 }
332 return Ok(string);
333 }
334}
335
336impl B16Encode<Vec<i16>,Vec<u8>,B16EncodeError> for B16<Vec<u8>>{
337 fn encode(input:Vec<i16>)->Result<Vec<u8>,B16EncodeError>{
338 let length_input=input.len();
339 let mut vector=Vec::<u8>::with_capacity(length_input<<2);
340 unsafe{
341 vector.set_len(length_input<<2);
342 encode_2(input.as_ptr() as *const u16,length_input,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
343 }
344 return Ok(vector);
345 }
346}
347
348impl B16Encode<Vec<u8>,String,B16EncodeError> for B16<String>{
349 fn encode(input:Vec<u8>)->Result<String,B16EncodeError>{
350 let length_input=input.len();
351 let mut string=String::with_capacity(length_input<<1);
352 unsafe{
353 let vector=&mut string.as_mut_vec();
354 vector.set_len(length_input<<1);
355 encode_1(input.as_ptr(),length_input,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
356 }
357 return Ok(string);
358 }
359}
360
361impl B16Encode<Vec<u8>,Vec<u8>,B16EncodeError> for B16<Vec<u8>>{
362 fn encode(input:Vec<u8>)->Result<Vec<u8>,B16EncodeError>{
363 let length_input=input.len();
364 let mut vector=Vec::<u8>::with_capacity(length_input<<1);
365 unsafe{
366 vector.set_len(length_input<<1);
367 encode_1(input.as_ptr(),length_input,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
368 }
369 return Ok(vector);
370 }
371}
372
373impl B16Encode<Vec<i8>,String,B16EncodeError> for B16<String>{
374 fn encode(input:Vec<i8>)->Result<String,B16EncodeError>{
375 let length_input=input.len();
376 let mut string=String::with_capacity(length_input<<1);
377 unsafe{
378 let vector=&mut string.as_mut_vec();
379 vector.set_len(length_input<<1);
380 encode_1(input.as_ptr() as *const u8,length_input,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
381 }
382 return Ok(string);
383 }
384}
385
386impl B16Encode<Vec<i8>,Vec<u8>,B16EncodeError> for B16<Vec<u8>>{
387 fn encode(input:Vec<i8>)->Result<Vec<u8>,B16EncodeError>{
388 let length_input=input.len();
389 let mut vector=Vec::<u8>::with_capacity(length_input<<1);
390 unsafe{
391 vector.set_len(length_input<<1);
392 encode_1(input.as_ptr() as *const u8,length_input,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
393 }
394 return Ok(vector);
395 }
396}
397
398impl B16Encode<u8,String,B16EncodeError> for B16<String>{
399 fn encode(input:u8)->Result<String,B16EncodeError>{
400 let mut string=String::with_capacity(2);
401 unsafe{
402 let vector=&mut string.as_mut_vec();
403 vector.set_len(2);
404 encode_1(&input as *const u8,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
405 }
406 return Ok(string);
407 }
408}
409
410impl B16Encode<u8,Vec<u8>,B16EncodeError> for B16<Vec<u8>>{
411 fn encode(input:u8)->Result<Vec<u8>,B16EncodeError>{
412 let mut vector=Vec::<u8>::with_capacity(2);
413 unsafe{
414 vector.set_len(2);
415 encode_1(&input as *const u8,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
416 }
417 return Ok(vector);
418 }
419}
420
421impl<'a> B16Encode<&'a u8,String,B16EncodeError> for B16<String>{
422 fn encode(input:&'a u8)->Result<String,B16EncodeError>{
423 let mut string=String::with_capacity(2);
424 unsafe{
425 let vector=&mut string.as_mut_vec();
426 vector.set_len(2);
427 encode_1(input as *const u8,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
428 }
429 return Ok(string);
430 }
431}
432
433impl<'a> B16Encode<&'a u8,Vec<u8>,B16EncodeError> for B16<Vec<u8>>{
434 fn encode(input:&'a u8)->Result<Vec<u8>,B16EncodeError>{
435 let mut vector=Vec::<u8>::with_capacity(2);
436 unsafe{
437 vector.set_len(2);
438 encode_1(input as *const u8,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
439 }
440 return Ok(vector);
441 }
442}
443
444impl B16Encode<i8,String,B16EncodeError> for B16<String>{
445 fn encode(input:i8)->Result<String,B16EncodeError>{
446 let mut string=String::with_capacity(2);
447 unsafe{
448 let vector=&mut string.as_mut_vec();
449 vector.set_len(2);
450 encode_1((&input as *const i8) as *const u8,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
451 }
452 return Ok(string);
453 }
454}
455
456impl B16Encode<i8,Vec<u8>,B16EncodeError> for B16<Vec<u8>>{
457 fn encode(input:i8)->Result<Vec<u8>,B16EncodeError>{
458 let mut vector=Vec::<u8>::with_capacity(2);
459 unsafe{
460 vector.set_len(2);
461 encode_1((&input as *const i8) as *const u8,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
462 }
463 return Ok(vector);
464 }
465}
466
467impl<'a> B16Encode<&'a i8,String,B16EncodeError> for B16<String>{
468 fn encode(input:&'a i8)->Result<String,B16EncodeError>{
469 let mut string=String::with_capacity(2);
470 unsafe{
471 let vector=&mut string.as_mut_vec();
472 vector.set_len(2);
473 encode_1((input as *const i8) as *const u8,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
474 }
475 return Ok(string);
476 }
477}
478
479impl<'a> B16Encode<&'a i8,Vec<u8>,B16EncodeError> for B16<Vec<u8>>{
480 fn encode(input:&'a i8)->Result<Vec<u8>,B16EncodeError>{
481 let mut vector=Vec::<u8>::with_capacity(2);
482 unsafe{
483 vector.set_len(2);
484 encode_1((input as *const i8) as *const u8,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
485 }
486 return Ok(vector);
487 }
488}
489
490impl B16Encode<u16,String,B16EncodeError> for B16<String>{
491 fn encode(input:u16)->Result<String,B16EncodeError>{
492 let mut string=String::with_capacity(4);
493 unsafe{
494 let vector=&mut string.as_mut_vec();
495 vector.set_len(4);
496 encode_2(&input as *const u16,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
497 }
498 return Ok(string);
499 }
500}
501
502impl B16Encode<u16,Vec<u8>,B16EncodeError> for B16<Vec<u8>>{
503 fn encode(input:u16)->Result<Vec<u8>,B16EncodeError>{
504 let mut vector=Vec::<u8>::with_capacity(4);
505 unsafe{
506 vector.set_len(4);
507 encode_2(&input as *const u16,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
508 }
509 return Ok(vector);
510 }
511}
512
513impl<'a> B16Encode<&'a u16,String,B16EncodeError> for B16<String>{
514 fn encode(input:&'a u16)->Result<String,B16EncodeError>{
515 let mut string=String::with_capacity(4);
516 unsafe{
517 let vector=&mut string.as_mut_vec();
518 vector.set_len(4);
519 encode_2(input as *const u16,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
520 }
521 return Ok(string);
522 }
523}
524
525impl<'a> B16Encode<&'a u16,Vec<u8>,B16EncodeError> for B16<Vec<u8>>{
526 fn encode(input:&'a u16)->Result<Vec<u8>,B16EncodeError>{
527 let mut vector=Vec::<u8>::with_capacity(4);
528 unsafe{
529 vector.set_len(4);
530 encode_2(input as *const u16,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
531 }
532 return Ok(vector);
533 }
534}
535
536impl B16Encode<i16,String,B16EncodeError> for B16<String>{
537 fn encode(input:i16)->Result<String,B16EncodeError>{
538 let mut string=String::with_capacity(4);
539 unsafe{
540 let vector=&mut string.as_mut_vec();
541 vector.set_len(4);
542 encode_2((&input as *const i16) as *const u16,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
543 }
544 return Ok(string);
545 }
546}
547
548impl B16Encode<i16,Vec<u8>,B16EncodeError> for B16<Vec<u8>>{
549 fn encode(input:i16)->Result<Vec<u8>,B16EncodeError>{
550 let mut vector=Vec::<u8>::with_capacity(4);
551 unsafe{
552 vector.set_len(4);
553 encode_2((&input as *const i16) as *const u16,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
554 }
555 return Ok(vector);
556 }
557}
558
559impl<'a> B16Encode<&'a i16,String,B16EncodeError> for B16<String>{
560 fn encode(input:&'a i16)->Result<String,B16EncodeError>{
561 let mut string=String::with_capacity(4);
562 unsafe{
563 let vector=&mut string.as_mut_vec();
564 vector.set_len(4);
565 encode_2((input as *const i16) as *const u16,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
566 }
567 return Ok(string);
568 }
569}
570
571impl<'a> B16Encode<&'a i16,Vec<u8>,B16EncodeError> for B16<Vec<u8>>{
572 fn encode(input:&'a i16)->Result<Vec<u8>,B16EncodeError>{
573 let mut vector=Vec::<u8>::with_capacity(4);
574 unsafe{
575 vector.set_len(4);
576 encode_2((input as *const i16) as *const u16,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
577 }
578 return Ok(vector);
579 }
580}
581
582impl B16Encode<u32,String,B16EncodeError> for B16<String>{
583 fn encode(input:u32)->Result<String,B16EncodeError>{
584 let mut string=String::with_capacity(8);
585 unsafe{
586 let vector=&mut string.as_mut_vec();
587 vector.set_len(8);
588 encode_4(&input as *const u32,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
589 }
590 return Ok(string);
591 }
592}
593
594impl B16Encode<u32,Vec<u8>,B16EncodeError> for B16<Vec<u8>>{
595 fn encode(input:u32)->Result<Vec<u8>,B16EncodeError>{
596 let mut vector=Vec::<u8>::with_capacity(8);
597 unsafe{
598 vector.set_len(8);
599 encode_4(&input as *const u32,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
600 }
601 return Ok(vector);
602 }
603}
604
605impl<'a> B16Encode<&'a u32,String,B16EncodeError> for B16<String>{
606 fn encode(input:&'a u32)->Result<String,B16EncodeError>{
607 let mut string=String::with_capacity(8);
608 unsafe{
609 let vector=&mut string.as_mut_vec();
610 vector.set_len(8);
611 encode_4(input as *const u32,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
612 }
613 return Ok(string);
614 }
615}
616
617impl<'a> B16Encode<&'a u32,Vec<u8>,B16EncodeError> for B16<Vec<u8>>{
618 fn encode(input:&'a u32)->Result<Vec<u8>,B16EncodeError>{
619 let mut vector=Vec::<u8>::with_capacity(8);
620 unsafe{
621 vector.set_len(8);
622 encode_4(input as *const u32,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
623 }
624 return Ok(vector);
625 }
626}
627
628impl B16Encode<i32,String,B16EncodeError> for B16<String>{
629 fn encode(input:i32)->Result<String,B16EncodeError>{
630 let mut string=String::with_capacity(8);
631 unsafe{
632 let vector=&mut string.as_mut_vec();
633 vector.set_len(8);
634 encode_4((&input as * const i32) as *const u32,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
635 }
636 return Ok(string);
637 }
638}
639
640impl B16Encode<i32,Vec<u8>,B16EncodeError> for B16<Vec<u8>>{
641 fn encode(input:i32)->Result<Vec<u8>,B16EncodeError>{
642 let mut vector=Vec::<u8>::with_capacity(8);
643 unsafe{
644 vector.set_len(8);
645 encode_4((&input as * const i32) as *const u32,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
646 }
647 return Ok(vector);
648 }
649}
650
651impl<'a> B16Encode<&'a i32,String,B16EncodeError> for B16<String>{
652 fn encode(input:&'a i32)->Result<String,B16EncodeError>{
653 let mut string=String::with_capacity(8);
654 unsafe{
655 let vector=&mut string.as_mut_vec();
656 vector.set_len(8);
657 encode_4((input as * const i32) as *const u32,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
658 }
659 return Ok(string);
660 }
661}
662
663impl<'a> B16Encode<&'a i32,Vec<u8>,B16EncodeError> for B16<Vec<u8>>{
664 fn encode(input:&'a i32)->Result<Vec<u8>,B16EncodeError>{
665 let mut vector=Vec::<u8>::with_capacity(8);
666 unsafe{
667 vector.set_len(8);
668 encode_4((input as * const i32) as *const u32,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
669 }
670 return Ok(vector);
671 }
672}
673
674impl B16Encode<u64,String,B16EncodeError> for B16<String>{
675 fn encode(input:u64)->Result<String,B16EncodeError>{
676 let mut string=String::with_capacity(16);
677 unsafe{
678 let vector=&mut string.as_mut_vec();
679 vector.set_len(16);
680 encode_8(&input as *const u64,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
681 }
682 return Ok(string);
683 }
684}
685
686impl B16Encode<u64,Vec<u8>,B16EncodeError> for B16<Vec<u8>>{
687 fn encode(input:u64)->Result<Vec<u8>,B16EncodeError>{
688 let mut vector=Vec::<u8>::with_capacity(16);
689 unsafe{
690 vector.set_len(16);
691 encode_8(&input as *const u64,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
692 }
693 return Ok(vector);
694 }
695}
696
697impl<'a> B16Encode<&'a u64,String,B16EncodeError> for B16<String>{
698 fn encode(input:&'a u64)->Result<String,B16EncodeError>{
699 let mut string=String::with_capacity(16);
700 unsafe{
701 let vector=&mut string.as_mut_vec();
702 vector.set_len(16);
703 encode_8(input as *const u64,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
704 }
705 return Ok(string);
706 }
707}
708
709impl<'a> B16Encode<&'a u64,Vec<u8>,B16EncodeError> for B16<Vec<u8>>{
710 fn encode(input:&'a u64)->Result<Vec<u8>,B16EncodeError>{
711 let mut vector=Vec::<u8>::with_capacity(16);
712 unsafe{
713 vector.set_len(16);
714 encode_8(input as *const u64,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
715 }
716 return Ok(vector);
717 }
718}
719
720impl B16Encode<i64,String,B16EncodeError> for B16<String>{
721 fn encode(input:i64)->Result<String,B16EncodeError>{
722 let mut string=String::with_capacity(16);
723 unsafe{
724 let vector=&mut string.as_mut_vec();
725 vector.set_len(16);
726 encode_8((&input as *const i64) as *const u64,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
727 }
728 return Ok(string);
729 }
730}
731
732impl B16Encode<i64,Vec<u8>,B16EncodeError> for B16<Vec<u8>>{
733 fn encode(input:i64)->Result<Vec<u8>,B16EncodeError>{
734 let mut vector=Vec::<u8>::with_capacity(16);
735 unsafe{
736 vector.set_len(16);
737 encode_8((&input as *const i64) as *const u64,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
738 }
739 return Ok(vector);
740 }
741}
742
743impl<'a> B16Encode<&'a i64,String,B16EncodeError> for B16<Vec<u8>>{
744 fn encode(input:&'a i64)->Result<String,B16EncodeError>{
745 let mut string=String::with_capacity(16);
746 unsafe{
747 let vector=&mut string.as_mut_vec();
748 vector.set_len(16);
749 encode_8((input as *const i64) as *const u64,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
750 }
751 return Ok(string);
752 }
753}
754
755impl<'a> B16Encode<&'a i64,Vec<u8>,B16EncodeError> for B16<Vec<u8>>{
756 fn encode(input:&'a i64)->Result<Vec<u8>,B16EncodeError>{
757 let mut vector=Vec::<u8>::with_capacity(16);
758 unsafe{
759 vector.set_len(16);
760 encode_8((input as *const i64) as *const u64,1,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
761 }
762 return Ok(vector);
763 }
764}
765
766impl B16Encode<String,String,B16EncodeError> for B16<String>{
767 fn encode(input:String)->Result<String,B16EncodeError>{
768 let bytes=input.into_bytes();
769 let length_bytes=bytes.len();
770 let mut string=String::with_capacity(length_bytes<<1);
771 unsafe{
772 let vector=&mut string.as_mut_vec();
773 vector.set_len(length_bytes<<1);
774 encode_1(bytes.as_ptr(),length_bytes,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
775 }
776 return Ok(string);
777 }
778}
779
780impl B16Encode<String,Vec<u8>,B16EncodeError> for B16<Vec<u8>>{
781 fn encode(input:String)->Result<Vec<u8>,B16EncodeError>{
782 let bytes=input.into_bytes();
783 let length_bytes=bytes.len();
784 let mut vector=Vec::<u8>::with_capacity(length_bytes<<1);
785 unsafe{
786 vector.set_len(length_bytes<<1);
787 encode_1(bytes.as_ptr(),length_bytes,ALPHABET16_ENCODE.as_ptr(),vector.as_mut_ptr());
788 }
789 return Ok(vector);
790 }
791}
792
793impl B16Encode<fs::File,String,B16EncodeError> for B16<String>{
794 fn encode(mut input:fs::File)->Result<String,B16EncodeError>{
795 let metadata = match input.metadata(){
796 Ok(m) => m,
797 Err(e) => return Err(B16EncodeError::IOError(e))
798 };
799 let length_input=metadata.len() as usize;
800 let mut string=String::with_capacity(length_input<<1);
801 unsafe{
802 let ptr_alphabet=ALPHABET16_ENCODE.as_ptr();
803 let vector=&mut string.as_mut_vec();
804 vector.set_len(length_input<<1);
805 let mut ptr_vector=vector.as_mut_ptr();
806 let mut buffer=[0u8;4096];
807 let ptr_buffer=buffer.as_ptr();
808 let mut num = match input.read(&mut buffer){
809 Ok(n) => n,
810 Err(e) => return Err(B16EncodeError::IOError(e))
811 };
812 while num>0{
813 encode_1(ptr_buffer,num,ptr_alphabet,ptr_vector);
814 num = match input.read(&mut buffer){
815 Ok(n) => {
816 ptr_vector=ptr_vector.offset((num<<1) as isize);
817 n
818 },
819 Err(e) => return Err(B16EncodeError::IOError(e))
820 };
821 }
822 }
823 return Ok(string);
824 }
825}
826
827impl B16Encode<fs::File,Vec<u8>,B16EncodeError> for B16<Vec<u8>>{
828 fn encode(mut input:fs::File)->Result<Vec<u8>,B16EncodeError>{
829 let metadata = match input.metadata(){
830 Ok(m)=>m,
831 Err(e)=>return Err(B16EncodeError::IOError(e))
832 };
833 let length_input=metadata.len() as usize;
834 let mut vector=Vec::<u8>::with_capacity(length_input<<1);
835 unsafe{
836 let ptr_alphabet=ALPHABET16_ENCODE.as_ptr();
837 vector.set_len(length_input<<1);
838 let mut ptr_vector=vector.as_mut_ptr();
839 let mut buffer=[0u8;4096];
840 let ptr_buffer=buffer.as_ptr();
841 let mut num = match input.read(&mut buffer){
842 Ok(n)=>n,
843 Err(e)=>return Err(B16EncodeError::IOError(e))
844 };
845 while num>0{
846 encode_1(ptr_buffer,num,ptr_alphabet,ptr_vector);
847 num = match input.read(&mut buffer){
848 Ok(n)=>{
849 ptr_vector=ptr_vector.offset((num<<1) as isize);
850 n
851 },
852 Err(e)=>return Err(B16EncodeError::IOError(e))
853 };
854 }
855 }
856 return Ok(vector);
857 }
858}