Struct letter_sequence::sequence::builder::SequenceBuilder

pub struct SequenceBuilder { /* fields omitted */ }

use letter_sequence::sequence::builder;
use std::convert::TryFrom;

let mut seq = builder::SequenceBuilder::try_from("Z")
  .unwrap()
	.upper()
	.build()
	.unwrap();
assert_eq!( seq.to_string(), "Z" );
seq.next();
assert_eq!( seq.to_string(), "AA" );

This time with .max_render_capacity() set, and lowercase

use letter_sequence::sequence::builder;
use std::convert::TryFrom;

let mut seq = builder::SequenceBuilder::try_from('y')
  .unwrap()
	.lower()
	.max_render_capacity(1)
	.build()
	.unwrap();
assert_eq!( seq.next().unwrap().to_string(), "z"  );
assert_eq!( seq.to_string(),                 "z"  );
// Without .max_render_capacity(1) this would reutrn "aa"
assert_eq!( seq.next(),                      None );

Also boring number sequence

use letter_sequence::sequence::builder;
use std::convert::TryFrom;

let mut seq = builder::SequenceBuilder::from(102)
	.numeric()
	.build()
	.unwrap();
assert_eq!( seq.next().unwrap().to_string(), "103"  );
assert_eq!( seq.to_string(),                 "103"  );

Implementations

impl SequenceBuilder

pub fn new(start: u64) -> Self

Creates a new Sequence starting at start (0-base)

use letter_sequence::sequence::builder;

let seq = builder::SequenceBuilder::new(2).upper().build().unwrap();
assert_eq!( seq.to_string(), "C" );

let seq = builder::SequenceBuilder::new(5).build().unwrap();
assert_eq!( seq.to_string(), "5" );

pub fn max_render_capacity(self, chars: u8) -> Self

Limits the chacters in rendered output, incrementing past limit generates error. default: unlimited

pub fn length(self, chars: u8) -> Self

Limits the minimum width of the rendered output, this only works on Numeric which effectively zero-pads the output.

pub fn lower(self) -> Self

Render the sequence in lowercase

pub fn upper(self) -> Self

Render the sequence in uppercase, default

pub fn numeric(self) -> Self

Render the sequence in digits

pub fn build(self) -> Result<Sequence, SequenceError>

Trait Implementations

impl Debug for SequenceBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for SequenceBuilder

fn default() -> SequenceBuilder

Returns the “default value” for a type.

impl From<u64> for SequenceBuilder

fn from(value: u64) -> Self

Performs the conversion.

impl TryFrom<&'_ str> for SequenceBuilder

use letter_sequence::sequence::builder::SequenceBuilder;
use std::convert::TryFrom;
assert_eq!(
	SequenceBuilder::try_from("00001")
		.unwrap()
		.build()
		.unwrap()
		.to_string(),
	"1"
);
assert_eq!(
	SequenceBuilder::try_from("00001")
		.unwrap()
		.upper()
		.build()
		.unwrap()
		.to_string(),
	"B"
);

type Error = SequenceError

The type returned in the event of a conversion error.

fn try_from(value: &str) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<char> for SequenceBuilder

type Error = SequenceError

The type returned in the event of a conversion error.

fn try_from(value: char) -> Result<Self, Self::Error>

Performs the conversion.