Device.h

/*
 * Copyright (c) 2021, 2022 G. R. McDorman
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
 
#pragma once
 
#include <WString.h>
#include <vector>
#include <ArduinoJson.h>
 
#include "grmcdorman/Setting.h"
 
namespace grmcdorman::device
{
    class SettingInterface;
 
    class Device
    {
        public:
            Device(const __FlashStringHelper *device_name, const __FlashStringHelper *device_identifier);
            virtual ~Device() {}
 
            static constexpr int D0 = 16; 
            static constexpr int D1 =  5; 
            static constexpr int D2 =  4; 
            static constexpr int D3 =  0; 
            static constexpr int D4 =  2; 
            static constexpr int D5 = 14; 
            static constexpr int D6 = 12; 
            static constexpr int D7 = 13; 
            static constexpr int D8 = 15; 
 
            class Definition
            {
                public:
                    virtual const __FlashStringHelper *get_name_suffix() const = 0;
                    virtual const __FlashStringHelper *get_value_template() const = 0;
 
                    virtual const __FlashStringHelper *get_unique_id_suffix() const = 0;
                    virtual const __FlashStringHelper *get_unit_of_measurement() const = 0;
                    virtual const __FlashStringHelper *get_json_attributes_template() const = 0;
                    virtual const __FlashStringHelper *get_icon() const = 0;
            };
 
            const __FlashStringHelper *name() const
            {
                return device_name;
            }
 
            virtual const __FlashStringHelper *identifier() const
            {
                return device_identifier;
            }
 
            static void set_system_identifiers(const __FlashStringHelper *firmware_name_value, const String &system_identifier_value = String());
 
            static const __FlashStringHelper *get_firmware_name()
            {
                return firmware_name;
            }
 
            static const String &get_system_identifier()
            {
                return system_identifier;
            }
 
            virtual void set_defaults()
            {
            }
 
            virtual void set_devices(const std::vector<Device *> &list)
            {
            }
 
            virtual void setup() = 0;
 
            virtual void loop() = 0;
 
            virtual bool publish(DynamicJsonDocument &json) const
            {
                return false;
            }
 
 
            virtual DynamicJsonDocument as_json() const
            {
                // Return a null document.
                return DynamicJsonDocument(8);
            }
 
            typedef std::vector<const Definition *> definition_list_t;
 
            const definition_list_t &get_definitions() const
            {
                return definitions;
            }
 
            const ::grmcdorman::SettingInterface::settings_list_t &get_settings() const
            {
                return settings;
            }
 
            bool is_enabled() const
            {
                return enabled.get();
            }
 
            void set_enabled(bool state)
            {
                enabled.set(state);
            }
 
            void set(const String &setting, const String &value);
 
            String get(const String &setting) const;
 
            virtual String get_status() const
            {
                return String();
            }
 
            virtual bool get_is_published() const
            {
                return is_published;
            }
 
            void set_is_published()
            {
                is_published = true;
            }
 
            void clear_is_published()
            {
                is_published = false;
            }
            static const ExclusiveOptionSetting::names_list_t data_line_names;  
        protected:
            void initialize(definition_list_t &&definition_list, ::grmcdorman::SettingInterface::settings_list_t &&setting_list)
            {
                definitions = std::move(definition_list);
                settings = std::move(setting_list);
            }
 
            static int index_to_dataline(int index)
            {
                return settingsMap[index];
            }
 
            static int dataline_to_index(int dataLine);
 
            static const int settingsMap[6];
 
            ToggleSetting enabled;                                      
        private:
            const __FlashStringHelper *device_name;                     
            const __FlashStringHelper *device_identifier;               
            bool is_published = true;                                   
 
            static const __FlashStringHelper *firmware_name;            
            static String system_identifier;                            
 
 
            definition_list_t definitions;                              
            ::grmcdorman::SettingInterface::settings_list_t settings;   
    };
}