Struct Slice 

pub struct Slice<'a> { /* private fields */ }

Slice is the core interface for exchanging data with LevelDB.

Slice can exist in one of two states:

• Borrowed: References a byte array
• Owned: Owns LevelDB-allocated byte data

Data Access

Use the as_bytes() method to obtain a reference to the internal data.

Important: Iterator Lifetime Warning

When a Slice is returned from an iterator, it only holds a reference to LevelDB’s internal data. After the iterator continues iteration (calling next(), seek(), etc.), the data references in previously returned Slices may become invalid. If longer ownership is required, consider copying the data:

Memory Management

• Borrowed state: Slice does not own data, lifetime must not exceed original data
• Owned state: Slice owns LevelDB-allocated memory and automatically frees it on Drop

Implementations

impl<'a> Slice<'a>

pub fn as_bytes(&self) -> &[u8]

Get a byte slice reference to the internal data.

Returns

Returns a &[u8] reference to the internal data. Regardless of whether the Slice is in Borrowed or Owned state, the actual data content can be accessed through this method.

Important Lifetime Warning

Critical: If this Slice comes from an iterator, the returned reference’s lifetime is limited by the iterator’s state. This reference may become invalid after the iterator continues iteration.

Trait Implementations

impl<'a> Debug for Slice<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for Slice<'a>

impl<'a> From<&'a [u8]> for Slice<'a>

fn from(data: &'a [u8]) -> Self

Create a Slice from a byte slice.

This constructor is intended for creating Slice instances from user owned data. The Slice will borrow the data, so the original data must outlive the Slice.

Use this when user owned byte data needs to be passed to LevelDB operations like put(), delete(), or get(). The Slice will only hold a reference, avoiding data copying.

impl From<Bytes> for Slice<'static>

fn from(bytes: Bytes) -> Self

Create a Slice from LevelDB-allocated bytes.

This is used internally to wrap data that LevelDB allocates and returns to the Rust layer. The Slice becomes responsible for managing the memory and ensuring it’s properly freed when no longer needed.

impl<'a> Ord for Slice<'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<'a> PartialEq for Slice<'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<'a> PartialEq<&[u8]> for Slice<'a>

fn eq(&self, other: &&[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.

impl<const N: usize> PartialEq<Slice<'_>> for [u8; N]

fn eq(&self, other: &Slice<'_>) -> 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<'a> PartialEq<Slice<'a>> for Vec<u8>

fn eq(&self, other: &Slice<'a>) -> 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<'a> PartialEq<Slice<'a>> for &[u8]

fn eq(&self, other: &Slice<'a>) -> 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<'a> PartialEq<Vec<u8>> for Slice<'a>

fn eq(&self, other: &Vec<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.

impl<const N: usize> PartialEq<[u8; N]> for Slice<'_>

fn eq(&self, other: &[u8; 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<'a> PartialOrd for Slice<'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.