Struct canadensis::register::RegisterHandler

pub struct RegisterHandler<B> { /* private fields */ }

Handles access requests for registers

Basic steps:

1. Create a register block (this may be a tuple of Registers or a custom type that implements RegisterBlock)
2. Create a handler using RegisterHandler::init. Pass the register block and a node used to receive service requests
3. When calling accept on the node, pass the register handler as a transfer handler (or use some other method to pass incoming service requests to the register handler). This lets the register handler process requests and send responses.

Implementations

impl<B> RegisterHandler<B> where
    B: RegisterBlock, 

pub fn new(block: B) -> Self

Creates a register handler

pub fn subscribe_requests<N>(
    node: &mut N
) -> Result<(), <N::Receiver as Receiver<N::Instant>>::Error> where
    N: Node, 

Subscribes to register list and register access requests

This function returns an error if the provided node does not have enough space to listen for requests.

pub fn block(&self) -> &B

Returns a reference to the register block

This can be used to read the current values.

pub fn block_mut(&mut self) -> &mut B

Returns a mutable reference to the register block

This can be used to write the register values.

Trait Implementations

impl<I, B, T> TransferHandler<I, T> for RegisterHandler<B> where
    I: Instant,
    B: RegisterBlock,
    T: Transport, 

fn handle_request<N: Node<Instant = I, Transport = T>>(
    &mut self,
    node: &mut N,
    token: ResponseToken<T>,
    transfer: &ServiceTransfer<Vec<u8>, I, T>
) -> bool

Potentially handles an incoming service request

fn handle_message<N: Node<Instant = I, Transport = T>>(
    &mut self,
    node: &mut N,
    transfer: &MessageTransfer<Vec<u8>, I, T>
) -> bool

Potentially handles an incoming message transfer

fn handle_response<N: Node<Instant = I, Transport = T>>(
    &mut self,
    node: &mut N,
    transfer: &ServiceTransfer<Vec<u8>, I, T>
) -> bool

Potentially handles an incoming service response

fn chain<H>(self, next: H) -> TransferHandlerChain<Self, H> where
    Self: Sized,
    H: TransferHandler<I, T>, 

Chains another handler after this handler and returns the combined handler