EepromSecureData.h

/*
   Copyright (C) 2023 epsilonrt <epsilonrt@gmail.com>
   SPDX-License-Identifier: LGPL-2.1-or-later
*/
#include <EEPROM.h>
#include <assert.h>
#include "CrcIButton.h"
#include "EepromBase.h"
#pragma once
 
template <class T>
class EepromSecureData {
 
  public:
    EepromSecureData () : m_eem (EepromBase::counter) {
      EepromBase::counter += size();
      // assert (EepromBase::counter < EEPROM.length());
    }
 
    EepromSecureData (const T &data) : EepromSecureData() {
      m_data = data;
    }
 
    ~EepromSecureData() {
      save();
    }
 
    bool save() {
 
      updateCrc();
      EEPROM.put (m_eem, m_data);
      EEPROM.write (m_eem + sizeof (T), m_crc.value ());
      #if defined(ESP32) || defined(ESP8266)
      return EEPROM.commit();
      #else
      return true;
      #endif
    }
 
    bool load (const T &defaultData = T()) {
 
      EEPROM.get (m_eem, m_data);
      uint8_t crc = EEPROM.read (m_eem + sizeof (T));
      updateCrc();
 
      if (m_crc.value () != crc) {
        m_data = defaultData;
        updateCrc();
        save();
        return false;
      }
      return true;
    }
 
    inline uint16_t size() const {
      return sizeof (T) + sizeof (m_crc);
    }
 
    T &data() {
      return m_data;
    }
 
    const T &data() const {
      return m_data;
    }
 
    operator T &() {
      return m_data;
    }
 
    operator const T &() const {
      return m_data;
    }
 
    T *operator&() {
      return & m_data;
    }
 
    const T *operator&() const {
      return & m_data;
    }
 
    T &operator= (const T &t) {
      m_data = t;
      updateCrc();
      return m_data;
    }
 
    EepromSecureData &operator = (const EepromSecureData &rhs) {
      m_data = rhs.m_data;
      return *this;
    }
 
    bool  operator == (const EepromSecureData &rhs) const {
      return m_data == rhs.m_data;
    }
 
    bool  operator != (const EepromSecureData &rhs) const {
      return ! (*this == rhs);
    }
 
  protected:
    // update CRC
    void updateCrc () {
      m_crc.reset ();
      m_crc.update (m_data);
    }
 
  protected:
    uint16_t m_eem; // EEPROM memory address of the object
    T m_data; // data object itself (RAM)
    CrcIButton <T> m_crc; // CRC object
};