Trait CalculatorLocalServerHandler 

pub trait CalculatorLocalServerHandler<___T = Channel>
where
    ___T: Transport,
{
    // Required methods
    fn add(
        &mut self,
        request: Request<Add, ___T>,
        responder: Responder<Add, ___T>,
    ) -> impl Future<Output = ()>;
    fn subtract(
        &mut self,
        request: Request<Subtract, ___T>,
        responder: Responder<Subtract, ___T>,
    ) -> impl Future<Output = ()>;
    fn multiply(
        &mut self,
        request: Request<Multiply, ___T>,
        responder: Responder<Multiply, ___T>,
    ) -> impl Future<Output = ()>;
    fn divide(
        &mut self,
        request: Request<Divide, ___T>,
        responder: Responder<Divide, ___T>,
    ) -> impl Future<Output = ()>;
    fn pow(
        &mut self,
        request: Request<Pow, ___T>,
        responder: Responder<Pow, ___T>,
    ) -> impl Future<Output = ()>;
}

A server handler for the Calculator protocol.

See Calculator for more details.

Required Methods

fn add( &mut self, request: Request<Add, ___T>, responder: Responder<Add, ___T>, ) -> impl Future<Output = ()>

Adds two numbers together and returns their sum.

For example, with a being 4.5 and b being 3.2, the response sum is 7.7.

• request a the first number to be added.
• request b the second number to be added.

• response sum the sum of a and b.

fn subtract( &mut self, request: Request<Subtract, ___T>, responder: Responder<Subtract, ___T>, ) -> impl Future<Output = ()>

Subtracts two numbers and returns their difference.

For example, with a being 7.7 and b being 3.2, the response difference is 4.5

• request a the number to be subracted from.
• request b the number to subtract.

• response difference the difference between a and b.

fn multiply( &mut self, request: Request<Multiply, ___T>, responder: Responder<Multiply, ___T>, ) -> impl Future<Output = ()>

Multiplies two numbers and returns their product.

For example, with a being 1.5 and b being 2.0, the response product is 3.0

• request a the first number used to calculatorulate the product.
• request b the second number used to calculatorulate the product.

• response product the result of multiplying a and b.

fn divide( &mut self, request: Request<Divide, ___T>, responder: Responder<Divide, ___T>, ) -> impl Future<Output = ()>

Divides one number by another and return the quotient.

For example with a dividend of 2.0 and a divisor of 4.0, the response quotient is 0.5.

• request dividend the number to divide with.
• request divisor the number to divide into.

• response quotient the result of dividing the dividend into the divisor.

fn pow( &mut self, request: Request<Pow, ___T>, responder: Responder<Pow, ___T>, ) -> impl Future<Output = ()>

Takes base to the exponent and returns the power.

For example with a base of 3.0 and an exponent of 4.0, the response power is 81.0.

• request base the number to multiply by itself.
• request exponent the number of times to successively multiply base.

• response power the result of multiplying base by itself exponent times..

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<___H, ___T> CalculatorLocalServerHandler<___T> for Local<___H>

where ___H: CalculatorServerHandler<___T>, ___T: Transport,

async fn add( &mut self, request: Request<Add, ___T>, responder: Responder<Add, ___T>, )

async fn subtract( &mut self, request: Request<Subtract, ___T>, responder: Responder<Subtract, ___T>, )

async fn multiply( &mut self, request: Request<Multiply, ___T>, responder: Responder<Multiply, ___T>, )

async fn divide( &mut self, request: Request<Divide, ___T>, responder: Responder<Divide, ___T>, )

async fn pow( &mut self, request: Request<Pow, ___T>, responder: Responder<Pow, ___T>, )

Implementors