ser: list and set

Author: muzarski

scylla-rust-wrapper/src/value.rs

@@ -1,12 +1,12 @@
-use std::net::IpAddr;
+use std::{convert::TryInto, net::IpAddr};
 
 use scylla::{
     frame::{response::result::ColumnType, value::CqlDate},
     serialize::{
         value::{
             BuiltinSerializationError, BuiltinSerializationErrorKind, BuiltinTypeCheckError,
-            BuiltinTypeCheckErrorKind, SerializeCql, TupleSerializationErrorKind,
-            TupleTypeCheckErrorKind,
+            BuiltinTypeCheckErrorKind, SerializeCql, SetOrListSerializationErrorKind,
+            SetOrListTypeCheckErrorKind, TupleSerializationErrorKind, TupleTypeCheckErrorKind,
         },
         writers::WrittenCellProof,
         CellWriter, SerializationError,
@@ -98,9 +98,9 @@ impl SerializeCql for CassCqlValue {
                 };
                 serialize_tuple_like(typ, fields.iter(), t.iter(), writer)
             }
-            CassCqlValue::List(_) => todo!(),
+            CassCqlValue::List(l) => serialize_sequence(l.len(), l.iter(), typ, writer),
             CassCqlValue::Map(_) => todo!(),
-            CassCqlValue::Set(_) => todo!(),
+            CassCqlValue::Set(s) => serialize_sequence(s.len(), s.iter(), typ, writer),
             CassCqlValue::UserDefinedType {
                 keyspace,
                 type_name,
@@ -261,3 +261,48 @@ fn serialize_tuple_like<'t, 'b>(
         .finish()
         .map_err(|_| mk_ser_err::<CassCqlValue>(typ, BuiltinSerializationErrorKind::SizeOverflow))
 }
+
+fn serialize_sequence<'t, 'b, T: SerializeCql + 't>(
+    len: usize,
+    iter: impl Iterator<Item = &'t T>,
+    typ: &ColumnType,
+    writer: CellWriter<'b>,
+) -> Result<WrittenCellProof<'b>, SerializationError> {
+    let rust_name = std::any::type_name::<CassCqlValue>();
+
+    let elt = match typ {
+        ColumnType::List(elt) | ColumnType::Set(elt) => elt,
+        _ => {
+            return Err(mk_typck_err_named(
+                rust_name,
+                typ,
+                SetOrListTypeCheckErrorKind::NotSetOrList,
+            ));
+        }
+    };
+
+    let mut builder = writer.into_value_builder();
+
+    let element_count: i32 = len.try_into().map_err(|_| {
+        mk_ser_err_named(
+            rust_name,
+            typ,
+            SetOrListSerializationErrorKind::TooManyElements,
+        )
+    })?;
+    builder.append_bytes(&element_count.to_be_bytes());
+
+    for el in iter {
+        T::serialize(el, elt, builder.make_sub_writer()).map_err(|err| {
+            mk_ser_err_named(
+                rust_name,
+                typ,
+                SetOrListSerializationErrorKind::ElementSerializationFailed(err),
+            )
+        })?;
+    }
+
+    builder
+        .finish()
+        .map_err(|_| mk_ser_err_named(rust_name, typ, BuiltinSerializationErrorKind::SizeOverflow))
+}