Struct Registry 

pub struct Registry<State = Invalid> { /* private fields */ }

A collection of signals with their computational dependencies.

The Registry struct serves as the central data structure for managing asset signals. It stores signal definitions indexed by their unique IDs and provides methods for accessing and validating them.

The State type parameter indicates whether the registry has been validated:

• Registry<Invalid> - A registry that has not been validated or has failed validation
• Registry<Valid> - A registry that has been successfully validated

Examples

Creating and validating a registry:

use bothan_lib::registry::{Registry, Invalid, Valid};
use serde_json::json;

// Create a registry from JSON
let json_data = json!({
    "BTC-USD": {
        "sources": [
            {
                "source_id": "binance",
                "id": "btcusdt",
                "routes": []
            }
        ],
        "processor": {
            "function": "median",
            "params": {
                "min_source_count": 1
            }
        },
        "post_processors": []
    }
});

let registry_json = serde_json::to_string(&json_data).unwrap();
let registry: Registry<Invalid> = serde_json::from_str(&registry_json).unwrap();

// Validate the registry
let valid_registry: Registry<Valid> = registry.validate().unwrap();

// Use the validated registry
assert!(valid_registry.contains("BTC-USD"));

Implementations

impl Registry<Invalid>

pub fn validate(self) -> Result<Registry<Valid>, ValidationError>

Validates the registry, ensuring all dependencies exist and there are no cycles.

This method performs a thorough validation of the registry, checking that:

• All signal dependencies (referenced by signal IDs) exist in the registry
• There are no circular dependencies between signals

If validation is successful, the registry is converted to the Valid state. If validation fails, an error is returned explaining the validation failure.

Returns

• Ok(Registry<Valid>) if validation is successful
• Err(ValidationError) if validation fails

Examples

use bothan_lib::registry::{Registry, ValidationError};
use serde_json::json;

// Create a valid registry
let valid_json = json!({
    "USDT-USD": {
        "sources": [
            {
                "source_id": "coingecko",
                "id": "tether",
                "routes": []
            }
        ],
        "processor": {
            "function": "median",
            "params": {
                "min_source_count": 1
            }
        },
        "post_processors": []
    }
});

let valid_registry: Registry = serde_json::from_value(valid_json).unwrap();
assert!(valid_registry.validate().is_ok());

// Create an invalid registry with a missing dependency
let invalid_json = json!({
    "BTC-USD": {
        "sources": [
            {
                "source_id": "binance",
                "id": "btcusdt",
                "routes": [
                    {
                        "signal_id": "USDT-USD", // This dependency doesn't exist
                        "operation": "*"
                    }
                ]
            }
        ],
        "processor": {
            "function": "median",
            "params": {
                "min_source_count": 1
            }
        },
        "post_processors": []
    }
});

let invalid_registry: Registry = serde_json::from_value(invalid_json).unwrap();
assert!(invalid_registry.validate().is_err());

impl<T> Registry<T>

pub fn get(&self, signal_id: &str) -> Option<&Signal>

Returns the signal for a given signal id.

This method retrieves a reference to the Signal with the specified ID, if it exists in the registry.

Returns

• Some(&Signal) if the signal exists in the registry
• None if the signal does not exist

pub fn contains(&self, signal_id: &str) -> bool

Returns true if the registry contains the given signal id.

This method checks whether a signal with the specified ID exists in the registry.

Returns

• true if the signal exists in the registry
• false if the signal does not exist

pub fn signal_ids(&self) -> impl Iterator<Item = &String>

An iterator visiting all signal ids in the registry in arbitrary order.

This method returns an iterator over all signal IDs in the registry. The order of iteration is not specified and may vary between calls.

Returns

An iterator yielding references to signal IDs

pub fn iter(&self) -> impl Iterator<Item = (&String, &Signal)>

An iterator visiting all the signal ids and their signals in the registry in arbitrary order.

This method returns an iterator over all signal IDs and their corresponding signals in the registry. The order of iteration is not specified and may vary between calls.

Returns

An iterator yielding pairs of references to signal IDs and their signals

Trait Implementations

impl<State: Clone> Clone for Registry<State>

fn clone(&self) -> Registry<State>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<State: Debug> Debug for Registry<State>

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

Formats the value using the given formatter.

impl<Context> Decode<Context> for Registry<Invalid>

fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError>

Decodes a registry from binary serialization.

This implementation enables efficient binary deserialization of the registry using the bincode crate. It decodes the inner map of signals and creates an invalid registry that must be validated before use.

Errors

Returns a DecodeError if decoding fails

impl Default for Registry<Valid>

fn default() -> Self

Creates a new empty validated registry.

This method creates a default validated registry, which is empty. This is useful as a starting point for building a registry programmatically.

Returns

An empty Registry<Valid>

impl<'de, State> Deserialize<'de> for Registry<State>

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<State> Encode for Registry<State>

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

Encodes the registry for binary serialization.

This implementation enables efficient binary serialization of the registry using the bincode crate. It encodes the inner map of signals.

Errors

Returns an EncodeError if encoding fails

impl<State: PartialEq> PartialEq for Registry<State>

fn eq(&self, other: &Registry<State>) -> 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<State> Serialize for Registry<State>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<State> StructuralPartialEq for Registry<State>