flowsurface-data 0.9.0

Data aggregation, indexing, and configuration utilities for Flowsurface
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

use crate::chart::kline::IndicatorInstanceId;
use indicator_engine::{OutputPrecision, ReadoutBehavior};

/// The value domain supported by a declared indicator output.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum OutputValueType {
    Number,
    Boolean,
    Ohlc,
    Range,
}

/// A stable, definition-local output channel declaration.
#[derive(Debug, Clone, PartialEq)]
pub struct OutputChannelSpec {
    pub id: String,
    pub label: String,
    pub value_type: OutputValueType,
    pub precision: OutputPrecision,
    pub line_width: f32,
    pub readout: ReadoutBehavior,
    pub style_slot: Option<String>,
    pub offset_bars: i32,
    pub style_by: Option<String>,
    pub independent_scale: bool,
}

/// A value emitted by an indicator for one chart bar.
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum OutputValue {
    Number(f64),
    Boolean(bool),
}

impl OutputValue {
    pub const fn value_type(self) -> OutputValueType {
        match self {
            Self::Number(_) => OutputValueType::Number,
            Self::Boolean(_) => OutputValueType::Boolean,
        }
    }

    pub fn as_f64(self) -> f64 {
        match self {
            Self::Number(value) => value,
            Self::Boolean(value) => f64::from(value),
        }
    }

    pub fn as_number(self) -> Option<f64> {
        match self {
            Self::Number(value) => value.is_finite().then_some(value),
            Self::Boolean(_) => None,
        }
    }

    pub fn as_boolean(self) -> Option<bool> {
        match self {
            Self::Boolean(value) => Some(value),
            Self::Number(_) => None,
        }
    }
}

/// A reference to one named output of one indicator instance.
#[derive(Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
pub struct IndicatorOutputRef {
    pub instance_id: IndicatorInstanceId,
    pub channel_id: String,
}

impl IndicatorOutputRef {
    pub fn new(instance_id: IndicatorInstanceId, channel_id: impl Into<String>) -> Self {
        Self {
            instance_id,
            channel_id: channel_id.into(),
        }
    }

    pub fn is_valid(&self) -> bool {
        !self.channel_id.trim().is_empty()
    }
}