Day 1 Afternoon Exercises

Designing a Library

(back to exercise)

  1. // Copyright 2022 Google LLC
  2. //
  3. // Licensed under the Apache License, Version 2.0 (the "License");
  4. // you may not use this file except in compliance with the License.
  5. // You may obtain a copy of the License at
  6. //
  7. //      http://www.apache.org/licenses/LICENSE-2.0
  8. //
  9. // Unless required by applicable law or agreed to in writing, software
  10. // distributed under the License is distributed on an "AS IS" BASIS,
  11. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12. // See the License for the specific language governing permissions and
  13. // limitations under the License.
  15. // ANCHOR: setup
  16. struct Library {
  17.     books: Vec<Book>,
  18. }
  20. struct Book {
  21.     title: String,
  22.     year: u16,
  23. }
  25. impl Book {
  26.     // This is a constructor, used below.
  27.     fn new(title: &str, year: u16) -> Book {
  28.         Book {
  29.             title: String::from(title),
  30.             year,
  31.         }
  32.     }
  33. }
  35. // This makes it possible to print Book values with {}.
  36. impl std::fmt::Display for Book {
  37.     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  38.         write!(f, "{} ({})", self.title, self.year)
  39.     }
  40. }
  41. // ANCHOR_END: setup
  43. // ANCHOR: Library_new
  44. impl Library {
  45.     fn new() -> Library {
  46.         // ANCHOR_END: Library_new
  47.         Library { books: Vec::new() }
  48.     }
  50.     // ANCHOR: Library_len
  51.     //fn len(self) -> usize {
  52.     //    unimplemented!()
  53.     //}
  54.     // ANCHOR_END: Library_len
  55.     fn len(&self) -> usize {
  56.         self.books.len()
  57.     }
  59.     // ANCHOR: Library_is_empty
  60.     //fn is_empty(self) -> bool {
  61.     //    unimplemented!()
  62.     //}
  63.     // ANCHOR_END: Library_is_empty
  64.     fn is_empty(&self) -> bool {
  65.         self.books.is_empty()
  66.     }
  68.     // ANCHOR: Library_add_book
  69.     //fn add_book(self, book: Book) {
  70.     //    unimplemented!()
  71.     //}
  72.     // ANCHOR_END: Library_add_book
  73.     fn add_book(&mut self, book: Book) {
  74.         self.books.push(book)
  75.     }
  77.     // ANCHOR: Library_print_books
  78.     //fn print_books(self) {
  79.     //    unimplemented!()
  80.     //}
  81.     // ANCHOR_END: Library_print_books
  82.     fn print_books(&self) {
  83.         for book in &self.books {
  84.             println!("{}", book);
  85.         }
  86.     }
  88.     // ANCHOR: Library_oldest_book
  89.     //fn oldest_book(self) -> Option<&Book> {
  90.     //    unimplemented!()
  91.     //}
  92.     // ANCHOR_END: Library_oldest_book
  93.     fn oldest_book(&self) -> Option<&Book> {
  94.         self.books.iter().min_by_key(|book| book.year)
  95.     }
  96. }
  98. // ANCHOR: main
  99. // This shows the desired behavior. Uncomment the code below and
  100. // implement the missing methods. You will need to update the
  101. // method signatures, including the "self" parameter! You may
  102. // also need to update the variable bindings within main.
  103. fn main() {
  104.     let library = Library::new();
  106.     //println!("Our library is empty: {}", library.is_empty());
  107.     //
  108.     //library.add_book(Book::new("Lord of the Rings", 1954));
  109.     //library.add_book(Book::new("Alice's Adventures in Wonderland", 1865));
  110.     //
  111.     //library.print_books();
  112.     //
  113.     //match library.oldest_book() {
  114.     //    Some(book) => println!("My oldest book is {book}"),
  115.     //    None => println!("My library is empty!"),
  116.     //}
  117.     //
  118.     //println!("Our library has {} books", library.len());
  119. }
  120. // ANCHOR_END: main
  122. #[test]
  123. fn test_library_len() {
  124.     let mut library = Library::new();
  125.     assert_eq!(library.len(), 0);
  126.     assert!(library.is_empty());
  128.     library.add_book(Book::new("Lord of the Rings", 1954));
  129.     library.add_book(Book::new("Alice's Adventures in Wonderland", 1865));
  130.     assert_eq!(library.len(), 2);
  131.     assert!(!library.is_empty());
  132. }
  134. #[test]
  135. fn test_library_is_empty() {
  136.     let mut library = Library::new();
  137.     assert!(library.is_empty());
  139.     library.add_book(Book::new("Lord of the Rings", 1954));
  140.     assert!(!library.is_empty());
  141. }
  143. #[test]
  144. fn test_library_print_books() {
  145.     let mut library = Library::new();
  146.     library.add_book(Book::new("Lord of the Rings", 1954));
  147.     library.add_book(Book::new("Alice's Adventures in Wonderland", 1865));
  148.     // We could try and capture stdout, but let us just call the
  149.     // method to start with.
  150.     library.print_books();
  151. }
  153. #[test]
  154. fn test_library_oldest_book() {
  155.     let mut library = Library::new();
  156.     assert!(library.oldest_book().is_none());
  158.     library.add_book(Book::new("Lord of the Rings", 1954));
  159.     assert_eq!(
  160.         library.oldest_book().map(|b| b.title.as_str()),
  161.         Some("Lord of the Rings")
  162.     );
  164.     library.add_book(Book::new("Alice's Adventures in Wonderland", 1865));
  165.     assert_eq!(
  166.         library.oldest_book().map(|b| b.title.as_str()),
  167.         Some("Alice's Adventures in Wonderland")
  168.     );
  169. }