Struct BaseCustom

pub struct BaseCustom<T> {
    pub base: u64,
    /* private fields */
}

The BaseCustom struct holds the information to perform number conversions via the gen and decimal methods.

A new instance of BaseCustom can be created with either

• BaseCustom::<char>::new(Vec<char>)
• BaseCustom::<char>::from_ordinal_range(Range)
• BaseCustom::<String>::new(String, Option<char>)

If you are going to provide a delimiter you need to use the <String> implementation. A delimiter is optional.

The primitives for BaseCustom get built from the provides characters or string groups and conversion methods are available to use then. String groupings will be single character strings if no delimiter is given, otherwise they may be strings of any length split only by the delimiter provided.

Fields

base: u64

The size of the base

Implementations

impl BaseCustom<u8>

pub fn new(bytes: &[u8]) -> BaseCustom<u8>

‘new’ creates a new BaseCustom instance and propogates the values for converting numeric bases.

new for BaseCustom<u8> requires a &[u8] as its parameters and units for measuring the custom numeric base will only be one u8 long each.

pub fn gen(&self, input_val: u64) -> Vec<u8>

gen returns a byte sequence computed from positional values the given u64 parameter evalutes to for your custom base

Example

use base_custom::BaseCustom;

let base2 = BaseCustom::<u8>::new(&[0x00, 0x01]);
assert_eq!(base2.gen(3), vec![0x01, 0x01]);

Output

vec![0x01, 0x01]

pub fn decimal(&self, input_val: &[u8]) -> u64

decimal returns a u64 value on computed from the units that form the custom base.

Example

use base_custom::BaseCustom;

let base2 = BaseCustom::<u8>::new(b"01");
assert_eq!(base2.decimal(b"00011"), 3);

Output

3

pub fn zero(&self) -> u8

Returns the zero value of your custom base

pub fn one(&self) -> u8

Returns the one value of your custom base

pub fn nth(&self, pos: usize) -> Option<u8>

Returns the nth value of your custom base

Like most indexing operations, the count starts from zero, so nth(0) returns the first value, nth(1) the second, and so on.

impl BaseCustom<char>

pub fn new(chars: Vec<char>) -> BaseCustom<char>

‘new’ creates a new BaseCustom instance and propogates the values for converting numeric bases.

new for BaseCustom<char> requires a Vec<char> as its parameters and units for measuring the custom numeric base will only be one character long each.

pub fn gen(&self, input_val: u64) -> String

gen returns a String computed from the character mapping and positional values the given u64 parameter evalutes to for your custom base

Example

use base_custom::BaseCustom;

let base2 = BaseCustom::<char>::new(vec!['0','1']);
assert_eq!(base2.gen(3), "11");

Output

"11"

pub fn char(&self, input_val: usize) -> Option<char>

char returns a char straight from the character mapping. decimal value must be within character range for a Some result.

Example

use base_custom::BaseCustom;

let base10 = BaseCustom::<char>::new("0123456789".chars().collect());
assert_eq!(base10.char(9), Some('9'));

Output

'9'

pub fn decimal<S>(&self, input_val: S) -> u64

where S: Into<String>,

decimal returns a u64 value on computed from the units that form the custom base.

Example

use base_custom::BaseCustom;

let base2 = BaseCustom::<char>::new(vec!['0','1']);
assert_eq!(base2.decimal("00011"), 3);

Output

3

pub fn zero(&self) -> &char

Returns the zero value of your custom base

pub fn one(&self) -> &char

Returns the one value of your custom base

pub fn nth(&self, pos: usize) -> Option<&char>

Returns the nth value of your custom base

Like most indexing operations, the count starts from zero, so nth(0) returns the first value, nth(1) the second, and so on.

pub fn from_ordinal_range(range: Range<u32>) -> BaseCustom<char>

Create a custom numeric base from an ascii range of ordinal values

This method currently restricts the ascii character range of the 95 typical characters starting from 32 and ending with 127. If you’d like to use characters outside of this range please use the new method.

impl BaseCustom<String>

pub fn new<S>(chars: S, delim: Option<char>) -> BaseCustom<String>

where S: Into<String>,

‘new’ creates a new BaseCustom instance and propogates the values for converting numeric bases.

new for BaseCustom<String> requires a String as its first parameter and units for measuring the custom numeric base can be one character long, or many in length. The second parameter is of Option<char> is a delimiter option for determining whether to split the string into single character length strings or possibly multiple length if the delimiter is partitioning the string in such a way.

pub fn gen(&self, input_val: u64) -> String

gen returns a String computed from the character mapping and positional values the given u64 parameter evalutes to for your custom base

Example

use base_custom::BaseCustom;

let base2 = BaseCustom::<String>::new("01", None);
assert_eq!(base2.gen(3), "11");

Output

"11"

pub fn decimal<S>(&self, input_val: S) -> u64

where S: Into<String>,

decimal returns a u64 value on computed from the units that form the custom base.

Example

use base_custom::BaseCustom;

let base2 = BaseCustom::<String>::new("01", None);
assert_eq!(base2.decimal("00011"), 3);

Output

3

pub fn zero(&self) -> &str

Returns the zero value of your custom base

pub fn one(&self) -> &str

Returns the one value of your custom base

pub fn nth(&self, pos: usize) -> Option<&str>

Returns the nth value of your custom base

Like most indexing operations, the count starts from zero, so nth(0) returns the first value, nth(1) the second, and so on.

Trait Implementations

impl<T: Clone> Clone for BaseCustom<T>

fn clone(&self) -> BaseCustom<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BaseCustom<String>

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

Formats the value using the given formatter.

impl Debug for BaseCustom<char>

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

Formats the value using the given formatter.

impl Debug for BaseCustom<u8>

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

Formats the value using the given formatter.

impl PartialEq for BaseCustom<String>

fn eq(&self, other: &BaseCustom<String>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq for BaseCustom<char>

fn eq(&self, other: &BaseCustom<char>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq for BaseCustom<u8>

fn eq(&self, other: &BaseCustom<u8>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.