Enum EntityLabel 

pub enum EntityLabel<K, T, L> {
    KeyLabel(Key<K>, L),
    Data(Box<T>),
    None,
}

Enum for situations when you want to define not just a Key but also a Label

This may be useful for faster access to avoid an extra LEFT JOIN or because you may have missing data, thus no Key, and having the Label makes the entity still valid

Variants

KeyLabel(Key<K>, L)

Key and Label for this entity

Data(Box<T>)

Created/Fetched data for the entity

None

For when you have no data to fill or null from database

Implementations

impl<K, T, L> EntityLabel<K, T, L>

pub fn data(&self) -> Result<&T, Error>

Returns the data if it exists and was fetched/created

pub fn data_mut(&mut self) -> Result<&mut T, Error>

Returns the mutable data if it exists and was fetched/created

pub fn is_keylabel(&self) -> bool

Is this a KeyLabel variant?

pub fn is_data(&self) -> bool

Is this a Data variant?

pub fn is_none(&self) -> bool

Is this a None variant?

Trait Implementations

impl<K, T, L> Clone for EntityLabel<K, T, L>

where K: Clone, T: Clone, L: Clone,

fn clone(&self) -> EntityLabel<K, T, L>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K, T, L> Debug for EntityLabel<K, T, L>

where K: Debug, T: Debug, L: Debug,

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

Formats the value using the given formatter.

impl<K, T, L> Default for EntityLabel<K, T, L>

fn default() -> EntityLabel<K, T, L>

Returns the “default value” for a type.

impl<'de, K, T, L> Deserialize<'de> for EntityLabel<K, T, L>

where K: Deserialize<'de>, T: Deserialize<'de>, L: Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<EntityLabel<K, T, L>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<K, T, L> From<T> for EntityLabel<K, T, L>

fn from(entity: T) -> EntityLabel<K, T, L>

Converts to this type from the input type.

impl<K, T, L> Keyed for EntityLabel<K, T, L>

where T: Keyed<KeyType = K>,

type KeyType = K

The type of the Key

fn key(&self) -> Result<&Key<<EntityLabel<K, T, L> as Keyed>::KeyType>, Error>

Returns the Key for the Entity

impl<K, T, L> Label for EntityLabel<K, T, L>

where T: Label<LabelType = L>,

type LabelType = L

The type of the Label

fn label(&self) -> Result<&<EntityLabel<K, T, L> as Label>::LabelType, Error>

Returns the Label for the Entity

impl<K, T, L> PartialEq for EntityLabel<K, T, L>

where K: PartialEq, T: PartialEq, L: PartialEq,

fn eq(&self, other: &EntityLabel<K, T, L>) -> 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<K, T, L> Serialize for EntityLabel<K, T, L>

where K: Serialize, T: Serialize, L: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<K, T, L> Eq for EntityLabel<K, T, L>

where K: Eq, T: Eq, L: Eq,

impl<K, T, L> StructuralPartialEq for EntityLabel<K, T, L>