use crate::error::Error;
use crate::head::{Major, Simple, write_head};
#[derive(Debug)]
pub struct Encoder<'b> {
pub(crate) buf: &'b mut [u8],
pub(crate) pos: usize,
#[cfg(feature = "indefinite")]
pub(crate) indef: [u8; 16],
#[cfg(feature = "indefinite")]
pub(crate) indef_sp: u8,
}
impl<'b> Encoder<'b> {
#[inline]
#[must_use]
pub const fn new(buf: &'b mut [u8]) -> Self {
{
#[cfg(feature = "indefinite")]
let this = Self { buf, pos: 0, indef: [0; 16], indef_sp: 0 };
#[cfg(not(feature = "indefinite"))]
let this = Self { buf, pos: 0 };
this
}
}
#[inline]
#[must_use]
pub const fn written(&self) -> usize {
self.pos
}
#[inline]
#[must_use]
pub const fn remaining(&self) -> usize {
self.buf.len() - self.pos
}
#[inline]
#[must_use]
pub const fn finish(self) -> (&'b [u8], usize) {
(self.buf, self.pos)
}
#[inline]
pub(crate) const fn reserve(&self, n: usize) -> Result<(), Error> {
match n > self.remaining() {
true => Err(Error::OUT_OF_SPACE),
false => Ok(()),
}
}
#[inline]
pub(crate) fn put_head(&mut self, major: Major, arg: u64) -> Result<(), Error> {
let n = write_head(self.tail(), major, arg)?;
self.pos += n;
Ok(())
}
#[inline]
fn tail(&mut self) -> &mut [u8] {
&mut self.buf[self.pos..]
}
#[inline]
pub(crate) fn put_payload(&mut self, major: Major, payload: &[u8]) -> Result<&mut Self, Error> {
let len = u64::try_from(payload.len()).map_err(|_| Error::OUT_OF_SPACE)?;
self.reserve(crate::head::head_len(len) + payload.len())?;
let head = crate::head::head_len(len);
let _ = write_head(self.tail(), major, len)?;
self.pos += head;
self.copy_payload(payload);
Ok(self)
}
#[inline]
fn copy_payload(&mut self, payload: &[u8]) {
let end = self.pos + payload.len();
self.buf[self.pos..end].copy_from_slice(payload);
self.pos = end;
}
#[inline]
pub fn uint(&mut self, v: u64) -> Result<&mut Self, Error> {
self.put_head(Major::Unsigned, v)?;
Ok(self)
}
#[inline]
pub fn nint(&mut self, n: u64) -> Result<&mut Self, Error> {
self.put_head(Major::Negative, n)?;
Ok(self)
}
#[inline]
pub fn i64(&mut self, v: i64) -> Result<&mut Self, Error> {
match v >= 0 {
true => self.uint(v as u64),
false => self.nint(!(v as u64)),
}
}
#[inline]
pub fn u8(&mut self, v: u8) -> Result<&mut Self, Error> {
self.uint(u64::from(v))
}
#[inline]
pub fn u16(&mut self, v: u16) -> Result<&mut Self, Error> {
self.uint(u64::from(v))
}
#[inline]
pub fn u32(&mut self, v: u32) -> Result<&mut Self, Error> {
self.uint(u64::from(v))
}
#[inline]
pub fn u64(&mut self, v: u64) -> Result<&mut Self, Error> {
self.uint(v)
}
#[inline]
pub fn i8(&mut self, v: i8) -> Result<&mut Self, Error> {
self.i64(i64::from(v))
}
#[inline]
pub fn i16(&mut self, v: i16) -> Result<&mut Self, Error> {
self.i64(i64::from(v))
}
#[inline]
pub fn i32(&mut self, v: i32) -> Result<&mut Self, Error> {
self.i64(i64::from(v))
}
#[inline]
pub fn bytes(&mut self, b: &[u8]) -> Result<&mut Self, Error> {
self.put_payload(Major::Bytes, b)
}
#[inline]
pub fn str(&mut self, s: &str) -> Result<&mut Self, Error> {
self.put_payload(Major::Text, s.as_bytes())
}
#[inline]
pub fn bool(&mut self, v: bool) -> Result<&mut Self, Error> {
self.simple(match v {
true => Simple::TRUE,
false => Simple::FALSE,
})
}
#[inline]
pub fn null(&mut self) -> Result<&mut Self, Error> {
self.simple(Simple::NULL)
}
#[inline]
pub fn undefined(&mut self) -> Result<&mut Self, Error> {
self.simple(Simple::UNDEFINED)
}
#[inline]
pub fn simple(&mut self, s: Simple) -> Result<&mut Self, Error> {
match s.0 < 24 || s.valid_two_byte() {
true => {
self.put_head(Major::Simple, u64::from(s.0))?;
Ok(self)
}
false => Err(Error::INVALID_SIMPLE),
}
}
#[inline]
pub fn tag(&mut self, number: u64) -> Result<&mut Self, Error> {
self.put_head(Major::Tag, number)?;
Ok(self)
}
#[inline]
pub fn array_len(&mut self, len: usize) -> Result<&mut Self, Error> {
match u64::try_from(len) {
Ok(n) => self.put_head(Major::Array, n)?,
Err(_) => return Err(Error::OUT_OF_SPACE),
}
Ok(self)
}
#[inline]
pub fn map_len(&mut self, pairs: usize) -> Result<&mut Self, Error> {
match u64::try_from(pairs) {
Ok(n) => self.put_head(Major::Map, n)?,
Err(_) => return Err(Error::OUT_OF_SPACE),
}
Ok(self)
}
}
#[cfg(feature = "float")]
mod float_impls {
use super::{Encoder, Error};
use crate::float::{f16_bits_of, f32_of_f16_bits};
use crate::head::write_head_exact;
impl Encoder<'_> {
pub fn f32(&mut self, v: f32) -> Result<&mut Self, Error> {
match f16_bits_of(v) {
Some(half) => self.float_exact(u64::from(half), 25),
None => self.float_exact(u64::from(v.to_bits()), 26),
}
}
pub fn f64(&mut self, v: f64) -> Result<&mut Self, Error> {
if v.is_nan() {
return self.float_exact(0x7e00, 25);
}
if let Some(half) = f16_bits_of(v as f32)
&& f64::from(f32_of_f16_bits(half)) == v
{
return self.float_exact(u64::from(half), 25);
}
if f64::from(v as f32) == v {
return self.float_exact(u64::from((v as f32).to_bits()), 26);
}
self.float_exact(v.to_bits(), 27)
}
pub fn f16(&mut self, v: f32) -> Result<&mut Self, Error> {
let half = f16_bits_of(v).unwrap_or(0x7e00);
self.float_exact(u64::from(half), 25)
}
#[inline]
fn float_exact(&mut self, bits: u64, ai: u8) -> Result<&mut Self, Error> {
let n = write_head_exact(self.tail(), bits, ai)?;
self.pos += n;
Ok(self)
}
}
}
pub mod consts {
use crate::error::Error;
use crate::head::{Major, write_head};
#[inline]
#[must_use]
pub const fn uint_len(v: u64) -> usize {
crate::head::uint_len(v)
}
#[inline]
#[must_use]
pub const fn i64_len(v: i64) -> usize {
match v >= 0 {
true => uint_len(v as u64),
false => uint_len(!(v as u64)),
}
}
#[inline]
#[must_use]
pub const fn chunk_len(payload_len: usize) -> usize {
uint_len(payload_len as u64) + payload_len
}
#[inline]
#[must_use]
pub const fn put_u64(buf: &mut [u8], v: u64) -> usize {
expect(write_head(buf, Major::Unsigned, v))
}
#[inline]
#[must_use]
pub const fn put_i64(buf: &mut [u8], v: i64) -> usize {
match v >= 0 {
true => put_u64(buf, v as u64),
false => expect(write_head(buf, Major::Negative, !(v as u64))),
}
}
#[inline]
const fn expect(r: Result<usize, Error>) -> usize {
match r {
Ok(n) => n,
Err(_) => panic!("const-cbor: output buffer too small"),
}
}
}
#[cfg(test)]
mod tests {
use super::Encoder;
use super::consts::{chunk_len, i64_len, put_i64, put_u64, uint_len};
use crate::Error;
#[test]
fn integers_preferred_widths() {
let mut b = [0u8; 20];
let mut e = Encoder::new(&mut b);
e.u8(23).unwrap().u8(24).unwrap().u32(1000).unwrap();
e.u64(1_000_000).unwrap().u64(u64::MAX).unwrap();
assert_eq!(e.written(), 20, "1 + 2 + 3 + 5 + 9 bytes expected");
assert_eq!(
&b,
&[
0x17, 0x18, 0x18, 0x19, 0x03, 0xe8, 0x1a, 0x00, 0x0f, 0x42, 0x40, 0x1b, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
]
);
}
#[test]
fn negative_mapping_rfc_examples() {
let cases: [(i64, &[u8]); 4] =
[(-1, &[0x20]), (-10, &[0x29]), (-100, &[0x38, 0x63]), (-1000, &[0x39, 0x03, 0xe7])];
for (v, want) in cases {
let mut b = [0u8; 9];
let mut e = Encoder::new(&mut b);
e.i64(v).unwrap();
let n = e.written();
assert_eq!(&b[..n], want);
}
let mut b = [0u8; 9];
let mut e = Encoder::new(&mut b);
e.i64(i64::MIN).unwrap();
assert_eq!(e.written(), 9);
let mut b2 = [0u8; 9];
let mut e2 = Encoder::new(&mut b2);
e2.nint(u64::MAX).unwrap();
assert_eq!(e2.written(), 9);
}
#[test]
fn strings_and_bytes() {
let mut b = [0u8; 32];
let mut e = Encoder::new(&mut b);
e.str("hello").unwrap().bytes(&[1, 2, 3]).unwrap();
assert_eq!(e.written(), 6 + 4);
assert_eq!(&b[..6], &[0x65, b'h', b'e', b'l', b'l', b'o']);
}
#[test]
fn headers_and_tags() {
let mut b = [0u8; 16];
let mut e = Encoder::new(&mut b);
e.array_len(3).unwrap().map_len(2).unwrap().tag(1).unwrap().u32(1).unwrap();
assert_eq!(e.written(), 4);
assert_eq!(&b[..4], &[0x83, 0xa2, 0xc1, 0x01]);
}
#[test]
fn simple_values() {
let mut b = [0u8; 4];
let mut e = Encoder::new(&mut b);
e.bool(true).unwrap().null().unwrap();
assert!(e.simple(crate::Simple(31)).is_err_and(|err| err == Error::INVALID_SIMPLE));
assert!(e.simple(crate::Simple(99)).is_ok());
let Encoder { buf, .. } = e;
let _ = buf;
assert_eq!(&b, &[0xf5, 0xf6, 0xf8, 99]);
}
#[test]
fn out_of_space_preserves_cursor() {
let mut b = [0u8; 3];
let mut e = Encoder::new(&mut b);
e.u8(7).unwrap();
assert!(e.str("toolong").is_err_and(|err| err == Error::OUT_OF_SPACE));
assert_eq!(e.written(), 1);
}
#[test]
fn const_helpers_match_runtime() {
assert_eq!(uint_len(23), 1);
assert_eq!(i64_len(-1000), 3);
assert_eq!(chunk_len(300), 303);
let mut b = [0u8; 9];
let n = put_i64(&mut b, -1000);
assert_eq!(n, 3);
assert_eq!(put_u64(&mut b[n..], 0), 1);
}
}