适用于最小写入单元受限的 Flash 存储的数据库实现 (Database implementation for Flash storage with minimum write unit restrictions). More...

#include <database.hpp>

Inheritance diagram for LibXR::DatabaseRaw< MinWriteSize >:

Collaboration diagram for LibXR::DatabaseRaw< MinWriteSize >:

Data Structures
struct	BlockBoolData

class	BlockBoolUtil

struct	FlashInfo
	Flash 存储的块信息结构 (Structure representing a Flash storage block). More...

struct	KeyInfo
	键信息结构，存储键的元数据 (Structure containing key metadata). More...

Public Member Functions
ErrorCode	Get (Database::KeyBase &key) override
	获取数据库中的键值 (Retrieve the key's value from the database).

ErrorCode	Set (KeyBase &key, RawData data) override
	设置数据库中的键值 (Set the key's value in the database).

ErrorCode	Add (KeyBase &key) override
	添加新键到数据库 (Add a new key to the database).

	DatabaseRaw (Flash &flash, size_t recycle_threshold=128)
	构造函数，初始化 Flash 存储和缓冲区 (Constructor to initialize Flash storage and buffer).

void	Init ()
	初始化数据库存储区，确保主备块正确 (Initialize database storage, ensuring main and backup blocks are valid).

void	Restore ()
	还原存储数据，清空 Flash 区域 (Restore storage data, clearing Flash memory area).

ErrorCode	Recycle ()
	回收 Flash 空间，整理数据 (Recycle Flash storage space and organize data).

Private Types
enum class	BlockType : uint8_t { MAIN = 0 , BACKUP = 1 }

Private Member Functions
size_t	AvailableSize ()
	计算可用的存储空间大小 (Calculate the available storage size).

ErrorCode	AddKeyBody (size_t name_len, size_t size, size_t &key_buf_offset)

ErrorCode	AddKey (size_t name_offset, size_t name_len, const void *data, size_t size)

ErrorCode	AddKey (const char name, const void data, size_t size)

ErrorCode	SetKeyCommon (size_t key_offset, size_t name_len, const void *data, size_t size)

ErrorCode	SetKey (size_t name_offset, size_t name_length, const void *data, size_t size)

ErrorCode	SetKey (const char name, const void data, size_t size, bool recycle=true)

size_t	GetKeyData (size_t offset)

size_t	GetKeyName (size_t offset)

void	InitBlock (BlockType block)

bool	IsBlockInited (BlockType block)

bool	IsBlockEmpty (BlockType block)

bool	IsBlockError (BlockType block)

size_t	GetKeySize (size_t offset)

size_t	GetNextKey (size_t offset)

size_t	GetLastKey (BlockType block)

bool	KeyDataCompare (size_t offset, const void *data, size_t size)

bool	KeyNameCompare (size_t offset, const char *name)

bool	KeyNameCompare (size_t offset_a, size_t offset_b)

void	CopyFlashData (size_t dst_offset, size_t src_offset, size_t size)

size_t	SearchKey (const char *name)

size_t	AlignSize (size_t size)
	计算对齐后的大小 (Calculate the aligned size).

ErrorCode	Write (size_t offset, ConstRawData data)
	以最小写入单元对齐的方式写入数据 (Write data aligned to the minimum write unit).

Private Attributes
size_t	recycle_threshold_ = 0
	回收阈值 (Recycle threshold).

Flash &	flash_
	目标 Flash 存储设备 (Target Flash storage device).

uint32_t	block_size_
	Flash 块大小 (Flash block size).

uint8_t	write_buffer_ [MinWriteSize]
	写入缓冲区 (Write buffer).

Static Private Attributes
static constexpr uint32_t	FLASH_HEADER
	Flash 头部标识 (Flash header identifier).

static constexpr uint32_t	CHECKSUM_BYTE = 0x9abcedf0
	校验字节 (Checksum byte).

Detailed Description

template<size_t MinWriteSize>
class LibXR::DatabaseRaw< MinWriteSize >

适用于最小写入单元受限的 Flash 存储的数据库实现 (Database implementation for Flash storage with minimum write unit restrictions).

This class provides key-value storage management for Flash memory that requires data to be written in fixed-size blocks. 此类提供适用于 Flash 存储的键值存储管理，该存储要求数据以固定大小块写入。

Template Parameters

MinWriteSize Flash 的最小写入单元大小 (Minimum write unit size for Flash storage).

Definition at line 325 of file database.hpp.

Member Enumeration Documentation

◆ BlockType

template<size_t MinWriteSize>

enum class LibXR::DatabaseRaw::BlockType : uint8_t

strongprivate

Enumerator
MAIN	主块 (Main block).
BACKUP	备份块 (Backup block).

Definition at line 332 of file database.hpp.

  {
    MAIN = 0,   
    BACKUP = 1  
  };

Constructor & Destructor Documentation

◆ DatabaseRaw()

template<size_t MinWriteSize>

LibXR::DatabaseRaw< MinWriteSize >::DatabaseRaw	(	Flash &	flash,
		size_t	recycle_threshold = 128 )

inlineexplicit

构造函数，初始化 Flash 存储和缓冲区 (Constructor to initialize Flash storage and buffer).

Parameters

flash	目标 Flash 存储设备 (Target Flash storage device).
recycle_threshold	回收阈值 (Recycle threshold).

Definition at line 968 of file database.hpp.

      : 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();
  }

Member Function Documentation

◆ Add()

template<size_t MinWriteSize>

ErrorCode LibXR::DatabaseRaw< MinWriteSize >::Add ( KeyBase & key )

inlineoverridevirtual

添加新键到数据库 (Add a new key to the database).

Parameters

key	需要添加的键 (Key to add).

Returns: 操作结果 (Operation result).

Implements LibXR::Database.

Definition at line 956 of file database.hpp.

  {
    return AddKey(key.name_, key.raw_data_.addr_, key.raw_data_.size_);
  }

◆ AddKey() [1/2]

template<size_t MinWriteSize>

ErrorCode LibXR::DatabaseRaw< MinWriteSize >::AddKey	(	const char *	name,
		const void *	data,
		size_t	size )

inlineprivate

Definition at line 558 of file database.hpp.

  {
    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;
    }
    Write(GetKeyName(key_buf_offset), {reinterpret_cast<const uint8_t*>(name), name_len});
    Write(GetKeyData(key_buf_offset), {reinterpret_cast<const uint8_t*>(data), size});
    return ErrorCode::OK;
  }

◆ AddKey() [2/2]

template<size_t MinWriteSize>

ErrorCode LibXR::DatabaseRaw< MinWriteSize >::AddKey	(	size_t	name_offset,
		size_t	name_len,
		const void *	data,
		size_t	size )

inlineprivate

Definition at line 545 of file database.hpp.

  {
    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);
    Write(GetKeyData(key_buf_offset), {reinterpret_cast<const uint8_t*>(data), size});
    return ErrorCode::OK;
  }

◆ AddKeyBody()

template<size_t MinWriteSize>

ErrorCode LibXR::DatabaseRaw< MinWriteSize >::AddKeyBody	(	size_t	name_len,
		size_t	size,
		size_t &	key_buf_offset )

inlineprivate

Definition at line 471 of file database.hpp.

  {
    bool recycle = false;
  add_again:
    size_t last_key_offset = GetLastKey(BlockType::MAIN);
    key_buf_offset = 0;
 
    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);
      Write(0, flash_info);
      key_buf_offset = GetNextKey(OFFSET_OF(FlashInfo, key));
    }
    else
    {
      key_buf_offset = GetNextKey(last_key_offset);
    }
 
    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;
      }
    }
 
    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);
 
    Write(key_buf_offset, new_key);
    BlockBoolUtil<MinWriteSize>::SetFlag(new_key.uninit, false);
 
    if (last_key_offset != 0)
    {
      KeyInfo last_key;
      flash_.Read(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());
 
      Write(last_key_offset, new_last_key);
    }
 
    Write(key_buf_offset, new_key);
 
    return ErrorCode::OK;
  }

◆ AlignSize()

template<size_t MinWriteSize>

size_t LibXR::DatabaseRaw< MinWriteSize >::AlignSize ( size_t size )

inlineprivate

计算对齐后的大小 (Calculate the aligned size).

Parameters

size	需要对齐的大小 (Size to align).

Returns: 对齐后的大小 (Aligned size).

Definition at line 875 of file database.hpp.

  {
    return static_cast<size_t>((size + MinWriteSize - 1) / MinWriteSize) * MinWriteSize;
  }

◆ AvailableSize()

template<size_t MinWriteSize>

size_t LibXR::DatabaseRaw< MinWriteSize >::AvailableSize ( )

inlineprivate

计算可用的存储空间大小 (Calculate the available storage size).

Returns: 剩余的可用字节数 (Remaining available bytes).

Definition at line 465 of file database.hpp.

  {
    auto offset = GetNextKey(GetLastKey(BlockType::MAIN));
    return block_size_ - sizeof(CHECKSUM_BYTE) - offset;
  }

◆ CopyFlashData()

template<size_t MinWriteSize>

void LibXR::DatabaseRaw< MinWriteSize >::CopyFlashData	(	size_t	dst_offset,
		size_t	src_offset,
		size_t	size )

inlineprivate

Definition at line 813 of file database.hpp.

  {
    for (size_t i = 0; i < size; i += MinWriteSize)
    {
      flash_.Read(src_offset + i, {write_buffer_, MinWriteSize});
      flash_.Write(dst_offset + i, {write_buffer_, MinWriteSize});
    }
  }

◆ Get()

template<size_t MinWriteSize>

ErrorCode LibXR::DatabaseRaw< MinWriteSize >::Get ( Database::KeyBase & key )

inlineoverridevirtual

获取数据库中的键值 (Retrieve the key's value from the database).

Parameters

key	需要获取的键 (Key to retrieve).

Returns: 操作结果，如果找到则返回 ErrorCode::OK，否则返回 ErrorCode::NOT_FOUND (Operation result, returns ErrorCode::OK if found, otherwise ErrorCode::NOT_FOUND).

Implements LibXR::Database.

Definition at line 922 of file database.hpp.

  {
    auto ans = SearchKey(key.name_);
    if (!ans)
    {
      return ErrorCode::NOT_FOUND;
    }
 
    KeyInfo key_buffer;
    flash_.Read(ans, key_buffer);
 
    if (key.raw_data_.size_ < key_buffer.GetDataSize())
    {
      return ErrorCode::FAILED;
    }
 
    flash_.Read(GetKeyData(ans), key.raw_data_);
 
    return ErrorCode::OK;
  }

◆ GetKeyData()

template<size_t MinWriteSize>

size_t LibXR::DatabaseRaw< MinWriteSize >::GetKeyData ( size_t offset )

inlineprivate

Definition at line 654 of file database.hpp.

  {
    KeyInfo key;
    flash_.Read(offset, key);
    return offset + AlignSize(sizeof(KeyInfo)) + AlignSize(key.GetNameLength());
  }

◆ GetKeyName()

template<size_t MinWriteSize>

size_t LibXR::DatabaseRaw< MinWriteSize >::GetKeyName ( size_t offset )

inlineprivate

Definition at line 661 of file database.hpp.

661{ return offset + AlignSize(sizeof(KeyInfo)); }

◆ GetKeySize()

template<size_t MinWriteSize>

size_t LibXR::DatabaseRaw< MinWriteSize >::GetKeySize ( size_t offset )

inlineprivate

Definition at line 721 of file database.hpp.

  {
    KeyInfo key;
    flash_.Read(offset, key);
    return AlignSize(sizeof(KeyInfo)) + AlignSize(key.GetNameLength()) +
           AlignSize(key.GetDataSize());
  }

◆ GetLastKey()

template<size_t MinWriteSize>

size_t LibXR::DatabaseRaw< MinWriteSize >::GetLastKey ( BlockType block )

inlineprivate

Definition at line 736 of file database.hpp.

  {
    if (IsBlockEmpty(block))
    {
      return 0;
    }
 
    KeyInfo key;
    size_t key_offset = OFFSET_OF(FlashInfo, key);
    if (block != BlockType::MAIN)
    {
      key_offset += block_size_;
    }
    flash_.Read(key_offset, key);
    while (!BlockBoolUtil<MinWriteSize>::ReadFlag(key.no_next_key))
    {
      key_offset = GetNextKey(key_offset);
      flash_.Read(key_offset, key);
    }
    return key_offset;
  }

◆ GetNextKey()

template<size_t MinWriteSize>

size_t LibXR::DatabaseRaw< MinWriteSize >::GetNextKey ( size_t offset )

inlineprivate

Definition at line 729 of file database.hpp.

  {
    KeyInfo key;
    flash_.Read(offset, key);
    return offset + GetKeySize(offset);
  }

◆ Init()

template<size_t MinWriteSize>

void LibXR::DatabaseRaw< MinWriteSize >::Init ( )

inline

初始化数据库存储区，确保主备块正确 (Initialize database storage, ensuring main and backup blocks are valid).

Definition at line 982 of file database.hpp.

  {
    if (!IsBlockInited(BlockType::BACKUP) || IsBlockError(BlockType::BACKUP))
    {
      InitBlock(BlockType::BACKUP);
    }
 
    if (!IsBlockInited(BlockType::MAIN) || IsBlockError(BlockType::MAIN))
    {
      if (IsBlockEmpty(BlockType::BACKUP))
      {
        InitBlock(BlockType::MAIN);
      }
      else
      {
        flash_.Erase(0, block_size_);
        for (uint32_t i = 0; i < block_size_; i += MinWriteSize)
        {
          flash_.Read(i + block_size_, {write_buffer_, MinWriteSize});
          flash_.Write(i, {write_buffer_, MinWriteSize});
        }
      }
    }
 
    if (!IsBlockEmpty(BlockType::BACKUP))
    {
      InitBlock(BlockType::BACKUP);
    }
 
    KeyInfo key;
    size_t key_offset = OFFSET_OF(FlashInfo, key);
    flash_.Read(key_offset, key);
    size_t need_cycle = 0;
    while (!BlockBoolUtil<MinWriteSize>::ReadFlag(key.no_next_key))
    {
      key_offset = GetNextKey(key_offset);
      flash_.Read(key_offset, key);
      // TODO: 恢复损坏数据
      if (BlockBoolUtil<MinWriteSize>::ReadFlag(key.uninit))
      {
        InitBlock(BlockType::MAIN);
        break;
      }
      if (!BlockBoolUtil<MinWriteSize>::ReadFlag(key.available_flag))
      {
        need_cycle += 1;
      }
    }
 
    if (need_cycle > recycle_threshold_)
    {
      Recycle();
    }
  }

◆ InitBlock()

template<size_t MinWriteSize>

void LibXR::DatabaseRaw< MinWriteSize >::InitBlock ( BlockType block )

inlineprivate

Definition at line 663 of file database.hpp.

  {
    size_t offset = 0;
    if (block == BlockType::BACKUP)
    {
      offset = block_size_;
    }
    flash_.Erase(offset, block_size_);
 
    FlashInfo info;  // padding filled with 0xFF by constructor
    info.header = FLASH_HEADER;
    KeyInfo& tmp_key = info.key;
    BlockBoolUtil<MinWriteSize>::SetFlag(tmp_key.no_next_key, true);
    BlockBoolUtil<MinWriteSize>::SetFlag(tmp_key.available_flag, true);
    BlockBoolUtil<MinWriteSize>::SetFlag(tmp_key.uninit, false);
    tmp_key.SetNameLength(0);
    tmp_key.SetDataSize(0);
    Write(offset, {reinterpret_cast<uint8_t*>(&info), sizeof(FlashInfo)});
    Write(offset + block_size_ - AlignSize(sizeof(CHECKSUM_BYTE)),
          {&CHECKSUM_BYTE, sizeof(CHECKSUM_BYTE)});
  }

◆ IsBlockEmpty()

template<size_t MinWriteSize>

bool LibXR::DatabaseRaw< MinWriteSize >::IsBlockEmpty ( BlockType block )

inlineprivate

Definition at line 697 of file database.hpp.

  {
    size_t offset = 0;
    if (block == BlockType::BACKUP)
    {
      offset = block_size_;
    }
    FlashInfo flash_data;
    flash_.Read(offset, flash_data);
    return BlockBoolUtil<MinWriteSize>::ReadFlag(flash_data.key.available_flag) == true;
  }

◆ IsBlockError()

template<size_t MinWriteSize>

bool LibXR::DatabaseRaw< MinWriteSize >::IsBlockError ( BlockType block )

inlineprivate

Definition at line 709 of file database.hpp.

  {
    size_t offset = 0;
    if (block == BlockType::BACKUP)
    {
      offset = block_size_;
    }
    uint32_t checksum = 0;
    flash_.Read(offset + block_size_ - AlignSize(sizeof(CHECKSUM_BYTE)), checksum);
    return checksum != CHECKSUM_BYTE;
  }

◆ IsBlockInited()

template<size_t MinWriteSize>

bool LibXR::DatabaseRaw< MinWriteSize >::IsBlockInited ( BlockType block )

inlineprivate

Definition at line 685 of file database.hpp.

  {
    size_t offset = 0;
    if (block == BlockType::BACKUP)
    {
      offset = block_size_;
    }
    FlashInfo flash_data;
    flash_.Read(offset, flash_data);
    return flash_data.header == FLASH_HEADER;
  }

◆ KeyDataCompare()

template<size_t MinWriteSize>

bool LibXR::DatabaseRaw< MinWriteSize >::KeyDataCompare	(	size_t	offset,
		const void *	data,
		size_t	size )

inlineprivate

Definition at line 758 of file database.hpp.

  {
    KeyInfo key;
    flash_.Read(offset, key);
    size_t key_data_offset = GetKeyData(offset);
    uint8_t data_buffer = 0;
    for (size_t i = 0; i < size; i++)
    {
      flash_.Read(key_data_offset + i, data_buffer);
      if (data_buffer != (reinterpret_cast<const uint8_t*>(data))[i])
      {
        return true;
      }
    }
    return false;
  }

◆ KeyNameCompare() [1/2]

template<size_t MinWriteSize>

bool LibXR::DatabaseRaw< MinWriteSize >::KeyNameCompare	(	size_t	offset,
		const char *	name )

inlineprivate

Definition at line 775 of file database.hpp.

  {
    KeyInfo key;
    flash_.Read(offset, key);
    for (size_t i = 0; i < key.GetNameLength(); i++)
    {
      uint8_t data_buffer = 0;
      flash_.Read(offset + AlignSize(sizeof(KeyInfo)) + i, data_buffer);
      if (data_buffer != name[i])
      {
        return true;
      }
    }
    return false;
  }

◆ KeyNameCompare() [2/2]

template<size_t MinWriteSize>

bool LibXR::DatabaseRaw< MinWriteSize >::KeyNameCompare	(	size_t	offset_a,
		size_t	offset_b )

inlineprivate

Definition at line 791 of file database.hpp.

  {
    KeyInfo key_a, key_b;
    flash_.Read(offset_a, key_a);
    flash_.Read(offset_b, key_b);
    if (key_a.GetNameLength() != key_b.GetNameLength())
    {
      return true;
    }
    for (size_t i = 0; i < key_a.GetNameLength(); i++)
    {
      uint8_t data_buffer_a = 0, data_buffer_b = 0;
      flash_.Read(offset_a + sizeof(KeyInfo) + i, data_buffer_a);
      flash_.Read(offset_b + sizeof(KeyInfo) + i, data_buffer_b);
      if (data_buffer_a != data_buffer_b)
      {
        return true;
      }
    }
    return false;
  }

◆ Recycle()

template<size_t MinWriteSize>

ErrorCode LibXR::DatabaseRaw< MinWriteSize >::Recycle ( )

inline

回收 Flash 空间，整理数据 (Recycle Flash storage space and organize data).

Moves valid keys from the main block to the backup block and erases the main block. 将主存储块中的有效键移动到备份块，并擦除主存储块。

Returns: 操作结果 (Operation result).

Definition at line 1057 of file database.hpp.

  {
    if (IsBlockEmpty(BlockType::MAIN))
    {
      return ErrorCode::OK;
    }
 
    KeyInfo key;
    size_t key_offset = OFFSET_OF(FlashInfo, key);
    flash_.Read(key_offset, key);
 
    if (!IsBlockEmpty(BlockType::BACKUP))
    {
      ASSERT(false);
      return ErrorCode::FAILED;
    }
 
    size_t write_buff_offset = OFFSET_OF(FlashInfo, key) + block_size_;
 
    auto new_key = KeyInfo{};
    BlockBoolUtil<MinWriteSize>::SetFlag(new_key.uninit, false);
    BlockBoolUtil<MinWriteSize>::SetFlag(new_key.available_flag, false);
    BlockBoolUtil<MinWriteSize>::SetFlag(new_key.no_next_key, false);
    Write(write_buff_offset, new_key);
 
    write_buff_offset += GetKeySize(write_buff_offset);
 
    do
    {
      key_offset = GetNextKey(key_offset);
      flash_.Read(key_offset, key);
 
      if (!BlockBoolUtil<MinWriteSize>::ReadFlag(key.available_flag))
      {
        continue;
      }
 
      Write(write_buff_offset, key);
      write_buff_offset += AlignSize(sizeof(KeyInfo));
      CopyFlashData(write_buff_offset, GetKeyName(key_offset), key.GetNameLength());
      write_buff_offset += AlignSize(key.GetNameLength());
      CopyFlashData(write_buff_offset, GetKeyData(key_offset), key.GetDataSize());
      write_buff_offset += AlignSize(key.GetDataSize());
    } while (!BlockBoolUtil<MinWriteSize>::ReadFlag(key.no_next_key));
 
    flash_.Erase(0, block_size_);
    for (uint32_t i = 0; i < block_size_; i += MinWriteSize)
    {
      flash_.Read(i + block_size_, {write_buffer_, MinWriteSize});
      flash_.Write(i, {write_buffer_, MinWriteSize});
    }
 
    InitBlock(BlockType::BACKUP);
 
    return ErrorCode::OK;
  }

◆ Restore()

template<size_t MinWriteSize>

void LibXR::DatabaseRaw< MinWriteSize >::Restore ( )

inline

还原存储数据，清空 Flash 区域 (Restore storage data, clearing Flash memory area).

Definition at line 1041 of file database.hpp.

  {
    InitBlock(BlockType::MAIN);
    InitBlock(BlockType::BACKUP);
  }

◆ SearchKey()

template<size_t MinWriteSize>

size_t LibXR::DatabaseRaw< MinWriteSize >::SearchKey ( const char * name )

inlineprivate

Definition at line 822 of file database.hpp.

  {
    if (IsBlockEmpty(BlockType::MAIN))
    {
      return 0;
    }
 
    KeyInfo key;
    size_t key_offset = OFFSET_OF(FlashInfo, key);
    flash_.Read(key_offset, key);
 
    size_t ans = 0, need_cycle = 0;
 
    while (true)
    {
      if (!BlockBoolUtil<MinWriteSize>::ReadFlag(key.available_flag))
      {
        key_offset = GetNextKey(key_offset);
        flash_.Read(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);
      flash_.Read(key_offset, key);
    }
 
    if (need_cycle > recycle_threshold_)
    {
      Recycle();
      return SearchKey(name);
    }
 
    return ans;
  }

◆ Set()

template<size_t MinWriteSize>

ErrorCode LibXR::DatabaseRaw< MinWriteSize >::Set	(	KeyBase &	key,
		RawData	data )

inlineoverridevirtual

设置数据库中的键值 (Set the key's value in the database).

Parameters

key	目标键 (Target key).
data	需要存储的新值 (New value to store).

Returns: 操作结果 (Operation result).

Implements LibXR::Database.

Definition at line 950 of file database.hpp.

  {
    memcpy(key.raw_data_.addr_, data.addr_, data.size_);
    return SetKey(key.name_, data.addr_, data.size_);
  }

◆ SetKey() [1/2]

template<size_t MinWriteSize>

ErrorCode LibXR::DatabaseRaw< MinWriteSize >::SetKey	(	const char *	name,
		const void *	data,
		size_t	size,
		bool	recycle = true )

inlineprivate

Definition at line 611 of file database.hpp.

  {
    size_t key_offset = SearchKey(name);
    if (key_offset)
    {
      KeyInfo key;
      flash_.Read(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);
          Write(key_offset, new_key);
          return AddKey(GetKeyName(key_offset), key.GetNameLength(), data, size);
        }
        return ErrorCode::OK;
      }
    }
    return ErrorCode::FAILED;
  }

◆ SetKey() [2/2]

template<size_t MinWriteSize>

ErrorCode LibXR::DatabaseRaw< MinWriteSize >::SetKey	(	size_t	name_offset,
		size_t	name_length,
		const void *	data,
		size_t	size )

inlineprivate

Definition at line 605 of file database.hpp.

  {
    size_t key_offset = SearchKey(name_offset, name_length);
    return SetKeyCommon(key_offset, name_length, data, size);
  }

◆ SetKeyCommon()

template<size_t MinWriteSize>

ErrorCode LibXR::DatabaseRaw< MinWriteSize >::SetKeyCommon	(	size_t	key_offset,
		size_t	name_len,
		const void *	data,
		size_t	size )

inlineprivate

Definition at line 576 of file database.hpp.

  {
    if (key_offset)
    {
      KeyInfo key;
      flash_.Read(key_offset, key);
      if (key.GetDataSize() == size)
      {
        if (KeyDataCompare(key_offset, data, size))
        {
          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(name_len);
          new_key.SetDataSize(size);
          Write(key_offset, new_key);
          return AddKey(GetKeyName(key_offset), name_len, data, size);
        }
        return ErrorCode::OK;
      }
    }
    return ErrorCode::FAILED;
  }

◆ Write()

template<size_t MinWriteSize>

ErrorCode LibXR::DatabaseRaw< MinWriteSize >::Write	(	size_t	offset,
		ConstRawData	data )

inlineprivate

以最小写入单元对齐的方式写入数据 (Write data aligned to the minimum write unit).

Parameters

offset	写入偏移量 (Write offset).
data	要写入的数据 (Data to write).

Returns: 操作结果 (Operation result).

Definition at line 887 of file database.hpp.

  {
    if (data.size_ == 0)
    {
      return ErrorCode::OK;
    }
 
    if (data.size_ % MinWriteSize == 0)
    {
      return flash_.Write(offset, data);
    }
    else
    {
      auto final_block_index = data.size_ - data.size_ % MinWriteSize;
      if (final_block_index != 0)
      {
        flash_.Write(offset, {data.addr_, final_block_index});
      }
      memset(write_buffer_, 0xff, MinWriteSize);
      memcpy(write_buffer_,
             reinterpret_cast<const uint8_t*>(data.addr_) + final_block_index,
             data.size_ % MinWriteSize);
      return flash_.Write(offset + final_block_index, {write_buffer_, MinWriteSize});
    }
  }

Field Documentation

◆ block_size_

template<size_t MinWriteSize>

uint32_t LibXR::DatabaseRaw< MinWriteSize >::block_size_

private

Flash 块大小 (Flash block size).

Definition at line 457 of file database.hpp.

◆ CHECKSUM_BYTE

template<size_t MinWriteSize>

uint32_t LibXR::DatabaseRaw< MinWriteSize >::CHECKSUM_BYTE = 0x9abcedf0

staticconstexprprivate

校验字节 (Checksum byte).

Definition at line 330 of file database.hpp.

◆ flash_

template<size_t MinWriteSize>

Flash& LibXR::DatabaseRaw< MinWriteSize >::flash_

private

目标 Flash 存储设备 (Target Flash storage device).

Definition at line 456 of file database.hpp.

◆ FLASH_HEADER

template<size_t MinWriteSize>

uint32_t LibXR::DatabaseRaw< MinWriteSize >::FLASH_HEADER

staticconstexprprivate

Initial value:

=

0x12345678 + LIBXR_DATABASE_VERSION

Flash 头部标识 (Flash header identifier).

Definition at line 327 of file database.hpp.

◆ recycle_threshold_

template<size_t MinWriteSize>

size_t LibXR::DatabaseRaw< MinWriteSize >::recycle_threshold_ = 0

private

回收阈值 (Recycle threshold).

Definition at line 455 of file database.hpp.

◆ write_buffer_

template<size_t MinWriteSize>

uint8_t LibXR::DatabaseRaw< MinWriteSize >::write_buffer_[MinWriteSize]

private

写入缓冲区 (Write buffer).

Definition at line 458 of file database.hpp.

The documentation for this class was generated from the following file:

src/middleware/database.hpp

Data Structures

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Enumeration Documentation

◆ BlockType

Constructor & Destructor Documentation

◆ DatabaseRaw()

Member Function Documentation

◆ Add()

◆ AddKey() [1/2]

◆ AddKey() [2/2]

◆ AddKeyBody()

◆ AlignSize()

◆ AvailableSize()

◆ CopyFlashData()

◆ Get()

◆ GetKeyData()

◆ GetKeyName()

◆ GetKeySize()

◆ GetLastKey()

◆ GetNextKey()

◆ Init()

◆ InitBlock()

◆ IsBlockEmpty()

◆ IsBlockError()

◆ IsBlockInited()

◆ KeyDataCompare()

◆ KeyNameCompare() [1/2]

◆ KeyNameCompare() [2/2]

◆ Recycle()

◆ Restore()

◆ SearchKey()

◆ Set()

◆ SetKey() [1/2]

◆ SetKey() [2/2]

◆ SetKeyCommon()

◆ Write()

Field Documentation

◆ block_size_

◆ CHECKSUM_BYTE

◆ flash_

◆ FLASH_HEADER

◆ recycle_threshold_

◆ write_buffer_