storage.h

// SPDX-FileCopyrightText: AC SOFTWARE SP. Z O.O.
// SPDX-License-Identifier: GPL-2.0-or-later
 
#ifndef SRC_SUPLA_SUPLET_STORAGE_H_
#define SRC_SUPLA_SUPLET_STORAGE_H_
 
#include <stdint.h>
#include <stddef.h>
#include <supla/suplet/channel_map.h>
#include <supla/suplet/config.h>
 
namespace Supla {
 
class Config;
 
namespace Suplet {
 
struct InstanceRecord {
  InstanceRecord();
  InstanceRecord(const InstanceRecord &other);
  InstanceRecord &operator=(const InstanceRecord &other);
  ~InstanceRecord();
 
  bool setConfig(const uint8_t *data, uint16_t size);
  void clearConfig();
 
  uint8_t instanceId = 0;
  uint32_t definitionId = 0;
  uint16_t definitionVersion = 0;
  uint8_t subDeviceId = 0;
  uint16_t configSize = 0;
  ChannelMap channelMap = {};
  uint8_t *config = nullptr;
};
 
class InstanceTable {
 public:
  InstanceTable();
  InstanceTable(const InstanceTable &) = delete;
  InstanceTable &operator=(const InstanceTable &) = delete;
  ~InstanceTable();
 
  uint8_t getCount() const;
  void clear();
 
  bool add(const InstanceRecord &record);
  bool removeByInstanceId(uint8_t instanceId);
  InstanceRecord *findByInstanceId(uint8_t instanceId);
  const InstanceRecord *findByInstanceId(uint8_t instanceId) const;
  InstanceRecord *findBySubDeviceId(uint8_t subDeviceId);
  const InstanceRecord *findBySubDeviceId(uint8_t subDeviceId) const;
  InstanceRecord *getRecord(uint8_t index);
  const InstanceRecord *getRecord(uint8_t index) const;
 
 private:
  bool resize(uint8_t newCount);
 
  InstanceRecord *records = nullptr;
  uint8_t count = 0;
};
 
class Storage {
 public:
  explicit Storage(Supla::Config *config);
 
  bool load(InstanceTable *table);
  bool loadIndex(InstanceTable *table);
  bool loadInstance(uint8_t instanceId, InstanceRecord *record);
  bool save(const InstanceTable &table);
  bool erase();
 
 private:
#pragma pack(push, 1)
  struct StoredInstanceHeader {
    uint8_t version = 0;
    uint8_t reserved = 0;
    uint32_t definitionId = 0;
    uint16_t definitionVersion = 0;
    uint8_t channelCount = 0;
    uint16_t configSize = 0;
  };
 
  struct StoredChannelMapping {
    uint8_t channelId = 0;
    uint8_t channelNumber = 0;
  };
#pragma pack(pop)
 
  bool loadVariant(uint8_t instanceId, uint8_t variant, InstanceRecord *record)
      const;
  bool loadVariant(uint8_t instanceId,
                   uint8_t variant,
                   InstanceRecord *record,
                   bool loadConfig) const;
  bool loadActiveVariant(uint8_t instanceId,
                         uint8_t *activeVariant,
                         InstanceRecord *record,
                         bool loadConfig,
                         bool cleanup);
  bool saveVariant(const InstanceRecord &record, uint8_t variant);
  bool eraseVariant(uint8_t instanceId, uint8_t variant);
  bool eraseInstance(uint8_t instanceId);
  bool cleanupLoadedInstance(uint8_t instanceId,
                             uint8_t activeVariant,
                             uint8_t loadedVariant);
  bool slotExists(uint8_t instanceId) const;
  void makeActKey(uint8_t instanceId, char *output) const;
  void makeHeaderKey(uint8_t instanceId, uint8_t variant, char *output) const;
  void makeChannelMapKey(uint8_t instanceId,
                         uint8_t variant,
                         char *output) const;
  void makeConfigKey(uint8_t instanceId, uint8_t variant, char *output) const;
  bool readBlobExact(const char *key, char *output, size_t expectedSize) const;
 
  Supla::Config *config = nullptr;
};
 
}  // namespace Suplet
}  // namespace Supla
 
#endif  // SRC_SUPLA_SUPLET_STORAGE_H_