diff --git a/esphome/components/sensor/sensor.cpp b/esphome/components/sensor/sensor.cpp index df6bd644e8..30187f498b 100644 --- a/esphome/components/sensor/sensor.cpp +++ b/esphome/components/sensor/sensor.cpp @@ -74,9 +74,9 @@ StateClass Sensor::get_state_class() { void Sensor::publish_state(float state) { this->raw_state = state; - if (this->raw_callback_) { - this->raw_callback_->call(state); - } + + // Call raw callbacks (before filters) + this->callbacks_.call_first(this->raw_count_, state); ESP_LOGV(TAG, "'%s': Received new state %f", this->name_.c_str(), state); @@ -87,12 +87,12 @@ void Sensor::publish_state(float state) { } } -void Sensor::add_on_state_callback(std::function &&callback) { this->callback_.add(std::move(callback)); } +void Sensor::add_on_state_callback(std::function &&callback) { + this->callbacks_.add_second(std::move(callback)); +} + void Sensor::add_on_raw_state_callback(std::function &&callback) { - if (!this->raw_callback_) { - this->raw_callback_ = make_unique>(); - } - this->raw_callback_->add(std::move(callback)); + this->callbacks_.add_first(std::move(callback), &this->raw_count_); } void Sensor::add_filter(Filter *filter) { @@ -132,7 +132,10 @@ void Sensor::internal_send_state_to_frontend(float state) { this->state = state; ESP_LOGD(TAG, "'%s': Sending state %.5f %s with %d decimals of accuracy", this->get_name().c_str(), state, this->get_unit_of_measurement_ref().c_str(), this->get_accuracy_decimals()); - this->callback_.call(state); + + // Call filtered callbacks (after filters) + this->callbacks_.call_second(this->raw_count_, state); + #if defined(USE_SENSOR) && defined(USE_CONTROLLER_REGISTRY) ControllerRegistry::notify_sensor_update(this); #endif diff --git a/esphome/components/sensor/sensor.h b/esphome/components/sensor/sensor.h index a4210e5e6c..42e540a349 100644 --- a/esphome/components/sensor/sensor.h +++ b/esphome/components/sensor/sensor.h @@ -124,8 +124,7 @@ class Sensor : public EntityBase, public EntityBase_DeviceClass, public EntityBa void internal_send_state_to_frontend(float state); protected: - std::unique_ptr> raw_callback_; ///< Storage for raw state callbacks (lazy allocated). - CallbackManager callback_; ///< Storage for filtered state callbacks. + PartitionedCallbackManager callbacks_; Filter *filter_list_{nullptr}; ///< Store all active filters. @@ -140,6 +139,8 @@ class Sensor : public EntityBase, public EntityBase_DeviceClass, public EntityBa uint8_t force_update : 1; uint8_t reserved : 5; // Reserved for future use } sensor_flags_{}; + + uint8_t raw_count_{0}; ///< Number of raw callbacks (partition point in callbacks_ vector) }; } // namespace sensor diff --git a/esphome/components/text_sensor/text_sensor.cpp b/esphome/components/text_sensor/text_sensor.cpp index a7bcf19967..65d7b1f0be 100644 --- a/esphome/components/text_sensor/text_sensor.cpp +++ b/esphome/components/text_sensor/text_sensor.cpp @@ -26,9 +26,9 @@ void log_text_sensor(const char *tag, const char *prefix, const char *type, Text void TextSensor::publish_state(const std::string &state) { this->raw_state = state; - if (this->raw_callback_) { - this->raw_callback_->call(state); - } + + // Call raw callbacks (before filters) + this->callbacks_.call_first(this->raw_count_, state); ESP_LOGV(TAG, "'%s': Received new state %s", this->name_.c_str(), state.c_str()); @@ -70,13 +70,11 @@ void TextSensor::clear_filters() { } void TextSensor::add_on_state_callback(std::function callback) { - this->callback_.add(std::move(callback)); + this->callbacks_.add_second(std::move(callback)); } + void TextSensor::add_on_raw_state_callback(std::function callback) { - if (!this->raw_callback_) { - this->raw_callback_ = make_unique>(); - } - this->raw_callback_->add(std::move(callback)); + this->callbacks_.add_first(std::move(callback), &this->raw_count_); } std::string TextSensor::get_state() const { return this->state; } @@ -85,7 +83,10 @@ void TextSensor::internal_send_state_to_frontend(const std::string &state) { this->state = state; this->set_has_state(true); ESP_LOGD(TAG, "'%s': Sending state '%s'", this->name_.c_str(), state.c_str()); - this->callback_.call(state); + + // Call filtered callbacks (after filters) + this->callbacks_.call_second(this->raw_count_, state); + #if defined(USE_TEXT_SENSOR) && defined(USE_CONTROLLER_REGISTRY) ControllerRegistry::notify_text_sensor_update(this); #endif diff --git a/esphome/components/text_sensor/text_sensor.h b/esphome/components/text_sensor/text_sensor.h index db2e857ae3..1f4f3170e0 100644 --- a/esphome/components/text_sensor/text_sensor.h +++ b/esphome/components/text_sensor/text_sensor.h @@ -58,11 +58,11 @@ class TextSensor : public EntityBase, public EntityBase_DeviceClass { void internal_send_state_to_frontend(const std::string &state); protected: - std::unique_ptr> - raw_callback_; ///< Storage for raw state callbacks (lazy allocated). - CallbackManager callback_; ///< Storage for filtered state callbacks. + PartitionedCallbackManager callbacks_; Filter *filter_list_{nullptr}; ///< Store all active filters. + + uint8_t raw_count_{0}; ///< Number of raw callbacks (partition point in callbacks_ vector) }; } // namespace text_sensor diff --git a/esphome/core/helpers.h b/esphome/core/helpers.h index 1f496995d1..289126609d 100644 --- a/esphome/core/helpers.h +++ b/esphome/core/helpers.h @@ -872,6 +872,73 @@ template class CallbackManager { std::vector> callbacks_; }; +template class PartitionedCallbackManager; + +/** Helper class for callbacks partitioned into two sections. + * + * Uses a single vector partitioned into two sections: [first_0, ..., first_m-1, second_0, ..., second_n-1] + * The partition point is tracked externally by the caller (typically stored in the entity class for optimal alignment). + * + * Memory efficient: Only stores a single pointer (4 bytes on 32-bit platforms, 8 bytes on 64-bit platforms). + * The partition count lives in the entity class where it can be packed with other small fields to avoid padding waste. + * + * Design rationale: The asymmetric API (add_first takes first_count*, while call_first/call_second take it by value) + * is intentional - add_first must increment the count, while call methods only read it. This avoids storing first_count + * internally, saving memory per instance. + * + * @tparam Ts The arguments for the callbacks, wrapped in void(). + */ +template class PartitionedCallbackManager { + public: + /// Add a callback to the first partition. + void add_first(std::function &&callback, uint8_t *first_count) { + if (!this->callbacks_) { + this->callbacks_ = make_unique>>(); + } + + // Add to first partition: append then rotate into position + this->callbacks_->push_back(std::move(callback)); + // Avoid potential underflow: rewrite comparison to not subtract from size() + if (*first_count + 1 < this->callbacks_->size()) { + // Use std::rotate to maintain registration order in second partition + std::rotate(this->callbacks_->begin() + *first_count, this->callbacks_->end() - 1, this->callbacks_->end()); + } + (*first_count)++; + } + + /// Add a callback to the second partition. + void add_second(std::function &&callback) { + if (!this->callbacks_) { + this->callbacks_ = make_unique>>(); + } + + // Add to second partition: just append (already at end after first partition) + this->callbacks_->push_back(std::move(callback)); + } + + /// Call all callbacks in the first partition. + void call_first(uint8_t first_count, Ts... args) { + if (this->callbacks_) { + for (size_t i = 0; i < first_count; i++) { + (*this->callbacks_)[i](args...); + } + } + } + + /// Call all callbacks in the second partition. + void call_second(uint8_t first_count, Ts... args) { + if (this->callbacks_) { + for (size_t i = first_count; i < this->callbacks_->size(); i++) { + (*this->callbacks_)[i](args...); + } + } + } + + protected: + /// Partitioned callback storage: [first_0, ..., first_m-1, second_0, ..., second_n-1] + std::unique_ptr>> callbacks_; +}; + /// Helper class to deduplicate items in a series of values. template class Deduplicator { public: