Struct Entry 

pub struct Entry<Val: Record> {
    pub key: Val::SelfId,
    pub val: Val,
}

Fields

key: Val::SelfId

val: Val

Implementations

impl<Val: Record> Entry<Val>

pub fn new(key: Val::SelfId, val: Val) -> Self

pub fn key(self) -> Val::SelfId

pub fn value(&self) -> &Val

pub fn get_id(self) -> Val::SelfId

👎Deprecated

pub fn get_val(&self) -> &Val

👎Deprecated

pub fn split(self) -> (Val::SelfId, Val)

pub fn split_ref(&self) -> (&Val::SelfId, &Val)

pub fn split_mut(&mut self) -> (&mut Val::SelfId, &mut Val)

Trait Implementations

impl<Val: Clone + Record> Clone for Entry<Val>

where Val::SelfId: Clone,

fn clone(&self) -> Entry<Val>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Val: Debug + Record> Debug for Entry<Val>

where Val::SelfId: Debug,

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

Formats the value using the given formatter.

impl<Val: Record> Deref for Entry<Val>

type Target = Val

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<Val: Record> From<(<Val as Record>::SelfId, Val)> for Entry<Val>

fn from(tuple: (Val::SelfId, Val)) -> Self

Converts to this type from the input type.

impl<Item: Record> From<Updater<Item>> for Entry<Item>

fn from(value: Updater<Item>) -> Self

Converts to this type from the input type.

impl<Val> Rapira for Entry<Val>

where Val: Record + Rapira, <Val::SelfId as Cid>::B: Rapira,

const STATIC_SIZE: Option<usize>

const MIN_SIZE: usize

fn size(&self) -> usize

size of bytes for serialize

fn check_bytes(slice: &mut &[u8]) -> Result<()>

check bytes, collections len, check utf-8, NonZero, f32 and others…

unsafe fn from_slice_unchecked(slice: &mut &[u8]) -> Result<Self>

where Self: Sized,

Safety

fn from_slice(slice: &mut &[u8]) -> Result<Self>

where Self: Sized,

this is safe, but not check collections capacity! recommend use only for safe data (example: from DB), not external data.

unsafe fn from_slice_unsafe(slice: &mut &[u8]) -> Result<Self>

where Self: Sized,

Safety

fn convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize)

fn try_convert_to_bytes( &self, slice: &mut [u8], cursor: &mut usize, ) -> Result<()>

fn debug_from_slice(slice: &mut &[u8]) -> Result<Self, RapiraError>

where Self: Sized + Debug,

impl<Val> Serialize for Entry<Val>

where Val: Serialize + Record, Val::SelfId: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.