series_graph.hpp

Go to the documentation of this file.

#pragma once

 
#if (defined(_MSVC_LANG) ? _MSVC_LANG : __cplusplus) < 201703L
#error \
    "OpenPine C++ wrapper headers require C++17 (std::optional, std::string_view)."
#endif
 
#include <cstdint>
#include <memory>
#include <optional>
 
#include "../ffi.hpp"
#include "../types.hpp"
#include "background_colors.hpp"
#include "fill.hpp"
#include "plot.hpp"
#include "plot_arrow.hpp"
#include "plot_bar.hpp"
#include "plot_candle.hpp"
#include "plot_char.hpp"
#include "plot_shape.hpp"
 
namespace openpine {

class SeriesGraph {
 private:
  const ffi::SeriesGraph* p_;
 
 public:
  SeriesGraph(const ffi::SeriesGraph* p) : p_(p) {}

  SeriesGraphType type() const { return ffi::seriesGraphType(p_); }

  std::optional<seriesgraph::Plot> asPlot() const {
    const ffi::Plot* plot_ptr = ffi::seriesGraphPlot(p_);
    if (plot_ptr) {
      return seriesgraph::Plot{plot_ptr};
    } else {
      return std::nullopt;
    }
  }

  std::optional<seriesgraph::BackgroundColors> asBackgroundColors() const {
    const ffi::BackgroundColors* p = ffi::seriesGraphBackgroundColors(p_);
    if (p) {
      return seriesgraph::BackgroundColors{p};
    } else {
      return std::nullopt;
    }
  }

  std::optional<seriesgraph::Fill> asFill() const {
    const ffi::Fill* p = ffi::seriesGraphFill(p_);
    if (p) {
      return seriesgraph::Fill{p};
    } else {
      return std::nullopt;
    }
  }

  std::optional<seriesgraph::PlotArrow> asPlotArrow() const {
    const ffi::PlotArrow* p = ffi::seriesGraphPlotArrow(p_);
    if (p) {
      return seriesgraph::PlotArrow{p};
    } else {
      return std::nullopt;
    }
  }

  std::optional<seriesgraph::PlotBar> asPlotBar() const {
    const ffi::PlotBar* p = ffi::seriesGraphPlotBar(p_);
    if (p) {
      return seriesgraph::PlotBar{p};
    } else {
      return std::nullopt;
    }
  }

  std::optional<seriesgraph::PlotCandle> asPlotCandle() const {
    const ffi::PlotCandle* p = ffi::seriesGraphPlotCandle(p_);
    if (p) {
      return seriesgraph::PlotCandle{p};
    } else {
      return std::nullopt;
    }
  }

  std::optional<seriesgraph::PlotChar> asPlotChar() const {
    const ffi::PlotChar* p = ffi::seriesGraphPlotChar(p_);
    if (p) {
      return seriesgraph::PlotChar{p};
    } else {
      return std::nullopt;
    }
  }

  std::optional<seriesgraph::PlotShape> asPlotShape() const {
    const ffi::PlotShape* p = ffi::seriesGraphPlotShape(p_);
    if (p) {
      return seriesgraph::PlotShape{p};
    } else {
      return std::nullopt;
    }
  }
};

class SeriesGraphIterator {
 private:
  std::unique_ptr<ffi::CSeriesGraphIterator,
                  decltype(&ffi::seriesGraphIteratorDelete)>
      p_;
  std::optional<ffi::SeriesGraphType> type_filter_;
  int64_t id_;
  const ffi::SeriesGraph* graph_;
 
 public:
  SeriesGraphIterator(ffi::CSeriesGraphIterator* p,
                      std::optional<ffi::SeriesGraphType> type = std::nullopt)
      : p_(p, ffi::seriesGraphIteratorDelete), type_filter_(type) {}

  bool next() {
    while (ffi::seriesGraphIteratorNext(p_.get(), &id_, &graph_)) {
      if (!type_filter_.has_value() ||
          ffi::seriesGraphType(graph_) == *type_filter_) {
        return true;
      }
    }
    return false;
  }

  int64_t id() const { return id_; }

  SeriesGraph seriesGraph() const { return SeriesGraph{graph_}; }
};
 
}  // namespace openpine