definition_cache.h

// SPDX-FileCopyrightText: AC SOFTWARE SP. Z O.O.
// SPDX-License-Identifier: GPL-2.0-or-later
 
#ifndef SRC_SUPLA_SUPLET_DEFINITION_CACHE_H_
#define SRC_SUPLA_SUPLET_DEFINITION_CACHE_H_
 
#include <stddef.h>
#include <stdint.h>
#include <supla/suplet/config.h>
 
namespace Supla {
 
class Config;
 
namespace Suplet {
 
struct CachedDefinitionInfo {
  uint32_t definitionId = 0;
  uint16_t definitionVersion = 0;
  uint16_t jsonSize = 0;
  uint32_t crc32 = 0;
};
 
struct DefinitionCacheHandle {
  uint8_t slot = 255;
  uint8_t variant = 0;
};
 
class DefinitionCache {
 public:
  explicit DefinitionCache(Supla::Config *config);
 
  bool save(uint32_t definitionId,
            uint16_t definitionVersion,
            const char *json);
  bool load(uint32_t definitionId,
            uint16_t definitionVersion,
            char *json,
            size_t jsonSize,
            CachedDefinitionInfo *info = nullptr) const;
  bool contains(uint32_t definitionId, uint16_t definitionVersion) const;
  bool contentEquals(uint32_t definitionId,
                     uint16_t definitionVersion,
                     const uint8_t *data,
                     size_t size) const;
  bool erase(uint32_t definitionId, uint16_t definitionVersion);
  bool getInfo(uint8_t index, CachedDefinitionInfo *info) const;
  bool getInfoAndRepair(uint8_t index, CachedDefinitionInfo *info) const;
  bool beginStagedSave(uint32_t definitionId,
                       uint16_t definitionVersion,
                       uint16_t jsonSize,
                       DefinitionCacheHandle *handle);
  bool writeStagedChunk(DefinitionCacheHandle handle,
                        uint16_t chunkIndex,
                        const uint8_t *data,
                        uint16_t size);
  bool loadStaged(DefinitionCacheHandle handle,
                  uint32_t definitionId,
                  uint16_t definitionVersion,
                  char *json,
                  size_t jsonSize,
                  CachedDefinitionInfo *info = nullptr) const;
  bool commitStaged(DefinitionCacheHandle handle,
                    uint32_t definitionId,
                    uint16_t definitionVersion,
                    uint16_t jsonSize);
  bool abortStaged(DefinitionCacheHandle handle);
 
 private:
  bool verifyCrc32(const char *json,
                   uint16_t jsonSize,
                   uint32_t expectedCrc32) const;
  bool readActiveHeader(uint8_t index,
                        CachedDefinitionInfo *info,
                        uint8_t *activeVariant = nullptr,
                        uint16_t *chunkCount = nullptr,
                        uint16_t *chunkSize = nullptr) const;
  bool loadAndRepairActiveHeader(uint8_t index,
                                 CachedDefinitionInfo *info,
                                 uint8_t *activeVariant = nullptr,
                                 uint16_t *chunkCount = nullptr,
                                 uint16_t *chunkSize = nullptr) const;
  bool loadHeader(uint8_t index,
                  uint8_t variant,
                  CachedDefinitionInfo *info,
                  uint16_t *chunkCount = nullptr,
                  uint16_t *chunkSize = nullptr) const;
  bool saveSlot(uint8_t index,
                uint32_t definitionId,
                uint16_t definitionVersion,
                const char *json,
                uint16_t jsonSize,
                uint32_t crc32);
  bool saveHeader(uint8_t index,
                  uint8_t variant,
                  const CachedDefinitionInfo &info,
                  uint16_t chunkCount,
                  uint16_t chunkSize);
  bool loadPayload(uint8_t slot,
                   uint8_t variant,
                   const CachedDefinitionInfo &info,
                   uint16_t chunkCount,
                   uint16_t chunkSize,
                   char *json,
                   size_t jsonSize) const;
  bool eraseChunks(uint8_t index, uint8_t variant);
  bool eraseVariant(uint8_t index, uint8_t variant);
  bool eraseLegacySlot(uint8_t index);
  bool eraseSlot(uint8_t index);
  bool setActiveVariant(uint8_t index, uint8_t variant);
  bool variantExists(uint8_t index, uint8_t variant) const;
  bool slotExists(uint8_t index) const;
  int findSlot(uint32_t definitionId,
               uint16_t definitionVersion,
               bool repair) const;
  int findFreeSlot() const;
  static uint8_t otherVariant(uint8_t variant);
  static bool isValidVariant(uint8_t variant);
  static bool isValidHandle(DefinitionCacheHandle handle);
  static bool makeActKey(uint8_t index, char *output, size_t outputSize);
  static bool makeHeaderKey(uint8_t index,
                            uint8_t variant,
                            char *output,
                            size_t outputSize);
  static bool makeChunkKey(uint8_t index,
                           uint8_t variant,
                           uint16_t chunkIndex,
                           char *output,
                           size_t outputSize);
  static bool makeLegacyHeaderKey(uint8_t index,
                                  char *output,
                                  size_t outputSize);
  static bool makeLegacyChunkKey(uint8_t index,
                                 uint16_t chunkIndex,
                                 char *output,
                                 size_t outputSize);
 
  Supla::Config *config = nullptr;
};
 
}  // namespace Suplet
}  // namespace Supla
 
#endif  // SRC_SUPLA_SUPLET_DEFINITION_CACHE_H_