Trait OwnedHaystackable 

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

    // Required methods
    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;
}

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>, 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

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: <<String as OwnedHaystackable<char>>::Hay<'a> as HaystackIter<'a>>::Slice, )

where String: 'a,

fn as_haystack<'a>(&'a self) -> <String as OwnedHaystackable<char>>::Hay<'a>

fn as_slice<'a>( &'a self, ) -> <<String as OwnedHaystackable<char>>::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: <<EcoString as OwnedHaystackable<char>>::Hay<'a> as HaystackIter<'a>>::Slice, )

where EcoString: 'a,

fn as_haystack<'a>(&'a self) -> <EcoString as OwnedHaystackable<char>>::Hay<'a>

fn as_slice<'a>( &'a self, ) -> <<EcoString as OwnedHaystackable<char>>::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: <<Vec<u8> as OwnedHaystackable<u8>>::Hay<'a> as HaystackIter<'a>>::Slice, )

where Vec<u8>: 'a,

fn as_haystack<'a>(&'a self) -> <Vec<u8> as OwnedHaystackable<u8>>::Hay<'a>

fn as_slice<'a>( &'a self, ) -> <<Vec<u8> as OwnedHaystackable<u8>>::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: <<BString as OwnedHaystackable<u8>>::Hay<'a> as HaystackIter<'a>>::Slice, )

where BString: 'a,

fn as_haystack<'a>(&'a self) -> <BString as OwnedHaystackable<u8>>::Hay<'a>

fn as_slice<'a>( &'a self, ) -> <<BString as OwnedHaystackable<u8>>::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: <<EcoVec<u8> as OwnedHaystackable<u8>>::Hay<'a> as HaystackIter<'a>>::Slice, )

where EcoVec<u8>: 'a,

fn as_haystack<'a>(&'a self) -> <EcoVec<u8> as OwnedHaystackable<u8>>::Hay<'a>

fn as_slice<'a>( &'a self, ) -> <<EcoVec<u8> as OwnedHaystackable<u8>>::Hay<'a> as HaystackIter<'a>>::Slice

fn len(&self) -> usize

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

where B: Backend,

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

fn replace_range<'a>( &mut self, range: Range<usize>, with: <<HipStr<'s, B> as OwnedHaystackable<char>>::Hay<'a> as HaystackIter<'a>>::Slice, )

where HipStr<'s, B>: 'a,

fn as_haystack<'a>( &'a self, ) -> <HipStr<'s, B> as OwnedHaystackable<char>>::Hay<'a>

fn as_slice<'a>( &'a self, ) -> <<HipStr<'s, B> as OwnedHaystackable<char>>::Hay<'a> as HaystackIter<'a>>::Slice

fn len(&self) -> usize

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

where B: Backend,

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

fn replace_range<'a>( &mut self, range: Range<usize>, with: <<HipByt<'s, B> as OwnedHaystackable<u8>>::Hay<'a> as HaystackIter<'a>>::Slice, )

where HipByt<'s, B>: 'a,

fn as_haystack<'a>( &'a self, ) -> <HipByt<'s, B> as OwnedHaystackable<u8>>::Hay<'a>

fn as_slice<'a>( &'a self, ) -> <<HipByt<'s, B> as OwnedHaystackable<u8>>::Hay<'a> as HaystackIter<'a>>::Slice

fn len(&self) -> usize

Implementors