Struct letter_sequence::sequence::builder::SequenceBuilder

pub struct SequenceBuilder { /* private fields */ }

use letter_sequence::SequenceBuilder;
use std::convert::TryFrom;

let mut seq = SequenceBuilder::try_from("Z")
  .unwrap()
	.upper()
	.build()
	.unwrap();
// First call to .next() returns starting element
let elem = seq.next().unwrap();
assert_eq!( elem.to_string(), "Z" );
let elem = seq.next().unwrap();
assert_eq!( elem.to_string(), "AA" );
let elem = seq.next().unwrap();
assert_eq!( elem.to_string(), "AB" );
let elem = seq.next().unwrap();
assert_eq!( elem.to_string(), "AC" );

This time with .max_render_capacity() set, and lowercase

use letter_sequence::SequenceBuilder;
use std::convert::TryFrom;

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

Also boring number sequence

use letter_sequence::SequenceBuilder;
use std::convert::TryFrom;

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

You can also set the step!

use letter_sequence::SequenceBuilder;
use std::convert::TryFrom;
 
let mut seq = SequenceBuilder::from(0)
	.numeric()
	.step(2)
	.build()
	.unwrap();
let elem = seq.next().unwrap();
assert_eq!( elem.to_string(), "0"  );
let elem = seq.next().unwrap();
assert_eq!( elem.to_string(), "2"  );
let elem = seq.next().unwrap();
assert_eq!( elem.to_string(), "4"  );

let mut seq = SequenceBuilder::try_from("A")
  .unwrap()
	.step(2)
	.upper()
	.build()
	.unwrap();
let elem = seq.next().unwrap();
assert_eq!( elem.to_string(), "A" );
let elem = seq.next().unwrap();
assert_eq!( elem.to_string(), "C" );
let elem = seq.next().unwrap();
assert_eq!( elem.to_string(), "E" );

Implementations

impl SequenceBuilder

pub fn new() -> Self

pub fn end(self, end: u64) -> Self

Sets the end, default half-open (exclusive end), see .inclusive()

pub fn start(self, start: u64) -> Self

Sets the start

pub fn step(self, step: u32) -> Self

Sets the increment to step to

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

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

use letter_sequence::{ SequenceBuilder, SequenceError };
use std::convert::TryFrom;
let mut seq = SequenceBuilder::try_from("y").unwrap().max_render_capacity(1).build().unwrap();
let elem = seq.next().unwrap();
assert_eq!( elem.to_string(), "y" );
let elem = seq.next().unwrap();
assert_eq!( elem.to_string(), "z" );
assert_eq!( seq.next(), None );
assert_eq!( seq.next(), None );

pub fn min_render_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 exclusive(self) -> Self

This is the default: a half-open range that excludes the end

pub fn inclusive(self) -> Self

Close the range, include the end

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() -> Self

Returns the “default value” for a type.

impl From<u64> for SequenceBuilder

fn from(start: u64) -> Self

Converts to this type from the input type.

impl TryFrom<&str> for SequenceBuilder

// use letter_sequence::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<(&str, &str)> for SequenceBuilder

type Error = SequenceError

The type returned in the event of a conversion error.

fn try_from((start, end): (&str, &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.