Trait OwnedHaystackable 

pub trait OwnedHaystackable<I: HaystackItem> {
    type Hay<'a>: HaystackOf<'a, I>
       where Self: 'a;

    // Required methods
    fn replace_range<'a>(
        &mut self,
        range: Range<usize>,
        replacement: <Self::Hay<'a> as HaystackIter<'a>>::Slice,
    )
       where Self: 'a;
    fn as_haystack<'a>(&'a self) -> Self::Hay<'a>;
    fn as_slice<'a>(&'a self) -> <Self::Hay<'a> as HaystackIter<'a>>::Slice;
    fn len(&self) -> usize;

    // Provided method
    fn is_empty(&self) -> bool { ... }
}

A trait representing an owned, mutable type that can be converted into a Haystack as required. This allows for Regex methods that replace matches or captures from the original Haystack.

It is also used as the return type of the closures take by a couple of Regex replace methods.

Required Associated Types

type Hay<'a>: HaystackOf<'a, I> where Self: 'a

Required Methods

fn replace_range<'a>( &mut self, range: Range<usize>, replacement: <Self::Hay<'a> as HaystackIter<'a>>::Slice, )

where Self: 'a,

Replaces the substring at the position indicated by range with the replacement HaystackSlice.

fn as_haystack<'a>(&'a self) -> Self::Hay<'a>

Creates a temporary Haystack out of the underlying slice. This should usually be done by borrowing (or cloning if reference counted) and calling IntoHaystack::into_haystack.

fn as_slice<'a>(&'a self) -> <Self::Hay<'a> as HaystackIter<'a>>::Slice

Borrows the underlying HaystackSlice without creating a haystack. Used for slicing substrings. Note that HaystackSlice is inherently borrowed and probably be implemented for a reference.

fn len(&self) -> usize

Returns the length of the underlying slice.

Provided Methods

fn is_empty(&self) -> bool

Returns true if the underlying slice is empty.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl OwnedHaystackable<char> for String

type Hay<'a> = StrStack<'a>

fn replace_range<'a>( &mut self, range: Range<usize>, with: <Self::Hay<'a> as HaystackIter<'a>>::Slice, )

where Self: 'a,

fn as_haystack<'a>(&'a self) -> Self::Hay<'a>

fn as_slice<'a>(&'a self) -> <Self::Hay<'a> as HaystackIter<'a>>::Slice

fn len(&self) -> usize

impl OwnedHaystackable<char> for EcoString

type Hay<'a> = StrStack<'a>

fn replace_range<'a>( &mut self, range: Range<usize>, with: <Self::Hay<'a> as HaystackIter<'a>>::Slice, )

where Self: 'a,

fn as_haystack<'a>(&'a self) -> Self::Hay<'a>

fn as_slice<'a>(&'a self) -> <Self::Hay<'a> as HaystackIter<'a>>::Slice

fn len(&self) -> usize

impl OwnedHaystackable<u8> for Vec<u8>

type Hay<'a> = ByteStack<'a>

fn replace_range<'a>( &mut self, range: Range<usize>, with: <Self::Hay<'a> as HaystackIter<'a>>::Slice, )

where Self: 'a,

fn as_haystack<'a>(&'a self) -> Self::Hay<'a>

fn as_slice<'a>(&'a self) -> <Self::Hay<'a> as HaystackIter<'a>>::Slice

fn len(&self) -> usize

impl OwnedHaystackable<u8> for BString

type Hay<'a> = BStrStack<'a>

fn replace_range<'a>( &mut self, range: Range<usize>, with: <Self::Hay<'a> as HaystackIter<'a>>::Slice, )

where Self: 'a,

fn as_haystack<'a>(&'a self) -> Self::Hay<'a>

fn as_slice<'a>(&'a self) -> <Self::Hay<'a> as HaystackIter<'a>>::Slice

fn len(&self) -> usize

impl OwnedHaystackable<u8> for EcoVec<u8>

type Hay<'a> = ByteStack<'a>

fn replace_range<'a>( &mut self, range: Range<usize>, with: <Self::Hay<'a> as HaystackIter<'a>>::Slice, )

where Self: 'a,

fn as_haystack<'a>(&'a self) -> Self::Hay<'a>

fn as_slice<'a>(&'a self) -> <Self::Hay<'a> as HaystackIter<'a>>::Slice

fn len(&self) -> usize

impl<'s, B: Backend> OwnedHaystackable<char> for HipStr<'s, B>

type Hay<'a> = HipStrStack<'a, B> where Self: 'a

fn replace_range<'a>( &mut self, range: Range<usize>, with: <Self::Hay<'a> as HaystackIter<'a>>::Slice, )

where Self: 'a,

fn as_haystack<'a>(&'a self) -> Self::Hay<'a>

fn as_slice<'a>(&'a self) -> <Self::Hay<'a> as HaystackIter<'a>>::Slice

fn len(&self) -> usize

impl<'s, B: Backend> OwnedHaystackable<u8> for HipByt<'s, B>

type Hay<'a> = HipBytStack<'a, B> where Self: 'a

fn replace_range<'a>( &mut self, range: Range<usize>, with: <Self::Hay<'a> as HaystackIter<'a>>::Slice, )

where Self: 'a,

fn as_haystack<'a>(&'a self) -> Self::Hay<'a>

fn as_slice<'a>(&'a self) -> <Self::Hay<'a> as HaystackIter<'a>>::Slice

fn len(&self) -> usize

Implementors