redis-protocol-mm 4.2.0

Structs and functions to implement the Redis protocol.
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
127
128
129
130
131
132
133
134
135
136
137
138

use bytes::buf::IntoIter;
use bytes::Bytes;
use nom::{AsBytes, FindSubstring, InputIter, InputLength, InputTake, Needed, Offset, Slice, UnspecializedInput};
use core::iter::Enumerate;
use core::ops::{Deref, DerefMut, Range, RangeFrom, RangeFull, RangeTo};
#[cfg(feature = "decode-logs")]
use core::str;

/// A wrapper type for `Bytes` that implements the Nom traits necessary to operate on Bytes slices directly with nom functions.
#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct NomBytes(Bytes);

impl NomBytes {
  pub fn into_bytes(self) -> Bytes {
    self.0
  }
}

impl From<Bytes> for NomBytes {
  fn from(buf: Bytes) -> Self {
    NomBytes(buf)
  }
}

impl<'a> From<&'a Bytes> for NomBytes {
  fn from(buf: &'a Bytes) -> Self {
    NomBytes(buf.clone())
  }
}

impl Deref for NomBytes {
  type Target = Bytes;

  fn deref(&self) -> &Self::Target {
    &self.0
  }
}

impl DerefMut for NomBytes {
  fn deref_mut(&mut self) -> &mut Self::Target {
    &mut self.0
  }
}

impl AsRef<NomBytes> for NomBytes {
  fn as_ref(&self) -> &NomBytes {
    &self
  }
}

impl InputTake for NomBytes {
  fn take(&self, count: usize) -> Self {
    // operate on a shallow copy and split off the bytes to create a new shallow window into the bytes
    self.0.clone().split_to(count).into()
  }

  fn take_split(&self, count: usize) -> (Self, Self) {
    let mut right = self.clone();
    let left = right.split_to(count);
    // i wish this was at least called out in the docs
    (right, left.into())
  }
}

impl InputLength for NomBytes {
  fn input_len(&self) -> usize {
    self.0.len()
  }
}

impl<'a> FindSubstring<&'a [u8]> for NomBytes {
  fn find_substring(&self, substr: &'a [u8]) -> Option<usize> {
    decode_log!(
      "FindSubstring in {:?}. Offset: {:?}, len: {}",
      str::from_utf8(&self).ok(),
      self.0.as_bytes().find_substring(substr),
      self.len()
    );
    self.0.as_bytes().find_substring(substr)
  }
}

impl UnspecializedInput for NomBytes {}

impl InputIter for NomBytes {
  type Item = u8;
  type Iter = Enumerate<Self::IterElem>;
  type IterElem = IntoIter<Bytes>;

  fn iter_indices(&self) -> Self::Iter {
    self.iter_elements().enumerate()
  }

  fn iter_elements(&self) -> Self::IterElem {
    self.0.clone().into_iter()
  }

  fn position<P>(&self, predicate: P) -> Option<usize>
  where
    P: Fn(Self::Item) -> bool,
  {
    self.0.as_bytes().position(predicate)
  }

  fn slice_index(&self, count: usize) -> Result<usize, Needed> {
    self.0.as_bytes().slice_index(count)
  }
}

impl Offset for NomBytes {
  fn offset(&self, second: &Self) -> usize {
    self.0.as_bytes().offset(second.0.as_bytes())
  }
}

impl Slice<Range<usize>> for NomBytes {
  fn slice(&self, range: Range<usize>) -> Self {
    self.0.slice(range).into()
  }
}

impl Slice<RangeTo<usize>> for NomBytes {
  fn slice(&self, range: RangeTo<usize>) -> Self {
    self.0.slice(0..range.end).into()
  }
}

impl Slice<RangeFrom<usize>> for NomBytes {
  fn slice(&self, range: RangeFrom<usize>) -> Self {
    self.0.slice(range.start..).into()
  }
}

impl Slice<RangeFull> for NomBytes {
  fn slice(&self, _: RangeFull) -> Self {
    self.clone()
  }
}