sark-json 0.21.0

Borrowed JSON decoding and streaming encoding for sark
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

use std::{mem, result};

use o3::{
    alloc,
    buffer::{segments, storage, write::consume},
    mem::rc,
};

mod bytes;
pub mod input;
mod nesting;
pub mod parsing;
pub mod segment;
mod source;
mod token;
pub mod writing;

pub use bytes::{
    Bytes,
    proofs::{Backing, Plain, PlainError, Raw, Text, TextValue},
};
pub(crate) use nesting::Nesting;
#[doc(hidden)]
pub use o3;
/// Derives decoding/encoding on nongeneric structs; `encode`/`try_encode` also accept generics.
/// `seq, nested` accepts `&Owner: IntoIterator` of owned/borrowed encoders; decoding requires `Vec<T>`.
/// Exact writes are checked independently of sizing, even if the owner changes between traversals.
pub use sark_gen::json;
#[doc(hidden)]
pub use sark_http;
pub use source::Source;
pub use token::Token;

#[derive(Debug)]
pub enum Error {
    Invalid,
    Depth,
    Token(consume::Error),
    Storage(Storage),
    Allocation(alloc::Error),
    Exhausted(alloc::Exhausted),
    Retain(rc::Error),
    InputLength {
        current: usize,
        add: usize,
    },
    InputSegments {
        current: segments::Count,
        add: segments::Count,
    },
    OutputLength(consume::Error),
}

#[derive(Debug)]
pub enum Storage {
    Capacity(consume::Error),
    Exhausted(alloc::Exhausted),
}

impl From<storage::AllocError> for Error {
    fn from(error: storage::AllocError) -> Self {
        Self::Storage(match error {
            storage::AllocError::Capacity(error) => Storage::Capacity(error),
            storage::AllocError::Exhausted(error) => Storage::Exhausted(error),
        })
    }
}

type Result<T> = result::Result<T, Error>;

const _: () = assert!(mem::size_of::<Error>() == mem::size_of::<usize>() * 3);