Struct Rank 

pub struct Rank(/* private fields */);

Comparable ranks ordered lexicographically.

Generated ranks are always in normal form: a non-empty alphanumeric string with no trailing 0. In that form, lexicographic comparison matches the intended rank order; see Rank::parse for the validation rules.

Implementations

impl Rank

pub fn as_str(&self) -> &str

Return the rank string.

pub fn parse(s: &str) -> Result<Rank>

Parse a rank from its string representation.

Conditions for a valid rank (normal form):

• Non-empty and all base-36 alphanumeric characters (0-9a-z).
• Does not end with 0. A trailing zero does not change a base-36 fraction ("1" and "10" both represent 1/36), which would permit multiple strings for the same rank. Disallowing it makes the mapping between rank strings and values one-to-one, so lexicographic comparison always matches numeric order. Leading and middle zeroes remain valid: they contribute to the value ("01" ≠ "1").
• This rule also excludes zero (all digits 0), which is reserved as the lower endpoint of the open rank interval.

If the condition is not met, Error::InvalidRank.

Examples

use pinto::rank::Rank;

let lower = Rank::parse("i").expect("canonical rank");
let upper = Rank::after(Some(&lower));
assert!(lower < upper);

pub fn between(lo: Option<&Rank>, hi: Option<&Rank>) -> Result<Rank>

Return a rank between lo and hi. None represents the open lower or upper endpoint.

Precondition: lo < hi (when both are Some). The return value mid satisfies lo < mid < hi.

Returns Error::InvalidRank when the bounds are not in ascending order.

pub fn after(prev: Option<&Rank>) -> Rank

Return the rank immediately following (greater than) prev. If prev is None, return the first rank.

Uses tail-add-only logic and does not go through between(prev, None) (midpoint to 1.0). The midpoint method halves the difference from 1.0 on each append, which makes repeated appends produce increasingly long strings. Instead, compute the shortest rank greater than prev directly:

• Increase the digits less than z (BASE-1) by one when looking from the right edge, and truncate the rest. It lexicographically exceeds prev by that digit, and the number of digits does not increase (often decreases).
• Only when all digits are z (prev ≒ 1.0), add an intermediate digit (BASE/2) to the end to extend it.

The incremented digits and added intermediate digits are always non-zero, so the result is always in normal form (no trailing zeros).

pub fn before(next: Option<&Rank>) -> Rank

Return the rank immediately preceding (less than) next.

This is a convenience wrapper around between(None, Some(next)), matching Rank::after so callers do not need to spell out the open lower endpoint.

• before(Some(n)) always returns a rank less than n.
• before(None) returns the median rank (base-36 "i" = 0.5), matching Rank::after with None.

pub fn rebalance(count: usize) -> Vec<Rank>

Generate a short, evenly spaced rank sequence while maintaining the order.

The smallest fixed width that can hold count canonical ranks is chosen. Every rank has that width and a non-zero last digit, so it remains in normal form. The returned sequence is strictly monotonically increasing and leaves roughly equal gaps between adjacent values.

If count is zero, the returned vector is empty.

Trait Implementations

impl Clone for Rank

fn clone(&self) -> Rank

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Rank

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

Formats the value using the given formatter.

impl Display for Rank

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

Formats the value using the given formatter.

impl Eq for Rank

impl FromStr for Rank

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self>

Parses a string s to return a value of this type.

impl Hash for Rank

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Rank

fn cmp(&self, other: &Rank) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Rank

fn eq(&self, other: &Rank) -> bool

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Rank

fn partial_cmp(&self, other: &Rank) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for Rank