Struct messaging_thread_pool::samples::Randoms

pub struct Randoms {
    pub id: usize,
    pub numbers: Vec<u64>,
}

This represents a simple collection of random numbers which is hosted inside the thread pool

It is tied to a particular thread by the modulus of its id.

The interface that it supports is governed by its implementation of the PoolItem trait. This in turn needs to be supported by the use of two enums of supported requests and responses

It supports the following operations Init creates a new Random with an stack based store of random numbers Mean calculates the mean of the contained numbers Sum calculates the sum of the contained numbers

Fields

id: usize

numbers: Vec<u64>

Implementations

impl Randoms

pub fn new(id: usize) -> Self

pub fn mean(&self) -> u128

#[no_mangle]

pub fn sum(&self) -> u128

Trait Implementations

impl Debug for Randoms

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

Formats the value using the given formatter.

impl IdTargeted for Randoms

fn id(&self) -> usize

impl PartialEq<Randoms> for Randoms

fn eq(&self, other: &Randoms) -> 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 PoolItem for Randoms

The implementation of this trait allows the Randoms struct to be used in the thread pool infrastructure

type Init = RandomsAddRequest

This is a struct that defines the message that will initiate a new instance of the struct within the thread pool

type Api = RandomsApi

This is the enum that will define that messaging api that can be used to communicate with instances of the struct It will be an enum where each variant will define a request/response pair of structs

fn name() -> &'static str

used for debug only; allows logging to output the name of the type

fn process_message(&mut self, request: Self::Api) -> ThreadRequestResponse<Self>

This is the function that will define how the struct processes the messages that it receives. It will typically consist of a match statement that will discriminate amongst the various messages type defined in the Api

fn add_pool_item_tracing(&self) -> Option<Vec<Box<dyn GuardDrop>>>

This method is called to optionally add tracing before each message is processed. The tracing is removed once the message is processed. If the tracing is being written to a file it is important that the file is not truncated The implementation needs to return a vec of guards of any subscribers added.

fn new_pool_item(request: Self::Init) -> Result<Self, NewPoolItemError>

This function defines how a new struct will be created when it receives The Init message. It returns the created new instance of the struct

fn shutdown_pool(&self) -> Vec<ThreadShutdownResponse>

This function is a hook that is called when the pool is shutting down.

fn id_not_found(request: &Self::Api) -> ThreadRequestResponse<Self>

The function called if an item with the specified is not found The default behaviour is to panic

fn add_pool_thread_tracing( id: usize ) -> Option<(DefaultGuard, Vec<WorkerGuard>)>

This method provides any required tracing in the pool items thread pool threads This tracing is added when the thread is spawned and remains in place until the thread dies

impl RequestWithResponse<Randoms> for MeanRequest

ties together the request with a response

type Response = MeanResponse

impl RequestWithResponse<Randoms> for PanicRequest

ties together the request with a response

type Response = PanicResponse

impl RequestWithResponse<Randoms> for RandomsAddRequest

type Response = AddResponse

impl RequestWithResponse<Randoms> for SumRequest

ties together the request with a response

type Response = SumResponse

impl Eq for Randoms

impl StructuralEq for Randoms

impl StructuralPartialEq for Randoms