smol-bytes 0.2.1

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
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

macro_rules! method_forward {
  ($repr:tt { $(
    $(#[$meta:meta])*
    fn $name:ident($( $arg:ident : $arg_ty:ty ),*) $(-> $ret:ty)?
  );+$(;)? }) => {
    $(
      $(#[$meta])*
      #[cfg_attr(not(coverage), inline(always))]
      fn $name(&mut self, $( $arg : $arg_ty ),*) $(-> $ret)? {
        match &mut self.$repr {
          Repr::Inline(buffer) => buffer.$name($( $arg ),*),
          Repr::Heap(bytes) => bytes.$name($( $arg ),*),
        }
      }
    )*
  };
  ($(
    $(#[$meta:meta])*
    fn $name:ident($($arg:ident : $arg_ty:ty ),*) $(-> $ret:ty)?
  );+$(;)?) => {
    $(
      $(#[$meta])*
      #[cfg_attr(not(coverage), inline(always))]
      fn $name(&mut self, $( $arg : $arg_ty ),*) $(-> $ret)? {
        Self::$name(self, $( $arg ),*)
      }
    )*
  };
}

macro_rules! forward_buf_mut {
  ($repr:tt { $($suffix:ident), +$(,)? }) => {
    paste::paste! {
      $(
        $crate::macros::method_forward! { $repr {
          fn [< put_ $suffix >](val: $suffix);
          fn [< put_ $suffix _le >](val: $suffix);
          fn [< put_ $suffix _ne >](val: $suffix);
        }}
      )*

      $crate::macros::method_forward! {$repr {
        fn put_i8(val: i8);
        fn put_u8(val: u8);

        fn put_uint(n: u64, nbytes: usize);
        fn put_uint_le(n: u64, nbytes: usize);
        fn put_uint_ne(n: u64, nbytes: usize);
        fn put_int(n: i64, nbytes: usize);
        fn put_int_le(n: i64, nbytes: usize);
        fn put_int_ne(n: i64, nbytes: usize);
      }}
    }
  };
  ($($suffix:ident), +$(,)?) => {
    paste::paste! {
      $(
        $crate::macros::method_forward! {
          fn [< put_ $suffix >](val: $suffix);
          fn [< put_ $suffix _le >](val: $suffix);
          fn [< put_ $suffix _ne >](val: $suffix);
        }
      )*

      $crate::macros::method_forward! {
        fn put_i8(val: i8);
        fn put_u8(val: u8);

        fn put_uint(n: u64, nbytes: usize);
        fn put_uint_le(n: u64, nbytes: usize);
        fn put_uint_ne(n: u64, nbytes: usize);

        fn put_int(n: i64, nbytes: usize);
        fn put_int_le(n: i64, nbytes: usize);
        fn put_int_ne(n: i64, nbytes: usize);
      }
    }
  };
}

pub(super) use forward_buf_mut;
pub(super) use method_forward;

/// Formats arguments into the default shared [`Utf8Bytes`](crate::Utf8Bytes).
///
/// This is similar to `format!`, but returns a value that retains heap storage
/// when later shortened. Use `format_compact_utf8bytes!` when short results
/// should use inline storage.
///
/// # Examples
///
/// ```
/// use smol_bytes::{format_utf8bytes, Utf8Bytes};
///
/// let name = "Ada";
/// let greeting: Utf8Bytes = format_utf8bytes!("hello, {name}!");
/// assert_eq!(greeting.as_str(), "hello, Ada!");
/// ```
#[macro_export]
macro_rules! format_utf8bytes {
  ($($tt:tt)*) => {{
    let mut value = $crate::Utf8BytesMut::new();
    ::core::fmt::Write::write_fmt(&mut value, ::core::format_args!($($tt)*))
      .expect("a formatting trait implementation returned an error");
    value.freeze_shared()
  }};
}

/// Formats arguments into compact [`Utf8Bytes`](crate::compact::Utf8Bytes).
///
/// This is similar to `format!`, but returns a value that uses inline storage
/// when its contents fit, including after a larger value is later shortened.
/// Use `format_utf8bytes!` when retaining heap storage after shrinking is preferred.
///
/// # Examples
///
/// ```
/// use smol_bytes::{compact, format_compact_utf8bytes};
///
/// let name = "Ada";
/// let greeting: compact::Utf8Bytes = format_compact_utf8bytes!("hello, {name}!");
/// assert_eq!(greeting.as_str(), "hello, Ada!");
/// ```
#[macro_export]
macro_rules! format_compact_utf8bytes {
  ($($tt:tt)*) => {{
    let mut value = $crate::Utf8BytesMut::new();
    ::core::fmt::Write::write_fmt(&mut value, ::core::format_args!($($tt)*))
      .expect("a formatting trait implementation returned an error");
    value.freeze_compact()
  }};
}