pine_core/

output.rs

// Output-related types, traits, and implementations

use std::collections::HashMap;

/// Represents a color with RGBA components
#[derive(Clone, Debug, PartialEq)]
pub struct Color {
    pub r: u8, // Red component (0-255)
    pub g: u8, // Green component (0-255)
    pub b: u8, // Blue component (0-255)
    pub t: u8, // Transparency (0-100)
}

impl Color {
    pub fn new(r: u8, g: u8, b: u8, t: u8) -> Self {
        Color { r, g, b, t }
    }
}

/// Represents a label drawable object
#[derive(Clone, Debug)]
pub struct Label {
    pub x: f64,
    pub y: f64,
    pub text: String,
    pub xloc: String,
    pub yloc: String,
    pub color: Option<Color>,
    pub style: String,
    pub textcolor: Option<Color>,
    pub size: String,
    pub textalign: String,
    pub tooltip: Option<String>,
    pub text_font_family: String,
}

/// Represents a box drawable object
/// A `fill(...)` between two plots or hlines.
#[derive(Clone, Debug)]
pub struct FillObject {
    /// Id of the first plot/hline (`None` when it was `na`).
    pub id1: Option<usize>,
    /// Id of the second plot/hline.
    pub id2: Option<usize>,
    pub color: Option<Color>,
    pub title: String,
}

/// Chart-wide settings written by global functions like `bgcolor`/`barcolor`.
#[derive(Clone, Debug, Default)]
pub struct GlobalContext {
    /// Background color (`bgcolor`).
    pub bgcolor: Option<Color>,
    /// Price-bar color (`barcolor`).
    pub barcolor: Option<Color>,
}

/// How often an `alert(...)` call re-fires within a bar / across bars.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Frequency {
    /// Every time the call is reached (`alert.freq_all`).
    All,
    /// Once per realtime bar (`alert.freq_once_per_bar`).
    OncePerBar,
    /// Once per bar, on the bar's close (`alert.freq_once_per_bar_close`).
    OncePerBarClose,
}

impl Frequency {
    /// Parse a `freq_*` constant string, defaulting to `OncePerBar`.
    pub fn from_const(value: &str) -> Frequency {
        match value {
            "freq_all" => Frequency::All,
            "freq_once_per_bar_close" => Frequency::OncePerBarClose,
            _ => Frequency::OncePerBar,
        }
    }
}

/// An `alertcondition(...)` declaration or an `alert(...)` fire — a named alert
/// with a message. `frequency` is `None` for `alertcondition` and `Some` for
/// `alert`, which specifies one.
#[derive(Clone, Debug, Default)]
pub struct AlertCondition {
    pub title: String,
    pub message: String,
    pub frequency: Option<Frequency>,
}

/// The `indicator(...)` declaration — a script's identity and display settings.
#[derive(Clone, Debug, Default)]
pub struct Indicator {
    pub title: String,
    pub shorttitle: String,
    pub overlay: bool,
    pub format: String,
    pub precision: Option<i64>,
    pub timeframe: String,
}

/// The `library(...)` declaration — marks a script as a reusable library.
#[derive(Clone, Debug, Default)]
pub struct Library {
    pub title: String,
    pub overlay: bool,
    pub dynamic_requests: Option<bool>,
}

/// A trend line drawn between two points, `(x1, y1)`–`(x2, y2)`.
#[derive(Clone, Debug)]
pub struct LineObject {
    pub x1: f64,
    pub y1: f64,
    pub x2: f64,
    pub y2: f64,
    pub xloc: String,
    pub extend: String,
    pub color: Option<Color>,
    pub style: String,
    pub width: f64,
}

/// One cell of a [`Table`].
#[derive(Clone, Debug, Default)]
pub struct TableCell {
    pub text: String,
    pub text_color: Option<Color>,
    pub bgcolor: Option<Color>,
    pub text_size: String,
    pub text_halign: String,
    pub text_valign: String,
}

/// A table overlay: a fixed grid of cells anchored to a chart position.
#[derive(Clone, Debug)]
pub struct Table {
    pub position: String,
    pub columns: usize,
    pub rows: usize,
    pub bgcolor: Option<Color>,
    pub cells: HashMap<(usize, usize), TableCell>,
}

#[derive(Clone, Debug)]
pub struct PineBox {
    pub left: f64,
    pub top: f64,
    pub right: f64,
    pub bottom: f64,
    pub border_color: Option<Color>,
    pub border_width: f64,
    pub border_style: String,
    pub extend: String,
    pub xloc: String,
    pub bgcolor: Option<Color>,
    pub text: String,
    pub text_size: f64,
    pub text_color: Option<Color>,
    pub text_halign: String,
    pub text_valign: String,
    pub text_wrap: String,
    pub text_font_family: String,
}

/// Represents a plot output
#[derive(Clone, Debug, Default)]
pub struct Plot {
    pub series: f64,
    pub title: String,
    pub color: Option<Color>,
    pub linewidth: f64,
    pub style: String,
    pub trackprice: bool,
    pub histbase: f64,
    pub offset: f64,
    pub join: bool,
    pub editable: bool,
    pub show_last: Option<f64>,
    pub display: String,
    pub format: Option<String>,
    pub precision: Option<f64>,
    pub force_overlay: bool,
    pub linestyle: String,
}

/// Represents a plotarrow output
#[derive(Clone, Debug)]
pub struct Plotarrow {
    pub series: f64,
    pub title: String,
    pub colorup: Option<Color>,
    pub colordown: Option<Color>,
    pub offset: f64,
    pub minheight: f64,
    pub maxheight: f64,
    pub editable: bool,
    pub show_last: Option<f64>,
    pub display: String,
    pub format: Option<String>,
    pub precision: Option<f64>,
    pub force_overlay: bool,
}

/// Represents a plotbar output
#[derive(Clone, Debug)]
pub struct Plotbar {
    pub open: f64,
    pub high: f64,
    pub low: f64,
    pub close: f64,
    pub title: String,
    pub color: Option<Color>,
    pub editable: bool,
    pub show_last: Option<f64>,
    pub display: String,
    pub format: Option<String>,
    pub precision: Option<f64>,
    pub force_overlay: bool,
}

/// Represents a plotcandle output
#[derive(Clone, Debug)]
pub struct Plotcandle {
    pub open: f64,
    pub high: f64,
    pub low: f64,
    pub close: f64,
    pub title: String,
    pub color: Option<Color>,
    pub wickcolor: Option<Color>,
    pub editable: bool,
    pub show_last: Option<f64>,
    pub bordercolor: Option<Color>,
    pub display: String,
    pub format: Option<String>,
    pub precision: Option<f64>,
    pub force_overlay: bool,
}

/// Represents a plotchar output
#[derive(Clone, Debug)]
pub struct Plotchar {
    pub series: f64,
    pub title: String,
    pub char: String,
    pub location: String,
    pub color: Option<Color>,
    pub offset: f64,
    pub text: String,
    pub textcolor: Option<Color>,
    pub editable: bool,
    pub size: String,
    pub show_last: Option<f64>,
    pub display: String,
    pub format: Option<String>,
    pub precision: Option<f64>,
    pub force_overlay: bool,
}

/// Represents a plotshape output
#[derive(Clone, Debug)]
pub struct Plotshape {
    pub series: f64,
    pub title: String,
    pub style: String,
    pub location: String,
    pub color: Option<Color>,
    pub offset: f64,
    pub text: String,
    pub textcolor: Option<Color>,
    pub editable: bool,
    pub size: String,
    pub show_last: Option<f64>,
    pub display: String,
    pub format: Option<String>,
    pub precision: Option<f64>,
    pub force_overlay: bool,
}

/// Log level
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LogLevel {
    Info,
    Warning,
    Error,
}

/// A log entry with level and message
#[derive(Debug, Clone)]
pub struct LogEntry {
    pub level: LogLevel,
    pub message: String,
}

/// The default value of a declared input, preserved with its type so a host can
/// render the right settings widget.
///
/// Deserializes from a JSON scalar (untagged) so host input overrides can be read
/// from config.
#[derive(Debug, Clone, PartialEq, serde::Deserialize)]
#[serde(untagged)]
pub enum InputValue {
    Bool(bool),
    Int(i64),
    Float(f64),
    Str(String),
    #[serde(skip)]
    Color(Color),
}

/// A declared script input (`input.int(...)`, `input.source(...)`, ...).
///
/// Recorded into the output so a host can enumerate a script's configurable
/// settings without executing anything itself.
#[derive(Debug, Clone)]
pub struct Input {
    /// Which `input.*` function declared it: `"int"`, `"float"`, `"bool"`,
    /// `"string"`, `"source"`, `"color"`, `"session"`, `"time"`.
    pub kind: String,
    /// Display title (`title` argument), empty when none was given.
    pub title: String,
    /// Group the input belongs to (`group` argument), empty when none.
    pub group: String,
    /// The `defval` the script declared.
    pub default: InputValue,
    pub value: InputValue,
}

/// Base trait for all output implementations
///
/// This trait defines the minimal contract that all output types must implement.
/// Extension traits (LogOutput, PlotOutput, etc.) add additional capabilities.
pub trait PineOutput: Default + Clone + std::fmt::Debug + 'static {
    /// Clear all output data for a new iteration
    fn clear(&mut self);
}

/// Extension trait for logging output
pub trait LogOutput: PineOutput {
    /// Add a log entry with the given level and message
    fn add_log(&mut self, level: LogLevel, message: String);
    /// Get all log entries
    fn get_logs(&self) -> &[LogEntry];
}

/// Macro to easily implement all output traits by delegating to a base field
///
/// # Example
/// ```ignore
/// impl_output_traits_delegate!(CustomOutput, base);
/// ```
#[macro_export]
macro_rules! impl_output_traits_delegate {
    ($type:ty, $field:ident) => {
        impl $crate::LogOutput for $type {
            fn add_log(&mut self, level: $crate::LogLevel, message: String) {
                self.$field.add_log(level, message)
            }
            fn get_logs(&self) -> &[$crate::LogEntry] {
                self.$field.get_logs()
            }
        }

        impl $crate::PlotOutput for $type {
            fn add_plot(&mut self, plot: $crate::Plot) {
                self.$field.add_plot(plot)
            }
            fn plots(&self) -> &[$crate::Plot] {
                self.$field.plots()
            }
            fn add_plotarrow(&mut self, arrow: $crate::Plotarrow) {
                self.$field.add_plotarrow(arrow)
            }
            fn plotarrows(&self) -> &[$crate::Plotarrow] {
                self.$field.plotarrows()
            }
            fn add_plotbar(&mut self, bar: $crate::Plotbar) {
                self.$field.add_plotbar(bar)
            }
            fn plotbars(&self) -> &[$crate::Plotbar] {
                self.$field.plotbars()
            }
            fn add_plotcandle(&mut self, candle: $crate::Plotcandle) {
                self.$field.add_plotcandle(candle)
            }
            fn plotcandles(&self) -> &[$crate::Plotcandle] {
                self.$field.plotcandles()
            }
            fn add_plotchar(&mut self, char: $crate::Plotchar) {
                self.$field.add_plotchar(char)
            }
            fn plotchars(&self) -> &[$crate::Plotchar] {
                self.$field.plotchars()
            }
            fn add_plotshape(&mut self, shape: $crate::Plotshape) {
                self.$field.add_plotshape(shape)
            }
            fn plotshapes(&self) -> &[$crate::Plotshape] {
                self.$field.plotshapes()
            }
        }

        impl $crate::LabelOutput for $type {
            fn add_label(&mut self, label: $crate::Label) -> usize {
                self.$field.add_label(label)
            }
            fn get_label(&self, id: usize) -> Option<&$crate::Label> {
                self.$field.get_label(id)
            }
            fn get_label_mut(&mut self, id: usize) -> Option<&mut $crate::Label> {
                self.$field.get_label_mut(id)
            }
            fn delete_label(&mut self, id: usize) -> bool {
                self.$field.delete_label(id)
            }
        }

        impl $crate::BoxOutput for $type {
            fn add_box(&mut self, box_obj: $crate::PineBox) -> usize {
                self.$field.add_box(box_obj)
            }
            fn get_box(&self, id: usize) -> Option<&$crate::PineBox> {
                self.$field.get_box(id)
            }
            fn get_box_mut(&mut self, id: usize) -> Option<&mut $crate::PineBox> {
                self.$field.get_box_mut(id)
            }
            fn delete_box(&mut self, id: usize) -> bool {
                self.$field.delete_box(id)
            }
        }

        impl $crate::InputOutput for $type {
            fn add_input(&mut self, input: $crate::Input) {
                self.$field.add_input(input)
            }
            fn inputs(&self) -> &[$crate::Input] {
                self.$field.inputs()
            }
        }

        impl $crate::MetadataOutput for $type {
            fn set_indicator(&mut self, indicator: $crate::Indicator) {
                self.$field.set_indicator(indicator)
            }
            fn indicator(&self) -> Option<&$crate::Indicator> {
                self.$field.indicator()
            }
            fn set_library(&mut self, library: $crate::Library) {
                self.$field.set_library(library)
            }
            fn library(&self) -> Option<&$crate::Library> {
                self.$field.library()
            }
        }

        impl $crate::AlertConditionOutput for $type {
            fn add_alertcondition(&mut self, alert: $crate::AlertCondition) {
                self.$field.add_alertcondition(alert)
            }
            fn alertconditions(&self) -> &[$crate::AlertCondition] {
                self.$field.alertconditions()
            }
        }

        impl $crate::FillOutput for $type {
            fn add_fill(&mut self, fill: $crate::FillObject) {
                self.$field.add_fill(fill)
            }
            fn fills(&self) -> &[$crate::FillObject] {
                self.$field.fills()
            }
        }

        impl $crate::GlobalOutput for $type {
            fn set_bgcolor(&mut self, color: Option<$crate::Color>) {
                self.$field.set_bgcolor(color)
            }
            fn set_barcolor(&mut self, color: Option<$crate::Color>) {
                self.$field.set_barcolor(color)
            }
            fn global_context(&self) -> &$crate::GlobalContext {
                self.$field.global_context()
            }
        }

        impl $crate::LineOutput for $type {
            fn add_line(&mut self, line: $crate::LineObject) -> usize {
                self.$field.add_line(line)
            }
            fn get_line(&self, id: usize) -> Option<&$crate::LineObject> {
                self.$field.get_line(id)
            }
            fn get_line_mut(&mut self, id: usize) -> Option<&mut $crate::LineObject> {
                self.$field.get_line_mut(id)
            }
            fn delete_line(&mut self, id: usize) -> bool {
                self.$field.delete_line(id)
            }
        }

        impl $crate::DrawingOutput for $type {
            fn add_linefill(&mut self, linefill: $crate::LinefillObject) -> usize {
                self.$field.add_linefill(linefill)
            }
            fn get_linefill(&self, id: usize) -> Option<&$crate::LinefillObject> {
                self.$field.get_linefill(id)
            }
            fn get_linefill_mut(&mut self, id: usize) -> Option<&mut $crate::LinefillObject> {
                self.$field.get_linefill_mut(id)
            }
            fn delete_linefill(&mut self, id: usize) -> bool {
                self.$field.delete_linefill(id)
            }
            fn add_polyline(&mut self, polyline: $crate::PolylineObject) -> usize {
                self.$field.add_polyline(polyline)
            }
            fn delete_polyline(&mut self, id: usize) -> bool {
                self.$field.delete_polyline(id)
            }
        }

        impl $crate::TableOutput for $type {
            fn add_table(&mut self, table: $crate::Table) -> usize {
                self.$field.add_table(table)
            }
            fn get_table(&self, id: usize) -> Option<&$crate::Table> {
                self.$field.get_table(id)
            }
            fn get_table_mut(&mut self, id: usize) -> Option<&mut $crate::Table> {
                self.$field.get_table_mut(id)
            }
            fn delete_table(&mut self, id: usize) -> bool {
                self.$field.delete_table(id)
            }
        }
    };
}

/// Extension trait for plot-related output
pub trait PlotOutput: PineOutput {
    /// Add a plot output
    fn add_plot(&mut self, plot: Plot);
    /// Get all plot outputs
    fn plots(&self) -> &[Plot];

    /// Add a plotarrow output
    fn add_plotarrow(&mut self, arrow: Plotarrow);
    /// Get all plotarrow outputs
    fn plotarrows(&self) -> &[Plotarrow];

    /// Add a plotbar output
    fn add_plotbar(&mut self, bar: Plotbar);
    /// Get all plotbar outputs
    fn plotbars(&self) -> &[Plotbar];

    /// Add a plotcandle output
    fn add_plotcandle(&mut self, candle: Plotcandle);
    /// Get all plotcandle outputs
    fn plotcandles(&self) -> &[Plotcandle];

    /// Add a plotchar output
    fn add_plotchar(&mut self, char: Plotchar);
    /// Get all plotchar outputs
    fn plotchars(&self) -> &[Plotchar];

    /// Add a plotshape output
    fn add_plotshape(&mut self, shape: Plotshape);
    /// Get all plotshape outputs
    fn plotshapes(&self) -> &[Plotshape];
}

/// Extension trait for label output
pub trait LabelOutput: PineOutput {
    /// Add a label and return its ID
    fn add_label(&mut self, label: Label) -> usize;
    /// Get a reference to a label by ID
    fn get_label(&self, id: usize) -> Option<&Label>;
    /// Get a mutable reference to a label by ID
    fn get_label_mut(&mut self, id: usize) -> Option<&mut Label>;
    /// Delete a label by ID and return true if it existed
    fn delete_label(&mut self, id: usize) -> bool;
}

/// Extension trait for box output
pub trait BoxOutput: PineOutput {
    /// Add a box and return its ID
    fn add_box(&mut self, box_obj: PineBox) -> usize;
    /// Get a reference to a box by ID
    fn get_box(&self, id: usize) -> Option<&PineBox>;
    /// Get a mutable reference to a box by ID
    fn get_box_mut(&mut self, id: usize) -> Option<&mut PineBox>;
    /// Delete a box by ID and return true if it existed
    fn delete_box(&mut self, id: usize) -> bool;
}

/// Extension trait for table output
pub trait TableOutput: PineOutput {
    /// Add a table and return its ID
    fn add_table(&mut self, table: Table) -> usize;
    /// Get a reference to a table by ID
    fn get_table(&self, id: usize) -> Option<&Table>;
    /// Get a mutable reference to a table by ID
    fn get_table_mut(&mut self, id: usize) -> Option<&mut Table>;
    /// Delete a table by ID and return true if it existed
    fn delete_table(&mut self, id: usize) -> bool;
}

/// Extension trait for line output
pub trait LineOutput: PineOutput {
    /// Add a line and return its ID
    fn add_line(&mut self, line: LineObject) -> usize;
    /// Get a reference to a line by ID
    fn get_line(&self, id: usize) -> Option<&LineObject>;
    /// Get a mutable reference to a line by ID
    fn get_line_mut(&mut self, id: usize) -> Option<&mut LineObject>;
    /// Delete a line by ID and return true if it existed
    fn delete_line(&mut self, id: usize) -> bool;
}

/// A fill between two lines (`linefill.new`).
#[derive(Clone, Debug)]
pub struct LinefillObject {
    pub line1: usize,
    pub line2: usize,
    pub color: Option<Color>,
}

/// A multi-point polyline (`polyline.new`).
#[derive(Clone, Debug, Default)]
pub struct PolylineObject {
    /// The `(x, y)` vertices, in order.
    pub points: Vec<(f64, f64)>,
    pub curved: bool,
    pub closed: bool,
    pub xloc: String,
    pub line_color: Option<Color>,
    pub fill_color: Option<Color>,
    pub line_style: String,
    pub line_width: f64,
}

/// One extension trait recording both `linefill` and `polyline` drawings, which
/// share a sink since neither carries much state.
pub trait DrawingOutput: PineOutput {
    fn add_linefill(&mut self, linefill: LinefillObject) -> usize;
    fn get_linefill(&self, id: usize) -> Option<&LinefillObject>;
    fn get_linefill_mut(&mut self, id: usize) -> Option<&mut LinefillObject>;
    fn delete_linefill(&mut self, id: usize) -> bool;
    fn add_polyline(&mut self, polyline: PolylineObject) -> usize;
    fn delete_polyline(&mut self, id: usize) -> bool;
}

/// Extension trait for recording `fill(...)` areas.
pub trait FillOutput: PineOutput {
    fn add_fill(&mut self, fill: FillObject);
    fn fills(&self) -> &[FillObject];
}

/// Extension trait for chart-wide globals (`bgcolor`, `barcolor`).
pub trait GlobalOutput: PineOutput {
    fn set_bgcolor(&mut self, color: Option<Color>);
    fn set_barcolor(&mut self, color: Option<Color>);
    /// The accumulated chart-wide settings.
    fn global_context(&self) -> &GlobalContext;
}

/// Extension trait for recording declared alert conditions.
pub trait AlertConditionOutput: PineOutput {
    /// Record a declared alert condition.
    fn add_alertcondition(&mut self, alert: AlertCondition);
    /// Every alert condition declared so far, in declaration order.
    fn alertconditions(&self) -> &[AlertCondition];
}

/// Extension trait for a script's declaration statement — `indicator(...)` or
/// `library(...)` (a script has at most one).
pub trait MetadataOutput: PineOutput {
    /// Record the indicator declaration.
    fn set_indicator(&mut self, indicator: Indicator);
    /// The indicator declaration, if the script declared one.
    fn indicator(&self) -> Option<&Indicator>;
    /// Record the library declaration.
    fn set_library(&mut self, library: Library);
    /// The library declaration, if the script declared one.
    fn library(&self) -> Option<&Library>;
}

/// Extension trait for recording declared inputs
pub trait InputOutput: PineOutput {
    /// Record a declared input.
    fn add_input(&mut self, input: Input);
    /// Every input declared so far, in declaration order.
    fn inputs(&self) -> &[Input];
}

/// Default implementation of PineOutput that supports all features
#[derive(Default, Clone, Debug)]
pub struct DefaultPineOutput {
    /// Label storage for drawable objects
    labels: HashMap<usize, Label>,
    /// Next label ID
    next_label_id: usize,
    /// Box storage for drawable objects
    boxes: HashMap<usize, PineBox>,
    /// Next box ID
    next_box_id: usize,
    /// Line storage for drawable objects
    lines: HashMap<usize, LineObject>,
    /// Next line ID
    next_line_id: usize,
    /// Table storage for drawable objects
    tables: HashMap<usize, Table>,
    /// Next table ID
    next_table_id: usize,
    /// Plot outputs
    plots: Vec<Plot>,
    /// Plotarrow outputs
    plotarrows: Vec<Plotarrow>,
    /// Plotbar outputs
    plotbars: Vec<Plotbar>,
    /// Plotcandle outputs
    plotcandles: Vec<Plotcandle>,
    /// Plotchar outputs
    plotchars: Vec<Plotchar>,
    /// Plotshape outputs
    plotshapes: Vec<Plotshape>,
    /// Log entries
    logs: Vec<LogEntry>,
    /// Declared inputs
    inputs: Vec<Input>,
    /// The `indicator(...)` declaration, if any.
    indicator: Option<Indicator>,
    /// The `library(...)` declaration, if any.
    library: Option<Library>,
    /// Chart-wide settings (`bgcolor`, `barcolor`).
    globals: GlobalContext,
    /// Declared alert conditions.
    alertconditions: Vec<AlertCondition>,
    /// `fill(...)` areas.
    fills: Vec<FillObject>,
    /// Linefill storage for drawable objects.
    linefills: HashMap<usize, LinefillObject>,
    /// Next linefill ID.
    next_linefill_id: usize,
    /// Polyline storage for drawable objects.
    polylines: HashMap<usize, PolylineObject>,
    /// Next polyline ID.
    next_polyline_id: usize,
}

impl PineOutput for DefaultPineOutput {
    fn clear(&mut self) {
        self.labels.clear();
        self.boxes.clear();
        self.plots.clear();
        self.plotarrows.clear();
        self.plotbars.clear();
        self.plotcandles.clear();
        self.plotchars.clear();
        self.plotshapes.clear();
        self.logs.clear();
        self.inputs.clear();
        self.indicator = None;
        self.globals = GlobalContext::default();
        self.alertconditions.clear();
        self.fills.clear();
        self.lines.clear();
        self.tables.clear();
        // Reset ID counters
        self.next_label_id = 0;
        self.next_box_id = 0;
        self.next_line_id = 0;
        self.next_table_id = 0;
    }
}

impl LogOutput for DefaultPineOutput {
    fn add_log(&mut self, level: LogLevel, message: String) {
        self.logs.push(LogEntry { level, message });
    }

    fn get_logs(&self) -> &[LogEntry] {
        &self.logs
    }
}

impl PlotOutput for DefaultPineOutput {
    fn add_plot(&mut self, plot: Plot) {
        self.plots.push(plot);
    }

    fn plots(&self) -> &[Plot] {
        &self.plots
    }

    fn add_plotarrow(&mut self, arrow: Plotarrow) {
        self.plotarrows.push(arrow);
    }

    fn plotarrows(&self) -> &[Plotarrow] {
        &self.plotarrows
    }

    fn add_plotbar(&mut self, bar: Plotbar) {
        self.plotbars.push(bar);
    }

    fn plotbars(&self) -> &[Plotbar] {
        &self.plotbars
    }

    fn add_plotcandle(&mut self, candle: Plotcandle) {
        self.plotcandles.push(candle);
    }

    fn plotcandles(&self) -> &[Plotcandle] {
        &self.plotcandles
    }

    fn add_plotchar(&mut self, char: Plotchar) {
        self.plotchars.push(char);
    }

    fn plotchars(&self) -> &[Plotchar] {
        &self.plotchars
    }

    fn add_plotshape(&mut self, shape: Plotshape) {
        self.plotshapes.push(shape);
    }

    fn plotshapes(&self) -> &[Plotshape] {
        &self.plotshapes
    }
}

impl LabelOutput for DefaultPineOutput {
    fn add_label(&mut self, label: Label) -> usize {
        let id = self.next_label_id;
        self.next_label_id += 1;
        self.labels.insert(id, label);
        id
    }

    fn get_label(&self, id: usize) -> Option<&Label> {
        self.labels.get(&id)
    }

    fn get_label_mut(&mut self, id: usize) -> Option<&mut Label> {
        self.labels.get_mut(&id)
    }

    fn delete_label(&mut self, id: usize) -> bool {
        self.labels.remove(&id).is_some()
    }
}

impl BoxOutput for DefaultPineOutput {
    fn add_box(&mut self, box_obj: PineBox) -> usize {
        let id = self.next_box_id;
        self.next_box_id += 1;
        self.boxes.insert(id, box_obj);
        id
    }

    fn get_box(&self, id: usize) -> Option<&PineBox> {
        self.boxes.get(&id)
    }

    fn get_box_mut(&mut self, id: usize) -> Option<&mut PineBox> {
        self.boxes.get_mut(&id)
    }

    fn delete_box(&mut self, id: usize) -> bool {
        self.boxes.remove(&id).is_some()
    }
}

impl LineOutput for DefaultPineOutput {
    fn add_line(&mut self, line: LineObject) -> usize {
        let id = self.next_line_id;
        self.next_line_id += 1;
        self.lines.insert(id, line);
        id
    }

    fn get_line(&self, id: usize) -> Option<&LineObject> {
        self.lines.get(&id)
    }

    fn get_line_mut(&mut self, id: usize) -> Option<&mut LineObject> {
        self.lines.get_mut(&id)
    }

    fn delete_line(&mut self, id: usize) -> bool {
        self.lines.remove(&id).is_some()
    }
}

impl DrawingOutput for DefaultPineOutput {
    fn add_linefill(&mut self, linefill: LinefillObject) -> usize {
        let id = self.next_linefill_id;
        self.next_linefill_id += 1;
        self.linefills.insert(id, linefill);
        id
    }

    fn get_linefill(&self, id: usize) -> Option<&LinefillObject> {
        self.linefills.get(&id)
    }

    fn get_linefill_mut(&mut self, id: usize) -> Option<&mut LinefillObject> {
        self.linefills.get_mut(&id)
    }

    fn delete_linefill(&mut self, id: usize) -> bool {
        self.linefills.remove(&id).is_some()
    }

    fn add_polyline(&mut self, polyline: PolylineObject) -> usize {
        let id = self.next_polyline_id;
        self.next_polyline_id += 1;
        self.polylines.insert(id, polyline);
        id
    }

    fn delete_polyline(&mut self, id: usize) -> bool {
        self.polylines.remove(&id).is_some()
    }
}

impl TableOutput for DefaultPineOutput {
    fn add_table(&mut self, table: Table) -> usize {
        let id = self.next_table_id;
        self.next_table_id += 1;
        self.tables.insert(id, table);
        id
    }

    fn get_table(&self, id: usize) -> Option<&Table> {
        self.tables.get(&id)
    }

    fn get_table_mut(&mut self, id: usize) -> Option<&mut Table> {
        self.tables.get_mut(&id)
    }

    fn delete_table(&mut self, id: usize) -> bool {
        self.tables.remove(&id).is_some()
    }
}

impl InputOutput for DefaultPineOutput {
    fn add_input(&mut self, input: Input) {
        self.inputs.push(input);
    }

    fn inputs(&self) -> &[Input] {
        &self.inputs
    }
}

impl MetadataOutput for DefaultPineOutput {
    fn set_indicator(&mut self, indicator: Indicator) {
        self.indicator = Some(indicator);
    }

    fn indicator(&self) -> Option<&Indicator> {
        self.indicator.as_ref()
    }

    fn set_library(&mut self, library: Library) {
        self.library = Some(library);
    }

    fn library(&self) -> Option<&Library> {
        self.library.as_ref()
    }
}

impl AlertConditionOutput for DefaultPineOutput {
    fn add_alertcondition(&mut self, alert: AlertCondition) {
        self.alertconditions.push(alert);
    }

    fn alertconditions(&self) -> &[AlertCondition] {
        &self.alertconditions
    }
}

impl FillOutput for DefaultPineOutput {
    fn add_fill(&mut self, fill: FillObject) {
        self.fills.push(fill);
    }

    fn fills(&self) -> &[FillObject] {
        &self.fills
    }
}

impl GlobalOutput for DefaultPineOutput {
    fn set_bgcolor(&mut self, color: Option<Color>) {
        self.globals.bgcolor = color;
    }

    fn set_barcolor(&mut self, color: Option<Color>) {
        self.globals.barcolor = color;
    }

    fn global_context(&self) -> &GlobalContext {
        &self.globals
    }
}