Add Template Publish Action (#453)

* Add Template Publish Action * Add cover * Fix * Fix * Fix * Fix * Fix templatable value
esphome · Feb 10, 2019 · 0a25c32 · 0a25c32
1 parent e2c9adf
commit 0a25c32
Show file tree

Hide file tree

Showing 16 changed files with 257 additions and 265 deletions.
diff --git a/src/esphomelib/automation.cpp b/src/esphomelib/automation.cpp
@@ -69,18 +69,6 @@ bool RangeCondition::check(float x) {
     return min <= x && x <= max;
   }
 }
-void RangeCondition::set_min(std::function<float(float)> &&min) {
-  this->min_ = std::move(min);
-}
-void RangeCondition::set_min(float min) {
-  this->min_ = min;
-}
-void RangeCondition::set_max(std::function<float(float)> &&max) {
-  this->max_ = std::move(max);
-}
-void RangeCondition::set_max(float max) {
-  this->max_ = max;
-}
 
 void Script::execute() {
   this->trigger();

diff --git a/src/esphomelib/automation.h b/src/esphomelib/automation.h
@@ -50,10 +50,10 @@ class RangeCondition : public Condition<float> {
   explicit RangeCondition();
   bool check(float x) override;
 
-  void set_min(std::function<float(float)> &&min);
-  void set_min(float min);
-  void set_max(std::function<float(float)> &&max);
-  void set_max(float max);
+  template<typename V>
+  void set_min(V value) { this->min_ = value; }
+  template<typename V>
+  void set_max(V value) { this->max_ = value; }
 
  protected:
   TemplatableValue<float, float> min_{NAN};
@@ -154,8 +154,8 @@ class DelayAction : public Action<T>, public Component {
  public:
   explicit DelayAction();
 
-  void set_delay(std::function<uint32_t(T)> &&delay);
-  void set_delay(uint32_t delay);
+  template<typename V>
+  void set_delay(V value) { this->delay_ = value; }
   void stop() override;
 
   void play(T x) override;

diff --git a/src/esphomelib/automation.tcc b/src/esphomelib/automation.tcc
@@ -78,14 +78,6 @@ void DelayAction<T>::play(T x) {
   });
 }
 template<typename T>
-void DelayAction<T>::set_delay(std::function<uint32_t(T)> &&delay) {
-  this->delay_ = std::move(delay);
-}
-template<typename T>
-void DelayAction<T>::set_delay(uint32_t delay) {
-  this->delay_ = delay;
-}
-template<typename T>
 float DelayAction<T>::get_setup_priority() const {
   return setup_priority::HARDWARE;
 }
@@ -207,17 +199,17 @@ void IfAction<T>::play(T x) {
 }
 template<typename T>
 void IfAction<T>::add_then(const std::vector<Action<T> *> &actions) {
-this->then_.add_actions(actions);
-this->then_.add_action(new LambdaAction<T>([this](T x) {
-this->play_next(x);
-}));
+  this->then_.add_actions(actions);
+  this->then_.add_action(new LambdaAction<T>([this](T x) {
+    this->play_next(x);
+  }));
 }
 template<typename T>
 void IfAction<T>::add_else(const std::vector<Action<T> *> &actions) {
-this->else_.add_actions(actions);
-this->else_.add_action(new LambdaAction<T>([this](T x) {
-this->play_next(x);
-}));
+  this->else_.add_actions(actions);
+  this->else_.add_action(new LambdaAction<T>([this](T x) {
+    this->play_next(x);
+  }));
 }
 template<typename T>
 void IfAction<T>::stop() {

diff --git a/src/esphomelib/binary_sensor/binary_sensor.h b/src/esphomelib/binary_sensor/binary_sensor.h
@@ -25,6 +25,8 @@ class StateTrigger;
 template<typename T>
 class BinarySensorCondition;
 class Filter;
+template<typename T>
+class BinarySensorPublishAction;
 
 struct MultiClickTriggerEvent {
   bool state;
@@ -100,6 +102,8 @@ class BinarySensor : public Nameable {
   BinarySensorCondition<T> *make_binary_sensor_is_on_condition();
   template<typename T>
   BinarySensorCondition<T> *make_binary_sensor_is_off_condition();
+  template<typename T>
+  BinarySensorPublishAction<T> *make_binary_sensor_publish_action();
 
   void add_filter(Filter *filter);
   void add_filters(std::vector<Filter *> filters);
@@ -209,6 +213,18 @@ class BinarySensorCondition : public Condition<T> {
   bool state_;
 };
 
+template<typename T>
+class BinarySensorPublishAction : public Action<T> {
+ public:
+  BinarySensorPublishAction(BinarySensor *sensor);
+  template<typename V>
+  void set_state(V value) { this->state_ = value; }
+  void play(T x) override;
+ protected:
+  BinarySensor *sensor_;
+  TemplatableValue<bool, T> state_;
+};
+
 template<typename T>
 BinarySensorCondition<T>::BinarySensorCondition(BinarySensor *parent, bool state) : parent_(parent), state_(state) {
 
@@ -226,6 +242,18 @@ template<typename T>
 BinarySensorCondition<T> *BinarySensor::make_binary_sensor_is_off_condition() {
   return new BinarySensorCondition<T>(this, false);
 }
+template<typename T>
+BinarySensorPublishAction<T>::BinarySensorPublishAction(BinarySensor *sensor) : sensor_(sensor) {}
+template<typename T>
+void BinarySensorPublishAction<T>::play(T x) {
+  auto val = this->state_.value(x);
+  this->sensor_->publish_state(val);
+  this->play_next(x);
+}
+template<typename T>
+BinarySensorPublishAction<T> *BinarySensor::make_binary_sensor_publish_action() {
+  return new BinarySensorPublishAction<T>(this);
+}
 
 } // namespace binary_sensor
 

diff --git a/src/esphomelib/cover/cover.h b/src/esphomelib/cover/cover.h
@@ -30,6 +30,8 @@ template<typename T>
 class CloseAction;
 template<typename T>
 class StopAction;
+template<typename T>
+class CoverPublishAction;
 
 #define LOG_COVER(prefix, type, obj) \
     if (obj != nullptr) { \
@@ -61,6 +63,8 @@ class Cover : public Nameable {
   CloseAction<T> *make_close_action();
   template<typename T>
   StopAction<T> *make_stop_action();
+  template<typename T>
+  CoverPublishAction<T> *make_cover_publish_action();
 
   /** Return whether this cover is optimistic - i.e. if both the OPEN/CLOSE actions should be displayed in
    * Home Assistant because the real state is unknown.
@@ -124,6 +128,18 @@ class StopAction : public Action<T> {
   Cover *cover_;
 };
 
+template<typename T>
+class CoverPublishAction : public Action<T> {
+ public:
+  CoverPublishAction(Cover *cover);
+  template<typename V>
+  void set_state(V value) { this->state_ = value; }
+  void play(T x) override;
+ protected:
+  Cover *cover_;
+  TemplatableValue<CoverState, T> state_;
+};
+
 // =============== TEMPLATE DEFINITIONS ===============
 
 template<typename T>
@@ -174,6 +190,19 @@ StopAction<T> *Cover::make_stop_action() {
   return new StopAction<T>(this);
 }
 
+template<typename T>
+CoverPublishAction<T>::CoverPublishAction(Cover *cover) : cover_(cover) {}
+template<typename T>
+void CoverPublishAction<T>::play(T x) {
+  auto val = this->state_.value(x);
+  this->cover_->publish_state(val);
+  this->play_next(x);
+}
+template<typename T>
+CoverPublishAction<T> *Cover::make_cover_publish_action() {
+  return new CoverPublishAction<T>(this);
+}
+
 } // namespace cover
 
 ESPHOMELIB_NAMESPACE_END

diff --git a/src/esphomelib/fan/fan_state.h b/src/esphomelib/fan/fan_state.h
@@ -116,10 +116,10 @@ class TurnOnAction : public Action<T> {
  public:
   explicit TurnOnAction(FanState *state);
 
-  void set_oscillating(std::function<bool(T)> &&oscillating);
-  void set_oscillating(bool oscillating);
-  void set_speed(std::function<FanSpeed(T)> &&speed);
-  void set_speed(FanSpeed speed);
+  template<typename V>
+  void set_oscillating(V value) { this->oscillating_ = value; }
+  template<typename V>
+  void set_speed(V value) { this->speed_ = value; }
 
   void play(T x) override;
 
@@ -162,22 +162,6 @@ void ToggleAction<T>::play(T x) {
 template<typename T>
 TurnOnAction<T>::TurnOnAction(FanState *state) : state_(state) {
 
-}
-template<typename T>
-void TurnOnAction<T>::set_oscillating(std::function<bool(T)> &&oscillating) {
-  this->oscillating_ = std::move(oscillating);
-}
-template<typename T>
-void TurnOnAction<T>::set_oscillating(bool oscillating) {
-  this->oscillating_ = oscillating;
-}
-template<typename T>
-void TurnOnAction<T>::set_speed(std::function<FanSpeed(T)> &&speed) {
-  this->speed_ = std::move(speed);
-}
-template<typename T>
-void TurnOnAction<T>::set_speed(FanSpeed speed) {
-  this->speed_ = speed;
 }
 template<typename T>
 void TurnOnAction<T>::play(T x) {

diff --git a/src/esphomelib/helpers.h b/src/esphomelib/helpers.h
@@ -255,18 +255,36 @@ class CallbackManager<void(Ts...)> {
   std::vector<std::function<void(Ts...)>> callbacks_;
 };
 
+// https://stackoverflow.com/a/37161919/8924614
+template<class T, class...Args>
+struct is_callable
+{
+  template<class U> static auto test(U*p) -> decltype((*p)(std::declval<Args>()...), void(), std::true_type());
+
+  template<class U> static auto test(...) -> decltype(std::false_type());
+
+  static constexpr auto value = decltype(test<T>(nullptr))::value;
+};
+
+template<bool B, class T = void>
+using enable_if_t = typename std::enable_if<B, T>::type;
+
 template<typename T, typename X>
 class TemplatableValue {
  public:
   TemplatableValue() : type_(EMPTY) {
 
   }
 
-  TemplatableValue(T const &value) : type_(VALUE), value_(value) {
+  template <typename F, typename U = X,
+      enable_if_t<!is_callable<F, U>::value, int> = 0>
+  TemplatableValue(F value) : type_(VALUE), value_(value) {
 
   }
 
-  TemplatableValue(std::function<T(X)> f) : type_(LAMBDA), f_(f) {
+  template <typename F, typename U = X,
+      enable_if_t<is_callable<F, U>::value, int> = 0>
+  TemplatableValue(F f) : type_(LAMBDA), f_(f) {
 
   }