Struct TickPostProcessor 

pub struct TickPostProcessor {}

Post-processor that converts decimal values to tick values.

The TickPostProcessor converts decimal values to tick values based on a logarithmic scale. This conversion can be useful for representing a wide range of values in a compact form with consistent relative precision.

Tick Formula

The conversion uses the formula:

tick = log(value) / log(1.0001) + 262144

Constraints

The resulting tick value must be within the range [1, 524287]. If the conversion yields a value outside this range, an error is returned.

Examples

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 {});

// Convert a decimal value to a tick value
let value = Decimal::new(20, 0);  // The value 20.0
let result = post_processor.post_process(value).unwrap();

// The result will be approximately 292102.8

Implementations

impl TickPostProcessor

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

Converts a decimal value to its corresponding tick value.

This method applies the logarithmic conversion to transform a decimal value into a tick value. The tick value represents the position on a non-linear scale where each step corresponds to a 0.01% change in value.

Errors

Returns a PostProcessError if the computed tick value is outside the range [1, 524287].

Trait Implementations

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

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 TickPostProcessor

fn clone(&self) -> TickPostProcessor

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TickPostProcessor

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

Formats the value using the given formatter.

impl<__Context> Decode<__Context> for TickPostProcessor

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 TickPostProcessor

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encode for TickPostProcessor

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

Encode a given type.

impl PartialEq for TickPostProcessor

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

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 TickPostProcessor