key_ops.hpp

 
ErrorCode AddKeyBody(size_t name_len, size_t size, size_t& key_buf_offset)
{
  bool recycle = false;
add_again:
  size_t last_key_offset = GetLastKey(BlockType::MAIN);
  key_buf_offset = 0;
 
  if (AvailableSize() <
      AlignSize(sizeof(KeyInfo)) + AlignSize(name_len) + AlignSize(size))
  {
    if (!recycle)
    {
      Recycle();
      recycle = true;
      // NOLINTNEXTLINE
      goto add_again;
    }
    else
    {
      ASSERT(false);
      return ErrorCode::FULL;
    }
  }
 
  if (last_key_offset == 0)
  {
    FlashInfo flash_info;
    flash_info.header = FLASH_HEADER;
    KeyInfo& tmp_key = flash_info.key;
    BlockBoolUtil<MinWriteSize>::SetFlag(tmp_key.no_next_key, false);
    BlockBoolUtil<MinWriteSize>::SetFlag(tmp_key.available_flag, false);
    BlockBoolUtil<MinWriteSize>::SetFlag(tmp_key.uninit, false);
    tmp_key.SetNameLength(0);
    tmp_key.SetDataSize(0);
    WriteFlashOrExit(0, flash_info);
    key_buf_offset = GetNextKey(LibXR::OffsetOf(&FlashInfo::key));
  }
  else
  {
    key_buf_offset = GetNextKey(last_key_offset);
  }
 
  KeyInfo new_key = {};
  BlockBoolUtil<MinWriteSize>::SetFlag(new_key.no_next_key, true);
  BlockBoolUtil<MinWriteSize>::SetFlag(new_key.available_flag, true);
  BlockBoolUtil<MinWriteSize>::SetFlag(new_key.uninit, true);
  new_key.SetNameLength(name_len);
  new_key.SetDataSize(size);
 
  WriteFlashOrExit(key_buf_offset, new_key);
  BlockBoolUtil<MinWriteSize>::SetFlag(new_key.uninit, false);
 
  if (last_key_offset != 0)
  {
    KeyInfo last_key;
    ReadFlashOrExit(last_key_offset, last_key);
    KeyInfo new_last_key = {};
    BlockBoolUtil<MinWriteSize>::SetFlag(new_last_key.no_next_key, false);
    BlockBoolUtil<MinWriteSize>::SetFlag(
        new_last_key.available_flag,
        BlockBoolUtil<MinWriteSize>::ReadFlag(last_key.available_flag));
    BlockBoolUtil<MinWriteSize>::SetFlag(
        new_last_key.uninit, BlockBoolUtil<MinWriteSize>::ReadFlag(last_key.uninit));
    new_last_key.SetNameLength(last_key.GetNameLength());
    new_last_key.SetDataSize(last_key.GetDataSize());
 
    WriteFlashOrExit(last_key_offset, new_last_key);
  }
 
  WriteFlashOrExit(key_buf_offset, new_key);
 
  return ErrorCode::OK;
}
 
ErrorCode AddKey(size_t name_offset, size_t name_len, const void* data, size_t size)
{
  size_t key_buf_offset = 0;
  ErrorCode ec = AddKeyBody(name_len, size, key_buf_offset);
  if (ec != ErrorCode::OK)
  {
    return ec;
  }
  CopyFlashData(GetKeyName(key_buf_offset), name_offset, name_len);
  WriteFlashOrExit(GetKeyData(key_buf_offset),
                   {reinterpret_cast<const uint8_t*>(data), size});
  return ErrorCode::OK;
}
 
ErrorCode AddKey(const char* name, const void* data, size_t size)
{
  size_t name_len = strlen(name) + 1;
  if (auto ans = SearchKey(name))
  {
    return SetKey(name, data, size);
  }
  size_t key_buf_offset = 0;
  ErrorCode ec = AddKeyBody(name_len, size, key_buf_offset);
  if (ec != ErrorCode::OK)
  {
    return ec;
  }
  WriteFlashOrExit(GetKeyName(key_buf_offset),
                   {reinterpret_cast<const uint8_t*>(name), name_len});
  WriteFlashOrExit(GetKeyData(key_buf_offset),
                   {reinterpret_cast<const uint8_t*>(data), size});
  return ErrorCode::OK;
}
 
ErrorCode SetKey(const char* name, const void* data, size_t size, bool recycle = true)
{
  size_t key_offset = SearchKey(name);
  if (key_offset)
  {
    KeyInfo key;
    ReadFlashOrExit(key_offset, key);
    if (key.GetDataSize() == size)
    {
      if (KeyDataCompare(key_offset, data, size))
      {
        if (AvailableSize() <
            AlignSize(size) + AlignSize(sizeof(KeyInfo)) + AlignSize(key.GetNameLength()))
        {
          if (recycle)
          {
            Recycle();
            return SetKey(name, data, size, false);
          }
          else
          {
            ASSERT(false);
            return ErrorCode::FULL;
          }
        }
        KeyInfo new_key = {};
        BlockBoolUtil<MinWriteSize>::SetFlag(
            new_key.no_next_key, BlockBoolUtil<MinWriteSize>::ReadFlag(key.no_next_key));
        BlockBoolUtil<MinWriteSize>::SetFlag(new_key.available_flag, false);
        BlockBoolUtil<MinWriteSize>::SetFlag(
            new_key.uninit, BlockBoolUtil<MinWriteSize>::ReadFlag(key.uninit));
        new_key.SetNameLength(key.GetNameLength());
        new_key.SetDataSize(size);
        WriteFlashOrExit(key_offset, new_key);
        return AddKey(GetKeyName(key_offset), key.GetNameLength(), data, size);
      }
      return ErrorCode::OK;
    }
  }
  return ErrorCode::FAILED;
}
 
size_t GetKeyData(size_t offset)
{
  KeyInfo key;
  ReadFlashOrExit(offset, key);
  return offset + AlignSize(sizeof(KeyInfo)) + AlignSize(key.GetNameLength());
}
 
size_t GetKeyName(size_t offset) { return offset + AlignSize(sizeof(KeyInfo)); }
 
size_t GetKeySize(size_t offset)
{
  KeyInfo key;
  ReadFlashOrExit(offset, key);
  return AlignSize(sizeof(KeyInfo)) + AlignSize(key.GetNameLength()) +
         AlignSize(key.GetDataSize());
}
 
size_t GetNextKey(size_t offset)
{
  KeyInfo key;
  ReadFlashOrExit(offset, key);
  return offset + GetKeySize(offset);
}
 
size_t GetLastKey(BlockType block)
{
  if (IsBlockEmpty(block))
  {
    return 0;
  }
 
  KeyInfo key;
  size_t key_offset = GetBlockOffset(block) + LibXR::OffsetOf(&FlashInfo::key);
  ReadFlashOrExit(key_offset, key);
  while (!BlockBoolUtil<MinWriteSize>::ReadFlag(key.no_next_key))
  {
    key_offset = GetNextKey(key_offset);
    ReadFlashOrExit(key_offset, key);
  }
  return key_offset;
}
 
bool KeyDataCompare(size_t offset, const void* data, size_t size)
{
  KeyInfo key;
  ReadFlashOrExit(offset, key);
  size_t key_data_offset = GetKeyData(offset);
  uint8_t data_buffer = 0;
  for (size_t i = 0; i < size; i++)
  {
    ReadFlashOrExit(key_data_offset + i, data_buffer);
    if (data_buffer != (reinterpret_cast<const uint8_t*>(data))[i])
    {
      return true;
    }
  }
  return false;
}
 
bool KeyNameCompare(size_t offset, const char* name)
{
  KeyInfo key;
  ReadFlashOrExit(offset, key);
  for (size_t i = 0; i < key.GetNameLength(); i++)
  {
    uint8_t data_buffer = 0;
    ReadFlashOrExit(offset + AlignSize(sizeof(KeyInfo)) + i, data_buffer);
    if (data_buffer != name[i])
    {
      return true;
    }
  }
  return false;
}
 
size_t SearchKey(const char* name)
{
  if (IsBlockEmpty(BlockType::MAIN))
  {
    return 0;
  }
 
  KeyInfo key;
  size_t key_offset = LibXR::OffsetOf(&FlashInfo::key);
  ReadFlashOrExit(key_offset, key);
 
  size_t ans = 0, need_cycle = 0;
 
  while (true)
  {
    if (!BlockBoolUtil<MinWriteSize>::ReadFlag(key.available_flag))
    {
      key_offset = GetNextKey(key_offset);
      ReadFlashOrExit(key_offset, key);
      need_cycle++;
      continue;
    }
 
    if (!KeyNameCompare(key_offset, name))
    {
      ans = key_offset;
      break;
    }
 
    if (BlockBoolUtil<MinWriteSize>::ReadFlag(key.no_next_key))
    {
      break;
    }
 
    key_offset = GetNextKey(key_offset);
    ReadFlashOrExit(key_offset, key);
  }
 
  if (need_cycle > recycle_threshold_)
  {
    Recycle();
    return SearchKey(name);
  }
 
  return ans;
}