193 lines
3.9 KiB
Rust
193 lines
3.9 KiB
Rust
use pulse_macros::pwp;
|
|
|
|
use crate::PulseWire;
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct Symbol(pub String);
|
|
|
|
#[derive(Debug, Clone, Copy)]
|
|
pub struct USD(pub f64);
|
|
|
|
#[pwp]
|
|
#[derive(Copy, serde::Deserialize, serde::Serialize)]
|
|
pub enum TimeFrame {
|
|
#[serde(rename = "1m")]
|
|
M1,
|
|
#[serde(rename = "3m")]
|
|
M3,
|
|
#[serde(rename = "5m")]
|
|
M5,
|
|
#[serde(rename = "15m")]
|
|
M15,
|
|
#[serde(rename = "30m")]
|
|
M30,
|
|
|
|
#[serde(rename = "1h")]
|
|
H1,
|
|
#[serde(rename = "2h")]
|
|
H2,
|
|
#[serde(rename = "4h")]
|
|
H4,
|
|
#[serde(rename = "8h")]
|
|
H8,
|
|
#[serde(rename = "12h")]
|
|
H12,
|
|
|
|
#[serde(rename = "1d")]
|
|
D1,
|
|
#[serde(rename = "3d")]
|
|
D3,
|
|
|
|
#[serde(rename = "1w")]
|
|
W1,
|
|
#[serde(rename = "1M")]
|
|
Month1,
|
|
}
|
|
|
|
#[pwp]
|
|
pub enum Direction {
|
|
Buy,
|
|
Sell,
|
|
}
|
|
|
|
#[pwp]
|
|
pub enum Volatility {
|
|
Low,
|
|
Medium,
|
|
High,
|
|
}
|
|
|
|
impl std::fmt::Display for Symbol {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
write!(f, "\x1b[35m{}\x1b[0m", self.0)
|
|
}
|
|
}
|
|
|
|
impl std::fmt::Display for USD {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
if self.0 > 0.0 {
|
|
write!(f, "\x1b[32m${}\x1b[0m", format_f64(self.0))
|
|
} else {
|
|
write!(f, "\x1b[31m${}\x1b[0m", format_f64(self.0))
|
|
}
|
|
}
|
|
}
|
|
|
|
impl PulseWire for Symbol {
|
|
fn from_com(com: &mut Vec<u8>) -> Self {
|
|
Self(String::from_com(com))
|
|
}
|
|
|
|
fn to_com(&self) -> Vec<u8> {
|
|
self.0.to_com()
|
|
}
|
|
}
|
|
|
|
impl PulseWire for USD {
|
|
fn from_com(com: &mut Vec<u8>) -> Self {
|
|
Self(f64::from_com(com))
|
|
}
|
|
|
|
fn to_com(&self) -> Vec<u8> {
|
|
self.0.to_com()
|
|
}
|
|
}
|
|
|
|
pub fn format_f64(value: f64) -> String {
|
|
let abs = value.abs();
|
|
|
|
let (divisor, suffix) = if abs >= 1_000_000_000.0 {
|
|
(1_000_000_000.0, "B")
|
|
} else if abs >= 1_000_000.0 {
|
|
(1_000_000.0, "M")
|
|
} else if abs >= 1_000.0 {
|
|
(1_000.0, "K")
|
|
} else {
|
|
(1.0, "")
|
|
};
|
|
|
|
if divisor != 1.0 {
|
|
let formatted = value / divisor;
|
|
|
|
// Remove unnecessary trailing zeros
|
|
let s = format!("{:.2}", formatted)
|
|
.trim_end_matches('0')
|
|
.trim_end_matches('.')
|
|
.to_string();
|
|
|
|
return format!("{}{}", s, suffix);
|
|
}
|
|
|
|
let val = format!("{:.3}", value);
|
|
let parts: Vec<&str> = val.split('.').collect();
|
|
|
|
let int = parts[0].to_string();
|
|
let negative = int.starts_with('-');
|
|
|
|
let start = if negative { 1 } else { 0 };
|
|
let mut result = String::new();
|
|
|
|
for (i, c) in int[start..].chars().rev().enumerate() {
|
|
if i > 0 && i % 3 == 0 {
|
|
result.push(',');
|
|
}
|
|
result.push(c);
|
|
}
|
|
|
|
let mut formatted: String = result.chars().rev().collect();
|
|
|
|
if negative {
|
|
formatted.insert(0, '-');
|
|
}
|
|
|
|
if parts.len() > 1 {
|
|
formatted.push('.');
|
|
formatted.push_str(parts[1]);
|
|
}
|
|
|
|
formatted
|
|
}
|
|
|
|
impl TimeFrame {
|
|
pub fn as_str(&self) -> &'static str {
|
|
match self {
|
|
Self::M1 => "1m",
|
|
Self::M3 => "3m",
|
|
Self::M5 => "5m",
|
|
Self::M15 => "15m",
|
|
Self::M30 => "30m",
|
|
|
|
Self::H1 => "1h",
|
|
Self::H2 => "2h",
|
|
Self::H4 => "4h",
|
|
Self::H8 => "8h",
|
|
Self::H12 => "12h",
|
|
|
|
Self::D1 => "1d",
|
|
Self::D3 => "3d",
|
|
|
|
Self::W1 => "1w",
|
|
Self::Month1 => "1M",
|
|
}
|
|
}
|
|
}
|
|
|
|
impl std::fmt::Display for Direction {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
match self {
|
|
Self::Buy => write!(f, "BUY"),
|
|
Self::Sell => write!(f, "SELL"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl std::fmt::Display for Volatility {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
match self {
|
|
Self::Low => write!(f, "Low"),
|
|
Self::Medium => write!(f, "Medium"),
|
|
Self::High => write!(f, "High"),
|
|
}
|
|
}
|
|
}
|