tari_bor 0.13.0

The binary object representation (BOR) crate provides a binary encoding for template/engine data types
Documentation 
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

//   Copyright 2022 The Tari Project
//   SPDX-License-Identifier: BSD-3-Clause

#![cfg_attr(not(feature = "std"), no_std)]

#[cfg(not(feature = "std"))]
use alloc::{fmt, format, string::ToString, vec::Vec};

#[cfg(not(feature = "std"))]
extern crate alloc;

#[cfg(feature = "std")]
use std::fmt;

mod tag;
pub use tag::*;

mod byte_counter;
#[cfg(all(feature = "std", feature = "cbor_value_encoding_fix"))]
pub mod cbor_value_encoding_fix;
mod error;
mod walker;

pub use ciborium::{cbor, value::Value};
use ciborium::{de::from_reader, ser::into_writer};
pub use ciborium_io::{Read, Write};
pub use error::BorError;
pub use serde::{self, Deserialize, Serialize, de::DeserializeOwned};
pub use walker::*;

pub use crate::byte_counter::ByteCounter;

#[cfg(feature = "std")]
pub fn encode_into_writer<T, W>(val: &T, writer: &mut W) -> Result<(), BorError>
where
    T: Serialize + ?Sized,
    W: std::io::Write,
{
    into_writer(&val, writer).map_err(to_bor_error)
}

#[cfg(not(feature = "std"))]
pub fn encode_into_writer<T, W>(val: &T, writer: W) -> Result<(), BorError>
where
    T: Serialize + ?Sized,
    W: Write,
    W::Error: fmt::Debug,
{
    into_writer(&val, writer).map_err(to_bor_error)
}

pub fn encode<T: Serialize + ?Sized>(val: &T) -> Result<Vec<u8>, BorError> {
    let len = encoded_len(val)?;
    let mut buf = Vec::with_capacity(len);
    encode_into_writer(val, &mut buf)?;
    Ok(buf)
}

pub fn encoded_len<T: Serialize + ?Sized>(val: &T) -> Result<usize, BorError> {
    let mut counter = ByteCounter::new();
    encode_into_writer(val, &mut counter)?;
    Ok(counter.get())
}
pub fn encoded_len_with_limit<T: Serialize + ?Sized>(val: &T, limit: usize) -> Result<usize, BorError> {
    let mut counter = ByteCounter::with_limit(limit);
    encode_into_writer(val, &mut counter)?;
    Ok(counter.get())
}

/// Encodes any Rust type using CBOR
pub fn to_value<T: Serialize + ?Sized>(val: &T) -> Result<Value, BorError> {
    Value::serialized(val).map_err(to_bor_error)
}

pub fn from_value<T: DeserializeOwned>(val: &Value) -> Result<T, BorError> {
    Value::deserialized(val).map_err(to_bor_error)
}

pub fn decode<T: DeserializeOwned>(mut input: &[u8]) -> Result<T, BorError> {
    decode_inner(&mut input)
}

fn decode_inner<T: DeserializeOwned>(input: &mut &[u8]) -> Result<T, BorError> {
    let result = from_reader(input).map_err(to_bor_error)?;
    Ok(result)
}

pub fn decode_from_reader<T, R>(reader: R) -> Result<T, BorError>
where
    T: DeserializeOwned,
    R: Read,
    R::Error: fmt::Debug,
{
    let result = from_reader(reader).map_err(to_bor_error)?;
    Ok(result)
}

pub fn decode_exact<T: DeserializeOwned>(mut input: &[u8]) -> Result<T, BorError> {
    let val = decode_inner(&mut input)?;
    if !input.is_empty() {
        return Err(BorError::new(format!(
            "decode_exact: {} bytes remaining on input",
            input.len()
        )));
    }
    Ok(val)
}

fn to_bor_error<E>(e: E) -> BorError
where E: fmt::Display {
    BorError::new(e.to_string())
}