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;
  }