Struct `StateConverter`

struct StateConverter<'a, T: AsRef<str>> { ... }

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: 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 with_boundaries(self: 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
    .with_boundaries(&[Boundary::SPACE, Boundary::LOWER_UPPER]) // overwrites `from_case`
    .to_case(Case::Pascal);
assert_eq!("TheHumblingRiver-puscifer", song);  // doesn't split on hyphen `-`

fn without_boundaries(self: 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)
        .without_boundaries(&Boundary::digits())
        .to_case(Case::Snake)
);

fn to_case(self: 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)
);

`impl<'a, T> Freeze for StateConverter<'a, T>`

`impl<'a, T> RefUnwindSafe for StateConverter<'a, T>`

`impl<'a, T> Send for StateConverter<'a, T>`

`impl<'a, T> Sync for StateConverter<'a, T>`

`impl<'a, T> Unpin for StateConverter<'a, T>`

`impl<'a, T> UnsafeUnpin for StateConverter<'a, T>`

`impl<'a, T> UnwindSafe for StateConverter<'a, T>`

`impl<T> Any for StateConverter<'a, T>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for StateConverter<'a, T>`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for StateConverter<'a, T>`

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

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

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T, U> Into for StateConverter<'a, T>`

fn into(self: 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 for StateConverter<'a, T>`

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

`impl<T, U> TryInto for StateConverter<'a, T>`

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