StateBuilder.h

Go to the documentation of this file.

/*
 * Copyright 2015-2021 CNRS-UM LIRMM, CNRS-AIST JRL
 */
 
#pragma once
 
#include <mc_rtc/Configuration.h>
#include <mc_rtc/gui/elements.h>
#include <mc_rtc/gui/plot.h>
 
#include <unordered_map>
 
namespace mc_rtc
{
 
namespace gui
{
 
enum class ElementsStacking
{
  Vertical = 0,
  Horizontal
};
 
struct MC_RTC_GUI_DLLAPI StateBuilder
{
  static constexpr int8_t PROTOCOL_VERSION = 4;
 
  StateBuilder();
 
  template<typename T>
  void addElement(const std::vector<std::string> & category, T element);
 
  template<typename SourceT, typename T>
  void addElement(SourceT * source, const std::vector<std::string> & category, T element);
 
  template<typename T, typename... Args>
  void addElement(const std::vector<std::string> & category, T element, Args... args);
 
  template<typename SourceT, typename T, typename... Args>
  void addElement(SourceT * source, const std::vector<std::string> & category, T element, Args... args);
 
  template<typename T>
  void addElement(const std::vector<std::string> & category, ElementsStacking stacking, T element);
 
  template<typename SourceT, typename T>
  void addElement(SourceT * source, const std::vector<std::string> & category, ElementsStacking stacking, T element);
 
  template<typename T, typename... Args>
  void addElement(const std::vector<std::string> & category, ElementsStacking stacking, T element, Args... args);
 
  template<typename SourceT, typename T, typename... Args>
  void addElement(SourceT * source,
                  const std::vector<std::string> & category,
                  ElementsStacking stacking,
                  T element,
                  Args... args);
 
  bool hasElement(const std::vector<std::string> & category, const std::string & name);
 
  void reset();
 
  void removeCategory(const std::vector<std::string> & category);
 
  void removeElement(const std::vector<std::string> & category, const std::string & name);
 
  void removeElements(void * source);
 
  void removeElements(const std::vector<std::string> & category, void * source, bool recurse = false);
 
  template<typename... Args>
  void addXYPlot(const std::string & name,
                 plot::AxisConfiguration xConfig,
                 plot::AxisConfiguration yLeftConfig,
                 plot::AxisConfiguration yRightConfig,
                 Args... args);
 
  template<typename... Args>
  void addXYPlot(const std::string & name,
                 plot::AxisConfiguration xConfig,
                 plot::AxisConfiguration yLeftConfig,
                 Args... args);
 
  template<typename... Args>
  void addXYPlot(const std::string & name, plot::AxisConfiguration xConfig, Args... args);
 
  template<typename... Args>
  void addXYPlot(const std::string & name, Args... args);
 
  template<typename T, typename... Args>
  void addPlot(const std::string & name,
               T abscissa,
               plot::AxisConfiguration yLeftConfig,
               plot::AxisConfiguration yRightConfig,
               Args... args);
 
  template<typename T, typename... Args>
  void addPlot(const std::string & name, T abscissa, plot::AxisConfiguration yLeftConfig, Args... args);
 
  template<typename T, typename... Args>
  void addPlot(const std::string & name, T abscissa, Args... args);
 
  template<typename T>
  bool addPlotData(const std::string & name, T data);
 
  void removePlot(const std::string & name);
 
  size_t update(std::vector<char> & data);
 
  void update();
 
  bool handleRequest(const std::vector<std::string> & category,
                     const std::string & name,
                     const mc_rtc::Configuration & data);
 
  mc_rtc::Configuration data();
 
  inline size_t size() const { return elements_.size(); }
 
private:
  template<typename T>
  void addElementImpl(void * source,
                      const std::vector<std::string> & category,
                      ElementsStacking stacking,
                      T element,
                      size_t rem = 0);
 
  mc_rtc::Configuration data_;
  using plot_callback_function_t = std::function<void(mc_rtc::MessagePackBuilder &, const std::string &, bool)>;
  struct PlotCallback
  {
    plot::Plot type;
    size_t msg_size;
    plot_callback_function_t callback;
  };
  uint64_t plot_id_ = 0;
  std::unordered_map<std::string, PlotCallback> plots_;
  bool update_data_ = true;
  std::vector<char> data_buffer_;
  size_t data_buffer_size_ = 0;
  struct Category;
  struct MC_RTC_GUI_DLLAPI ElementStore
  {
    const Element & operator()() const;
    Element & operator()();
    std::function<Element &()> element;
    void (*write)(Element &, mc_rtc::MessagePackBuilder &);
    bool (*handleRequest)(Element &, const mc_rtc::Configuration &);
    void * source;
 
    template<typename T>
    ElementStore(T self, const Category & category, ElementsStacking stacking, void * source);
  };
  struct Category
  {
    std::string name;
    std::vector<ElementStore> elements;
    std::vector<Category> sub;
    std::vector<Category>::iterator find(const std::string & name);
    int id = 0;
    inline size_t size() const
    {
      size_t s = 0;
      for(const auto & c : sub) { s += c.size(); }
      return s + elements.size();
    }
  };
  Category elements_;
 
  Category * getCategory(const std::vector<std::string> & category, size_t depth = std::numeric_limits<size_t>::max());
 
  Category & getOrCreateCategory(const std::vector<std::string> & category);
 
  void update(mc_rtc::MessagePackBuilder & builder, Category & category);
 
  void removeElements(Category & category, void * source);
 
  std::string cat2str(const std::vector<std::string> & category);
 
  void addPlotData(PlotCallback &) {}
 
  template<typename T, typename... Args>
  void addPlotData(PlotCallback & callback, T plot, Args... args);
};
 
} // namespace gui
 
} // namespace mc_rtc
 
#include "StateBuilder.hpp"