WIP multiple prefix

oknozor · oknozor · commit f721ea37e77f · 2021-07-20T11:04:49.000+02:00
diff --git a/protocol-derive/src/codegen/mod.rs b/protocol-derive/src/codegen/mod.rs
@@ -1,8 +1,9 @@
 pub mod enums;
 
 use crate::attr;
-use proc_macro2::TokenStream;
+use proc_macro2::{TokenStream, Ident};
 use syn;
+use syn::Field;
 
 pub fn read_fields(fields: &syn::Fields)
     -> TokenStream {
@@ -31,10 +32,11 @@ fn read_named_fields(fields_named: &syn::FieldsNamed)
                      -> TokenStream {
     let field_initializers: Vec<_> = fields_named.named.iter().map(|field| {
         let field_name = &field.ident;
+        println!("READING NAMED FIELD {:?}", field_name);
         let field_ty = &field.ty;
-        // This field may store the length prefix of another field.
+        // This field may store the length prefix of one or more other field.
         let update_hints = update_hints_after_read(field, &fields_named.named);
-        let update_hints_fixed = update_hints__fixed_after_read(field, &fields_named.named);
+        let update_hints_fixed = update_hint_fixed_length(field, &fields_named.named);
 
         quote! {
             #field_name : {
@@ -55,9 +57,12 @@ fn update_hints_after_read<'a>(field: &'a syn::Field,
                                -> TokenStream {
     if let Some((length_prefix_of, kind, prefix_subfield_names)) = length_prefix_of(field, fields.clone()) {
         let kind = kind.path_expr();
-
+        let field_name = &field.ident.clone().map(|i| i.to_string());
+        let debug = (field_name, &length_prefix_of, &kind, &prefix_subfield_names);
+        println!("About to set hints for {:?}, of_index : {:?}, subfield names {:?}", field_name, &length_prefix_of, &prefix_subfield_names);
         quote! {
             if let Ok(parcel) = res.as_ref() {
+                 println!(" setting {:?} fields hint {:?}, {:?}, {:?}",#field_name, #length_prefix_of, (parcel #(.#prefix_subfield_names)* ).clone() as usize, #kind);
                       __hints.set_field_length(#length_prefix_of,
                                      (parcel #(.#prefix_subfield_names)* ).clone() as usize,
                                      #kind);
@@ -68,9 +73,9 @@ fn update_hints_after_read<'a>(field: &'a syn::Field,
     }
 }
 
-fn update_hints__fixed_after_read<'a>(field: &'a syn::Field,
-                               fields: impl IntoIterator<Item=&'a syn::Field> + Clone)
-                               -> TokenStream {
+fn update_hint_fixed_length<'a>(field: &'a syn::Field,
+                                fields: impl IntoIterator<Item=&'a syn::Field> + Clone)
+                                -> TokenStream {
 
      if let Some(attr::Protocol::FixedLength(length)) = attr::protocol(&field.attrs) {
         let position = fields.clone().into_iter().position(|f| f == field).unwrap();
@@ -89,8 +94,10 @@ fn update_hints_after_write<'a>(field: &'a syn::Field,
     if let Some((length_prefix_of, kind, prefix_subfield_names)) = length_prefix_of(field, fields.clone()) {
         let field_name = &field.ident;
         let kind = kind.path_expr();
-
+        let debug = (&field.ident.clone().map(|i| i.to_string()), &length_prefix_of, &kind, &prefix_subfield_names);
+        println!("About setting hints for {:?}", debug);
         quote! {
+            println!(" WRITE setting {:?} fields hint {:?}, {:?}",self.#field_name #(.#prefix_subfield_names)*, #length_prefix_of, #kind);
             if let Ok(()) = res {
                 __hints.set_field_length(#length_prefix_of,
                                          (self.#field_name #(.#prefix_subfield_names)* ).clone() as usize,
@@ -110,10 +117,10 @@ fn update_hints_after_write<'a>(field: &'a syn::Field,
 /// Returns the field index of the field whose length is specified.
 fn length_prefix_of<'a>(field: &'a syn::Field,
                         fields: impl IntoIterator<Item=&'a syn::Field> + Clone)
-    -> Option<(usize, attr::LengthPrefixKind, Vec<syn::Ident>)> {
+    -> Option<Vec<(usize, attr::LengthPrefixKind, Vec<syn::Ident>)>> {
     let potential_prefix = field.ident.as_ref();
 
-    let prefix_of = fields.clone().into_iter().find(|potential_prefix_of| {
+    let prefixes_of: Vec<&Ident> = fields.clone().into_iter().filter(|potential_prefix_of| {
         match attr::protocol(&potential_prefix_of.attrs) {
             Some(attr::Protocol::LengthPrefix { ref prefix_field_name, .. }) => {
                 if !fields.clone().into_iter().any(|f| f.ident.as_ref() == Some(prefix_field_name)) {
@@ -124,19 +131,23 @@ fn length_prefix_of<'a>(field: &'a syn::Field,
             },
             _ => false,
         }
-    });
+    }).collect();
 
-    if let Some(prefix_of) = prefix_of {
-        let prefix_of_index = fields.clone().into_iter().position(|f| f == prefix_of).unwrap();
-        match attr::protocol(&prefix_of.attrs).unwrap() {
-            attr::Protocol::LengthPrefix { kind, prefix_subfield_names, .. } => {
-                Some((prefix_of_index, kind.clone(), prefix_subfield_names))
-            },
-            _ => unreachable!(),
-        }
-    } else {
-        None
-    }
+
+    prefixes_of.iter()
+        .map(|prefix_of| {
+            if let Some(prefix_of) = prefix_of {
+                let prefix_of_index = fields.clone().into_iter().position(|f| f == prefix_of).unwrap();
+                match attr::protocol(&prefix_of.attrs).unwrap() {
+                    attr::Protocol::LengthPrefix { kind, prefix_subfield_names, .. } => {
+                        Some((prefix_of_index, kind.clone(), prefix_subfield_names))
+                    },
+                    _ => unreachable!(),
+                }
+            } else {
+                None
+            }
+        }).flatten().collect()
 }
 
 fn write_named_fields(fields_named: &syn::FieldsNamed)
@@ -145,8 +156,9 @@ fn write_named_fields(fields_named: &syn::FieldsNamed)
         let field_name = &field.ident;
         // This field may store the length prefix of another field.
         let update_hints = update_hints_after_write(field, &fields_named.named);
-        let update_hints_fixed = update_hints__fixed_after_read(field, &fields_named.named);
+        let update_hints_fixed = update_hint_fixed_length(field, &fields_named.named);
 
+        println!("WRITE Hints after ");
         quote! {
             {
                 #update_hints_fixed
diff --git a/protocol-derive/src/lib.rs b/protocol-derive/src/lib.rs
@@ -73,7 +73,9 @@ fn build_generics(ast: &syn::DeriveInput) -> (Vec<proc_macro2::TokenStream>, Vec
 fn impl_parcel_for_struct(ast: &syn::DeriveInput,
                           strukt: &syn::DataStruct) -> proc_macro2::TokenStream {
     let strukt_name = &ast.ident;
+    println!("Reading struct fields {:?}", &strukt.fields);
     let read_fields = codegen::read_fields(&strukt.fields);
+    println!("{}", read_fields);
     let write_fields = codegen::write_fields(&strukt.fields);
 
     impl_trait_for(ast, quote!(protocol::Parcel), quote! {
@@ -84,6 +86,7 @@ fn impl_parcel_for_struct(ast: &syn::DeriveInput,
                       __settings: &protocol::Settings,
                       _: &mut protocol::hint::Hints)
             -> Result<Self, protocol::Error> {
+            println!("reading fields with default Hints");
             // Each type gets its own hints.
             let mut __hints = protocol::hint::Hints::default();
             __hints.begin_fields();
diff --git a/protocol/src/hint.rs b/protocol/src/hint.rs
@@ -41,7 +41,10 @@ impl Hints {
     /// Gets the length of the field currently being
     /// read, if known.
     pub fn current_field_length(&self) -> Option<FieldLength> {
-        self.current_field_index.and_then(|index| self.known_field_lengths.get(&index)).cloned()
+        println!("Getting current field length");
+        let maybe_length = self.current_field_index.and_then(|index| self.known_field_lengths.get(&index)).cloned();
+        println!("Got {:?}", maybe_length);
+        maybe_length
     }
 }
 
@@ -53,12 +56,14 @@ mod protocol_derive_helpers {
         // Sets hints indicating a new set of fields are beginning.
         #[doc(hidden)]
         pub fn begin_fields(&mut self) {
+            println!("Starting from field 0");
             self.current_field_index = Some(0);
         }
 
         // Updates the hints to indicate a field was just read.
         #[doc(hidden)]
         pub fn next_field(&mut self) {
+            println!("Current field +1");
             *self.current_field_index.as_mut()
                 .expect("cannot increment next field when not in a struct")+= 1;
         }
@@ -69,6 +74,7 @@ mod protocol_derive_helpers {
                                 field_index: FieldIndex,
                                 length: usize,
                                 kind: LengthPrefixKind) {
+            println!("Set field length {:?}", (field_index, length, kind));
             self.known_field_lengths.insert(field_index, FieldLength { kind, length });
         }
     }
diff --git a/protocol/src/types/vec.rs b/protocol/src/types/vec.rs
@@ -49,6 +49,7 @@ mod std_vec {
         fn read_field(read: &mut dyn Read,
                       settings: &Settings,
                       hints: &mut hint::Hints) -> Result<Self, Error> {
+            println!("Vec hints {:?}", hints);
             util::read_list(read, settings, hints)
         }
 
diff --git a/protocol/src/util.rs b/protocol/src/util.rs
@@ -53,6 +53,7 @@ pub fn read_list<T>(read: &mut dyn Read,
                     hints: &mut hint::Hints)
     -> Result<Vec<T>, Error>
     where T: Parcel {
+    println!("read predixed list  with hints ->  {:?}", hints);
     self::read_list_ext::<SizeType, T>(read, settings, hints)
 }
 
@@ -74,6 +75,7 @@ pub fn read_list_ext<S,T>(read: &mut dyn Read,
     -> Result<Vec<T>, Error>
     where S: Integer,
           T: Parcel {
+    println!("About to read list ext with prefix and hint {:?}", hints);
     match hints.current_field_length() {
         Some(length) => {
             match length.kind {
@@ -102,6 +104,7 @@ pub fn read_list_ext<S,T>(read: &mut dyn Read,
                     Ok(items)
                 },
                 hint::LengthPrefixKind::Elements => {
+                    println!("Reading \"Element Kind\" with length : {:?}", length.length);
                     read_items(length.length, read, settings).map(|i| i.collect())
                 },
             }
diff --git a/tests/src/length_prefix.rs b/tests/src/length_prefix.rs
@@ -29,13 +29,33 @@ pub struct WithElementsLength {
     pub data: Vec<u32>,
 }
 
+#[derive(Protocol, Debug, PartialEq, Eq)]
+pub struct WithTwoPrefix {
+    pub count: u32,
+    pub count_2: u32,
+    pub foo: bool,
+    #[protocol(length_prefix(elements(count)))]
+    pub data: Vec<u32>,
+    #[protocol(length_prefix(elements(count_2)))]
+    pub data_2: Vec<u32>,
+}
+
+#[derive(Protocol, Debug, PartialEq, Eq)]
+pub struct WithElementsLengthUsedTwice {
+    pub count: u32,
+    pub foo: bool,
+    #[protocol(length_prefix(elements(count)))]
+    pub data_1: Vec<u32>,
+    #[protocol(length_prefix(elements(count)))]
+    pub data_2: Vec<u32>,
+}
+
 #[derive(Protocol, Debug, PartialEq, Eq)]
 pub struct WithFixedLength {
     #[protocol(fixed_length(3))]
     pub data: Vec<u32>,
 }
 
-
 #[test]
 fn can_read_length_prefix_5_bytes_string() {
     assert_eq!(Foo {
@@ -70,6 +90,49 @@ fn can_read_length_prefix_3_elements() {
                              &Settings::default()).unwrap());
 }
 
+#[test]
+fn can_read_twice_the_same_prefix_length() {
+    assert_eq!(WithElementsLengthUsedTwice {
+        count: 3,
+        foo: true,
+        data_1: vec![1, 2, 3],
+        data_2: vec![4, 5, 6],
+    }, WithElementsLengthUsedTwice::from_raw_bytes(
+        &[0, 0, 0, 3, // disjoint length prefix
+            1, // boolean true
+            0, 0, 0, 1, // 1
+            0, 0, 0, 2, // 2
+            0, 0, 0, 3, // 3
+            0, 0, 0, 1, // 4
+            0, 0, 0, 2, // 5
+            0, 0, 0, 3  // 6
+        ],
+        &Settings::default()).unwrap());
+}
+
+#[test]
+fn can_read_two_prefix_length() {
+    assert_eq!(WithTwoPrefix {
+        count: 3,
+        count_2: 3,
+        foo: true,
+        data: vec![1, 2, 3],
+        data_2: vec![4, 5, 6],
+    }, WithTwoPrefix::from_raw_bytes(
+        &[
+            0, 0, 0, 3, // disjoint length prefix
+            0, 0, 0, 3, // disjoint length prefix
+            1, // boolean true
+            0, 0, 0, 1, // 1
+            0, 0, 0, 2, // 2
+            0, 0, 0, 3, // 3
+            0, 0, 0, 4, // 4
+            0, 0, 0, 5, // 5
+            0, 0, 0, 6  // 6
+        ],
+        &Settings::default()).unwrap());
+}
+
 #[test]
 fn can_read_fixed_length_prefix() {
 

Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,10 @@ impl Hints {`
`41`	`41`	`/// Gets the length of the field currently being`
`42`	`42`	`/// read, if known.`
`43`	`43`	`pub fn current_field_length(&self) -> Option<FieldLength> {`
`44`		`- self.current_field_index.and_then(\|index\| self.known_field_lengths.get(&index)).cloned()`
	`44`	`+ println!("Getting current field length");`
	`45`	`+ let maybe_length = self.current_field_index.and_then(\|index\| self.known_field_lengths.get(&index)).cloned();`
	`46`	`+ println!("Got {:?}", maybe_length);`
	`47`	`+ maybe_length`
`45`	`48`	`}`
`46`	`49`	`}`
`47`	`50`
`@@ -53,12 +56,14 @@ mod protocol_derive_helpers {`
`53`	`56`	`// Sets hints indicating a new set of fields are beginning.`
`54`	`57`	`#[doc(hidden)]`
`55`	`58`	`pub fn begin_fields(&mut self) {`
	`59`	`+ println!("Starting from field 0");`
`56`	`60`	`self.current_field_index = Some(0);`
`57`	`61`	`}`
`58`	`62`
`59`	`63`	`// Updates the hints to indicate a field was just read.`
`60`	`64`	`#[doc(hidden)]`
`61`	`65`	`pub fn next_field(&mut self) {`
	`66`	`+ println!("Current field +1");`
`62`	`67`	`*self.current_field_index.as_mut()`
`63`	`68`	`.expect("cannot increment next field when not in a struct")+= 1;`
`64`	`69`	`}`
`@@ -69,6 +74,7 @@ mod protocol_derive_helpers {`
`69`	`74`	`field_index: FieldIndex,`
`70`	`75`	`length: usize,`
`71`	`76`	`kind: LengthPrefixKind) {`
	`77`	`+ println!("Set field length {:?}", (field_index, length, kind));`
`72`	`78`	`self.known_field_lengths.insert(field_index, FieldLength { kind, length });`
`73`	`79`	`}`
`74`	`80`	`}`
Original file line number	Diff line number	Diff line change
`@@ -49,6 +49,7 @@ mod std_vec {`
`49`	`49`	`fn read_field(read: &mut dyn Read,`
`50`	`50`	`settings: &Settings,`
`51`	`51`	`hints: &mut hint::Hints) -> Result<Self, Error> {`
	`52`	`+ println!("Vec hints {:?}", hints);`
`52`	`53`	`util::read_list(read, settings, hints)`
`53`	`54`	`}`
`54`	`55`