#![forbid(unsafe_code)]
mod footprint;
#[cfg(feature = "gpu")]
mod gpu;
mod grid;
mod heatmap;
mod levels;
#[cfg(feature = "testing")]
pub mod testing;
mod tpo;
mod trades;
use core::ops::Range;
use ferrochart_core::Chart;
use ferrochart_core::data::{DataChange, OhlcColumns, SeriesId, Timestamp};
use ferrochart_core::error::{Error, Result};
use ferrochart_core::plugin::CustomSeries;
pub use footprint::{
CELLS_MIN_SPACING, FOOTPRINT_KIND, Footprint, FootprintColors, FootprintMode, FootprintOptions,
NUMBERS_MIN_SPACING,
};
#[cfg(feature = "gpu")]
pub use gpu::{HeatmapGpu, register_gpu, supports_native_heatmap};
pub use grid::{Column, SparseGrid};
pub use heatmap::{
ColorScale, DepthSnapshot, HEATMAP_KIND, Heatmap, HeatmapColors, HeatmapOptions, HeatmapRange,
HeatmapSource, MAX_LEVELS_PER_ROW,
};
pub use levels::PriceLevels;
pub use tpo::{
SessionProfile, TPO_KIND, TPO_MIN_FONT, TPO_MIN_SPACING, Tpo, TpoColors, TpoOptions, tpo_letter,
};
pub use trades::{Side, TickColumns, TickRule};
pub(crate) fn column_start(time: Timestamp, period: i64) -> Timestamp {
time.div_euclid(period).checked_mul(period).unwrap_or(time)
}
pub(crate) trait TradeSink: CustomSeries {
fn timeframe(&self) -> i64;
fn last_column(&self) -> Option<Timestamp>;
fn apply(&mut self, trades: &TickColumns, range: Range<usize>) -> Result<()>;
}
pub fn append_trades(chart: &mut Chart, id: SeriesId, trades: &TickColumns) -> Result<()> {
trades.check(None)?;
if chart.custom_series::<Footprint>(id).is_some() {
return append::<Footprint>(chart, id, trades);
}
if let Some(h) = chart.custom_series::<Heatmap>(id) {
if h.options().source != HeatmapSource::Trades {
return Err(Error::InvalidArgument("the heatmap takes depth snapshots"));
}
return append::<Heatmap>(chart, id, trades);
}
chart.series_kind(id).ok_or(Error::UnknownId)?;
Err(Error::InvalidArgument("the series takes no trades"))
}
pub fn append_depth(chart: &mut Chart, id: SeriesId, snapshot: &DepthSnapshot<'_>) -> Result<()> {
if chart.custom_series::<Heatmap>(id).is_none() {
chart.series_kind(id).ok_or(Error::UnknownId)?;
return Err(Error::InvalidArgument(
"the series takes no depth snapshots",
));
}
let mut failed = None;
chart.update_custom(id, |h: &mut Heatmap| {
let (before, version) = (h.grid().columns(), h.version());
let result = h.push_depth(snapshot);
let change = match h.grid().columns() - before {
_ if h.version() == version => DataChange::Append { count: 0 },
0 => DataChange::UpdateLast,
count if result.is_ok() => DataChange::Append { count },
_ => DataChange::Replace,
};
failed = result.err();
change
})?;
failed.map_or(Ok(()), Err)
}
fn append<T: TradeSink>(chart: &mut Chart, id: SeriesId, trades: &TickColumns) -> Result<()> {
let s = chart.custom_series::<T>(id).ok_or(Error::UnknownId)?;
let (period, last) = (s.timeframe(), s.last_column());
let n = trades.len();
let split = match (last, trades.time.first()) {
(Some(last), Some(&t0)) if column_start(t0, period) < last => {
return Err(Error::TimeNotIncreasing { index: 0 });
}
(Some(last), _) => trades
.time
.partition_point(|&t| column_start(t, period) <= last),
(None, _) => 0,
};
let mut failed = None;
if split > 0 {
chart.update_custom(id, |s: &mut T| match s.apply(trades, 0..split) {
Ok(()) => DataChange::UpdateLast,
Err(e) => {
failed = Some(e);
DataChange::Replace
}
})?;
}
if failed.is_none() && split < n {
chart.update_custom(id, |s: &mut T| {
let before = s.times().len();
match s.apply(trades, split..n) {
Ok(()) => DataChange::Append {
count: s.times().len() - before,
},
Err(e) => {
failed = Some(e);
DataChange::Replace
}
}
})?;
}
failed.map_or(Ok(()), Err)
}
pub fn append_bars(chart: &mut Chart, id: SeriesId, bars: &OhlcColumns) -> Result<()> {
let Some(t) = chart.custom_series::<Tpo>(id) else {
chart.series_kind(id).ok_or(Error::UnknownId)?;
return Err(Error::InvalidArgument("the series takes no bars"));
};
tpo::check_bars(bars, t.price_levels())?;
let n = bars.time.len();
let split = match (t.last_session(), bars.time.first()) {
(Some(last), Some(&t0)) if t.session_start(t0) < last => {
return Err(Error::TimeNotIncreasing { index: 0 });
}
(Some(last), _) => bars.time.partition_point(|&x| t.session_start(x) <= last),
(None, _) => 0,
};
let apply = |t: &mut Tpo, range: Range<usize>| -> Result<()> {
let result = range.into_iter().try_for_each(|i| {
t.push_raw(bars.time[i], bars.high[i], bars.low[i])
.map(drop)
});
t.finish_last();
result
};
let mut failed = None;
if split > 0 {
chart.update_custom(id, |t: &mut Tpo| match apply(t, 0..split) {
Ok(()) => DataChange::UpdateLast,
Err(e) => {
failed = Some(e);
DataChange::Replace
}
})?;
}
if failed.is_none() && split < n {
chart.update_custom(id, |t: &mut Tpo| {
let before = t.sessions().len();
match apply(t, split..n) {
Ok(()) => DataChange::Append {
count: t.sessions().len() - before,
},
Err(e) => {
failed = Some(e);
DataChange::Replace
}
}
})?;
}
failed.map_or(Ok(()), Err)
}