Enum PostProcessor 

pub enum PostProcessor {
    TickConvertor(TickPostProcessor),
}

Represents different strategies for post-processing signal values.

The PostProcessor enum encapsulates different algorithms for transforming signal values after they have been processed from source data. Each variant contains its own configuration parameters.

Variants

• TickConvertor - Converts values to specific tick sizes

Examples

Creating a tick convertor post-processor:

use bothan_lib::registry::post_processor::{PostProcessor, tick::TickPostProcessor};
use serde_json::json;

// Create a post-processor from JSON
let json_data = json!({
    "function": "tick_convertor",
    "params": {}
});

let post_processor: PostProcessor = serde_json::from_value(json_data).unwrap();
assert_eq!(post_processor.name(), "tick_convertor");

Using a post-processor:

use bothan_lib::registry::post_processor::{PostProcessor, tick::TickPostProcessor};
use rust_decimal::Decimal;

// Create a tick convertor post-processor
let post_processor = PostProcessor::TickConvertor(TickPostProcessor {});

// Apply the post-processor to a value
let value = Decimal::new(1234, 0);
let result = post_processor.post_process(value).unwrap();

Variants

TickConvertor(TickPostProcessor)

Tick convertor that adjusts values to specific tick sizes.

Implementations

impl PostProcessor

pub fn name(&self) -> &str

Returns the name of the post-processor.

This method returns a string identifier for the post-processor type, which can be used for logging, debugging, or serialization purposes.

pub fn post_process(&self, data: Decimal) -> Result<Decimal, PostProcessError>

Applies the post-processor to a value.

This method applies the post-processor’s transformation algorithm to the input value to produce a transformed output value.

Errors

Returns a PostProcessError if the transformation operation fails, such as when:

• The input value is invalid for the transformation
• A mathematical error occurs during transformation

Trait Implementations

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

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 PostProcessor

fn clone(&self) -> PostProcessor

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PostProcessor

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

Formats the value using the given formatter.

impl<__Context> Decode<__Context> for PostProcessor

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 PostProcessor

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encode for PostProcessor

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

Encode a given type.

impl PartialEq for PostProcessor

fn eq(&self, other: &PostProcessor) -> 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 PostProcessor

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 PostProcessor