Enum ResourceKey 

pub enum ResourceKey<'a> {
    Value(Cow<'a, str>),
    Position(usize),
}

A key identifying where the content is held for a Resource, either by string or numeric position.

Examples

• Creating a key using From (Into is usable as well):

let position_key = ResourceKey::from(5);
let str_key = ResourceKey::from("OEBPS/nav/toc.xhtml");
// A path may be passed as well, although it must contain valid UTF-8.
// Otherwise, the requested file won't be found and an error will
// be propagated from methods that process a `ResourceKey`:
let str_key2 = ResourceKey::from(Path::new("EPUB/toc.ncx"));

assert!(matches!(position_key, ResourceKey::Position(5)));
assert!(matches!(str_key, ResourceKey::Value(Cow::Borrowed("OEBPS/nav/toc.xhtml"))));
assert!(matches!(str_key2, ResourceKey::Value(Cow::Borrowed("EPUB/toc.ncx"))));

Variants

Value(Cow<'a, str>)

A string-based key (e.g., file path, URI) that references where a resource is stored.

When using the From<&Path> impl, the input must be valid UTF-8; any non-UTF-8 sequences will be replaced with �.

Position(usize)

A numeric index-based key for locations that cannot be represented with a string value.

This is primarily useful for resources that do not have a string value available, but rather a “pointer” to access an element within an indexable structure, such as the MOBI format.

Implementations

impl ResourceKey<'_>

pub fn value(&self) -> Option<&str>

Returns the contained value if self is ResourceKey::Value.

Examples

• Retrieving the value:

let key = ResourceKey::from("value");
assert_eq!(Some("value"), key.value());
assert_eq!(None, key.position());

pub fn position(&self) -> Option<usize>

Returns the contained position if self is ResourceKey::Position.

Examples

• Retrieving the position:

let key = ResourceKey::from(5);
assert_eq!(Some(5), key.position());
assert_eq!(None, key.value());

Trait Implementations

impl<'a> Clone for ResourceKey<'a>

fn clone(&self) -> ResourceKey<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for ResourceKey<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for ResourceKey<'a>

impl<'a> From<&'a Path> for ResourceKey<'a>

It is expected that the given path is UTF-8 compliant. Otherwise, the associated resource will never be found within an ebook.

For fallible operations, prefer Path::to_str, which ensures the given string is UTF-8 compliant:

let epub = Epub::open("tests/ebooks/example_epub")?;
let mut path = PathBuf::from("/EPUB");
path.push("c1.xhtml");

// `path` is implicitly turned into a `Resource`
let bytes_a = epub.read_resource_bytes(&*path)?;

if let Some(utf8_value) = path.to_str() {
    // Explicitly providing a `Resource`
    let resource = Resource::from(utf8_value);
    let bytes_b = epub.read_resource_bytes(resource)?;
    assert_eq!(bytes_a, bytes_b);
}

Windows

This conversion allocates on Windows operating systems to convert path separators, if needed. Specifically, replacing back-slashes (\) with forward-slashes (/).

For example: path\to\content.xhtml → path/to/content.xhtml

fn from(path: &'a Path) -> Self

Converts to this type from the input type.

impl<'a> From<&'a ResourceKey<'a>> for ResourceKey<'a>

fn from(value: &'a Self) -> Self

Converts to this type from the input type.

impl<'a> From<&'a String> for ResourceKey<'a>

fn from(value: &'a String) -> Self

Converts to this type from the input type.

impl<'a> From<&'a str> for ResourceKey<'a>

fn from(value: &'a str) -> Self

Converts to this type from the input type.

impl<'a> From<Cow<'a, str>> for ResourceKey<'a>

fn from(value: Cow<'a, str>) -> Self

Converts to this type from the input type.

impl<'a> From<Href<'a>> for ResourceKey<'a>

fn from(value: Href<'a>) -> Self

Converts to this type from the input type.

impl From<String> for ResourceKey<'_>

fn from(value: String) -> Self

Converts to this type from the input type.

impl From<usize> for ResourceKey<'_>

fn from(value: usize) -> Self

Converts to this type from the input type.

impl<'a> Hash for ResourceKey<'a>

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> PartialEq for ResourceKey<'a>

fn eq(&self, other: &ResourceKey<'a>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<'a> StructuralPartialEq for ResourceKey<'a>