add examples of metadata round trips

Author: molpopgen

.github/workflows/tests.yml

@@ -33,7 +33,9 @@ jobs:
           override: true
       - run: cargo check
       - name: run tests
-        run: cargo test
+        run: |
+            cargo test
+            cargo test --examples
 
   build-osx:
     runs-on: macos-latest
@@ -53,7 +55,9 @@ jobs:
           override: true
       - run: cargo check
       - name: run tests
-        run: cargo test 
+        run: |
+            cargo test
+            cargo test --examples
 
   fmt:
     name: rust fmt

Cargo.toml

@@ -15,6 +15,10 @@ repository = "https://github.com/molpopgen/tskit_rust"
 thiserror = "1.0"
 libc = "0.2.81"
 
+[dev-dependencies]
+serde = {version = "1.0.118", features = ["derive"]}
+bincode = "1.3.1"
+
 [build-dependencies]
 bindgen = "0.56.0"
 cc = { version = "1.0", features = ["parallel"] }

examples/mutation.rs

@@ -0,0 +1,43 @@
+#![macro_use]
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct Mutation {
+    pub effect_size: f64,
+    pub dominance: f64,
+    pub origin_time: i32,
+}
+
+macro_rules! make_mutation_metadata_run {
+    () => {
+        pub fn run() {
+            let mut tables = TableCollection::new(1000.).unwrap();
+            // The simulation generates a mutation:
+            let m = Mutation {
+                effect_size: -0.235423,
+                dominance: 0.5,
+                origin_time: 1,
+            };
+
+            // The mutation's data are included as metadata:
+            tables
+                .add_mutation_with_metadata(0, 0, 0, 0.0, None, Some(&m))
+                .unwrap();
+
+            // Decoding requres 2 unwraps:
+            // 1. The first is to handle errors.
+            // 2. The second is b/c metadata are optional,
+            //    so a row may return None.
+            let decoded = tables.mutations().metadata::<Mutation>(0).unwrap().unwrap();
+
+            // Check that we've made the round trip:
+            assert_eq!(decoded.origin_time, 1);
+            assert!((m.effect_size - decoded.effect_size).abs() < f64::EPSILON);
+            assert!((m.dominance - decoded.dominance).abs() < f64::EPSILON);
+        }
+    };
+}
+
+#[allow(dead_code)]
+fn main() {
+}

examples/mutation_metadata_bincode.rs

@@ -0,0 +1,38 @@
+use tskit_rust::metadata;
+use tskit_rust::*;
+mod mutation;
+
+use mutation::Mutation;
+
+impl metadata::MetadataRoundtrip for Mutation {
+    fn encode(&self) -> Result<Vec<u8>, metadata::MetadataError> {
+        let mut rv = vec![];
+        rv.extend(self.effect_size.to_le_bytes().iter().copied());
+        rv.extend(self.dominance.to_le_bytes().iter().copied());
+        rv.extend(self.origin_time.to_le_bytes().iter().copied());
+        Ok(rv)
+    }
+
+    fn decode(md: &[u8]) -> Result<Self, metadata::MetadataError> {
+        use std::convert::TryInto;
+        let (effect_size_bytes, rest) = md.split_at(std::mem::size_of::<f64>());
+        let (dominance_bytes, rest) = rest.split_at(std::mem::size_of::<f64>());
+        let (origin_time_bytes, _) = rest.split_at(std::mem::size_of::<i32>());
+        Ok(Self {
+            effect_size: f64::from_le_bytes(effect_size_bytes.try_into().unwrap()),
+            dominance: f64::from_le_bytes(dominance_bytes.try_into().unwrap()),
+            origin_time: i32::from_le_bytes(origin_time_bytes.try_into().unwrap()),
+        })
+    }
+}
+
+make_mutation_metadata_run!();
+
+#[test]
+fn run_bincode() {
+    run();
+}
+
+fn main() {
+    run();
+}

examples/mutation_metadata_std.rs

@@ -0,0 +1,29 @@
+use tskit_rust::metadata;
+use tskit_rust::*;
+mod mutation;
+
+use mutation::Mutation;
+
+// Implement the metadata trait for our mutation
+// type.  Will will use the standard library for the implementation
+// details.
+impl metadata::MetadataRoundtrip for Mutation {
+    fn encode(&self) -> Result<Vec<u8>, metadata::MetadataError> {
+        Ok(bincode::serialize(&self).unwrap())
+    }
+
+    fn decode(md: &[u8]) -> Result<Self, metadata::MetadataError> {
+        Ok(bincode::deserialize(md).unwrap())
+    }
+}
+
+make_mutation_metadata_run!();
+
+#[test]
+fn run_std() {
+    run();
+}
+
+fn main() {
+    run();
+}