config_item.h

Go to the documentation of this file.

#ifndef SENSESP_SRC_SENSESP_NET_WEB_CONFIG_ITEM_H_
#define SENSESP_SRC_SENSESP_NET_WEB_CONFIG_ITEM_H_
 
#include <map>
#include <memory>
#include <vector>
#include <cstddef>
 
#include "Arduino.h"
#include "ArduinoJson.h"
#include "sensesp/system/saveable.h"
 
namespace sensesp {
 
// an unknown type may not be rendered in Json editor
template <class T>
const char* get_schema_type_string(const T dummy) {
  return "unknown";
}
template <>
const char* get_schema_type_string(const int dummy);
 
template <>
const char* get_schema_type_string(const float dummy);
 
template <>
const char* get_schema_type_string(const String& dummy);
 
template <>
const char* get_schema_type_string(const bool dummy);
 
inline const String ConfigSchema(const std::nullptr_t& obj) {
  return "null";
}
 
template <typename T>
bool ConfigRequiresRestart(const T& obj) {
  return false;
}
 
template <typename T>
bool ConfigRequiresRestart(const std::shared_ptr<T>& obj) {
  return ConfigRequiresRestart(*obj);
}
 
// Forward declarations
 
template <typename T>
class ConfigItemT;
 
template <typename T>
std::shared_ptr<ConfigItemT<T>> ConfigItem(std::shared_ptr<T>);
 
 
class ConfigItemBase
    : virtual public std::enable_shared_from_this<ConfigItemBase> {
 public:
  const String& get_title() const { return title_; }
  ConfigItemBase* set_title(const String& title) {
    title_ = title;
    return this;
  }
 
  const String& get_description() const { return description_; }
 
  ConfigItemBase* set_description(const String& description) {
    description_ = description;
    return this;
  }
 
  virtual const String get_config_schema() const {
    if (config_schema_ != "") {
      return config_schema_;
    }
    return get_default_config_schema();
  }
 
  int get_sort_order() const { return sort_order_; }
 
  ConfigItemBase* set_sort_order(int sort_order) {
    sort_order_ = sort_order;
    return this;
  }
 
  bool requires_restart() const { return requires_restart_; }
 
  ConfigItemBase* set_requires_restart(bool requires_restart) {
    requires_restart_ = requires_restart;
    return this;
  }
 
  static std::shared_ptr<ConfigItemBase> get_config_item(const String key) {
    auto it = ConfigItemBase::config_items_.find(key);
    if (it != ConfigItemBase::config_items_.end()) {
      return it->second;
    }
    return nullptr;
  }
 
  static std::unique_ptr<std::vector<std::shared_ptr<ConfigItemBase>>>
  get_config_items() {
    std::unique_ptr<std::vector<std::shared_ptr<ConfigItemBase>>>
        sorted_config_items(new std::vector<std::shared_ptr<ConfigItemBase>>());
 
    for (auto& it : ConfigItemBase::config_items_) {
      sorted_config_items->push_back(it.second);
    }
    std::sort(sorted_config_items->begin(), sorted_config_items->end(),
              [](std::shared_ptr<ConfigItemBase> a,
                 std::shared_ptr<ConfigItemBase> b) {
                return a->get_sort_order() < b->get_sort_order();
              });
 
    return sorted_config_items;
  }
 
  virtual bool load() = 0;
  virtual bool refresh() = 0;
  virtual bool save() = 0;
  virtual bool to_json(JsonObject& config) const = 0;
  virtual bool from_json(const JsonObject& config) const = 0;
  virtual const String& get_config_path() const = 0;
 
 protected:
  static std::map<String, std::shared_ptr<ConfigItemBase>> config_items_;
 
  String config_path_ = "";
  String config_schema_ = "";
  String title_ = "";
  String description_ = "";
  int sort_order_ = 1000;
  bool requires_restart_ = false;
 
  virtual const String get_default_config_schema() const = 0;
 
  template <typename T>
  friend std::shared_ptr<ConfigItemT<T>> ConfigItem(std::shared_ptr<T>);
};
 
template <typename T>
class ConfigItemT : public ConfigItemBase {
  // Template classes must inherit from Serializable and Saveable.
  static_assert(std::is_base_of<Serializable, T>::value,
                "T must inherit from Serializable");
  static_assert(std::is_base_of<Saveable, T>::value,
                "T must inherit from Saveable");
 
 public:
  ConfigItemT(std::shared_ptr<T> config_object)
      : ConfigItemBase(), config_object_{config_object} {}
 
  virtual bool to_json(JsonObject& config) const override {
    return config_object_->to_json(config);
  }
 
  virtual bool from_json(const JsonObject& config) const override {
    return config_object_->from_json(config);
  }
 
  virtual bool load() override { return config_object_->load(); }
  virtual bool refresh() override { return config_object_->refresh(); }
  virtual bool save() override { return config_object_->save(); }
 
  virtual const String& get_config_path() const override {
    return config_object_->get_config_path();
  }
 
  ConfigItemT<T>* set_title(const String& title) {
    ConfigItemBase::set_title(title);
    return this;
  }
 
  ConfigItemT<T>* set_description(const String& description) {
    ConfigItemBase::set_description(description);
    return this;
  }
 
  ConfigItemT<T>* set_sort_order(int sort_order) {
    ConfigItemBase::set_sort_order(sort_order);
    return this;
  }
 
  ConfigItemT<T>* set_requires_restart(bool requires_restart) {
    ConfigItemBase::set_requires_restart(requires_restart);
    return this;
  }
 
  ConfigItemT<T>* set_config_schema(const String& config_schema) {
    config_schema_ = config_schema;
    return this;
  }
 
  T* get_config_object() { return config_object_; }
 
 protected:
  // The object that this ConfigItemT is managing.
  std::shared_ptr<T> config_object_;
  const String get_default_config_schema() const {
    String schema = ConfigSchema(*config_object_);
    return schema;
  }
};
 
template <typename T>
std::shared_ptr<ConfigItemT<T>> ConfigItem(std::shared_ptr<T> config_object) {
  ESP_LOGD(__FILENAME__, "Registering ConfigItemT with path %s",
           config_object->get_config_path().c_str());
  auto config_item = std::make_shared<ConfigItemT<T>>(config_object);
  auto base_sptr = std::static_pointer_cast<ConfigItemBase>(config_item);
  ConfigItemBase::config_items_[config_object->get_config_path()] = base_sptr;
  return config_item;
}
 
// Unsafe: We don't know whether other shared_ptrs to the same object exist!
template <typename T>
std::shared_ptr<ConfigItemT<T>> ConfigItem(T* config_object) {
  auto config_object_sptr = std::shared_ptr<T>(config_object);
  return ConfigItem(config_object_sptr);
}
 
}  // namespace sensesp
 
#endif  // SENSESP_SRC_SENSESP_NET_WEB_CONFIG_ITEM_H_