Struct StateConverter

pub struct StateConverter<'a, T: AsRef<str>> { /* private fields */ }

Holds information about parsing before converting into a case.

This struct is used when invoking the from_case and with_boundaries methods on Casing. For a more fine grained approach to case conversion, consider using the Converter struct.

use convert_case::{Case, Casing};

let title = "ninety-nine_problems".from_case(Case::Snake).to_case(Case::Title);
assert_eq!("Ninety-nine Problems", title);

Implementations

impl<'a, T: AsRef<str>> StateConverter<'a, T>

fn from_case(self, case: Case<'_>) -> Self

Uses the boundaries associated with case for word segmentation. This will overwrite any boundary information initialized before. This method is likely not useful, but provided anyway.

use convert_case::{Case, Casing};

let name = "Chuck Schuldiner"
    .from_case(Case::Snake) // from Casing trait
    .from_case(Case::Title) // from StateConverter, overwrites previous
    .to_case(Case::Kebab);
assert_eq!("chuck-schuldiner", name);

fn set_boundaries(self, bs: &[Boundary]) -> Self

Overwrites boundaries for word segmentation with those provided. This will overwrite any boundary information initialized before. This method is likely not useful, but provided anyway.

use convert_case::{Boundary, Case, Casing};

let song = "theHumbling river-puscifer"
    .from_case(Case::Kebab) // from Casing trait
    .set_boundaries(&[Boundary::Space, Boundary::LowerUpper]) // overwrites `from_case`
    .to_case(Case::Pascal);
assert_eq!("TheHumblingRiver-puscifer", song);  // doesn't split on hyphen `-`

fn remove_boundaries(self, bs: &[Boundary]) -> Self

Removes any boundaries that were already initialized. This is particularly useful when a case like Case::Camel has a lot of associated word boundaries, but you want to exclude some.

use convert_case::{Boundary, Case, Casing};

assert_eq!(
    "2d_transformation",
    "2dTransformation"
        .from_case(Case::Camel)
        .remove_boundaries(&Boundary::digits())
        .to_case(Case::Snake)
);

fn to_case(self, case: Case<'_>) -> String

Consumes the StateConverter and returns the converted string.

use convert_case::{Boundary, Case, Casing};

assert_eq!(
    "ice-cream social",
    "Ice-Cream Social".from_case(Case::Title).to_case(Case::Lower)
);

Auto Trait Implementations

impl<'a, T> Freeze for StateConverter<'a, T> where &'a T: Freeze,

impl<'a, T> RefUnwindSafe for StateConverter<'a, T> where &'a T: RefUnwindSafe,

impl<'a, T> Send for StateConverter<'a, T> where &'a T: Send,

impl<'a, T> Sync for StateConverter<'a, T> where &'a T: Sync,

impl<'a, T> Unpin for StateConverter<'a, T> where &'a T: Unpin,

impl<'a, T> UnsafeUnpin for StateConverter<'a, T> where &'a T: UnsafeUnpin,

impl<'a, T> UnwindSafe for StateConverter<'a, T> where &'a T: UnwindSafe,

Blanket Implementations

impl<T> Any for StateConverter<'a, T> where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for StateConverter<'a, T> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for StateConverter<'a, T> where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> From<T> for StateConverter<'a, T>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into<U> for StateConverter<'a, T> where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom<U> for StateConverter<'a, T> where U: Into<T>,

type Error = Infallible;
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for StateConverter<'a, T> where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>