1. Open the Cargo.toml file that was generated earlier for you.

2. Under [dependencies], add the following lines:

serde = "1.0.24"
serde_derive = "1.0.24"

3. If you haven't done so already in the last recipe, add the following line as well:

csv = "1.0.0-beta.5"

4. If you want, you can go to the crates.io web pages for Serde (https://crates.io/crates/serde), serde_derive (https://crates.io/crates/serde_derive), and CSV (https://crates.io/crates/csv) to check for the newest versions and use those ones instead.

5. In the bin folder, create a file called serde_csv.rs.

4. Add the following code and run it with cargo run --bin serde_csv:

1    extern crate csv;
2    extern crate serde;
3    #[macro_use]
4    extern crate serde_derive;
5 
6    use std::io::{BufReader, BufWriter, Read, Seek, SeekFrom, 
     Write};
7    use std::fs::OpenOptions;
8 
9    #[derive(Serialize, Deserialize)]
10   struct Planet {
11     name: String,
12     radius: f32,
13     distance_from_sun: f32,
14     gravity: f32,
15   }
16 
17   fn main() {
18     let file = OpenOptions::new()
19       .read(true)
20       .write(true)
21       .create(true)
22       .open("solar_system_compared_to_earth.csv")
23       .expect("failed to create csv file");
24 
25     let buf_writer = BufWriter::new(&file);
26     write_records(buf_writer).expect("Failed to write csv");
27 
28     let mut buf_reader = BufReader::new(&file);
29     buf_reader
30       .seek(SeekFrom::Start(0))
31       .expect("Failed to jump to the beginning of the csv");
32     read_records(buf_reader).expect("Failed to read csv");
33   }
34 
35   fn write_records<W>(writer: W) -> csv::Result<()>
36   where
37   W: Write,
38  {
39     let mut wtr = csv::Writer::from_writer(writer);
40 
41     // No need to specify a header; Serde creates it for us
42     wtr.serialize(Planet {
43       name: "Mercury".to_string(),
44       radius: 0.38,
45       distance_from_sun: 0.47,
46       gravity: 0.38,
47     })?;
48     wtr.serialize(Planet {
49       name: "Venus".to_string(),
50       radius: 0.95,
51       distance_from_sun: 0.73,
52       gravity: 0.9,
53     })?;
54     wtr.serialize(Planet {
55       name: "Earth".to_string(),
56       radius: 1.0,
57       distance_from_sun: 1.0,
58       gravity: 1.0,
59     })?;
60     wtr.serialize(Planet {
61       name: "Mars".to_string(),
62       radius: 0.53,
63       distance_from_sun: 1.67,
64       gravity: 0.38,
65     })?;
66     wtr.serialize(Planet {
67       name: "Jupiter".to_string(),
68       radius: 11.21,
69       distance_from_sun: 5.46,
70       gravity: 2.53,
71     })?;
72     wtr.serialize(Planet {
73       name: "Saturn".to_string(),
74       radius: 9.45,
75       distance_from_sun: 10.12,
76       gravity: 1.07,
77    })?;
78    wtr.serialize(Planet {
79      name: "Uranus".to_string(),
80      radius: 4.01,
81      distance_from_sun: 20.11,
82      gravity: 0.89,
83    })?;
84    wtr.serialize(Planet {
85      name: "Neptune".to_string(),
86      radius: 3.88,
87      distance_from_sun: 30.33,
88      gravity: 1.14,
89    })?;
90    wtr.flush()?;
91    Ok(())
92  }
93 
94  fn read_records<R>(reader: R) -> csv::Result<()>
95  where
96  R: Read,
97  {
98    let mut rdr = csv::Reader::from_reader(reader);
99    println!("Comparing planets in the solar system with the 
   earth");
100   println!("where a value of '1' means 'equal to earth'");
101   for result in rdr.deserialize() {
102     println!("-------");
103     let planet: Planet = result?;
104     println!("Name: {}", planet.name);
105     println!("Radius: {}", planet.radius);
106     println!("Distance from sun: {}", planet.distance_from_sun);
107     println!("Surface gravity: {}", planet.gravity);
108   }
109   Ok(())
110 }