🏡 index : ~doyle/serde_bson.git

921419ff99ffd9681e0eecb9621f6f3d2918c47c [patch]

34fac0ac8be59150109fb177a5bca136acaec201

5fd130fdfa88accfb50a09b59702214621ca0eae

921419ff99ffd9681e0eecb9621f6f3d2918c47c.tar.gz

Implement support for tuples

Diff

 src/lib.rs |  2 ++
 src/ser.rs | 33 +++++++++++++++++++++++++++++----
 2 files changed, 31 insertions(+), 4 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 42461a1..5ee98d2 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -39,6 +39,7 @@ mod test {
            a: Vec<&'a str>,
            e: Test,
            e2: Test,
            t: (i32, i32, i32),
        }

        let test = &A {
@@ -50,6 +51,7 @@ mod test {
                a: vec!["yooo", "mayn"],
                e: Test::Abc,
                e2: Test::Def(1999),
                t: (16, 07, 1999),
            },
        };

diff --git a/src/ser.rs b/src/ser.rs
index 825db03..735bc24 100644
--- a/src/ser.rs
+++ b/src/ser.rs
@@ -1,6 +1,9 @@
use crate::Error;
use bytes::{BufMut, BytesMut};
use serde::{ser::SerializeStruct, Serialize};
use serde::{
    ser::{SerializeSeq, SerializeStruct},
    Serialize,
};
use std::convert::TryFrom;

pub struct Serializer<'a> {
@@ -25,7 +28,7 @@ impl<'a> serde::Serializer for Serializer<'a> {
    type Error = Error;

    type SerializeSeq = SeqSerializer<'a>;
    type SerializeTuple = serde::ser::Impossible<Self::Ok, Self::Error>;
    type SerializeTuple = TupleSerializer<'a>;
    type SerializeTupleStruct = serde::ser::Impossible<Self::Ok, Self::Error>;
    type SerializeTupleVariant = serde::ser::Impossible<Self::Ok, Self::Error>;
    type SerializeMap = serde::ser::Impossible<Self::Ok, Self::Error>;
@@ -193,8 +196,10 @@ impl<'a> serde::Serializer for Serializer<'a> {
        })
    }

    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
        todo!("tuple")
    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
        Ok(TupleSerializer {
            inner: self.serialize_seq(Some(len))?,
        })
    }

    fn serialize_tuple_struct(
@@ -247,6 +252,26 @@ impl<'a> serde::Serializer for Serializer<'a> {
    }
}

pub struct TupleSerializer<'a> {
    inner: SeqSerializer<'a>,
}

impl<'a> serde::ser::SerializeTuple for TupleSerializer<'a> {
    type Ok = ();
    type Error = <Serializer<'a> as serde::Serializer>::Error;

    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
    where
        T: Serialize,
    {
        self.inner.serialize_element(value)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        self.inner.end()
    }
}

pub struct SeqSerializer<'a> {
    original_output: &'a mut BytesMut,
    doc_output: BytesMut,