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::Clock>>::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 handle_loopback<N: Node<Instant = I, Transport = T>>( &mut self, _node: &mut N, _transfer: &Transfer<Vec<u8>, I, T> ) -> bool

Potentially handles a loopback transfer sent from this node

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