Struct Assignment 

pub struct Assignment<X>
where
    X: Eq + Hash,
{
    pub elements: HashMap<X, f64slx>,
    pub lattice_hash: u128slx,
}

Mass assignment: should be build from AssignmentBuilder

• Assignment contains a lattice hash and a sequence of weighted encoded element from this lattice
• Assignments are used in order to encode basic belief function and other belief functions
• There is no constructor for Assignment: use method From::from(...) to convert from a builder AssignmentBuilder
• X : type of lattice element encoding

Fields

elements: HashMap<X, f64slx>

lattice_hash: u128slx

Trait Implementations

impl<X> Archive for Assignment<X>

where X: Eq + Hash, HashMap<X, f64slx>: Archive, u128slx: Archive,

type Archived = ArchivedAssignment<X>

The archived representation of this type.

type Resolver = AssignmentResolver<X>

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

unsafe fn resolve( &self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived, )

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

impl<X> Clone for Assignment<X>

where X: Eq + Hash + Clone,

fn clone(&self) -> Assignment<X>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<X> Debug for Assignment<X>

where X: Eq + Hash + Debug,

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

Formats the value using the given formatter.

impl<'de, X> Deserialize<'de> for Assignment<X>

where X: Clone + Eq + Ord + Hash + SerdeDeserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D: Fallible + ?Sized, X> Deserialize<Assignment<X>, __D> for Archived<Assignment<X>>

where X: Eq + Hash, HashMap<X, f64slx>: Archive, Archived<HashMap<X, f64slx>>: Deserialize<HashMap<X, f64slx>, __D>, u128slx: Archive, Archived<u128slx>: Deserialize<u128slx, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Assignment<X>, __D::Error>

Deserializes using the given deserializer

impl<X> Display for Assignment<X>

where X: Eq + Hash + Display,

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

Formats the value using the given formatter.

impl<X> From<AssignmentBuilder<X>> for Assignment<X>

where X: Eq + Ord + Hash,

fn from(value: AssignmentBuilder<X>) -> Self

Converts to this type from the input type.

impl<X> HashedTypeDef for Assignment<X>

where X: Eq + Hash + HashedTypeDef, (): HashedTypeDef,

const TYPE_HASH_NATIVE: u128 = 99_778_188_517_683_644_382_290_188_690_343_885_966u128

native hash computation

const TYPE_HASH_LE: u128 = _

hash encoded to little endianess

const TYPE_HASH_BE: u128 = _

hash encoded to big endianess

const UUID: Uuid = _

hash encoded to Uuid

impl<X> Index<&SafeElement<X>> for Assignment<X>

where X: Eq + Ord + Hash,

type Output = f64slx

The returned type after indexing.

fn index(&self, _: &SafeElement<X>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, X> IntoIterator for &'a Assignment<X>

where X: Eq + Ord + Hash,

type Item = (SafeElement<&'a X>, f64slx)

The type of the elements being iterated over.

type IntoIter = IntoIter<<&'a Assignment<X> as IntoIterator>::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<X> IntoIterator for Assignment<X>

where X: Eq + Ord + Hash,

type Item = (SafeElement<X>, f64slx)

The type of the elements being iterated over.

type IntoIter = IntoIter<<Assignment<X> as IntoIterator>::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<__S: Fallible + ?Sized, X> Serialize<__S> for Assignment<X>

where X: Eq + Hash, HashMap<X, f64slx>: Serialize<__S>, u128slx: Serialize<__S>,

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<X> Serialize for Assignment<X>

where X: Clone + Eq + Ord + Hash + SerdeSerialize,

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

where S: Serializer,

Serialize this value into the given Serde serializer.