Trait CalculatorServerHandler

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

A server handler for the Calculator protocol.

See Calculator for more details.

Required Methods

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

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, sender: &ServerSender<Calculator, ___T>, request: Request<Subtract, ___T>, responder: Responder<Subtract>, ) -> impl Future<Output = ()> + Send

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, sender: &ServerSender<Calculator, ___T>, request: Request<Multiply, ___T>, responder: Responder<Multiply>, ) -> impl Future<Output = ()> + Send

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, sender: &ServerSender<Calculator, ___T>, request: Request<Divide, ___T>, responder: Responder<Divide>, ) -> impl Future<Output = ()> + Send

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, sender: &ServerSender<Calculator, ___T>, request: Request<Pow, ___T>, responder: Responder<Pow>, ) -> impl Future<Output = ()> + Send

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", so this trait is not object safe.

Implementors