Struct Converter

struct Converter { ... }

The parameters for performing a case conversion.

A Converter stores three fields needed for case conversion.

  1. boundaries: how a string is segmented into words.
  2. pattern: how words are mutated, or how each character's case will change.
  3. delim or delimeter: how the mutated words are joined into the final string.

Then calling convert on a Converter will apply a case conversion defined by those fields. The Converter struct is what is used underneath those functions available in the Casing struct.

You can use Converter when you need more specificity on conversion than those provided in Casing, or if it is simply more convenient or explicit.

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

let s = "DialogueBox-border-shadow";

// Convert using Casing trait
assert_eq!(
    "dialoguebox_border_shadow",
    s.from_case(Case::Kebab).to_case(Case::Snake)
);

// Convert using similar functions on Converter
let conv = Converter::new()
    .from_case(Case::Kebab)
    .to_case(Case::Snake);
assert_eq!("dialoguebox_border_shadow", conv.convert(s));

// Convert by setting each field explicitly.
let conv = Converter::new()
    .set_boundaries(&[Boundary::HYPHEN])
    .set_pattern(Pattern::Lowercase)
    .set_delim("_");
assert_eq!("dialoguebox_border_shadow", conv.convert(s));

Or you can use Converter when you are trying to make a unique case not provided as a variant of Case.

# use convert_case::{Boundary, Case, Casing, Converter, Pattern};
let dot_camel = Converter::new()
    .set_boundaries(&[Boundary::LOWER_UPPER, Boundary::LOWER_DIGIT])
    .set_pattern(Pattern::Camel)
    .set_delim(".");
assert_eq!("collision.Shape.2d", dot_camel.convert("CollisionShape2D"));

Fields

boundaries: Vec<Boundary>

How a string is segmented into words.

pattern: Option<Pattern>

How each word is mutated before joining. In the case that there is no pattern, none of the words will be mutated before joining and will maintain whatever case they were in the original string.

delim: String

The string used to join mutated words together.

Implementations

impl Converter

fn new() -> Self

Creates a new Converter with default fields. This is the same as Default::default(). The Converter will use Boundary::defaults() for boundaries, no pattern, and an empty string as a delimeter.

# use convert_case::Converter;
let conv = Converter::new();
assert_eq!("DeathPerennialQUEST", conv.convert("Death-Perennial QUEST"))

fn convert<T>(self: &Self, s: T) -> String
where
    T: AsRef<str>

Converts a string.

# use convert_case::{Case, Converter};
let conv = Converter::new()
    .to_case(Case::Camel);
assert_eq!("xmlHttpRequest", conv.convert("XML_HTTP_Request"))

fn to_case(self: Self, case: Case) -> Self

Set the pattern and delimiter to those associated with the given case.

# use convert_case::{Case, Converter};
let conv = Converter::new()
    .to_case(Case::Pascal);
assert_eq!("VariableName", conv.convert("variable name"))

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

Sets the boundaries to those associated with the provided case. This is used by the from_case function in the Casing trait.

# use convert_case::{Case, Converter};
let conv = Converter::new()
    .from_case(Case::Snake)
    .to_case(Case::Title);
assert_eq!("Dot Productvalue", conv.convert("dot_productValue"))

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

Sets the boundaries to those provided.

# use convert_case::{Boundary, Case, Converter};
let conv = Converter::new()
    .set_boundaries(&[Boundary::UNDERSCORE, Boundary::LOWER_UPPER])
    .to_case(Case::Lower);
assert_eq!("panic attack dream theater", conv.convert("panicAttack_dreamTheater"))

fn add_boundary(self: Self, b: Boundary) -> Self

Adds a boundary to the list of boundaries.

# use convert_case::{Boundary, Case, Converter};
let conv = Converter::new()
    .from_case(Case::Title)
    .add_boundary(Boundary::HYPHEN)
    .to_case(Case::Snake);
assert_eq!("my_biography_video_1", conv.convert("My Biography - Video 1"))

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

Adds a vector of boundaries to the list of boundaries.

# use convert_case::{Boundary, Case, Converter};
let conv = Converter::new()
    .from_case(Case::Kebab)
    .to_case(Case::Title)
    .add_boundaries(&[Boundary::UNDERSCORE, Boundary::LOWER_UPPER]);
assert_eq!("2020 10 First Day", conv.convert("2020-10_firstDay"));

fn remove_boundary(self: Self, b: Boundary) -> Self

Removes a boundary from the list of boundaries if it exists.

# use convert_case::{Boundary, Case, Converter};
let conv = Converter::new()
    .remove_boundary(Boundary::ACRONYM)
    .to_case(Case::Kebab);
assert_eq!("httprequest-parser", conv.convert("HTTPRequest_parser"));

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

Removes all the provided boundaries from the list of boundaries if it exists.

# use convert_case::{Boundary, Case, Converter};
let conv = Converter::new()
    .remove_boundaries(&Boundary::digits())
    .to_case(Case::Snake);
assert_eq!("c04_s03_path_finding.pdf", conv.convert("C04 S03 Path Finding.pdf"));

fn set_delim<T>(self: Self, d: T) -> Self
where
    T: ToString

Sets the delimeter.

# use convert_case::{Case, Converter};
let conv = Converter::new()
    .to_case(Case::Snake)
    .set_delim(".");
assert_eq!("lower.with.dots", conv.convert("LowerWithDots"));

fn remove_delim(self: Self) -> Self

Sets the delimeter to an empty string.

# use convert_case::{Case, Converter};
let conv = Converter::new()
    .to_case(Case::Snake)
    .remove_delim();
assert_eq!("nodelimshere", conv.convert("No Delims Here"));

fn set_pattern(self: Self, p: Pattern) -> Self

Sets the pattern.

# use convert_case::{Case, Converter, Pattern};
let conv = Converter::new()
    .set_delim("_")
    .set_pattern(Pattern::Sentence);
assert_eq!("Bjarne_case", conv.convert("BJARNE CASE"));

fn remove_pattern(self: Self) -> Self

Sets the pattern field to None. Where there is no pattern, a character's case is never mutated and will be maintained at the end of conversion.

# use convert_case::{Case, Converter};
let conv = Converter::new()
    .from_case(Case::Title)
    .to_case(Case::Snake)
    .remove_pattern();
assert_eq!("KoRn_Alone_I_Break", conv.convert("KoRn Alone I Break"));

impl Default for Converter

fn default() -> Self

impl Freeze for Converter

impl RefUnwindSafe for Converter

impl Send for Converter

impl Sync for Converter

impl Unpin for Converter

impl UnsafeUnpin for Converter

impl UnwindSafe for Converter

impl<T> Any for Converter

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for Converter

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

impl<T> BorrowMut for Converter

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

impl<T> From for Converter

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into for Converter

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 Converter

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

impl<T, U> TryInto for Converter

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