Struct StateConverter 

pub struct StateConverter<'a, T>
where
    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> StateConverter<'a, T>

where T: AsRef<str>,

pub fn from_case(self, case: Case) -> StateConverter<'a, T>

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);

pub fn with_boundaries(self, bs: &[Boundary]) -> StateConverter<'a, T>

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

pub fn without_boundaries(self, bs: &[Boundary]) -> StateConverter<'a, T>

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)
);

pub 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)
);