Struct fluent_uri::enc::EStr

#[repr(transparent)]
pub struct EStr { /* private fields */ }

Percent-encoded string slices.

Examples

Parse key-value pairs from a query string into a hash map:

use std::collections::HashMap;
use fluent_uri::enc::EStr;

let query = "name=%E5%BC%A0%E4%B8%89&speech=%C2%A1Ol%C3%A9!";
let map: HashMap<_, _> = EStr::new(query)
    .split('&')
    .filter_map(|pair| pair.split_once('='))
    .map(|(k, v)| (k.decode(), v.decode()))
    .filter_map(|(k, v)| k.into_string().ok().zip(v.into_string().ok()))
    .collect();
assert_eq!(map["name"], "张三");
assert_eq!(map["speech"], "¡Olé!");

Implementations

impl EStr

pub const fn new(s: &str) -> &EStr

Converts a string slice to an EStr.

Panics

Panics if the string is not properly encoded.

pub fn as_str(&self) -> &str

Yields the underlying string slice.

pub fn decode(&self) -> Decode<'_>

Decodes the EStr.

Examples

use fluent_uri::enc::EStr;

let dec = EStr::new("%C2%BF").decode();
assert_eq!(dec.as_bytes(), &[0xc2, 0xbf]);
assert_eq!(dec.into_string()?, "¿");

pub fn split(&self, delim: char) -> Split<'_>

Returns an iterator over subslices of the EStr separated by the given delimiter.

Panics

Panics if the delimiter is not a reserved character.

Examples

use fluent_uri::enc::EStr;

assert!(EStr::new("a,b,c").split(',').eq(["a", "b", "c"]));
assert!(EStr::new(",").split(',').eq(["", ""]));

pub fn split_once(&self, delim: char) -> Option<(&EStr, &EStr)>

Splits the EStr on the first occurrence of the given delimiter and returns prefix before delimiter and suffix after delimiter.

Returns None if the delimiter is not found.

Panics

Panics if the delimiter is not a reserved character.

Examples

use fluent_uri::enc::EStr;

let (k, v) = EStr::new("key=value").split_once('=').unwrap();
assert_eq!(k, "key");
assert_eq!(v, "value");

assert!(EStr::new("abc").split_once(';').is_none());

Trait Implementations

impl AsRef<[u8]> for EStr

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

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

impl AsRef<str> for EStr

fn as_ref(&self) -> &str

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

impl Borrow<str> for &EStr

fn borrow(&self) -> &str

Immutably borrows from an owned value.

impl Debug for EStr

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

Formats the value using the given formatter.

impl Default for &EStr

fn default() -> &'static EStr

Creates an empty EStr.

impl Display for EStr

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

Formats the value using the given formatter.

impl Hash for EStr

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

Feeds this value into the given Hasher.

impl PartialEq<EStr> for EStr

Implements equality comparisons on EStrs.

EStrs are compared by their byte values. Percent-encoding normalization is not performed prior to comparison.

fn eq(&self, other: &EStr) -> 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 PartialEq<EStr> for str

fn eq(&self, other: &EStr) -> 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 PartialEq<str> for EStr

fn eq(&self, other: &str) -> 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 Eq for EStr