[alarm_control_panel] Reduce heap allocations in arm/disarm methods

esphome/codegen.py

@@ -69,7 +69,6 @@ from esphome.cpp_types import (  # noqa: F401
     JsonObjectConst,
     Parented,
     PollingComponent,
-    StringRef,
     arduino_json_ns,
     bool_,
     const_char_ptr,

esphome/components/alarm_control_panel/alarm_control_panel.cpp

@@ -67,52 +67,29 @@ void AlarmControlPanel::add_on_ready_callback(std::function<void()> &&callback)
   this->ready_callback_.add(std::move(callback));
 }
 
-void AlarmControlPanel::arm_away(optional<std::string> code) {
+void AlarmControlPanel::arm_with_code_(AlarmControlPanelCall &(AlarmControlPanelCall::*arm_method)(),
+                                       const char *code) {
   auto call = this->make_call();
-  call.arm_away();
-  if (code.has_value())
-    call.set_code(code.value());
+  (call.*arm_method)();
+  if (code != nullptr)
+    call.set_code(code);
   call.perform();
 }
 
-void AlarmControlPanel::arm_home(optional<std::string> code) {
-  auto call = this->make_call();
-  call.arm_home();
-  if (code.has_value())
-    call.set_code(code.value());
-  call.perform();
+void AlarmControlPanel::arm_away(const char *code) { this->arm_with_code_(&AlarmControlPanelCall::arm_away, code); }
+
+void AlarmControlPanel::arm_home(const char *code) { this->arm_with_code_(&AlarmControlPanelCall::arm_home, code); }
+
+void AlarmControlPanel::arm_night(const char *code) { this->arm_with_code_(&AlarmControlPanelCall::arm_night, code); }
+
+void AlarmControlPanel::arm_vacation(const char *code) {
+  this->arm_with_code_(&AlarmControlPanelCall::arm_vacation, code);
 }
 
-void AlarmControlPanel::arm_night(optional<std::string> code) {
-  auto call = this->make_call();
-  call.arm_night();
-  if (code.has_value())
-    call.set_code(code.value());
-  call.perform();
+void AlarmControlPanel::arm_custom_bypass(const char *code) {
+  this->arm_with_code_(&AlarmControlPanelCall::arm_custom_bypass, code);
 }
 
-void AlarmControlPanel::arm_vacation(optional<std::string> code) {
-  auto call = this->make_call();
-  call.arm_vacation();
-  if (code.has_value())
-    call.set_code(code.value());
-  call.perform();
-}
-
-void AlarmControlPanel::arm_custom_bypass(optional<std::string> code) {
-  auto call = this->make_call();
-  call.arm_custom_bypass();
-  if (code.has_value())
-    call.set_code(code.value());
-  call.perform();
-}
-
-void AlarmControlPanel::disarm(optional<std::string> code) {
-  auto call = this->make_call();
-  call.disarm();
-  if (code.has_value())
-    call.set_code(code.value());
-  call.perform();
-}
+void AlarmControlPanel::disarm(const char *code) { this->arm_with_code_(&AlarmControlPanelCall::disarm, code); }
 
 }  // namespace esphome::alarm_control_panel

esphome/components/alarm_control_panel/alarm_control_panel.h

@@ -76,37 +76,53 @@ class AlarmControlPanel : public EntityBase {
    *
    * @param code The code
    */
-  void arm_away(optional<std::string> code = nullopt);
+  void arm_away(const char *code = nullptr);
+  void arm_away(const optional<std::string> &code) {
+    this->arm_away(code.has_value() ? code.value().c_str() : nullptr);
+  }
 
   /** arm the alarm in home mode
    *
    * @param code The code
    */
-  void arm_home(optional<std::string> code = nullopt);
+  void arm_home(const char *code = nullptr);
+  void arm_home(const optional<std::string> &code) {
+    this->arm_home(code.has_value() ? code.value().c_str() : nullptr);
+  }
 
   /** arm the alarm in night mode
    *
    * @param code The code
    */
-  void arm_night(optional<std::string> code = nullopt);
+  void arm_night(const char *code = nullptr);
+  void arm_night(const optional<std::string> &code) {
+    this->arm_night(code.has_value() ? code.value().c_str() : nullptr);
+  }
 
   /** arm the alarm in vacation mode
    *
    * @param code The code
    */
-  void arm_vacation(optional<std::string> code = nullopt);
+  void arm_vacation(const char *code = nullptr);
+  void arm_vacation(const optional<std::string> &code) {
+    this->arm_vacation(code.has_value() ? code.value().c_str() : nullptr);
+  }
 
   /** arm the alarm in custom bypass mode
    *
    * @param code The code
    */
-  void arm_custom_bypass(optional<std::string> code = nullopt);
+  void arm_custom_bypass(const char *code = nullptr);
+  void arm_custom_bypass(const optional<std::string> &code) {
+    this->arm_custom_bypass(code.has_value() ? code.value().c_str() : nullptr);
+  }
 
   /** disarm the alarm
    *
    * @param code The code
    */
-  void disarm(optional<std::string> code = nullopt);
+  void disarm(const char *code = nullptr);
+  void disarm(const optional<std::string> &code) { this->disarm(code.has_value() ? code.value().c_str() : nullptr); }
 
   /** Get the state
    *
@@ -118,6 +134,8 @@ class AlarmControlPanel : public EntityBase {
 
  protected:
   friend AlarmControlPanelCall;
+  // Helper to reduce code duplication for arm/disarm methods
+  void arm_with_code_(AlarmControlPanelCall &(AlarmControlPanelCall::*arm_method)(), const char *code);
   // in order to store last panel state in flash
   ESPPreferenceObject pref_;
   // current state

esphome/components/alarm_control_panel/alarm_control_panel_call.cpp

@@ -10,8 +10,10 @@ static const char *const TAG = "alarm_control_panel";
 
 AlarmControlPanelCall::AlarmControlPanelCall(AlarmControlPanel *parent) : parent_(parent) {}
 
-AlarmControlPanelCall &AlarmControlPanelCall::set_code(const std::string &code) {
-  this->code_ = code;
+AlarmControlPanelCall &AlarmControlPanelCall::set_code(const char *code) {
+  if (code != nullptr) {
+    this->code_ = std::string(code);
+  }
   return *this;
 }
 

esphome/components/alarm_control_panel/alarm_control_panel_call.h

@@ -14,7 +14,8 @@ class AlarmControlPanelCall {
  public:
   AlarmControlPanelCall(AlarmControlPanel *parent);
 
-  AlarmControlPanelCall &set_code(const std::string &code);
+  AlarmControlPanelCall &set_code(const char *code);
+  AlarmControlPanelCall &set_code(const std::string &code) { return this->set_code(code.c_str()); }
   AlarmControlPanelCall &arm_away();
   AlarmControlPanelCall &arm_home();
   AlarmControlPanelCall &arm_night();

esphome/components/alarm_control_panel/automation.h

@@ -66,15 +66,7 @@ template<typename... Ts> class ArmAwayAction : public Action<Ts...> {
 
   TEMPLATABLE_VALUE(std::string, code)
 
-  void play(const Ts &...x) override {
-    auto call = this->alarm_control_panel_->make_call();
-    auto code = this->code_.optional_value(x...);
-    if (code.has_value()) {
-      call.set_code(code.value());
-    }
-    call.arm_away();
-    call.perform();
-  }
+  void play(const Ts &...x) override { this->alarm_control_panel_->arm_away(this->code_.optional_value(x...)); }
 
  protected:
   AlarmControlPanel *alarm_control_panel_;
@@ -86,15 +78,7 @@ template<typename... Ts> class ArmHomeAction : public Action<Ts...> {
 
   TEMPLATABLE_VALUE(std::string, code)
 
-  void play(const Ts &...x) override {
-    auto call = this->alarm_control_panel_->make_call();
-    auto code = this->code_.optional_value(x...);
-    if (code.has_value()) {
-      call.set_code(code.value());
-    }
-    call.arm_home();
-    call.perform();
-  }
+  void play(const Ts &...x) override { this->alarm_control_panel_->arm_home(this->code_.optional_value(x...)); }
 
  protected:
   AlarmControlPanel *alarm_control_panel_;
@@ -106,15 +90,7 @@ template<typename... Ts> class ArmNightAction : public Action<Ts...> {
 
   TEMPLATABLE_VALUE(std::string, code)
 
-  void play(const Ts &...x) override {
-    auto call = this->alarm_control_panel_->make_call();
-    auto code = this->code_.optional_value(x...);
-    if (code.has_value()) {
-      call.set_code(code.value());
-    }
-    call.arm_night();
-    call.perform();
-  }
+  void play(const Ts &...x) override { this->alarm_control_panel_->arm_night(this->code_.optional_value(x...)); }
 
  protected:
   AlarmControlPanel *alarm_control_panel_;

esphome/components/datetime/date_entity.cpp

@@ -106,9 +106,9 @@ DateCall &DateCall::set_date(uint16_t year, uint8_t month, uint8_t day) {
 
 DateCall &DateCall::set_date(ESPTime time) { return this->set_date(time.year, time.month, time.day_of_month); };
 
-DateCall &DateCall::set_date(const char *date, size_t len) {
+DateCall &DateCall::set_date(const std::string &date) {
   ESPTime val{};
-  if (!ESPTime::strptime(date, len, val)) {
+  if (!ESPTime::strptime(date, val)) {
     ESP_LOGE(TAG, "Could not convert the date string to an ESPTime object");
     return *this;
   }

esphome/components/datetime/date_entity.h

@@ -67,9 +67,7 @@ class DateCall {
   void perform();
   DateCall &set_date(uint16_t year, uint8_t month, uint8_t day);
   DateCall &set_date(ESPTime time);
-  DateCall &set_date(const char *date, size_t len);
-  DateCall &set_date(const char *date) { return this->set_date(date, strlen(date)); }
-  DateCall &set_date(const std::string &date) { return this->set_date(date.c_str(), date.size()); }
+  DateCall &set_date(const std::string &date);
 
   DateCall &set_year(uint16_t year) {
     this->year_ = year;

esphome/components/datetime/datetime_entity.cpp

@@ -163,9 +163,9 @@ DateTimeCall &DateTimeCall::set_datetime(ESPTime datetime) {
                             datetime.second);
 };
 
-DateTimeCall &DateTimeCall::set_datetime(const char *datetime, size_t len) {
+DateTimeCall &DateTimeCall::set_datetime(const std::string &datetime) {
   ESPTime val{};
-  if (!ESPTime::strptime(datetime, len, val)) {
+  if (!ESPTime::strptime(datetime, val)) {
     ESP_LOGE(TAG, "Could not convert the time string to an ESPTime object");
     return *this;
   }

esphome/components/datetime/datetime_entity.h

@@ -71,11 +71,7 @@ class DateTimeCall {
   void perform();
   DateTimeCall &set_datetime(uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, uint8_t second);
   DateTimeCall &set_datetime(ESPTime datetime);
-  DateTimeCall &set_datetime(const char *datetime, size_t len);
-  DateTimeCall &set_datetime(const char *datetime) { return this->set_datetime(datetime, strlen(datetime)); }
-  DateTimeCall &set_datetime(const std::string &datetime) {
-    return this->set_datetime(datetime.c_str(), datetime.size());
-  }
+  DateTimeCall &set_datetime(const std::string &datetime);
   DateTimeCall &set_datetime(time_t epoch_seconds);
 
   DateTimeCall &set_year(uint16_t year) {

esphome/components/datetime/time_entity.cpp

@@ -74,9 +74,9 @@ TimeCall &TimeCall::set_time(uint8_t hour, uint8_t minute, uint8_t second) {
 
 TimeCall &TimeCall::set_time(ESPTime time) { return this->set_time(time.hour, time.minute, time.second); };
 
-TimeCall &TimeCall::set_time(const char *time, size_t len) {
+TimeCall &TimeCall::set_time(const std::string &time) {
   ESPTime val{};
-  if (!ESPTime::strptime(time, len, val)) {
+  if (!ESPTime::strptime(time, val)) {
     ESP_LOGE(TAG, "Could not convert the time string to an ESPTime object");
     return *this;
   }

esphome/components/datetime/time_entity.h

@@ -69,9 +69,7 @@ class TimeCall {
   void perform();
   TimeCall &set_time(uint8_t hour, uint8_t minute, uint8_t second);
   TimeCall &set_time(ESPTime time);
-  TimeCall &set_time(const char *time, size_t len);
-  TimeCall &set_time(const char *time) { return this->set_time(time, strlen(time)); }
-  TimeCall &set_time(const std::string &time) { return this->set_time(time.c_str(), time.size()); }
+  TimeCall &set_time(const std::string &time);
 
   TimeCall &set_hour(uint8_t hour) {
     this->hour_ = hour;

esphome/components/fan/__init__.py

@@ -77,7 +77,7 @@ FanSpeedSetTrigger = fan_ns.class_(
     "FanSpeedSetTrigger", automation.Trigger.template(cg.int_)
 )
 FanPresetSetTrigger = fan_ns.class_(
-    "FanPresetSetTrigger", automation.Trigger.template(cg.StringRef)
+    "FanPresetSetTrigger", automation.Trigger.template(cg.std_string)
 )
 
 FanIsOnCondition = fan_ns.class_("FanIsOnCondition", automation.Condition.template())
@@ -287,7 +287,7 @@ async def setup_fan_core_(var, config):
         await automation.build_automation(trigger, [(cg.int_, "x")], conf)
     for conf in config.get(CONF_ON_PRESET_SET, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
-        await automation.build_automation(trigger, [(cg.StringRef, "x")], conf)
+        await automation.build_automation(trigger, [(cg.std_string, "x")], conf)
 
 
 async def register_fan(var, config):

esphome/components/fan/automation.h

@@ -208,7 +208,7 @@ class FanSpeedSetTrigger : public Trigger<int> {
   int last_speed_;
 };
 
-class FanPresetSetTrigger : public Trigger<StringRef> {
+class FanPresetSetTrigger : public Trigger<std::string> {
  public:
   FanPresetSetTrigger(Fan *state) {
     state->add_on_state_callback([this, state]() {
@@ -216,7 +216,7 @@ class FanPresetSetTrigger : public Trigger<StringRef> {
       auto should_trigger = preset_mode != this->last_preset_mode_;
       this->last_preset_mode_ = preset_mode;
       if (should_trigger) {
-        this->trigger(preset_mode);
+        this->trigger(std::string(preset_mode));
       }
     });
     this->last_preset_mode_ = state->get_preset_mode();

esphome/components/select/__init__.py

@@ -33,7 +33,7 @@ SelectPtr = Select.operator("ptr")
 # Triggers
 SelectStateTrigger = select_ns.class_(
     "SelectStateTrigger",
-    automation.Trigger.template(cg.StringRef, cg.size_t),
+    automation.Trigger.template(cg.std_string, cg.size_t),
 )
 
 # Actions
@@ -100,7 +100,7 @@ async def setup_select_core_(var, config, *, options: list[str]):
     for conf in config.get(CONF_ON_VALUE, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         await automation.build_automation(
-            trigger, [(cg.StringRef, "x"), (cg.size_t, "i")], conf
+            trigger, [(cg.std_string, "x"), (cg.size_t, "i")], conf
         )
 
     if (mqtt_id := config.get(CONF_MQTT_ID)) is not None:

esphome/components/select/automation.h

@@ -6,11 +6,11 @@
 
 namespace esphome::select {
 
-class SelectStateTrigger : public Trigger<StringRef, size_t> {
+class SelectStateTrigger : public Trigger<std::string, size_t> {
  public:
   explicit SelectStateTrigger(Select *parent) : parent_(parent) {
     parent->add_on_state_callback(
-        [this](size_t index) { this->trigger(StringRef(this->parent_->option_at(index)), index); });
+        [this](size_t index) { this->trigger(std::string(this->parent_->option_at(index)), index); });
   }
 
  protected:

esphome/core/string_ref.h

@@ -72,7 +72,6 @@ class StringRef {
 
   constexpr const char *c_str() const { return base_; }
   constexpr size_type size() const { return len_; }
-  constexpr size_type length() const { return len_; }
   constexpr bool empty() const { return len_ == 0; }
   constexpr const_reference operator[](size_type pos) const { return *(base_ + pos); }
 
@@ -81,32 +80,6 @@ class StringRef {
 
   operator std::string() const { return str(); }
 
-  /// Find first occurrence of substring, returns std::string::npos if not found.
-  /// Note: Requires the underlying string to be null-terminated.
-  size_type find(const char *s, size_type pos = 0) const {
-    if (pos >= len_)
-      return std::string::npos;
-    const char *result = std::strstr(base_ + pos, s);
-    // Verify entire match is within bounds (strstr searches to null terminator)
-    if (result && result + std::strlen(s) <= base_ + len_)
-      return static_cast<size_type>(result - base_);
-    return std::string::npos;
-  }
-  size_type find(char c, size_type pos = 0) const {
-    if (pos >= len_)
-      return std::string::npos;
-    const void *result = std::memchr(base_ + pos, static_cast<unsigned char>(c), len_ - pos);
-    return result ? static_cast<size_type>(static_cast<const char *>(result) - base_) : std::string::npos;
-  }
-
-  /// Return substring as std::string
-  std::string substr(size_type pos = 0, size_type count = std::string::npos) const {
-    if (pos >= len_)
-      return std::string();
-    size_type actual_count = (count == std::string::npos || pos + count > len_) ? len_ - pos : count;
-    return std::string(base_ + pos, actual_count);
-  }
-
  private:
   const char *base_;
   size_type len_;
@@ -187,43 +160,6 @@ inline std::string operator+(const std::string &lhs, const StringRef &rhs) {
   str.append(rhs.c_str(), rhs.size());
   return str;
 }
-// String conversion functions for ADL compatibility (allows stoi(x) where x is StringRef)
-// Must be in esphome namespace for ADL to find them. Uses strtol/strtod directly to avoid heap allocation.
-namespace internal {
-// NOLINTBEGIN(google-runtime-int)
-template<typename R, typename F> inline R parse_number(const StringRef &str, size_t *pos, F conv) {
-  char *end;
-  R result = conv(str.c_str(), &end);
-  // Set pos to 0 on conversion failure (when no characters consumed), otherwise index after number
-  if (pos)
-    *pos = (end == str.c_str()) ? 0 : static_cast<size_t>(end - str.c_str());
-  return result;
-}
-template<typename R, typename F> inline R parse_number(const StringRef &str, size_t *pos, int base, F conv) {
-  char *end;
-  R result = conv(str.c_str(), &end, base);
-  // Set pos to 0 on conversion failure (when no characters consumed), otherwise index after number
-  if (pos)
-    *pos = (end == str.c_str()) ? 0 : static_cast<size_t>(end - str.c_str());
-  return result;
-}
-// NOLINTEND(google-runtime-int)
-}  // namespace internal
-// NOLINTBEGIN(readability-identifier-naming,google-runtime-int)
-inline int stoi(const StringRef &str, size_t *pos = nullptr, int base = 10) {
-  return static_cast<int>(internal::parse_number<long>(str, pos, base, std::strtol));
-}
-inline long stol(const StringRef &str, size_t *pos = nullptr, int base = 10) {
-  return internal::parse_number<long>(str, pos, base, std::strtol);
-}
-inline float stof(const StringRef &str, size_t *pos = nullptr) {
-  return internal::parse_number<float>(str, pos, std::strtof);
-}
-inline double stod(const StringRef &str, size_t *pos = nullptr) {
-  return internal::parse_number<double>(str, pos, std::strtod);
-}
-// NOLINTEND(readability-identifier-naming,google-runtime-int)
-
 #ifdef USE_JSON
 // NOLINTNEXTLINE(readability-identifier-naming)
 inline void convertToJson(const StringRef &src, JsonVariant dst) { dst.set(src.c_str()); }

esphome/core/time.cpp

@@ -67,7 +67,7 @@ std::string ESPTime::strftime(const char *format) {
 
 std::string ESPTime::strftime(const std::string &format) { return this->strftime(format.c_str()); }
 
-bool ESPTime::strptime(const char *time_to_parse, size_t len, ESPTime &esp_time) {
+bool ESPTime::strptime(const std::string &time_to_parse, ESPTime &esp_time) {
   uint16_t year;
   uint8_t month;
   uint8_t day;
@@ -75,41 +75,40 @@ bool ESPTime::strptime(const char *time_to_parse, size_t len, ESPTime &esp_time)
   uint8_t minute;
   uint8_t second;
   int num;
-  const int ilen = static_cast<int>(len);
 
-  if (sscanf(time_to_parse, "%04hu-%02hhu-%02hhu %02hhu:%02hhu:%02hhu %n", &year, &month, &day,  // NOLINT
-             &hour,                                                                              // NOLINT
-             &minute,                                                                            // NOLINT
-             &second, &num) == 6 &&                                                              // NOLINT
-      num == ilen) {
+  if (sscanf(time_to_parse.c_str(), "%04hu-%02hhu-%02hhu %02hhu:%02hhu:%02hhu %n", &year, &month, &day,  // NOLINT
+             &hour,                                                                                      // NOLINT
+             &minute,                                                                                    // NOLINT
+             &second, &num) == 6 &&                                                                      // NOLINT
+      num == static_cast<int>(time_to_parse.size())) {
     esp_time.year = year;
     esp_time.month = month;
     esp_time.day_of_month = day;
     esp_time.hour = hour;
     esp_time.minute = minute;
     esp_time.second = second;
-  } else if (sscanf(time_to_parse, "%04hu-%02hhu-%02hhu %02hhu:%02hhu %n", &year, &month, &day,  // NOLINT
-                    &hour,                                                                       // NOLINT
-                    &minute, &num) == 5 &&                                                       // NOLINT
-             num == ilen) {
+  } else if (sscanf(time_to_parse.c_str(), "%04hu-%02hhu-%02hhu %02hhu:%02hhu %n", &year, &month, &day,  // NOLINT
+                    &hour,                                                                               // NOLINT
+                    &minute, &num) == 5 &&                                                               // NOLINT
+             num == static_cast<int>(time_to_parse.size())) {
     esp_time.year = year;
     esp_time.month = month;
     esp_time.day_of_month = day;
     esp_time.hour = hour;
     esp_time.minute = minute;
     esp_time.second = 0;
-  } else if (sscanf(time_to_parse, "%02hhu:%02hhu:%02hhu %n", &hour, &minute, &second, &num) == 3 &&  // NOLINT
-             num == ilen) {
+  } else if (sscanf(time_to_parse.c_str(), "%02hhu:%02hhu:%02hhu %n", &hour, &minute, &second, &num) == 3 &&  // NOLINT
+             num == static_cast<int>(time_to_parse.size())) {
     esp_time.hour = hour;
     esp_time.minute = minute;
     esp_time.second = second;
-  } else if (sscanf(time_to_parse, "%02hhu:%02hhu %n", &hour, &minute, &num) == 2 &&  // NOLINT
-             num == ilen) {
+  } else if (sscanf(time_to_parse.c_str(), "%02hhu:%02hhu %n", &hour, &minute, &num) == 2 &&  // NOLINT
+             num == static_cast<int>(time_to_parse.size())) {
     esp_time.hour = hour;
     esp_time.minute = minute;
     esp_time.second = 0;
-  } else if (sscanf(time_to_parse, "%04hu-%02hhu-%02hhu %n", &year, &month, &day, &num) == 3 &&  // NOLINT
-             num == ilen) {
+  } else if (sscanf(time_to_parse.c_str(), "%04hu-%02hhu-%02hhu %n", &year, &month, &day, &num) == 3 &&  // NOLINT
+             num == static_cast<int>(time_to_parse.size())) {
     esp_time.year = year;
     esp_time.month = month;
     esp_time.day_of_month = day;

esphome/core/time.h

@@ -2,7 +2,6 @@
 
 #include <cstdint>
 #include <cstdlib>
-#include <cstring>
 #include <ctime>
 #include <span>
 #include <string>
@@ -81,20 +80,11 @@ struct ESPTime {
   }
 
   /** Convert a string to ESPTime struct as specified by the format argument.
-   * @param time_to_parse c string formatted like this: 2020-08-25 05:30:00.
-   * @param len length of the string (not including null terminator if present)
+   * @param time_to_parse null-terminated c string formatet like this: 2020-08-25 05:30:00.
    * @param esp_time an instance of a ESPTime struct
-   * @return the success state of the parsing
+   * @return the success sate of the parsing
    */
-  static bool strptime(const char *time_to_parse, size_t len, ESPTime &esp_time);
-  /// @copydoc strptime(const char *, size_t, ESPTime &)
-  static bool strptime(const char *time_to_parse, ESPTime &esp_time) {
-    return strptime(time_to_parse, strlen(time_to_parse), esp_time);
-  }
-  /// @copydoc strptime(const char *, size_t, ESPTime &)
-  static bool strptime(const std::string &time_to_parse, ESPTime &esp_time) {
-    return strptime(time_to_parse.c_str(), time_to_parse.size(), esp_time);
-  }
+  static bool strptime(const std::string &time_to_parse, ESPTime &esp_time);
 
   /// Convert a C tm struct instance with a C unix epoch timestamp to an ESPTime instance.
   static ESPTime from_c_tm(struct tm *c_tm, time_t c_time);

esphome/cpp_types.py

@@ -44,4 +44,3 @@ gpio_Flags = gpio_ns.enum("Flags", is_class=True)
 EntityCategory = esphome_ns.enum("EntityCategory")
 Parented = esphome_ns.class_("Parented")
 ESPTime = esphome_ns.struct("ESPTime")
-StringRef = esphome_ns.class_("StringRef")

tests/integration/fixtures/select_stringref_trigger.yaml

@@ -1,85 +0,0 @@
-esphome:
-  name: select-stringref-test
-  friendly_name: Select StringRef Test
-
-host:
-
-logger:
-  level: DEBUG
-
-api:
-
-select:
-  - platform: template
-    name: "Test Select"
-    id: test_select
-    optimistic: true
-    options:
-      - "Option A"
-      - "Option B"
-      - "Option C"
-    initial_option: "Option A"
-    on_value:
-      then:
-        # Test 1: Log the value directly (StringRef -> const char* via c_str())
-        - logger.log:
-            format: "Select value: %s"
-            args: ['x.c_str()']
-        # Test 2: String concatenation (StringRef + const char* -> std::string)
-        - lambda: |-
-            std::string with_suffix = x + " selected";
-            ESP_LOGI("test", "Concatenated: %s", with_suffix.c_str());
-        # Test 3: Comparison (StringRef == const char*)
-        - lambda: |-
-            if (x == "Option B") {
-              ESP_LOGI("test", "Option B was selected");
-            }
-        # Test 4: Use index parameter (variable name is 'i')
-        - lambda: |-
-            ESP_LOGI("test", "Select index: %d", (int)i);
-        # Test 5: StringRef.length() method
-        - lambda: |-
-            ESP_LOGI("test", "Length: %d", (int)x.length());
-        # Test 6: StringRef.find() method with substring
-        - lambda: |-
-            if (x.find("Option") != std::string::npos) {
-              ESP_LOGI("test", "Found 'Option' in value");
-            }
-        # Test 7: StringRef.find() method with character
-        - lambda: |-
-            size_t space_pos = x.find(' ');
-            if (space_pos != std::string::npos) {
-              ESP_LOGI("test", "Space at position: %d", (int)space_pos);
-            }
-        # Test 8: StringRef.substr() method
-        - lambda: |-
-            std::string prefix = x.substr(0, 6);
-            ESP_LOGI("test", "Substr prefix: %s", prefix.c_str());
-
-  # Second select with numeric options to test ADL functions
-  - platform: template
-    name: "Baud Rate"
-    id: baud_select
-    optimistic: true
-    options:
-      - "9600"
-      - "115200"
-    initial_option: "9600"
-    on_value:
-      then:
-        # Test 9: stoi via ADL
-        - lambda: |-
-            int baud = stoi(x);
-            ESP_LOGI("test", "stoi result: %d", baud);
-        # Test 10: stol via ADL
-        - lambda: |-
-            long baud_long = stol(x);
-            ESP_LOGI("test", "stol result: %ld", baud_long);
-        # Test 11: stof via ADL
-        - lambda: |-
-            float baud_float = stof(x);
-            ESP_LOGI("test", "stof result: %.0f", baud_float);
-        # Test 12: stod via ADL
-        - lambda: |-
-            double baud_double = stod(x);
-            ESP_LOGI("test", "stod result: %.0f", baud_double);

tests/integration/test_select_stringref_trigger.py

@@ -1,143 +0,0 @@
-"""Integration test for select on_value trigger with StringRef parameter."""
-
-from __future__ import annotations
-
-import asyncio
-import re
-
-import pytest
-
-from .types import APIClientConnectedFactory, RunCompiledFunction
-
-
-@pytest.mark.asyncio
-async def test_select_stringref_trigger(
-    yaml_config: str,
-    run_compiled: RunCompiledFunction,
-    api_client_connected: APIClientConnectedFactory,
-) -> None:
-    """Test select on_value trigger passes StringRef that works with string operations."""
-    loop = asyncio.get_running_loop()
-
-    # Track log messages to verify StringRef operations work
-    value_logged_future = loop.create_future()
-    concatenated_future = loop.create_future()
-    comparison_future = loop.create_future()
-    index_logged_future = loop.create_future()
-    length_future = loop.create_future()
-    find_substr_future = loop.create_future()
-    find_char_future = loop.create_future()
-    substr_future = loop.create_future()
-    # ADL functions
-    stoi_future = loop.create_future()
-    stol_future = loop.create_future()
-    stof_future = loop.create_future()
-    stod_future = loop.create_future()
-
-    # Patterns to match in logs
-    value_pattern = re.compile(r"Select value: Option B")
-    concatenated_pattern = re.compile(r"Concatenated: Option B selected")
-    comparison_pattern = re.compile(r"Option B was selected")
-    index_pattern = re.compile(r"Select index: 1")
-    length_pattern = re.compile(r"Length: 8")  # "Option B" is 8 chars
-    find_substr_pattern = re.compile(r"Found 'Option' in value")
-    find_char_pattern = re.compile(r"Space at position: 6")  # space at index 6
-    substr_pattern = re.compile(r"Substr prefix: Option")
-    # ADL function patterns (115200 from baud rate select)
-    stoi_pattern = re.compile(r"stoi result: 115200")
-    stol_pattern = re.compile(r"stol result: 115200")
-    stof_pattern = re.compile(r"stof result: 115200")
-    stod_pattern = re.compile(r"stod result: 115200")
-
-    def check_output(line: str) -> None:
-        """Check log output for expected messages."""
-        if not value_logged_future.done() and value_pattern.search(line):
-            value_logged_future.set_result(True)
-        if not concatenated_future.done() and concatenated_pattern.search(line):
-            concatenated_future.set_result(True)
-        if not comparison_future.done() and comparison_pattern.search(line):
-            comparison_future.set_result(True)
-        if not index_logged_future.done() and index_pattern.search(line):
-            index_logged_future.set_result(True)
-        if not length_future.done() and length_pattern.search(line):
-            length_future.set_result(True)
-        if not find_substr_future.done() and find_substr_pattern.search(line):
-            find_substr_future.set_result(True)
-        if not find_char_future.done() and find_char_pattern.search(line):
-            find_char_future.set_result(True)
-        if not substr_future.done() and substr_pattern.search(line):
-            substr_future.set_result(True)
-        # ADL functions
-        if not stoi_future.done() and stoi_pattern.search(line):
-            stoi_future.set_result(True)
-        if not stol_future.done() and stol_pattern.search(line):
-            stol_future.set_result(True)
-        if not stof_future.done() and stof_pattern.search(line):
-            stof_future.set_result(True)
-        if not stod_future.done() and stod_pattern.search(line):
-            stod_future.set_result(True)
-
-    async with (
-        run_compiled(yaml_config, line_callback=check_output),
-        api_client_connected() as client,
-    ):
-        # Verify device info
-        device_info = await client.device_info()
-        assert device_info is not None
-        assert device_info.name == "select-stringref-test"
-
-        # List entities to find our select
-        entities, _ = await client.list_entities_services()
-
-        select_entity = next(
-            (e for e in entities if hasattr(e, "options") and e.name == "Test Select"),
-            None,
-        )
-        assert select_entity is not None, "Test Select entity not found"
-
-        baud_entity = next(
-            (e for e in entities if hasattr(e, "options") and e.name == "Baud Rate"),
-            None,
-        )
-        assert baud_entity is not None, "Baud Rate entity not found"
-
-        # Change select to Option B - this should trigger on_value with StringRef
-        client.select_command(select_entity.key, "Option B")
-        # Change baud to 115200 - this tests ADL functions (stoi, stol, stof, stod)
-        client.select_command(baud_entity.key, "115200")
-
-        # Wait for all log messages confirming StringRef operations work
-        try:
-            await asyncio.wait_for(
-                asyncio.gather(
-                    value_logged_future,
-                    concatenated_future,
-                    comparison_future,
-                    index_logged_future,
-                    length_future,
-                    find_substr_future,
-                    find_char_future,
-                    substr_future,
-                    stoi_future,
-                    stol_future,
-                    stof_future,
-                    stod_future,
-                ),
-                timeout=5.0,
-            )
-        except TimeoutError:
-            results = {
-                "value_logged": value_logged_future.done(),
-                "concatenated": concatenated_future.done(),
-                "comparison": comparison_future.done(),
-                "index_logged": index_logged_future.done(),
-                "length": length_future.done(),
-                "find_substr": find_substr_future.done(),
-                "find_char": find_char_future.done(),
-                "substr": substr_future.done(),
-                "stoi": stoi_future.done(),
-                "stol": stol_future.done(),
-                "stof": stof_future.done(),
-                "stod": stod_future.done(),
-            }
-            pytest.fail(f"StringRef operations failed - received: {results}")