Enum CachePath

pub enum CachePath {
    Memory,
    Path(String),
}

The path of a cache database.

Variants

Memory

Stores the database in memory, wiping it on program exit.

Has the string representation of :memory:.

Path(String)

A filesystem/network/whatever path.

Implementations

impl CachePath

pub fn serialize<__S>( __self: &CachePath, __serializer: __S, ) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

impl<'de> CachePath

pub fn deserialize<__D>(__deserializer: __D) -> Result<CachePath, __D::Error>

where __D: Deserializer<'de>,

impl CachePath

pub fn as_str(&self) -> &str

The cache’s path as a str.

If self is Self::Memory, returns :memory:.

Examples

use url_cleaner_engine::glue::*;

assert_eq!(CachePath::Memory                          .as_str(), ":memory:");
assert_eq!(CachePath::Path(       "abc.sqlite".into()).as_str(), "abc.sqlite");
assert_eq!(CachePath::Path("file://abc.sqlite".into()).as_str(), "file://abc.sqlite");

Trait Implementations

impl AsRef<str> for CachePath

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for CachePath

fn clone(&self) -> CachePath

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CachePath

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

Formats the value using the given formatter.

impl Default for CachePath

fn default() -> CachePath

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CachePath

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl From<&str> for CachePath

fn from(value: &str) -> Self

Converts to this type from the input type.

impl From<CachePath> for Cache

fn from(value: CachePath) -> Self

Converts to this type from the input type.

impl From<CachePath> for InnerCache

fn from(value: CachePath) -> Self

Converts to this type from the input type.

impl From<String> for CachePath

fn from(value: String) -> Self

Converts to this type from the input type.

impl FromStr for CachePath

type Err = Infallible

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl PartialEq for CachePath

fn eq(&self, other: &CachePath) -> 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 CachePath

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl Eq for CachePath

impl StructuralPartialEq for CachePath