Struct massa_models::slot::Slot

pub struct Slot {
    pub period: u64,
    pub thread: u8,
}

a point in time where a block is expected

Fields

period: u64

period

thread: u8

thread

Implementations

impl Slot

pub fn new(period: u64, thread: u8) -> Slot

new slot from period and thread

pub fn new_last_of_cycle( cycle: u64, periods_per_cycle: u64, thread_count: u8, ) -> Result<Slot, ModelsError>

create the last slot of a given cycle

pub fn new_first_of_cycle( cycle: u64, periods_per_cycle: u64, ) -> Result<Slot, ModelsError>

create the first slot of a given cycle

pub const fn min() -> Slot

returns the minimal slot

pub const fn max(thread_count: u8) -> Slot

returns the maximal slot

pub fn get_first_bit(&self) -> bool

first bit of the slot, for seed purpose

pub fn get_cycle(&self, periods_per_cycle: u64) -> u64

cycle associated to that slot

pub fn is_last_of_cycle(&self, periods_per_cycle: u64, thread_count: u8) -> bool

check if the slot is last in the cycle

pub fn is_first_of_cycle(&self, periods_per_cycle: u64) -> bool

check if the slot is first in the cycle

pub fn to_bytes_key(&self) -> [u8; 9]

Returns a fixed-size sortable binary key

Example

let slot = Slot::new(10,5);
let key = slot.to_bytes_key();
let res = Slot::from_bytes_key(&key);
assert_eq!(slot, res);

pub fn from_bytes_key(buffer: &[u8; 9]) -> Self

Deserializes a slot from its fixed-size sortable binary key representation

Example

let slot = Slot::new(10,5);
let key = slot.to_bytes_key();
let res = Slot::from_bytes_key(&key);
assert_eq!(slot, res);

pub fn get_next_slot(&self, thread_count: u8) -> Result<Slot, ModelsError>

Returns the next Slot

Example

let slot = Slot::new(10,3);
assert_eq!(slot.get_next_slot(5).unwrap(), Slot::new(10, 4));
let slot = Slot::new(10,4);
assert_eq!(slot.get_next_slot(5).unwrap(), Slot::new(11, 0));

pub fn get_prev_slot(&self, thread_count: u8) -> Result<Slot, ModelsError>

Returns the previous Slot

Example

let slot = Slot::new(10,1);
assert_eq!(slot.get_prev_slot(5).unwrap(), Slot::new(10, 0));
let slot = Slot::new(10,0);
assert_eq!(slot.get_prev_slot(5).unwrap(), Slot::new(9, 4));

pub fn slots_since( &self, s: &Slot, thread_count: u8, ) -> Result<u64, ModelsError>

Counts the number of slots since the one passed in parameter and until self If the two slots are equal, the returned value is 0. If the passed slot is strictly higher than self, an error is returned

Trait Implementations

impl Clone for Slot

fn clone(&self) -> Slot

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Slot

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Slot

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Deserializer<Slot> for SlotDeserializer

fn deserialize<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>( &self, buffer: &'a [u8], ) -> IResult<&'a [u8], Slot, E>

use std::ops::Bound::Included;
use massa_serialization::{Serializer, Deserializer, DeserializeError};
use massa_models::slot::{Slot, SlotSerializer, SlotDeserializer};

let slot: Slot = Slot::new(1, 3);
let mut serialized = Vec::new();
let serializer = SlotSerializer::new();
let deserializer = SlotDeserializer::new((Included(u64::MIN), Included(u64::MAX)), (Included(u8::MIN), Included(u8::MAX.into())));
serializer.serialize(&slot, &mut serialized).unwrap();
let (rest, slot_deser) = deserializer.deserialize::<DeserializeError>(&serialized).unwrap();
assert!(rest.is_empty());
assert_eq!(slot, slot_deser);

impl Display for Slot

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

Formats the value using the given formatter.

impl From<Slot> for Slot

fn from(s: Slot) -> Self

Converts to this type from the input type.

impl From<Slot> for Slot

fn from(s: Slot) -> Self

Converts to this type from the input type.

impl FromStr for Slot

type Err = ModelsError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Slot

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Slot

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 + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Slot

fn eq(&self, other: &Slot) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Slot

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

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Slot

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Serializer<Slot> for SlotSerializer

fn serialize( &self, value: &Slot, buffer: &mut Vec<u8>, ) -> Result<(), SerializeError>

use std::ops::Bound::Included;
use massa_serialization::Serializer;
use massa_models::slot::{Slot, SlotSerializer};

let slot: Slot = Slot::new(1, 3);
let mut serialized = Vec::new();
let serializer = SlotSerializer::new();
serializer.serialize(&slot, &mut serialized).unwrap();

impl Copy for Slot

impl Eq for Slot

impl StructuralPartialEq for Slot