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.

assert_eq!(
    "By-Tor And The Snow Dog".from_case(Case::Title).to_case(Case::Snake),
    "by-tor_and_the_snow_dog",
);

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};
assert_eq!(
    "Alan Turing"
        .from_case(Case::Snake) // from Casing trait
        .from_case(Case::Title) // from StateConverter, overwrites previous
        .to_case(Case::Kebab),
    "alan-turing"
);

pub fn set_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};
assert_eq!(
    "Vector5d Transformation"
        .from_case(Case::Title) // from Casing trait
        .set_boundaries(&[Boundary::Space, Boundary::LowerDigit]) // overwrites `from_case`
        .to_case(Case::Kebab),
    "vector-5d-transformation"
);

pub fn remove_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!(
    "2dTransformation"
        .from_case(Case::Camel)
        .remove_boundaries(&Boundary::digits())
        .to_case(Case::Snake),
    "2d_transformation"
);

pub fn remove_empty(self) -> StateConverter<'a, T>

Prepends the RemoveEmpty pattern to filter out empty words before conversion. This is useful when splitting produces empty words from leading, trailing, and duplicate delimiters.

use convert_case::{Case, Casing};
assert_eq!(
    "_leading_underscore"
        .from_case(Case::Snake)
        .remove_empty()
        .to_case(Case::Camel),
    "leadingUnderscore"
);

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".from_case(Case::Title).to_case(Case::Lower),
    "ice-cream social",
);