Struct Nanoid 

pub struct Nanoid<const N: usize = 21, A: Alphabet = Base64UrlAlphabet> { /* private fields */ }

A Nano ID.

Generic parameters

• N: The length of the Nano ID. The default is 21.
• A: The alphabet used in the Nano ID. The default is Base64UrlAlphabet.

Generating

When you want a new Nano ID, you can generate one using the Nanoid::new.

use nid::Nanoid;
let id: Nanoid = Nanoid::new();

Parsing

You can parse a string into a Nano ID using Nanoid::try_from_str, std::str::FromStr or TryFrom<String>.

use nid::Nanoid;
let id: Nanoid = Nanoid::try_from_str("K8N4Q7MNmeHJ-OHHoVDcz")?;
let id: Nanoid = "3hYR3muA_xvjMrrrqFWxF".parse()?;
let id: Nanoid = "iH26rJ8CpRz-gfIh7TSRu".to_string().try_into()?;

If you try to parse an invalid Nano ID, you will get an error.

use nid::{Nanoid, ParseError};

let result: Result<Nanoid, _> = "61psxw-too_short".parse();
assert!(matches!(result, Err(ParseError::InvalidLength { .. })));

let result: Result<Nanoid, _> = "6yt_invalid_char#####".to_string().try_into();
assert!(matches!(result, Err(ParseError::InvalidCharacter(_))));

Converting to a string

You can get the string representation of the Nano ID using Nanoid::as_str, AsRef<str> or Display.

use nid::Nanoid;
let id: Nanoid = "Z9ifKfmBL7j69naN7hthu".parse()?;

// Convert to &str
assert_eq!(id.as_str(), "Z9ifKfmBL7j69naN7hthu");
assert_eq!(id.as_ref(), "Z9ifKfmBL7j69naN7hthu");

// Convert to String
assert_eq!(id.to_string(), "Z9ifKfmBL7j69naN7hthu");

Examples

use nid::{alphabet::Base62Alphabet, Nanoid};

// Generate a new Nano ID and print it.
let id: Nanoid = Nanoid::new();
println!("{}", id);

// Parse a string into a Nano ID and convert it back to a string.
let id: Nanoid = "abcdefg1234567UVWXYZ_".parse()?;
let s = id.to_string();

// Parse a string into a Nano ID with a different length and alphabet.
let id: Nanoid<9, Base62Alphabet> = "abc123XYZ".parse()?;

Implementations

impl<const N: usize, A: Alphabet> Nanoid<N, A>

pub fn new() -> Self

Generate a new Nano ID using random number generator seeded by the system.

Panics

The function will panic if the random number generator is not able to generate random numbers. This function also panics if the provided Alphabet produces non-ascii characters, but this never happens unless the alphabet is implemented incorrectly.

Examples

use nid::Nanoid;
let id: Nanoid = Nanoid::new();

pub fn new_with(rng: impl Rng) -> Self

Generate a new Nano ID using the provided random number generator.

Panics

The function will panic if the provided random number generator is not able to generate random numbers. This function also panics if the provided Alphabet produces non-ascii characters, but this never happens unless the alphabet is implemented incorrectly.

Examples

use nid::Nanoid;
let id: Nanoid = Nanoid::new_with(rand::thread_rng());

pub const fn try_from_str(s: &str) -> Result<Self, ParseError>

Parse a string into a Nanoid.

Errors

• If the length of the string is not equal to the expected length, this method returns ParseError::InvalidLength.
• If the string contains a character that is not in the alphabet, this method returns ParseError::InvalidCharacter.

Examples

use nid::Nanoid;
let id: Nanoid = Nanoid::try_from_str("r9p_QLd_9CD63JqQaGQ9I")?;

pub const fn try_from_bytes(buf: &[u8; N]) -> Result<Self, ParseError>

Parse a byte array into a Nanoid.

Errors

If the byte array contains a character that is not in the alphabet, this method returns ParseError::InvalidCharacter.

Examples

use nid::Nanoid;
let id: Nanoid = Nanoid::try_from_bytes(b"0tY_GxufiwmAxvmHR7G0R")?;

pub const fn as_str(&self) -> &str

Get the string representation of the Nanoid.

Examples

use nid::Nanoid;
let id: Nanoid = "vsB2sq2PfhCdU6WCXk37s".parse()?;
assert_eq!(id.as_str(), "vsB2sq2PfhCdU6WCXk37s");

Trait Implementations

impl<const N: usize, A: Alphabet> Archive for Nanoid<N, A>

Available on crate feature rkyv only.

type Archived = [u8; N]

The archived representation of this type.

type Resolver = [(); N]

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, _: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl<const N: usize, A: Alphabet> AsRef<str> for Nanoid<N, A>

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl<const N: usize, A: Alphabet> Clone for Nanoid<N, A>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const N: usize, A: Alphabet> Debug for Nanoid<N, A>

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

Formats the value using the given formatter.

impl<'de, const N: usize, A: Alphabet> Deserialize<'de> for Nanoid<N, A>

Available on crate feature serde only.

fn deserialize<D>(deserializer: D) -> Result<Nanoid<N, A>, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<const N: usize, A: Alphabet, D: Fallible + ?Sized> Deserialize<Nanoid<N, A>, D> for [u8; N]

Available on crate feature rkyv only.

fn deserialize(&self, _: &mut D) -> Result<Nanoid<N, A>, D::Error>

Deserializes using the given deserializer

impl<const N: usize, A: Alphabet> Display for Nanoid<N, A>

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

Formats the value using the given formatter.

impl<const N: usize, A: Alphabet> From<Nanoid<N, A>> for String

fn from(id: Nanoid<N, A>) -> Self

Converts to this type from the input type.

impl<const N: usize, A: Alphabet> FromStr for Nanoid<N, A>

type Err = ParseError

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<const N: usize, A: Alphabet> Hash for Nanoid<N, A>

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<const N: usize, A: Alphabet> Ord for Nanoid<N, A>

fn cmp(&self, other: &Self) -> 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<const N: usize, A: Alphabet> PartialEq for Nanoid<N, A>

fn eq(&self, other: &Self) -> 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<const N: usize, A: Alphabet> PartialOrd for Nanoid<N, A>

fn partial_cmp(&self, other: &Self) -> 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<const N: usize, A: Alphabet, S> Serialize<S> for Nanoid<N, A>

where S: Fallible + ?Sized,

Available on crate feature rkyv only.

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl<const N: usize, A: Alphabet> Serialize for Nanoid<N, A>

Available on crate feature serde only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<const N: usize, A: Alphabet> TryFrom<String> for Nanoid<N, A>

type Error = ParseError

The type returned in the event of a conversion error.

fn try_from(s: String) -> Result<Self, Self::Error>

Performs the conversion.

impl<const N: usize, A: Alphabet> Zeroize for Nanoid<N, A>

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.

impl<const N: usize, A: Alphabet> Copy for Nanoid<N, A>

impl<const N: usize, A: Alphabet> Eq for Nanoid<N, A>