ion-rs 1.0.0

Implementation of Amazon Ion
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
113
114
115
116
117
118

use crate::lazy::binary::raw::v1_1::binary_buffer::BinaryBuffer;
use crate::lazy::streaming_raw_reader::IoBuffer;
use crate::lazy::text::buffer::TextBuffer;
use crate::result::IonFailure;
use crate::{HasRange, IonError, IonResult};
use std::ops::Range;

/// Represents a slice of input data.
///
/// Various items in the Reader API implement the [`HasSpan`](crate::lazy::decoder::HasSpan) trait,
/// allowing the byte slice that represented that item in the input by calling `span()`.
#[derive(Debug, Copy, Clone)]
pub struct Span<'a> {
    // The input bytes that represented the item implementing `HasSpan`.
    bytes: &'a [u8],
    // The offset in the overall stream at which the contents of `bytes` were found.
    offset: usize,
}

impl AsRef<[u8]> for Span<'_> {
    fn as_ref(&self) -> &[u8] {
        self.bytes()
    }
}

impl<'a> From<Span<'a>> for &'a [u8] {
    fn from(value: Span<'a>) -> Self {
        value.bytes
    }
}

impl<A: AsRef<[u8]>> PartialEq<A> for Span<'_> {
    fn eq(&self, other: &A) -> bool {
        self.bytes() == other.as_ref()
    }
}

impl<'a> Span<'a> {
    pub fn with_offset(offset: usize, bytes: &'a [u8]) -> Self {
        Self { bytes, offset }
    }

    pub fn offset(&self) -> usize {
        self.offset
    }

    pub fn range(&self) -> Range<usize> {
        self.offset..self.offset + self.bytes.len()
    }

    pub fn bytes(&self) -> &'a [u8] {
        self.bytes
    }

    pub fn text(&self) -> Option<&'a str> {
        self.expect_text().ok()
    }

    pub fn expect_text(&self) -> IonResult<&'a str> {
        std::str::from_utf8(self.bytes)
            .map_err(|_| IonError::decoding_error("span text was not valid UTF-8"))
    }

    pub fn len(&self) -> usize {
        self.bytes.len()
    }

    pub fn is_empty(&self) -> bool {
        self.bytes.is_empty()
    }

    pub fn slice(&self, offset: usize, length: usize) -> Span<'a> {
        Self {
            bytes: &self.bytes[offset..offset + length],
            offset: self.offset + offset,
        }
    }

    pub fn slice_to_end(&self, offset: usize) -> Span<'a> {
        Self {
            bytes: &self.bytes[offset..],
            offset: self.offset + offset,
        }
    }
}

impl HasRange for Span<'_> {
    fn range(&self) -> Range<usize> {
        self.offset..self.offset + self.bytes.len()
    }
}

impl<'a> From<BinaryBuffer<'a>> for Span<'a> {
    fn from(value: BinaryBuffer<'a>) -> Self {
        Span {
            bytes: value.bytes(),
            offset: value.offset(),
        }
    }
}

impl<'a> From<TextBuffer<'a>> for Span<'a> {
    fn from(value: TextBuffer<'a>) -> Self {
        Span {
            bytes: value.bytes(),
            offset: value.offset(),
        }
    }
}

impl<'a> From<&'a IoBuffer> for Span<'a> {
    fn from(value: &'a IoBuffer) -> Self {
        Span {
            bytes: value.remaining_bytes(),
            offset: value.stream_position(),
        }
    }
}