From 0d761e292a32a31478d681027b3e18dfcf46467c Mon Sep 17 00:00:00 2001
From: Alexandru Agache <aagch@amazon.com>
Date: Sun, 31 May 2020 11:27:37 +0300
Subject: [PATCH] implement Versionize for VecDeque

Signed-off-by: Alexandru Agache <aagch@amazon.com>
---
 CHANGELOG.md                 | 10 +++++-
 coverage_config_aarch64.json |  2 +-
 src/primitives.rs            | 69 ++++++++++++++++++++++++++++++++++++
 3 files changed, 79 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 153ce76..7d86a8f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,11 @@
-# v0.1.0
+# Changelog
+
+## [Unreleased]
+
+### Added
+
+- Implemented `Versionize` for `VecDeque` as a primitive.
+
+## v0.1.0
 
 - "versionize" v0.1.0 first release.
diff --git a/coverage_config_aarch64.json b/coverage_config_aarch64.json
index 62fb767..ecf738b 100644
--- a/coverage_config_aarch64.json
+++ b/coverage_config_aarch64.json
@@ -1 +1 @@
-{"coverage_score": 92.3, "exclude_path": "", "crate_features": ""}
+{"coverage_score": 92.4, "exclude_path": "", "crate_features": ""}
diff --git a/src/primitives.rs b/src/primitives.rs
index c614c74..5ca28cd 100644
--- a/src/primitives.rs
+++ b/src/primitives.rs
@@ -3,6 +3,8 @@
 //! Serialization support for primitive data types.
 #![allow(clippy::float_cmp)]
 
+use std::collections::VecDeque;
+
 use self::super::{VersionMap, Versionize, VersionizeError, VersionizeResult};
 use vmm_sys_util::fam::{FamStruct, FamStructWrapper};
 
@@ -335,6 +337,53 @@ where
     }
 }
 
+impl<T> Versionize for VecDeque<T>
+where
+    T: Versionize,
+{
+    #[inline]
+    fn serialize<W: std::io::Write>(
+        &self,
+        mut writer: &mut W,
+        version_map: &VersionMap,
+        app_version: u16,
+    ) -> VersionizeResult<()> {
+        // Serialize in the same fashion as bincode:
+        // Write len.
+        bincode::serialize_into(&mut writer, &self.len())
+            .map_err(|ref err| VersionizeError::Serialize(format!("{:?}", err)))?;
+        // Walk the vecdeque and write each elemenet.
+        for element in self {
+            element
+                .serialize(writer, version_map, app_version)
+                .map_err(|ref err| VersionizeError::Serialize(format!("{:?}", err)))?;
+        }
+        Ok(())
+    }
+
+    #[inline]
+    fn deserialize<R: std::io::Read>(
+        mut reader: &mut R,
+        version_map: &VersionMap,
+        app_version: u16,
+    ) -> VersionizeResult<Self> {
+        let mut v = VecDeque::new();
+        let len: u64 = bincode::deserialize_from(&mut reader)
+            .map_err(|ref err| VersionizeError::Deserialize(format!("{:?}", err)))?;
+        for _ in 0..len {
+            let element: T = T::deserialize(reader, version_map, app_version)
+                .map_err(|ref err| VersionizeError::Deserialize(format!("{:?}", err)))?;
+            v.push_back(element);
+        }
+        Ok(v)
+    }
+
+    // Not used yet.
+    fn version() -> u16 {
+        1
+    }
+}
+
 // Implement versioning for FAM structures by using the FamStructWrapper interface.
 impl<T: Default + FamStruct + Versionize> Versionize for FamStructWrapper<T>
 where
@@ -622,6 +671,26 @@ mod tests {
         assert_eq!(store, restore);
     }
 
+    #[test]
+    fn test_ser_de_vecdeque() {
+        let vm = VersionMap::new();
+        let mut snapshot_mem = vec![0u8; 64];
+
+        let mut store = VecDeque::new();
+        store.push_back("test 1".to_owned());
+        store.push_back("test 2".to_owned());
+        store.push_back("test 3".to_owned());
+
+        store
+            .serialize(&mut snapshot_mem.as_mut_slice(), &vm, 1)
+            .unwrap();
+        let restore =
+            <VecDeque<String> as Versionize>::deserialize(&mut snapshot_mem.as_slice(), &vm, 1)
+                .unwrap();
+
+        assert_eq!(store, restore);
+    }
+
     #[test]
     fn test_ser_de_option() {
         let vm = VersionMap::new();