filter.h

Go to the documentation of this file.

#pragma once
 
#include "esphome/core/defines.h"
#ifdef USE_TEXT_SENSOR_FILTER
 
#include <array>
 
#include "esphome/core/component.h"
#include "esphome/core/helpers.h"
 
namespace esphome::text_sensor {
 
class TextSensor;
 
class Filter {
 public:
  virtual bool new_value(std::string &value) = 0;
 
  virtual void initialize(TextSensor *parent, Filter *next);
 
  void input(std::string value);
 
  void output(std::string &value);
 
 protected:
  friend TextSensor;
 
  Filter *next_{nullptr};
  TextSensor *parent_{nullptr};
};
 
using lambda_filter_t = std::function<optional<std::string>(std::string)>;
 
class LambdaFilter : public Filter {
 public:
  explicit LambdaFilter(lambda_filter_t lambda_filter);
 
  bool new_value(std::string &value) override;
 
  const lambda_filter_t &get_lambda_filter() const;
  void set_lambda_filter(const lambda_filter_t &lambda_filter);
 
 protected:
  lambda_filter_t lambda_filter_;
};
 
class StatelessLambdaFilter : public Filter {
 public:
  explicit StatelessLambdaFilter(optional<std::string> (*lambda_filter)(std::string)) : lambda_filter_(lambda_filter) {}
 
  bool new_value(std::string &value) override {
    auto result = this->lambda_filter_(value);
    if (result.has_value()) {
      value = std::move(*result);
      return true;
    }
    return false;
  }
 
 protected:
  optional<std::string> (*lambda_filter_)(std::string);
};
 
class ToUpperFilter : public Filter {
 public:
  bool new_value(std::string &value) override;
};
 
class ToLowerFilter : public Filter {
 public:
  bool new_value(std::string &value) override;
};
 
class AppendFilter : public Filter {
 public:
  explicit AppendFilter(const char *suffix) : suffix_(suffix) {}
  bool new_value(std::string &value) override;
 
 protected:
  const char *suffix_;
};
 
class PrependFilter : public Filter {
 public:
  explicit PrependFilter(const char *prefix) : prefix_(prefix) {}
  bool new_value(std::string &value) override;
 
 protected:
  const char *prefix_;
};
 
struct Substitution {
  const char *from;
  const char *to;
};
 
bool substitute_filter_apply(const Substitution *substitutions, size_t count, std::string &value);
 
template<size_t N> class SubstituteFilter : public Filter {
 public:
  explicit SubstituteFilter(const std::initializer_list<Substitution> &substitutions) {
    init_array_from(this->substitutions_, substitutions);
  }
  bool new_value(std::string &value) override { return substitute_filter_apply(this->substitutions_.data(), N, value); }
 
 protected:
  std::array<Substitution, N> substitutions_{};
};
 
bool map_filter_apply(const Substitution *mappings, size_t count, std::string &value);
 
template<size_t N> class MapFilter : public Filter {
 public:
  explicit MapFilter(const std::initializer_list<Substitution> &mappings) {
    init_array_from(this->mappings_, mappings);
  }
  bool new_value(std::string &value) override { return map_filter_apply(this->mappings_.data(), N, value); }
 
 protected:
  std::array<Substitution, N> mappings_{};
};
 
}  // namespace esphome::text_sensor
 
#endif  // USE_TEXT_SENSOR_FILTER