smol-bytes 0.1.5

High-performance, clone-efficient byte buffers optimized for small data.
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

use crate::{
  Utf8Buffer, Utf8BytesMut,
  bytes::{RawBytes, strategy::ImmutableStorage},
  utf8_bytes::Utf8Bytes,
};
use schemars::{JsonSchema, Schema, SchemaGenerator};
use std::borrow::Cow;

impl JsonSchema for Utf8Buffer {
  fn inline_schema() -> bool {
    <str as JsonSchema>::inline_schema()
  }

  fn schema_name() -> Cow<'static, str> {
    <str as JsonSchema>::schema_name()
  }

  fn schema_id() -> Cow<'static, str> {
    <str as JsonSchema>::schema_id()
  }

  fn json_schema(generator: &mut SchemaGenerator) -> Schema {
    <str as JsonSchema>::json_schema(generator)
  }
}

impl JsonSchema for Utf8BytesMut {
  fn inline_schema() -> bool {
    <str as JsonSchema>::inline_schema()
  }

  fn schema_name() -> Cow<'static, str> {
    <str as JsonSchema>::schema_name()
  }

  fn schema_id() -> Cow<'static, str> {
    <str as JsonSchema>::schema_id()
  }

  fn json_schema(generator: &mut SchemaGenerator) -> Schema {
    <str as JsonSchema>::json_schema(generator)
  }
}

impl<S> JsonSchema for Utf8Bytes<S>
where
  RawBytes<S>: ImmutableStorage,
{
  fn inline_schema() -> bool {
    <str as JsonSchema>::inline_schema()
  }

  fn schema_name() -> Cow<'static, str> {
    <str as JsonSchema>::schema_name()
  }

  fn schema_id() -> Cow<'static, str> {
    <str as JsonSchema>::schema_id()
  }

  fn json_schema(generator: &mut SchemaGenerator) -> Schema {
    <str as JsonSchema>::json_schema(generator)
  }
}

#[cfg(test)]
mod tests {
  use std::{collections::BTreeMap, string::String, vec::Vec};

  use schemars::schema_for;

  use crate::{Utf8Buffer, Utf8Bytes, Utf8BytesMut, compact};

  #[test]
  fn utf8_wrappers_have_string_schemas() {
    let string_schema = schema_for!(String);
    assert_eq!(schema_for!(Utf8Buffer), string_schema);
    assert_eq!(schema_for!(Utf8Bytes), string_schema);
    assert_eq!(schema_for!(compact::Utf8Bytes), string_schema);
    assert_eq!(schema_for!(Utf8BytesMut), string_schema);
  }

  #[test]
  fn utf8_bytes_containers_have_string_schemas() {
    assert_string_container_schemas::<Utf8Buffer>();
    assert_string_container_schemas::<Utf8Bytes>();
    assert_string_container_schemas::<compact::Utf8Bytes>();
    assert_string_container_schemas::<Utf8BytesMut>();
  }

  fn assert_string_container_schemas<T>()
  where
    T: schemars::JsonSchema + Ord,
  {
    assert_eq!(schema_for!(Option<T>), schema_for!(Option<String>));
    assert_eq!(schema_for!(Vec<T>), schema_for!(Vec<String>));
    assert_eq!(
      schema_for!(BTreeMap<T, T>),
      schema_for!(BTreeMap<String, String>)
    );
  }
}