Struct StorableStr

#[repr(transparent)]
pub struct StorableStr(pub Cow<'static, str>);

A Storable string.

This is a wrapper around a Cow<'static, str> that can be stored in the database.

Invariant

StorableStr::from_bytes will panic if the bytes are not UTF-8. This should normally not be possible in database operations, although technically you can call this function yourself and input bad data.

Example

let string: StorableStr = StorableStr(Cow::Borrowed("a"));

// Into bytes.
let into = Storable::as_bytes(&string);
assert_eq!(into, &[97]);

// From bytes.
let from: StorableStr = Storable::from_bytes(&into);
assert_eq!(from, string);

Tuple Fields

0: Cow<'static, str>

Methods from Deref<Target = Cow<'static, str>>

pub fn is_borrowed(&self) -> bool

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

Returns true if the data is borrowed, i.e. if to_mut would require additional work.

Examples

#![feature(cow_is_borrowed)]
use std::borrow::Cow;

let cow = Cow::Borrowed("moo");
assert!(cow.is_borrowed());

let bull: Cow<'_, str> = Cow::Owned("...moo?".to_string());
assert!(!bull.is_borrowed());

pub fn is_owned(&self) -> bool

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

Returns true if the data is owned, i.e. if to_mut would be a no-op.

Examples

#![feature(cow_is_borrowed)]
use std::borrow::Cow;

let cow: Cow<'_, str> = Cow::Owned("moo".to_string());
assert!(cow.is_owned());

let bull = Cow::Borrowed("...moo?");
assert!(!bull.is_owned());

Trait Implementations

impl Borrow<Cow<'static, str>> for StorableStr

fn borrow(&self) -> &Cow<'static, str>

Immutably borrows from an owned value.

impl Clone for StorableStr

fn clone(&self) -> StorableStr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for StorableStr

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

Formats the value using the given formatter.

impl Deref for StorableStr

type Target = Cow<'static, str>

The resulting type after dereferencing.

fn deref(&self) -> &Cow<'static, str>

Dereferences the value.

impl Hash for StorableStr

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 Key for StorableStr

const KEY_COMPARE: KeyCompare = KeyCompare::Default

Compare 2 Key’s against each other.

impl Ord for StorableStr

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for StorableStr

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

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl Storable for StorableStr

fn as_bytes(&self) -> &[u8]

String::as_bytes.

const BYTE_LENGTH: Option<usize> = None

Is this type fixed width in byte length?

fn from_bytes(bytes: &[u8]) -> Self

Create an owned Self from bytes.

impl TransparentWrapper<Cow<'static, str>> for StorableStr

fn wrap(s: Inner) -> Self

where Self: Sized,

Convert the inner type into the wrapper type.

fn wrap_ref(s: &Inner) -> &Self

Convert a reference to the inner type into a reference to the wrapper type.

fn wrap_mut(s: &mut Inner) -> &mut Self

Convert a mutable reference to the inner type into a mutable reference to the wrapper type.

fn wrap_slice(s: &[Inner]) -> &[Self]

where Self: Sized,

Convert a slice to the inner type into a slice to the wrapper type.

fn wrap_slice_mut(s: &mut [Inner]) -> &mut [Self]

where Self: Sized,

Convert a mutable slice to the inner type into a mutable slice to the wrapper type.

fn peel(s: Self) -> Inner

where Self: Sized,

Convert the wrapper type into the inner type.

fn peel_ref(s: &Self) -> &Inner

Convert a reference to the wrapper type into a reference to the inner type.

fn peel_mut(s: &mut Self) -> &mut Inner

Convert a mutable reference to the wrapper type into a mutable reference to the inner type.

fn peel_slice(s: &[Self]) -> &[Inner]

where Self: Sized,

Convert a slice to the wrapped type into a slice to the inner type.

fn peel_slice_mut(s: &mut [Self]) -> &mut [Inner]

where Self: Sized,

Convert a mutable slice to the wrapped type into a mutable slice to the inner type.

impl Eq for StorableStr

impl StructuralPartialEq for StorableStr

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 24 bytes