Struct spider::CaseInsensitiveString

pub struct CaseInsensitiveString(/* private fields */);

case-insensitive string handling

Implementations

impl CaseInsensitiveString

pub fn new<'a, B>(bytes: &'a B) -> CaseInsensitiveString

where B: AsRef<[u8]> + ?Sized,

Creates a CaseInsensitiveString slice from any byte slice.

This is a cost-free conversion.

Example

You can create CaseInsensitiveString’s from byte arrays, byte slices or string slices:

use case_insensitive_string::CaseInsensitiveString;

let a = CaseInsensitiveString::new(b"abc");
let b = CaseInsensitiveString::new("abc");

assert_eq!(a, b);

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

pub fn inner(&self) -> &CompactString

pub fn push(&mut self, ch: char)

Appends the given char to the end of this CaseInsensitiveString.

Examples

let mut s = CaseInsensitiveString::new("foo");

s.push('b');
s.push('a');
s.push('r');

assert_eq!(CaseInsensitiveString::from("foobar"), s);

pub fn push_str(&mut self, s: &str)

Appends a given string slice onto the end of this CaseInsensitiveString

Examples

let mut s = CaseInsensitiveString::new("abc");

s.push_str("123");

assert_eq!(CaseInsensitiveString::new("abc123"), s);

pub fn remove(&mut self, idx: usize) -> char

Removes a char from this CaseInsensitiveString at a byte position and returns it.

This is an O(n) operation, as it requires copying every element in the buffer.

Panics

Panics if idx is larger than or equal to the CaseInsensitiveString’s length, or if it does not lie on a char boundary.

Examples

Basic usage:

let mut c = CaseInsensitiveString::from("hello world");

assert_eq!(c.remove(0), 'h');
assert_eq!(c, "ello world".into());

assert_eq!(c.remove(5), 'w');
assert_eq!(c, "ello orld".into());

Past total length:

let mut c = CaseInsensitiveString::from("hello there!");
c.remove(100);

Not on char boundary:

let mut c = CaseInsensitiveString::from("🦄");
c.remove(1);

pub fn len(&self) -> usize

Returns the length of the CaseInsensitiveString in bytes, not chars or graphemes.

When using UTF-8 encoding (which all strings in Rust do) a single character will be 1 to 4 bytes long, therefore the return value of this method might not be what a human considers the length of the string.

Examples

let ascii = CaseInsensitiveString::new("hello world");
assert_eq!(ascii.len(), 11);

let emoji = CaseInsensitiveString::new("👱");
assert_eq!(emoji.len(), 4);

pub fn is_empty(&self) -> bool

Returns true if the CaseInsensitiveString has a length of 0, false otherwise

Examples

let mut msg = CaseInsensitiveString::new("");
assert!(msg.is_empty());

// add some characters
msg.push_str("hello reader!");
assert!(!msg.is_empty());

Trait Implementations

impl AsRef<str> for CaseInsensitiveString

fn as_ref(&self) -> &str

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

impl Clone for CaseInsensitiveString

fn clone(&self) -> CaseInsensitiveString

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CaseInsensitiveString

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

Formats the value using the given formatter.

impl Default for CaseInsensitiveString

fn default() -> CaseInsensitiveString

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CaseInsensitiveString

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&[u8]> for CaseInsensitiveString

fn from(s: &[u8]) -> CaseInsensitiveString

Converts to this type from the input type.

impl From<&str> for CaseInsensitiveString

fn from(s: &str) -> CaseInsensitiveString

Converts to this type from the input type.

impl From<CompactString> for CaseInsensitiveString

fn from(s: CompactString) -> CaseInsensitiveString

Converts to this type from the input type.

impl From<String> for CaseInsensitiveString

fn from(s: String) -> CaseInsensitiveString

Converts to this type from the input type.

impl Hash for CaseInsensitiveString

fn hash<H>(&self, state: &mut H)

where H: Hasher,

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 PartialEq for CaseInsensitiveString

fn eq(&self, other: &CaseInsensitiveString) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for CaseInsensitiveString

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for CaseInsensitiveString