Struct FixedStringKey 

pub struct FixedStringKey<const N: usize>(/* private fields */);

A fixed-size key based on a string, suitable for use in the StaticBTree.

It stores the string’s bytes in a fixed-size array [u8; N]. If the input string is shorter than N, it’s padded with null bytes (\0). If the input string is longer than N, it’s truncated. Comparison (Ord) is based on the byte array content.

Implementations

impl<const N: usize> FixedStringKey<N>

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

Creates a key from a string slice, padding with 0 bytes or truncating if necessary to fit exactly N bytes.

Examples

let key_short = FixedStringKey::<10>::from_str("hello");
assert_eq!(key_short.to_string_lossy(), "hello");

let key_long = FixedStringKey::<3>::from_str("world");
assert_eq!(key_long.to_string_lossy(), "wor");

let key_exact = FixedStringKey::<5>::from_str("exact");
assert_eq!(key_exact.to_string_lossy(), "exact");

pub fn to_string_lossy(&self) -> String

Attempts to convert back to a String, stopping at the first null byte or using all N bytes if no null byte is found.

Note: This conversion is lossy if the original string contained null bytes before the Nth byte, or if it was truncated.

Examples

let key1 = FixedStringKey::<10>::from_str("test");
assert_eq!(key1.to_string_lossy(), "test");

let key2 = FixedStringKey::<5>::from_str("example"); // truncated to "examp"
assert_eq!(key2.to_string_lossy(), "examp");

let s_with_null = "null\0xy"; // String containing null byte
let key3 = FixedStringKey::<8>::from_str(s_with_null);
assert_eq!(key3.to_string_lossy(), "null"); // Stops at null byte

Trait Implementations

impl<const N: usize> Clone for FixedStringKey<N>

fn clone(&self) -> FixedStringKey<N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const N: usize> Debug for FixedStringKey<N>

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

Formats the value using the given formatter.

impl<const N: usize> Default for FixedStringKey<N>

fn default() -> Self

Returns the “default value” for a type.

impl<const N: usize> Key for FixedStringKey<N>

const SERIALIZED_SIZE: usize = N

The exact size of the key in bytes when serialized. This is crucial for calculating node sizes and offsets.

fn write_to<W: Write>(&self, writer: &mut W) -> Result<usize>

Serializes the key into the provided writer.

fn read_from<R: Read>(reader: &mut R) -> Result<Self>

Deserializes a key from the provided reader.

fn from_bytes(bytes: &[u8]) -> Result<Self>

Deserializes a key from the provided bytes.

impl<const N: usize> Max for FixedStringKey<N>

fn max_value() -> Self

Returns the maximum representable value for this type.

impl<const N: usize> Min for FixedStringKey<N>

fn min_value() -> Self

Returns the minimum representable value for this type.

impl<const N: usize> Ord for FixedStringKey<N>

fn cmp(&self, other: &FixedStringKey<N>) -> 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> PartialEq for FixedStringKey<N>

fn eq(&self, other: &FixedStringKey<N>) -> 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> PartialOrd for FixedStringKey<N>

fn partial_cmp(&self, other: &FixedStringKey<N>) -> 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> Eq for FixedStringKey<N>

impl<const N: usize> StructuralPartialEq for FixedStringKey<N>