Enum Operation 

pub enum Operation {
    Add,
    Subtract,
    Multiply,
    Divide,
}

Arithmetic operations that can be applied in routing transformations.

The Operation enum represents the four basic arithmetic operations that can be used to transform values during the routing process. Each operation is designed to safely handle potential numerical errors using checked operations.

Variants

• Add - Addition operation (+)
• Subtract - Subtraction operation (-)
• Multiply - Multiplication operation (*)
• Divide - Division operation (/)

Examples

use bothan_lib::registry::source::Operation;
use rust_decimal::Decimal;

// Create a multiplication operation
let operation = Operation::Multiply;

// Apply the operation to two values
let a = Decimal::new(10, 0);  // 10.0
let b = Decimal::new(15, 0);  // 15.0
let result = operation.execute(a, b).unwrap();

assert_eq!(result, Decimal::new(150, 0));  // 150.0

Variants

Add

Addition operation (+)

Subtract

Subtraction operation (-)

Multiply

Multiplication operation (*)

Divide

Division operation (/)

Implementations

impl Operation

pub fn execute<T>(&self, a: T, b: T) -> Option<T>

where T: CheckedAdd + CheckedSub + CheckedMul + CheckedDiv + Copy,

Executes the arithmetic operation on two values.

This method applies the operation represented by the enum variant to the provided operands. It uses checked operations to prevent numerical errors such as overflow or division by zero.

Examples

use bothan_lib::registry::source::Operation;

let add_op = Operation::Add;
assert_eq!(add_op.execute(5, 3), Some(8));

let div_op = Operation::Divide;
assert_eq!(div_op.execute(10, 2), Some(5));
assert_eq!(div_op.execute(10, 0), None);  // Division by zero returns None

Trait Implementations

impl<'__de, __Context> BorrowDecode<'__de, __Context> for Operation

fn borrow_decode<__D: BorrowDecoder<'__de, Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given BorrowDecode.

impl Clone for Operation

fn clone(&self) -> Operation

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Operation

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

Formats the value using the given formatter.

impl<__Context> Decode<__Context> for Operation

fn decode<__D: Decoder<Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given Decode.

impl<'de> Deserialize<'de> for Operation

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encode for Operation

fn encode<__E: Encoder>(&self, encoder: &mut __E) -> Result<(), EncodeError>

Encode a given type.

impl PartialEq for Operation

fn eq(&self, other: &Operation) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Operation

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Operation