raw_sequential.hpp

#pragma once
 
#include <cstdint>
#include <cstring>
 
#include "flash.hpp"
#include "interface.hpp"
 
namespace LibXR
{
 
class DatabaseRawSequential : public Database
{
 public:
  explicit DatabaseRawSequential(Flash& flash, size_t max_buffer_size = 256);
 
  void Init();
 
  void Save();
 
  void Load();
 
  void Restore();
 
  ErrorCode Get(Database::KeyBase& key) override;
 
  ErrorCode Set(KeyBase& key, RawData data) override
  {
    return SetKey(key.name_, data.addr_, data.size_);
  }
 
  ErrorCode Add(KeyBase& key) override
  {
    return AddKey(key.name_, key.raw_data_.addr_, key.raw_data_.size_);
  }
 
 private:
  enum class BlockType : uint8_t
  {
    MAIN = 0,   
    BACKUP = 1  
  };
 
  LIBXR_PACKED_BEGIN
  struct KeyInfo
  {
    uint32_t raw_data;  
 
    KeyInfo();
 
    KeyInfo(bool nextKey, uint8_t nameLength, uint32_t dataSize);
 
    void SetNextKeyExist(bool value);
 
    bool GetNextKeyExist() const;
 
    void SetNameLength(uint8_t len);
 
    uint8_t GetNameLength() const;
 
    void SetDataSize(uint32_t size);
 
    uint32_t GetDataSize() const;
  };
 
  static_assert(sizeof(KeyInfo) == 4, "KeyInfo size must be 4 bytes");
  LIBXR_PACKED_END
 
  struct FlashInfo
  {
    uint32_t header;  
    KeyInfo key;      
  };
 
  ErrorCode AddKey(const char* name, const void* data, size_t size);
  ErrorCode SetKey(const char* name, const void* data, size_t size);
  ErrorCode SetKey(size_t offset, const void* data, size_t size);
  ErrorCode GetKeyData(size_t offset, RawData data);
  void InitBlock(BlockType block);
  void ReadFlashOrExit(size_t offset, RawData data);
  void WriteFlashOrExit(size_t offset, ConstRawData data);
  void EraseFlashOrExit(size_t offset, size_t size);
  bool IsBlockInited(BlockType block);
  bool IsBlockEmpty(BlockType block);
  bool IsBlockError(BlockType block);
  bool HasLastKey(size_t offset);
  size_t GetKeySize(size_t offset);
  size_t GetNextKey(size_t offset);
  size_t GetLastKey(BlockType block);
  void SetNestKeyExist(size_t offset, bool exist);
  bool KeyDataCompare(size_t offset, const void* data, size_t size);
  bool KeyNameCompare(size_t offset, const char* name);
  size_t SearchKey(const char* name);
 
  static constexpr uint32_t FLASH_HEADER =
      0x12345678 + LIBXR_DATABASE_VERSION;  
  static constexpr uint8_t CHECKSUM_BYTE = 0x56;  
 
  Flash& flash_;              
  uint8_t* buffer_;           
  uint32_t block_size_;       
  uint32_t max_buffer_size_;  
};
 
}  // namespace LibXR