Add fixed length attribute

Author: oknozor

.gitignore

@@ -1,2 +1,3 @@
 target
 Cargo.lock
+.idea

protocol-derive/src/attr.rs

@@ -12,6 +12,7 @@ pub enum Protocol {
         prefix_field_name: syn::Ident,
         prefix_subfield_names: Vec<syn::Ident>,
     },
+    FixedLength(usize),
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
@@ -56,6 +57,18 @@ pub fn protocol(attrs: &[syn::Attribute])
         Some(syn::NestedMeta::Meta(syn::Meta::List(nested_list))) => {
             match &nested_list.path.get_ident().expect("meta is not an ident").to_string()[..] {
                 // #[protocol(length_prefix(<kind>(<prefix field name>)))]
+                "fixed_length" => {
+                    let nested_list = expect::meta_list::single_literal(nested_list)
+                        .expect("expected a nested list");
+
+                    match nested_list {
+                        syn::Lit::Int(len) => {
+                            let len = len.base10_parse::<usize>().expect("Invalid fixed length, expected usize");
+                            Some(Protocol::FixedLength(len))
+                        }
+                        _ => panic!("Invalid fixed length, expected usize")
+                    }
+                }
                 "length_prefix" => {
                     let nested_list = expect::meta_list::nested_list(nested_list)
                                             .expect("expected a nested list");

protocol-derive/src/codegen/mod.rs

@@ -28,15 +28,17 @@ pub fn write_fields(fields: &syn::Fields)
 ///
 /// Returns  `{ ..field initializers.. }`.
 fn read_named_fields(fields_named: &syn::FieldsNamed)
-    -> TokenStream {
+                     -> TokenStream {
     let field_initializers: Vec<_> = fields_named.named.iter().map(|field| {
         let field_name = &field.ident;
         let field_ty = &field.ty;
         // This field may store the length prefix of another 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);
 
         quote! {
             #field_name : {
+                #update_hints_fixed
                 let res: Result<#field_ty, _> = protocol::Parcel::read_field(__io_reader, __settings, &mut __hints);
                 #update_hints
                 __hints.next_field();
@@ -50,17 +52,32 @@ fn read_named_fields(fields_named: &syn::FieldsNamed)
 
 fn update_hints_after_read<'a>(field: &'a syn::Field,
                                fields: impl IntoIterator<Item=&'a syn::Field> + Clone)
-    -> TokenStream {
+                               -> TokenStream {
     if let Some((length_prefix_of, kind, prefix_subfield_names)) = length_prefix_of(field, fields.clone()) {
         let kind = kind.path_expr();
 
         quote! {
             if let Ok(parcel) = res.as_ref() {
-                __hints.set_field_length(#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);
             }
         }
+    }else {
+        quote! { }
+    }
+}
+
+fn update_hints__fixed_after_read<'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();
+
+        quote! {
+            __hints.set_field_length(#position, #length, protocol::hint::LengthPrefixKind::Elements);
+        }
     } else {
         quote! { }
     }
@@ -123,14 +140,16 @@ fn length_prefix_of<'a>(field: &'a syn::Field,
 }
 
 fn write_named_fields(fields_named: &syn::FieldsNamed)
-    -> TokenStream {
+                      -> TokenStream {
     let field_writers: Vec<_> = fields_named.named.iter().map(|field| {
         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);
 
         quote! {
             {
+                #update_hints_fixed
                 let res = protocol::Parcel::write_field(&self. #field_name, __io_writer, __settings, &mut __hints);
                 #update_hints
                 __hints.next_field();

tests/src/length_prefix.rs

@@ -29,6 +29,13 @@ pub struct WithElementsLength {
     pub data: 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 {
@@ -63,3 +70,17 @@ fn can_read_length_prefix_3_elements() {
                              &Settings::default()).unwrap());
 }
 
+#[test]
+fn can_read_fixed_length_prefix() {
+
+    assert_eq!(WithFixedLength {
+        data: vec![1, 2, 3],
+    }, WithFixedLength::from_raw_bytes(
+        &[
+            0, 0, 0, 1, // 1
+            0, 0, 0, 2, // 2
+            0, 0, 0, 3
+        ], // 3
+        &Settings::default()).unwrap());
+}
+