Struct Book 

pub struct Book {
    pub items: Vec<BookItem>,
}

A tree structure representing a book.

A book is just a collection of BookItems which are accessible by either iterating (immutably) over the book with iter(), or recursively applying a closure to each item to mutate the chapters, using for_each_mut().

Fields

items: Vec<BookItem>

The items in this book.

Implementations

impl Book

pub fn new() -> Book

Create an empty book.

pub fn new_with_items(items: Vec<BookItem>) -> Book

Creates a new book with the given items.

pub fn iter(&self) -> BookItems<'_>

Get a depth-first iterator over the items in the book.

pub fn chapters(&self) -> impl Iterator<Item = &Chapter>

A depth-first iterator over each Chapter, skipping draft chapters.

pub fn for_each_mut<F>(&mut self, func: F)

where F: FnMut(&mut BookItem),

Recursively apply a closure to each item in the book, allowing you to mutate them.

Note

Unlike the iter() method, this requires a closure instead of returning an iterator. This is because using iterators can possibly allow you to have iterator invalidation errors.

pub fn for_each_chapter_mut<F>(&mut self, func: F)

where F: FnMut(&mut Chapter),

Recursively apply a closure to each non-draft chapter in the book, allowing you to mutate them.

pub fn push_item<I>(&mut self, item: I) -> &mut Book

where I: Into<BookItem>,

Append a BookItem to the Book.

Trait Implementations

impl Clone for Book

fn clone(&self) -> Book

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Book

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for Book

fn default() -> Book

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Book

fn deserialize<__D>( __deserializer: __D, ) -> Result<Book, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Book

fn eq(&self, other: &Book) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Book

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Book