measured.h

#pragma once

#include <string>
#include <vector>
#include <functional>

#include "device/device_config.h"

#ifndef MEASURED_PERIOD_MS
#define MEASURED_PERIOD_MS 1000
#endif


namespace qthing {

    namespace measured {

        class MeasureResult {
            
            public:
                const float value;

                const std::string& sensor_name;
                const std::string& sensor_type;
                const std::string& sensor_unit;

                MeasureResult(const std::string& name, const std::string& type, const std::string& unit, float value);

        };

        class Sensor {

            enum skip_measurement_t { no_skip, skip };

            public:
                const std::string& name;
                const std::string& type;
                const std::string& unit;

                Sensor(const std::string& name, const std::string& type, const std::string& unit);

                virtual skip_measurement_t prepare_next_measurement();
                virtual MeasureResult measure() = 0;

            protected:
                MeasureResult create_result(float value);
        };

        // typedef std::function<float()> sensor_t;
        typedef std::function<void(const std::vector<MeasureResult>&)> backend_t;

        void register_backend(backend_t new_backend);
        void register_sensor(std::string name, std::string type, std::string unit, Sensor *sensor);
        void set_measure_period(uint16_t period);

        class Measured {

            public:
                Measured();
                void register_backend(backend_t new_backend);
                void register_sensor(std::string name, std::string type, std::string unit, Sensor *sensor);
                void set_measure_period(uint16_t period);

            private:
                std::vector<Sensor *> sensors;
                qthing::measured::backend_t backend;
                uint16_t measure_period = MEASURED_PERIOD_MS;
                void measured();
        };

        namespace backend {
            void mqtt(const std::vector<qthing::measured::MeasureResult>& data);
        }
    }
}