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 "box.hpp"
#include "hline.hpp"
#include "label.hpp"
#include "line.hpp"
#include "line_fill.hpp"
#include "polyline.hpp"
#include "table.hpp"
 
namespace openpine {

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

  GraphType type() const { return ffi::graphType(p_); }

  std::optional<graph::Hline> asHline() const {
    const ffi::Hline* p = ffi::graphHline(p_);
    if (p) {
      return graph::Hline{p};
    }
    return std::nullopt;
  }

  std::optional<graph::Label> asLabel() const {
    const ffi::Label* p = ffi::graphLabel(p_);
    if (p) {
      return graph::Label{p};
    }
    return std::nullopt;
  }

  std::optional<graph::Line> asLine() const {
    const ffi::Line* p = ffi::graphLine(p_);
    if (p) {
      return graph::Line{p};
    }
    return std::nullopt;
  }

  std::optional<graph::LineFill> asLineFill() const {
    const ffi::LineFill* p = ffi::graphLineFill(p_);
    if (p) {
      return graph::LineFill{p};
    }
    return std::nullopt;
  }

  std::optional<graph::Box> asBox() const {
    const ffi::Box* p = ffi::graphBox(p_);
    if (p) {
      return graph::Box{p};
    }
    return std::nullopt;
  }

  std::optional<graph::Polyline> asPolyline() const {
    const ffi::Polyline* p = ffi::graphPolyline(p_);
    if (p) {
      return graph::Polyline{p};
    }
    return std::nullopt;
  }

  std::optional<graph::Table> asTable() const {
    const ffi::Table* p = ffi::graphTable(p_);
    if (p) {
      return graph::Table{p};
    }
    return std::nullopt;
  }
};

class GraphIterator {
 private:
  std::unique_ptr<ffi::CGraphIterator, decltype(&ffi::graphIteratorDelete)> p_;
  std::optional<ffi::GraphType> type_filter_;
  int64_t id_;
  const ffi::Graph* graph_;
 
 public:
  GraphIterator(ffi::CGraphIterator* p,
                std::optional<ffi::GraphType> type = std::nullopt)
      : p_(p, ffi::graphIteratorDelete), type_filter_(type) {}

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

  int64_t id() const { return id_; }

  Graph graph() const { return Graph{graph_}; }
};
 
}  // namespace openpine