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>,
    pub description: Option<EPubContentType>,
    // 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

description: Option<EPubContentType>

Description of the book, if any.

Methods

impl EPubBook

pub 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()))));

pub 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()))));

pub 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();

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

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

This function is equivalent to write_zip() with all config arguments defaulted.

Config arguments:

• string_toc – whether to process Raw elements for TOC specifiers – default: false

Note: functionality governed by this additional config is accessible only via the API.

Examples

In the following example the resulting ePub will have the following TOC:

• Introduxion
• The Parodies

Wherease without string_toc, the TOC would be empty.

let mut book = EPubBook::from_elements(vec![
    BookElement::Name("String TOC demonstration".to_string()),
    BookElement::StringContent(r#"
<!-- ePub title: "Introduxion" -->
It is a measure of Sherlock Holmes' immense popularity, that he's literature's most imitated character.
"#.to_string()),
    BookElement::StringContent(r#"
<!-- ePub title: "The Parodies" -->
Sherlock Holmes appeared for the first time in A Study in Scarlet and The Sign of The Four, two novels published in
1887 and 1890.
"#.to_string()),
    BookElement::Author("nabijaczleweli".to_string()),
    BookElement::Date(DateTime::parse_from_rfc3339("2018-06-27T12:30:38+02:00").unwrap()),
    BookElement::Language("en-GB".to_string()),
]).unwrap();
book.write_zip_ext(
    true, &mut File::create("write_zip_ext.epub").unwrap(), false, &mut stdout()).unwrap();

Trait Implementations

impl PartialEq<EPubBook> for EPubBook

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

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

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

This method tests for !=.

impl Ord for EPubBook

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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 Eq for EPubBook

impl PartialOrd<EPubBook> for EPubBook

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

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

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

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

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

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

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

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

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

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

impl Debug for EPubBook

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

Formats the value using the given formatter.

impl Hash for EPubBook

fn hash<__H: Hasher>(&self, state: &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].