Struct tinyid::TinyId

pub struct TinyId { /* private fields */ }

A tiny 8-byte ID type that is NOT cryptographically secure, but is easy and convenient for tasks that don’t require the utmost security or uniqueness. During lightweight testing, between 1 and 10 million IDs can be generated without any collisions, and performance has been pretty good.

Implementations

impl TinyId

pub const LETTER_COUNT: usize = 64usize

The number of letters that make up the potential pool of characters for a TinyId.

pub const LETTERS: [u8; 64] = _

The letter pool used during generation of a TinyId.

pub const NULL_CHAR: u8 = 0u8

The byte used to represent null data / ids.

pub const NULL_DATA: [u8; 8] = _

An instance of a fully null byte array, used as the basis for null ids.

pub const fn is_valid_byte(byte: u8) -> bool

Test whether the given byte is valid for use as one of the 8 bytes in a TinyId.

This function exists because I’m tired of writing if LETTERS.contains(&byte) everywhere. Hopefully it is also more efficient to do it this way. Letters (as u8): [45, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 95, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122] aka [45, 48..=57, 65..=90, 95, 97..=122]

pub fn null() -> Self

Create an instance of the null TinyId.

Examples found in repository

examples/basic.rs (line 48)

fn main() {
    // Create a random ID
    let rand_id = TinyId::random();

    // Parse a string into a Result<TinyId, TinyIdError> for possibly unsafe / invalid ID strings
    let maybe = TinyId::from_str("AAAABBBB");
    assert!(maybe.is_ok());
    let bad = TinyId::from_str("AAAABBB");
    assert!(bad.is_err());

    // Parse a string you **KNOW** is safe into a TinyId
    let parsed = TinyId::from_str_unchecked("AAAABBBB");

    // All expected operations are available on TinyIds
    // Equality is a simple byte comparison so it should be fast and cheap!
    assert_eq!(maybe.unwrap(), parsed);

    // IDs may be printed using Display or Debug
    println!("Random ID: {rand_id}");
    println!("Parsed ID: {parsed}");
    println!(" Debug ID: {parsed:?}");

    // IDs are small!
    println!("TinyID Size: {}", std::mem::size_of::<TinyId>());

    // IDs are case-sensitive
    let parsed2 = TinyId::from_str_unchecked("aaaaBBBB");
    assert_ne!(parsed, parsed2);

    // Check whether an ID starts with a given string. Example use case would be providing a
    // list of IDs to a user, and asking for a partial string to match against so the user
    // doesn't have to type the entire thing.
    assert!(parsed.starts_with("AAAA"));
    assert!(parsed.ends_with("BBBB"));
    assert!(!parsed.starts_with("BBBB"));

    // IDs are copied when assigned.
    let mut switched = parsed;
    assert_eq!(switched, parsed);

    // Validity can be checked, and a "marker" exists for null / invalid IDs.
    assert!(switched.is_valid());
    assert!(!switched.is_null());
    assert_ne!(switched, TinyId::null());
    // Mutable IDs can be made null. This change has no effect on the `parsed` variable.
    switched.make_null();
    assert!(!switched.is_valid());
    assert!(switched.is_null());
    assert_eq!(switched, TinyId::null());
}

pub fn random() -> Self

Create a new random TinyId.

Examples found in repository

examples/collision.rs (line 30)

fn get_collision() -> usize {
    let mut ids = std::collections::HashSet::new();
    loop {
        let id = TinyId::random();
        if !ids.insert(id) {
            break;
        }
    }
    ids.len()
}

examples/collision_average.rs (line 47)

fn run_until_collision() -> usize {
    let mut ids = std::collections::HashSet::new();
    let mut iters = 0;
    loop {
        iters += 1;
        let id = TinyId::random();
        if !ids.insert(id) {
            break;
        }
    }
    iters
}

examples/sample.rs (line 14)

fn main() {
    println!("Generating {ITERS} TinyIds...");
    for x in (0..(ITERS)).step_by(2) {
        let id = TinyId::random();
        let mut n = x + 1;
        print!("#{n:03}: {id}");
        print!(" | ");
        let id = TinyId::random();
        n += 1;
        println!("#{n:03}: {id}");
    }
}

examples/basic.rs (line 7)

fn main() {
    // Create a random ID
    let rand_id = TinyId::random();

    // Parse a string into a Result<TinyId, TinyIdError> for possibly unsafe / invalid ID strings
    let maybe = TinyId::from_str("AAAABBBB");
    assert!(maybe.is_ok());
    let bad = TinyId::from_str("AAAABBB");
    assert!(bad.is_err());

    // Parse a string you **KNOW** is safe into a TinyId
    let parsed = TinyId::from_str_unchecked("AAAABBBB");

    // All expected operations are available on TinyIds
    // Equality is a simple byte comparison so it should be fast and cheap!
    assert_eq!(maybe.unwrap(), parsed);

    // IDs may be printed using Display or Debug
    println!("Random ID: {rand_id}");
    println!("Parsed ID: {parsed}");
    println!(" Debug ID: {parsed:?}");

    // IDs are small!
    println!("TinyID Size: {}", std::mem::size_of::<TinyId>());

    // IDs are case-sensitive
    let parsed2 = TinyId::from_str_unchecked("aaaaBBBB");
    assert_ne!(parsed, parsed2);

    // Check whether an ID starts with a given string. Example use case would be providing a
    // list of IDs to a user, and asking for a partial string to match against so the user
    // doesn't have to type the entire thing.
    assert!(parsed.starts_with("AAAA"));
    assert!(parsed.ends_with("BBBB"));
    assert!(!parsed.starts_with("BBBB"));

    // IDs are copied when assigned.
    let mut switched = parsed;
    assert_eq!(switched, parsed);

    // Validity can be checked, and a "marker" exists for null / invalid IDs.
    assert!(switched.is_valid());
    assert!(!switched.is_null());
    assert_ne!(switched, TinyId::null());
    // Mutable IDs can be made null. This change has no effect on the `parsed` variable.
    switched.make_null();
    assert!(!switched.is_valid());
    assert!(switched.is_null());
    assert_eq!(switched, TinyId::null());
}

pub fn is_valid(self) -> bool

Checks whether this TinyId is null or has any invalid bytes.

Examples found in repository

examples/basic.rs (line 46)

fn main() {
    // Create a random ID
    let rand_id = TinyId::random();

    // Parse a string into a Result<TinyId, TinyIdError> for possibly unsafe / invalid ID strings
    let maybe = TinyId::from_str("AAAABBBB");
    assert!(maybe.is_ok());
    let bad = TinyId::from_str("AAAABBB");
    assert!(bad.is_err());

    // Parse a string you **KNOW** is safe into a TinyId
    let parsed = TinyId::from_str_unchecked("AAAABBBB");

    // All expected operations are available on TinyIds
    // Equality is a simple byte comparison so it should be fast and cheap!
    assert_eq!(maybe.unwrap(), parsed);

    // IDs may be printed using Display or Debug
    println!("Random ID: {rand_id}");
    println!("Parsed ID: {parsed}");
    println!(" Debug ID: {parsed:?}");

    // IDs are small!
    println!("TinyID Size: {}", std::mem::size_of::<TinyId>());

    // IDs are case-sensitive
    let parsed2 = TinyId::from_str_unchecked("aaaaBBBB");
    assert_ne!(parsed, parsed2);

    // Check whether an ID starts with a given string. Example use case would be providing a
    // list of IDs to a user, and asking for a partial string to match against so the user
    // doesn't have to type the entire thing.
    assert!(parsed.starts_with("AAAA"));
    assert!(parsed.ends_with("BBBB"));
    assert!(!parsed.starts_with("BBBB"));

    // IDs are copied when assigned.
    let mut switched = parsed;
    assert_eq!(switched, parsed);

    // Validity can be checked, and a "marker" exists for null / invalid IDs.
    assert!(switched.is_valid());
    assert!(!switched.is_null());
    assert_ne!(switched, TinyId::null());
    // Mutable IDs can be made null. This change has no effect on the `parsed` variable.
    switched.make_null();
    assert!(!switched.is_valid());
    assert!(switched.is_null());
    assert_eq!(switched, TinyId::null());
}

pub fn is_null(self) -> bool

Checks whether this TinyId is null.

Examples found in repository

examples/basic.rs (line 47)

fn main() {
    // Create a random ID
    let rand_id = TinyId::random();

    // Parse a string into a Result<TinyId, TinyIdError> for possibly unsafe / invalid ID strings
    let maybe = TinyId::from_str("AAAABBBB");
    assert!(maybe.is_ok());
    let bad = TinyId::from_str("AAAABBB");
    assert!(bad.is_err());

    // Parse a string you **KNOW** is safe into a TinyId
    let parsed = TinyId::from_str_unchecked("AAAABBBB");

    // All expected operations are available on TinyIds
    // Equality is a simple byte comparison so it should be fast and cheap!
    assert_eq!(maybe.unwrap(), parsed);

    // IDs may be printed using Display or Debug
    println!("Random ID: {rand_id}");
    println!("Parsed ID: {parsed}");
    println!(" Debug ID: {parsed:?}");

    // IDs are small!
    println!("TinyID Size: {}", std::mem::size_of::<TinyId>());

    // IDs are case-sensitive
    let parsed2 = TinyId::from_str_unchecked("aaaaBBBB");
    assert_ne!(parsed, parsed2);

    // Check whether an ID starts with a given string. Example use case would be providing a
    // list of IDs to a user, and asking for a partial string to match against so the user
    // doesn't have to type the entire thing.
    assert!(parsed.starts_with("AAAA"));
    assert!(parsed.ends_with("BBBB"));
    assert!(!parsed.starts_with("BBBB"));

    // IDs are copied when assigned.
    let mut switched = parsed;
    assert_eq!(switched, parsed);

    // Validity can be checked, and a "marker" exists for null / invalid IDs.
    assert!(switched.is_valid());
    assert!(!switched.is_null());
    assert_ne!(switched, TinyId::null());
    // Mutable IDs can be made null. This change has no effect on the `parsed` variable.
    switched.make_null();
    assert!(!switched.is_valid());
    assert!(switched.is_null());
    assert_eq!(switched, TinyId::null());
}

pub fn make_null(&mut self)

Makes this TinyId null.

Examples found in repository

examples/basic.rs (line 50)

fn main() {
    // Create a random ID
    let rand_id = TinyId::random();

    // Parse a string into a Result<TinyId, TinyIdError> for possibly unsafe / invalid ID strings
    let maybe = TinyId::from_str("AAAABBBB");
    assert!(maybe.is_ok());
    let bad = TinyId::from_str("AAAABBB");
    assert!(bad.is_err());

    // Parse a string you **KNOW** is safe into a TinyId
    let parsed = TinyId::from_str_unchecked("AAAABBBB");

    // All expected operations are available on TinyIds
    // Equality is a simple byte comparison so it should be fast and cheap!
    assert_eq!(maybe.unwrap(), parsed);

    // IDs may be printed using Display or Debug
    println!("Random ID: {rand_id}");
    println!("Parsed ID: {parsed}");
    println!(" Debug ID: {parsed:?}");

    // IDs are small!
    println!("TinyID Size: {}", std::mem::size_of::<TinyId>());

    // IDs are case-sensitive
    let parsed2 = TinyId::from_str_unchecked("aaaaBBBB");
    assert_ne!(parsed, parsed2);

    // Check whether an ID starts with a given string. Example use case would be providing a
    // list of IDs to a user, and asking for a partial string to match against so the user
    // doesn't have to type the entire thing.
    assert!(parsed.starts_with("AAAA"));
    assert!(parsed.ends_with("BBBB"));
    assert!(!parsed.starts_with("BBBB"));

    // IDs are copied when assigned.
    let mut switched = parsed;
    assert_eq!(switched, parsed);

    // Validity can be checked, and a "marker" exists for null / invalid IDs.
    assert!(switched.is_valid());
    assert!(!switched.is_null());
    assert_ne!(switched, TinyId::null());
    // Mutable IDs can be made null. This change has no effect on the `parsed` variable.
    switched.make_null();
    assert!(!switched.is_valid());
    assert!(switched.is_null());
    assert_eq!(switched, TinyId::null());
}

pub fn from_str_unchecked(s: &str) -> Self

Convert from &str to TinyId, without checking the length or individual characters of the input.

Examples found in repository

examples/basic.rs (line 16)

fn main() {
    // Create a random ID
    let rand_id = TinyId::random();

    // Parse a string into a Result<TinyId, TinyIdError> for possibly unsafe / invalid ID strings
    let maybe = TinyId::from_str("AAAABBBB");
    assert!(maybe.is_ok());
    let bad = TinyId::from_str("AAAABBB");
    assert!(bad.is_err());

    // Parse a string you **KNOW** is safe into a TinyId
    let parsed = TinyId::from_str_unchecked("AAAABBBB");

    // All expected operations are available on TinyIds
    // Equality is a simple byte comparison so it should be fast and cheap!
    assert_eq!(maybe.unwrap(), parsed);

    // IDs may be printed using Display or Debug
    println!("Random ID: {rand_id}");
    println!("Parsed ID: {parsed}");
    println!(" Debug ID: {parsed:?}");

    // IDs are small!
    println!("TinyID Size: {}", std::mem::size_of::<TinyId>());

    // IDs are case-sensitive
    let parsed2 = TinyId::from_str_unchecked("aaaaBBBB");
    assert_ne!(parsed, parsed2);

    // Check whether an ID starts with a given string. Example use case would be providing a
    // list of IDs to a user, and asking for a partial string to match against so the user
    // doesn't have to type the entire thing.
    assert!(parsed.starts_with("AAAA"));
    assert!(parsed.ends_with("BBBB"));
    assert!(!parsed.starts_with("BBBB"));

    // IDs are copied when assigned.
    let mut switched = parsed;
    assert_eq!(switched, parsed);

    // Validity can be checked, and a "marker" exists for null / invalid IDs.
    assert!(switched.is_valid());
    assert!(!switched.is_null());
    assert_ne!(switched, TinyId::null());
    // Mutable IDs can be made null. This change has no effect on the `parsed` variable.
    switched.make_null();
    assert!(!switched.is_valid());
    assert!(switched.is_null());
    assert_eq!(switched, TinyId::null());
}

pub fn to_bytes(self) -> [u8; 8]

Convert this TinyId to an array of 8 bytes.

pub fn from_u64(n: u64) -> Result<Self, TinyIdError>

Attempt to create a new TinyId from a u64.

Errors

• TinyIdError::InvalidLength if the input is not 8 bytes long.
• TinyIdError::InvalidCharacters if the input contains invalid chars/bytes.

pub fn from_u64_unchecked(n: u64) -> Self

Creates a new TinyId from the given u64, without validating that the bytes are valid.

pub fn to_u64(self) -> u64

Convert this TinyId to a u64 representation.

pub fn from_bytes(bytes: [u8; 8]) -> Result<Self, TinyIdError>

Attempt to create a new TinyId from the given byte array.

Errors

• TinyIdError::InvalidCharacters if the input contains invalid chars/bytes.

pub fn from_bytes_unchecked(bytes: [u8; 8]) -> Self

Creates a new TinyId from the given [u8; 8], without validating that the bytes are valid.

pub fn starts_with(&self, input: &str) -> bool

Checks whether this TinyId starts with the given string. This converts self to string so any associated overhead is incurred.

Examples found in repository

examples/basic.rs (line 37)

fn main() {
    // Create a random ID
    let rand_id = TinyId::random();

    // Parse a string into a Result<TinyId, TinyIdError> for possibly unsafe / invalid ID strings
    let maybe = TinyId::from_str("AAAABBBB");
    assert!(maybe.is_ok());
    let bad = TinyId::from_str("AAAABBB");
    assert!(bad.is_err());

    // Parse a string you **KNOW** is safe into a TinyId
    let parsed = TinyId::from_str_unchecked("AAAABBBB");

    // All expected operations are available on TinyIds
    // Equality is a simple byte comparison so it should be fast and cheap!
    assert_eq!(maybe.unwrap(), parsed);

    // IDs may be printed using Display or Debug
    println!("Random ID: {rand_id}");
    println!("Parsed ID: {parsed}");
    println!(" Debug ID: {parsed:?}");

    // IDs are small!
    println!("TinyID Size: {}", std::mem::size_of::<TinyId>());

    // IDs are case-sensitive
    let parsed2 = TinyId::from_str_unchecked("aaaaBBBB");
    assert_ne!(parsed, parsed2);

    // Check whether an ID starts with a given string. Example use case would be providing a
    // list of IDs to a user, and asking for a partial string to match against so the user
    // doesn't have to type the entire thing.
    assert!(parsed.starts_with("AAAA"));
    assert!(parsed.ends_with("BBBB"));
    assert!(!parsed.starts_with("BBBB"));

    // IDs are copied when assigned.
    let mut switched = parsed;
    assert_eq!(switched, parsed);

    // Validity can be checked, and a "marker" exists for null / invalid IDs.
    assert!(switched.is_valid());
    assert!(!switched.is_null());
    assert_ne!(switched, TinyId::null());
    // Mutable IDs can be made null. This change has no effect on the `parsed` variable.
    switched.make_null();
    assert!(!switched.is_valid());
    assert!(switched.is_null());
    assert_eq!(switched, TinyId::null());
}

pub fn ends_with(&self, input: &str) -> bool

Checks whether this TinyId ends with the given string. This converts self to string so any associated overhead is incurred.

Examples found in repository

examples/basic.rs (line 38)

fn main() {
    // Create a random ID
    let rand_id = TinyId::random();

    // Parse a string into a Result<TinyId, TinyIdError> for possibly unsafe / invalid ID strings
    let maybe = TinyId::from_str("AAAABBBB");
    assert!(maybe.is_ok());
    let bad = TinyId::from_str("AAAABBB");
    assert!(bad.is_err());

    // Parse a string you **KNOW** is safe into a TinyId
    let parsed = TinyId::from_str_unchecked("AAAABBBB");

    // All expected operations are available on TinyIds
    // Equality is a simple byte comparison so it should be fast and cheap!
    assert_eq!(maybe.unwrap(), parsed);

    // IDs may be printed using Display or Debug
    println!("Random ID: {rand_id}");
    println!("Parsed ID: {parsed}");
    println!(" Debug ID: {parsed:?}");

    // IDs are small!
    println!("TinyID Size: {}", std::mem::size_of::<TinyId>());

    // IDs are case-sensitive
    let parsed2 = TinyId::from_str_unchecked("aaaaBBBB");
    assert_ne!(parsed, parsed2);

    // Check whether an ID starts with a given string. Example use case would be providing a
    // list of IDs to a user, and asking for a partial string to match against so the user
    // doesn't have to type the entire thing.
    assert!(parsed.starts_with("AAAA"));
    assert!(parsed.ends_with("BBBB"));
    assert!(!parsed.starts_with("BBBB"));

    // IDs are copied when assigned.
    let mut switched = parsed;
    assert_eq!(switched, parsed);

    // Validity can be checked, and a "marker" exists for null / invalid IDs.
    assert!(switched.is_valid());
    assert!(!switched.is_null());
    assert_ne!(switched, TinyId::null());
    // Mutable IDs can be made null. This change has no effect on the `parsed` variable.
    switched.make_null();
    assert!(!switched.is_valid());
    assert!(switched.is_null());
    assert_eq!(switched, TinyId::null());
}

Trait Implementations

impl Clone for TinyId

fn clone(&self) -> TinyId

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TinyId

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

Formats the value using the given formatter.

impl Default for TinyId

fn default() -> Self

Returns the “default value” for a type.

impl Display for TinyId

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

Formats the value using the given formatter.

impl FromStr for TinyId

type Err = TinyIdError

The associated error which can be returned from parsing.

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

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

impl Hash for TinyId

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 TinyId

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<&[u8; 8]> for TinyId

fn eq(&self, other: &&[u8; 8]) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<&[u8]> for TinyId

fn eq(&self, other: &&[u8]) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<&TinyId> for TinyId

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<&Vec<u8, Global>> for TinyId

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<[u8; 8]> for &TinyId

fn eq(&self, other: &[u8; 8]) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<[u8; 8]> for TinyId

fn eq(&self, other: &[u8; 8]) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<TinyId> for &[u8; 8]

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<TinyId> for &[u8]

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<TinyId> for &TinyId

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<TinyId> for &Vec<u8>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<TinyId> for [u8; 8]

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<TinyId> for TinyId

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<TinyId> for Vec<u8>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Vec<u8, Global>> for TinyId

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd<TinyId> for TinyId

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

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl<'a> TryFrom<&'a [u8]> for TinyId

type Error = TinyIdError

The type returned in the event of a conversion error.

fn try_from(value: &'a [u8]) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&[u8; 8]> for TinyId

type Error = TinyIdError

The type returned in the event of a conversion error.

fn try_from(value: &[u8; 8]) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<[u8; 8]> for TinyId

type Error = TinyIdError

The type returned in the event of a conversion error.

fn try_from(value: [u8; 8]) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<u64> for TinyId

type Error = TinyIdError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl Copy for TinyId

impl Eq for TinyId

impl StructuralEq for TinyId

impl StructuralPartialEq for TinyId