lifecycle.hpp

 
ErrorCode Get(Database::KeyBase& key) override
{
  auto ans = SearchKey(key.name_);
  if (!ans)
  {
    return ErrorCode::NOT_FOUND;
  }
 
  KeyInfo key_buffer;
  ReadFlashOrExit(ans, key_buffer);
 
  if (key.raw_data_.size_ != key_buffer.GetDataSize())
  {
    return ErrorCode::FAILED;
  }
 
  ReadFlashOrExit(GetKeyData(ans), key.raw_data_);
 
  return ErrorCode::OK;
}
 
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_);
}
 
explicit DatabaseRaw(Flash& flash, size_t recycle_threshold = 128)
    : recycle_threshold_(recycle_threshold), flash_(flash)
{
  ASSERT(flash.MinEraseSize() * 2 <= flash_.Size());
  ASSERT(flash_.MinWriteSize() <= MinWriteSize);
  auto block_num = static_cast<size_t>(flash_.Size() / flash.MinEraseSize());
  block_size_ = block_num / 2 * flash.MinEraseSize();
  Init();
}
 
void Init()
{
  size_t used_size = 0;
  if (IsBackupComplete(used_size) ||
      (!IsBlockValid(BlockType::MAIN) && IsBackupRestorable(used_size)))
  {
    EraseFlashOrExit(0, block_size_);
    CopyBlockPrefixAndChecksum(BlockType::MAIN, BlockType::BACKUP, used_size);
    PrepareBackup();
  }
  else
  {
    if (!IsBlockValid(BlockType::MAIN))
    {
      InitBlock(BlockType::MAIN);
    }
    if (IsBlockValid(BlockType::BACKUP) && !IsBlockEmpty(BlockType::BACKUP))
    {
      PrepareBackup();
    }
  }
 
  RepairMainChain();
}
 
void Restore()
{
  InitBlock(BlockType::MAIN);
  PrepareBackup();
}
 
ErrorCode Recycle()
{
  size_t used_size = LibXR::OffsetOf(&FlashInfo::key) + AlignSize(sizeof(KeyInfo));
  size_t key_offset = GetSentinelOffset(BlockType::MAIN);
  KeyInfo key;
  ReadFlashOrExit(key_offset, key);
  while (NextChainKey(BlockType::MAIN, key_offset, key))
  {
    if (IsKeyLive(key) && IsKeyNameTerminated(key_offset, key))
    {
      used_size += GetKeySpan(key);
    }
  }
  if (used_size + GetCrcSize() > GetChecksumOffset())
  {
    return ErrorCode::FULL;
  }
 
  if (!IsBackupPrepared())
  {
    PrepareBackup();
  }
 
  size_t backup_last_key = GetSentinelOffset(BlockType::BACKUP);
  key_offset = GetSentinelOffset(BlockType::MAIN);
  ReadFlashOrExit(key_offset, key);
  while (NextChainKey(BlockType::MAIN, key_offset, key))
  {
    if (!IsKeyLive(key) || !IsKeyNameTerminated(key_offset, key))
    {
      continue;
    }
 
    const size_t new_key_offset = GetNextKey(backup_last_key);
    WriteKeyHeader(new_key_offset, key.GetNameLength(), key.GetDataSize());
    CopyFlashData(GetKeyName(new_key_offset), GetKeyName(key_offset),
                  key.GetNameLength());
    CopyFlashData(GetKeyData(new_key_offset), GetKeyData(key_offset), key.GetDataSize());
    ClearKeyFlag(new_key_offset, &KeyInfo::uninit);
    LinkKey(BlockType::BACKUP, backup_last_key);
    backup_last_key = new_key_offset;
  }
  DEV_ASSERT(GetNextKey(backup_last_key) - block_size_ == used_size);
 
  const uint32_t crc = GetBackupCrc(used_size);
  WriteFlashOrExit(GetBlockOffset(BlockType::BACKUP) + used_size, crc);
  WriteBlockChecksum(BlockType::BACKUP);
 
  EraseFlashOrExit(0, block_size_);
  CopyBlockPrefixAndChecksum(BlockType::MAIN, BlockType::BACKUP, used_size);
 
  PrepareBackup();
 
  return ErrorCode::OK;
}