Struct gen_epub_book::ops::EPubBook

pub struct EPubBook {
    pub name: String,
    pub author: String,
    pub date: DateTime<FixedOffset>,
    pub language: String,
    pub cover: Option<EPubData>,
    // some fields omitted
}

Full ePub book, bundled together.

Fields

name: String

E-book's title

author: String

E-book's author

date: DateTime<FixedOffset>

E-book's authoring/publishing date

language: String

Language used in e-book

cover: Option<EPubData>

Image to use as e-book cover, if any

Methods

impl EPubBook

fn from_elements<E: IntoIterator<Item = BookElement>>(
    elems: E
) -> Result<EPubBook, Error>

Construct a book from loose elements

Returns an error upon violating any of the requirements laid forth in the variants of BookElement.

Examples

let book = EPubBook::from_elements(vec![
    BookElement::Name("Simple ePub demonstration".to_string()),
    BookElement::Cover(PathBuf::from("examples/cover.png")),
    BookElement::ImageContent(PathBuf::from("examples/simple/chapter_image.png")),
    BookElement::Content(PathBuf::from("examples/simple/ctnt.html")),
    BookElement::Author("nabijaczleweli".to_string()),
    BookElement::Date(DateTime::parse_from_rfc3339("2017-02-08T15:30:18+01:00").unwrap()),
    BookElement::Language("en-GB".to_string()),
]).unwrap();

assert_eq!(book.name, "Simple ePub demonstration".to_string());
assert_eq!(book.author, "nabijaczleweli".to_string());
assert_eq!(book.date, DateTime::parse_from_rfc3339("2017-02-08T15:30:18+01:00").unwrap());
assert_eq!(book.language, "en-GB".to_string());
assert_eq!(book.cover, Some(("cover-content-1".to_string(),
                             PathBuf::from("cover-data-1.html"),
                             EPubContentType::Raw("<center>\
                                                     <img src=\"examples-cover.png\" \
                                                          alt=\"examples-cover.png\"></img>\
                                                   </center>".to_string()))));

fn normalise_paths<W: Write>(
    &mut self,
    relroot: &[IncludeDirectory],
    verbose: bool,
    verb_out: &mut W
) -> Result<(), Error>

Normalise the paths in the book based on the specified relative path root, optionally printing verbose output to the specified stream.

Will return an error if the file the path points to doesn't exist or isn't a file.

Examples

let mut book = EPubBook::from_elements(vec![
    BookElement::Name("Path normalisation demonstration".to_string()),
    BookElement::Cover(PathBuf::from("cover.png")),
    BookElement::Content(PathBuf::from("content/ch01.html")),
    BookElement::Author("nabijaczleweli".to_string()),
    BookElement::Date(DateTime::parse_from_rfc3339("2017-02-08T15:30:18+01:00").unwrap()),
    BookElement::Language("en-GB".to_string()),
]).unwrap();
book.normalise_paths(&["./".parse().unwrap()], false, &mut stdout()).unwrap();
assert_eq!(book.cover,
           Some(("cover".to_string(),
                 PathBuf::from("cover.png"),
                 EPubContentType::File(
                    PathBuf::from("cover.png").canonicalize().unwrap()))));

fn write_zip<W: Write + Seek, V: Write>(
    &self,
    to: &mut W,
    verbose: bool,
    verb_out: &mut V
) -> Result<(), Error>

Write the book as ePub into the specified stream, optionally logging verbose output.

Examples

let mut book = EPubBook::from_elements(vec![
    BookElement::Name("Path normalisation demonstration".to_string()),
    BookElement::Cover(PathBuf::from("cover.png")),
    BookElement::Content(PathBuf::from("content/ch01.html")),
    BookElement::Author("nabijaczleweli".to_string()),
    BookElement::Date(DateTime::parse_from_rfc3339("2017-02-08T15:30:18+01:00").unwrap()),
    BookElement::Language("en-GB".to_string()),
]).unwrap();
book.normalise_paths(&["./".parse().unwrap()], false, &mut stdout()).unwrap();
book.write_zip(&mut File::create("write_zip.epub").unwrap(), false, &mut stdout()).unwrap();

Trait Implementations

impl Clone for EPubBook

fn clone(&self) -> EPubBook

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for EPubBook

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Hash for EPubBook

fn hash<__H: Hasher>(&self, __arg_0: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl PartialEq for EPubBook

fn eq(&self, __arg_0: &EPubBook) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, __arg_0: &EPubBook) -> bool

This method tests for !=.

impl Eq for EPubBook

impl PartialOrd for EPubBook

fn partial_cmp(&self, __arg_0: &EPubBook) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, __arg_0: &EPubBook) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, __arg_0: &EPubBook) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, __arg_0: &EPubBook) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, __arg_0: &EPubBook) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Ord for EPubBook

fn cmp(&self, __arg_0: &EPubBook) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

🔬 This is a nightly-only experimental API. (ord_max_min)

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

🔬 This is a nightly-only experimental API. (ord_max_min)

Compares and returns the minimum of two values.