sqlx-core 0.2.6

Core of SQLx, the rust SQL toolkit. Not intended to be used directly.
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
119
120
121
122
123
124
125
126

use byteorder::ByteOrder;
use memchr::memchr;
use std::{io, slice, str};

pub trait Buf {
    fn advance(&mut self, cnt: usize);

    fn get_uint<T: ByteOrder>(&mut self, n: usize) -> io::Result<u64>;

    fn get_u8(&mut self) -> io::Result<u8>;

    fn get_u16<T: ByteOrder>(&mut self) -> io::Result<u16>;

    fn get_i16<T: ByteOrder>(&mut self) -> io::Result<i16>;

    fn get_u24<T: ByteOrder>(&mut self) -> io::Result<u32>;

    fn get_i32<T: ByteOrder>(&mut self) -> io::Result<i32>;

    fn get_u32<T: ByteOrder>(&mut self) -> io::Result<u32>;

    fn get_u64<T: ByteOrder>(&mut self) -> io::Result<u64>;

    fn get_str(&mut self, len: usize) -> io::Result<&str>;

    fn get_str_nul(&mut self) -> io::Result<&str>;

    fn get_bytes(&mut self, len: usize) -> io::Result<&[u8]>;
}

impl<'a> Buf for &'a [u8] {
    fn advance(&mut self, cnt: usize) {
        *self = &self[cnt..];
    }

    fn get_uint<T: ByteOrder>(&mut self, n: usize) -> io::Result<u64> {
        let val = T::read_uint(*self, n);
        self.advance(n);

        Ok(val)
    }

    fn get_u8(&mut self) -> io::Result<u8> {
        let val = self[0];
        self.advance(1);

        Ok(val)
    }

    fn get_u16<T: ByteOrder>(&mut self) -> io::Result<u16> {
        let val = T::read_u16(*self);
        self.advance(2);

        Ok(val)
    }

    fn get_i16<T: ByteOrder>(&mut self) -> io::Result<i16> {
        let val = T::read_i16(*self);
        self.advance(2);

        Ok(val)
    }

    fn get_u24<T: ByteOrder>(&mut self) -> io::Result<u32> {
        let val = T::read_u24(*self);
        self.advance(3);

        Ok(val)
    }

    fn get_i32<T: ByteOrder>(&mut self) -> io::Result<i32> {
        let val = T::read_i32(*self);
        self.advance(4);

        Ok(val)
    }

    fn get_u32<T: ByteOrder>(&mut self) -> io::Result<u32> {
        let val = T::read_u32(*self);
        self.advance(4);

        Ok(val)
    }

    fn get_u64<T: ByteOrder>(&mut self) -> io::Result<u64> {
        let val = T::read_u64(*self);
        self.advance(8);

        Ok(val)
    }

    fn get_str(&mut self, len: usize) -> io::Result<&str> {
        str::from_utf8(self.get_bytes(len)?)
            .map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err))
    }

    fn get_str_nul(&mut self) -> io::Result<&str> {
        let len = memchr(b'\0', &*self).ok_or(io::ErrorKind::InvalidData)?;
        let s = &self.get_str(len + 1)?[..len];

        Ok(s)
    }

    fn get_bytes(&mut self, len: usize) -> io::Result<&[u8]> {
        let buf = &self[..len];
        self.advance(len);

        Ok(buf)
    }
}

pub trait ToBuf {
    fn to_buf(&self) -> &[u8];
}

impl ToBuf for [u8] {
    fn to_buf(&self) -> &[u8] {
        self
    }
}

impl ToBuf for u8 {
    fn to_buf(&self) -> &[u8] {
        slice::from_ref(self)
    }
}