Struct Signal 

pub struct Signal {
    pub source_queries: Vec<SourceQuery>,
    pub processor: Processor,
    pub post_processors: Vec<PostProcessor>,
}

A complete definition for computing a signal value.

The Signal struct encapsulates all the information required to compute a signal value: the sources to query for input data, the processing strategy to apply, and any post-processing transformations to perform on the result.

Signals are the fundamental building blocks of the registry system, allowing for flexible and configurable computation of asset information from various data sources.

Components

• source_queries - Definitions of where and how to obtain input data
• processor - Strategy for combining data from different sources
• post_processors - Optional transformations to apply to the processed value

Examples

use bothan_lib::registry::signal::Signal;
use bothan_lib::registry::source::{SourceQuery, OperationRoute, Operation};
use bothan_lib::registry::processor::{Processor, median::MedianProcessor};
use bothan_lib::registry::post_processor::{PostProcessor, tick::TickPostProcessor};

// Create a BTC-USD signal that uses data from multiple sources
let signal = Signal::new(
    // Source queries
    vec![
        SourceQuery::new(
            "binance".to_string(),
            "btcusdt".to_string(),
            vec![
                // Apply USDT-USD conversion route
                OperationRoute::new("USDT-USD".to_string(), Operation::Multiply),
            ],
        ),
        SourceQuery::new(
            "coinbase".to_string(),
            "BTC-USD".to_string(),
            vec![],
        ),
    ],
    // Processor (median with at least 1 source required)
    Processor::Median(MedianProcessor { min_source_count: 1 }),
    // Post-processors (convert to tick value)
    vec![PostProcessor::TickConvertor(TickPostProcessor {})],
);

Fields

source_queries: Vec<SourceQuery>

Source queries that define where to obtain input data.

Each query specifies a data source, an identifier within that source, and optionally a series of routes to apply to the data before processing.

processor: Processor

The processing strategy to apply to the source data.

This defines how data from different sources will be combined into a single output value, such as by taking the median or weighted median.

post_processors: Vec<PostProcessor>

Optional post-processing transformations to apply to the processed value.

These transformations are applied in sequence after the main processing step, allowing for additional adjustments like tick conversion.

Implementations

impl Signal

pub fn new( source_queries: Vec<SourceQuery>, processor: Processor, post_processors: Vec<PostProcessor>, ) -> Self

Creates a new Signal with the specified components.

This method constructs a complete signal definition from its constituent parts: the source queries for input data, the processor for combining data, and any post-processors for transforming the result.

Examples

use bothan_lib::registry::signal::Signal;
use bothan_lib::registry::source::SourceQuery;
use bothan_lib::registry::processor::{Processor, median::MedianProcessor};
use bothan_lib::registry::post_processor::PostProcessor;

// Create a simple signal with a median processor
let signal = Signal::new(
    vec![
        SourceQuery::new("exchange1".to_string(), "btc-usd".to_string(), vec![]),
        SourceQuery::new("exchange2".to_string(), "btc-usd".to_string(), vec![]),
    ],
    Processor::Median(MedianProcessor { min_source_count: 2 }),
    vec![], // No post-processors
);

Trait Implementations

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

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 Signal

fn clone(&self) -> Signal

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Signal

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

Formats the value using the given formatter.

impl<__Context> Decode<__Context> for Signal

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 Signal

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encode for Signal

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

Encode a given type.

impl PartialEq for Signal

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

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 Signal