适用于最小写入单元受限的 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 >:

[legend]

Data Structures
class	BlockBoolUtil

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

Public Member Functions
template<size_t BlockSize>
struct	__attribute__ ((packed)) BlockBoolData

	DatabaseRaw (Flash &flash)
	构造函数，初始化 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).

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).

Private Member Functions
struct	__attribute__ ((packed))
	键信息结构，存储键的元数据 (Structure containing key metadata).

template<size_t MinWriteSize>
struct LibXR::DatabaseRaw::FlashInfo	__attribute__ ((packed))

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

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

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

uint8_t *	GetKeyData (KeyInfo *key)
	获取指定键的数据信息 (Retrieve the data associated with a key).

const char *	GetKeyName (KeyInfo *key)
	获取键的名称 (Retrieve the name of a key).

void	InitBlock (FlashInfo *block)

bool	IsBlockInited (FlashInfo *block)

bool	IsBlockEmpty (FlashInfo *block)

bool	IsBlockError (FlashInfo *block)

size_t	GetKeySize (KeyInfo *key)

KeyInfo *	GetNextKey (KeyInfo *key)

KeyInfo *	GetLastKey (FlashInfo *block)

KeyInfo *	SearchKey (const char *name)

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

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
	KeyInfo

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

FlashInfo *	info_main_
	主存储区信息 (Main storage block information).

FlashInfo *	info_backup_
	备份存储区信息 (Backup storage block information).

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

uint8_t *	write_buffer_
	写入缓冲区 (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 322 of file database.hpp.

Constructor & Destructor Documentation

◆ DatabaseRaw()

template<size_t MinWriteSize>

LibXR::DatabaseRaw< MinWriteSize >::DatabaseRaw ( Flash & flash )

inlineexplicit

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

Parameters

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

Definition at line 387 of file database.hpp.

      : flash_(flash), write_buffer_(new uint8_t[flash_.min_write_size_])
  {
    ASSERT(flash.min_erase_size_ * 2 <= flash.flash_area_.size_);
    ASSERT(flash_.min_write_size_ <= MinWriteSize);
    auto block_num = static_cast<size_t>(flash.flash_area_.size_ / flash.min_erase_size_);
    block_size_ = block_num / 2 * flash.min_erase_size_;
    info_main_ = reinterpret_cast<FlashInfo*>(flash.flash_area_.addr_);
    info_backup_ = reinterpret_cast<FlashInfo*>(
        reinterpret_cast<uint8_t*>(flash.flash_area_.addr_) + block_size_);
    Init();
  }

Member Function Documentation

◆ attribute() [1/2]

template<size_t MinWriteSize>

struct LibXR::DatabaseRaw< MinWriteSize >::__attribute__ ( (packed) )

inlineprivate

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

< 是否是最后一个键 (Indicates if this is the last key).

< 该键是否有效 (Indicates if this key is available).

< 该键是否未初始化 (Indicates if this key is uninitialized).

< 键名长度 (Length of the key name).

< 数据大小 (Size of the stored data).

Definition at line 455 of file database.hpp.

  {
    BlockBoolData<MinWriteSize>
        no_next_key;  
    BlockBoolData<MinWriteSize>
        available_flag;  
    BlockBoolData<MinWriteSize>
        uninit;  
    uint32_t nameLength : 7;  
    size_t dataSize : 25;     
  } KeyInfo;

◆ attribute() [2/2]

template<size_t MinWriteSize>

template<size_t BlockSize>

struct LibXR::DatabaseRaw< MinWriteSize >::__attribute__ ( (packed) )

inline

Definition at line 214 of file database.hpp.

  {
    uint8_t data[BlockSize];
  };

◆ Add()

template<size_t MinWriteSize>

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

inlineoverrideprivatevirtual

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

Parameters

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

Returns: 操作结果 (Operation result).

Implements LibXR::Database.

Definition at line 799 of file database.hpp.

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

◆ AddKey()

template<size_t MinWriteSize>

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

inlineprivate

Definition at line 542 of file database.hpp.

  {
    if (auto ans = SearchKey(name))
    {
      return SetKey(name, data, size);
    }
 
    bool recycle = false;
 
  add_again:
    const uint32_t NAME_LEN = strlen(name) + 1;
    KeyInfo* last_key = GetLastKey(info_main_);
    KeyInfo* key_buf = nullptr;
 
    if (!last_key)
    {
      FlashInfo flash_info;
      memset(&flash_info, 0xff, sizeof(FlashInfo));
      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.nameLength = 0;
      tmp_key.dataSize = 0;
      Write(0, flash_info);
      key_buf = GetNextKey(&info_main_->key);
    }
    else
    {
      key_buf = GetNextKey(last_key);
    }
 
    if (AvailableSize() <
        AlignSize(sizeof(KeyInfo)) + AlignSize(NAME_LEN) + AlignSize(size))
    {
      if (!recycle)
      {
        Recycle();
        recycle = true;
        goto add_again;  // NOLINT
      }
      else
      {
        ASSERT(false);
        return ErrorCode::FULL;
      }
    }
 
    if (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.nameLength = last_key->nameLength;
      new_last_key.dataSize = last_key->dataSize;
 
      Write(reinterpret_cast<uint8_t*>(last_key) -
                reinterpret_cast<uint8_t*>(flash_.flash_area_.addr_),
            new_last_key);
    }
 
    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.nameLength = NAME_LEN;
    new_key.dataSize = size;
 
    Write(reinterpret_cast<uint8_t*>(key_buf) -
              reinterpret_cast<uint8_t*>(flash_.flash_area_.addr_),
          new_key);
    Write(reinterpret_cast<const uint8_t*>(GetKeyName(key_buf)) -
              reinterpret_cast<uint8_t*>(flash_.flash_area_.addr_),
          {reinterpret_cast<const uint8_t*>(name), NAME_LEN});
    Write(reinterpret_cast<uint8_t*>(GetKeyData(key_buf)) -
              reinterpret_cast<uint8_t*>(flash_.flash_area_.addr_),
          {reinterpret_cast<const uint8_t*>(data), size});
    BlockBoolUtil<MinWriteSize>::SetFlag(new_key.uninit, false);
    Write(reinterpret_cast<uint8_t*>(key_buf) -
              reinterpret_cast<uint8_t*>(flash_.flash_area_.addr_),
          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 810 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 535 of file database.hpp.

  {
    return block_size_ - sizeof(CHECKSUM_BYTE) -
           (reinterpret_cast<uint8_t*>(GetNextKey(GetLastKey(info_main_))) -
            reinterpret_cast<uint8_t*>(flash_.flash_area_.addr_));
  }

◆ 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 857 of file database.hpp.

  {
    auto ans = SearchKey(key.name_);
    if (!ans)
    {
      return ErrorCode::NOT_FOUND;
    }
 
    if (key.raw_data_.size_ != ans->dataSize)
    {
      return ErrorCode::FAILED;
    }
 
    memcpy(key.raw_data_.addr_, GetKeyData(ans), ans->dataSize);
 
    return ErrorCode::OK;
  }

◆ GetKeyData()

template<size_t MinWriteSize>

uint8_t * LibXR::DatabaseRaw< MinWriteSize >::GetKeyData ( KeyInfo * key )

inlineprivate

获取指定键的数据信息 (Retrieve the data associated with a key).

Parameters

key	目标键 (Key to retrieve data from).

Returns: 指向数据的指针 (Pointer to the key's data).

Definition at line 682 of file database.hpp.

  {
    return reinterpret_cast<uint8_t*>(key) + AlignSize(sizeof(KeyInfo)) +
           AlignSize(key->nameLength);
  }

◆ GetKeyName()

template<size_t MinWriteSize>

const char * LibXR::DatabaseRaw< MinWriteSize >::GetKeyName ( KeyInfo * key )

inlineprivate

获取键的名称 (Retrieve the name of a key).

Parameters

key	目标键 (Key to retrieve the name from).

Returns: 指向键名的指针 (Pointer to the key name).

Definition at line 694 of file database.hpp.

  {
    return reinterpret_cast<const char*>(key) + AlignSize(sizeof(KeyInfo));
  }

◆ GetKeySize()

template<size_t MinWriteSize>

size_t LibXR::DatabaseRaw< MinWriteSize >::GetKeySize ( KeyInfo * key )

inlineprivate

Definition at line 744 of file database.hpp.

  {
    return AlignSize(sizeof(KeyInfo)) + AlignSize(key->nameLength) +
           AlignSize(key->dataSize);
  }

◆ GetLastKey()

template<size_t MinWriteSize>

KeyInfo * LibXR::DatabaseRaw< MinWriteSize >::GetLastKey ( FlashInfo * block )

inlineprivate

Definition at line 753 of file database.hpp.

  {
    if (IsBlockEmpty(block))
    {
      return nullptr;
    }
 
    KeyInfo* key = &block->key;
    while (!BlockBoolUtil<MinWriteSize>::ReadFlag(key->no_next_key))
    {
      key = GetNextKey(key);
    }
    return key;
  }

◆ GetNextKey()

template<size_t MinWriteSize>

KeyInfo * LibXR::DatabaseRaw< MinWriteSize >::GetNextKey ( KeyInfo * key )

inlineprivate

Definition at line 749 of file database.hpp.

  {
    return reinterpret_cast<KeyInfo*>(reinterpret_cast<uint8_t*>(key) + GetKeySize(key));
  }

◆ Init()

template<size_t MinWriteSize>

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

inline

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

Definition at line 404 of file database.hpp.

  {
    if (!IsBlockInited(info_backup_) || IsBlockError(info_backup_))
    {
      InitBlock(info_backup_);
    }
 
    if (!IsBlockInited(info_main_) || IsBlockError(info_main_))
    {
      if (IsBlockEmpty(info_backup_))
      {
        InitBlock(info_main_);
      }
      else
      {
        flash_.Erase(0, block_size_);
        Write(0, {reinterpret_cast<uint8_t*>(info_backup_), block_size_});
      }
    }
    else if (!IsBlockEmpty(info_backup_))
    {
      InitBlock(info_backup_);
    }
 
    KeyInfo* key = &info_main_->key;
    while (!BlockBoolUtil<MinWriteSize>::ReadFlag(key->no_next_key))
    {
      key = GetNextKey(key);
      if (BlockBoolUtil<MinWriteSize>::ReadFlag(key->uninit))
      {
        InitBlock(info_main_);
        break;
      }
    }
  }

◆ InitBlock()

template<size_t MinWriteSize>

void LibXR::DatabaseRaw< MinWriteSize >::InitBlock ( FlashInfo * block )

inlineprivate

Definition at line 709 of file database.hpp.

  {
    flash_.Erase(reinterpret_cast<uint8_t*>(block) -
                     reinterpret_cast<uint8_t*>(flash_.flash_area_.addr_),
                 block_size_);
 
    FlashInfo info;
    memset(&info, 0xff, sizeof(FlashInfo));
    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.nameLength = 0;
    tmp_key.dataSize = 0;
    Write(reinterpret_cast<uint8_t*>(block) -
              reinterpret_cast<uint8_t*>(flash_.flash_area_.addr_),
          {reinterpret_cast<uint8_t*>(&info), sizeof(FlashInfo)});
    Write(reinterpret_cast<uint8_t*>(block) -
              reinterpret_cast<uint8_t*>(flash_.flash_area_.addr_) + block_size_ -
              AlignSize(sizeof(CHECKSUM_BYTE)),
          {&CHECKSUM_BYTE, sizeof(CHECKSUM_BYTE)});
  }

◆ IsBlockEmpty()

template<size_t MinWriteSize>

bool LibXR::DatabaseRaw< MinWriteSize >::IsBlockEmpty ( FlashInfo * block )

inlineprivate

Definition at line 734 of file database.hpp.

  {
    return BlockBoolUtil<MinWriteSize>::ReadFlag(block->key.available_flag) == true;
  }

◆ IsBlockError()

template<size_t MinWriteSize>

bool LibXR::DatabaseRaw< MinWriteSize >::IsBlockError ( FlashInfo * block )

inlineprivate

Definition at line 738 of file database.hpp.

  {
    auto checksum_byte_addr = reinterpret_cast<uint8_t*>(block) + block_size_ -
                              AlignSize(sizeof(CHECKSUM_BYTE));
    return *reinterpret_cast<uint32_t*>(checksum_byte_addr) != CHECKSUM_BYTE;
  }

◆ IsBlockInited()

template<size_t MinWriteSize>

bool LibXR::DatabaseRaw< MinWriteSize >::IsBlockInited ( FlashInfo * block )

inlineprivate

Definition at line 733 of file database.hpp.

733{ return block->header == FLASH_HEADER; }

◆ 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 455 of file database.hpp.

  {
    if (IsBlockEmpty(info_main_))
    {
      return ErrorCode::OK;
    }
 
    KeyInfo* key = &info_main_->key;
 
    if (!IsBlockEmpty(info_backup_))
    {
      ASSERT(false);
      return ErrorCode::FAILED;
    }
 
    uint8_t* write_buff = reinterpret_cast<uint8_t*>(&info_backup_->key);
 
    auto new_key = KeyInfo{};
    Write(write_buff - reinterpret_cast<uint8_t*>(flash_.flash_area_.addr_), new_key);
 
    write_buff += GetKeySize(&info_backup_->key);
 
    do
    {
      key = GetNextKey(key);
 
      if (!BlockBoolUtil<MinWriteSize>::ReadFlag(key->available_flag))
      {
        continue;
      }
 
      Write(write_buff - reinterpret_cast<uint8_t*>(flash_.flash_area_.addr_), *key);
      write_buff += AlignSize(sizeof(KeyInfo));
      Write(write_buff - reinterpret_cast<uint8_t*>(flash_.flash_area_.addr_),
            {GetKeyName(key), key->nameLength});
      write_buff += AlignSize(key->nameLength);
      Write(write_buff - reinterpret_cast<uint8_t*>(flash_.flash_area_.addr_),
            {GetKeyData(key), key->dataSize});
      write_buff += AlignSize(key->dataSize);
    } while (!BlockBoolUtil<MinWriteSize>::ReadFlag(key->no_next_key));
 
    flash_.Erase(0, block_size_);
    Write(0, {reinterpret_cast<uint8_t*>(info_backup_), block_size_});
    InitBlock(info_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 444 of file database.hpp.

444{}

◆ SearchKey()

template<size_t MinWriteSize>

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

inlineprivate

Definition at line 767 of file database.hpp.

  {
    if (IsBlockEmpty(info_main_))
    {
      return nullptr;
    }
 
    KeyInfo* key = &info_main_->key;
 
    while (true)
    {
      if (!BlockBoolUtil<MinWriteSize>::ReadFlag(key->available_flag))
      {
        key = GetNextKey(key);
        continue;
      }
 
      if (strcmp(name, GetKeyName(key)) == 0)
      {
        return key;
      }
      if (BlockBoolUtil<MinWriteSize>::ReadFlag(key->no_next_key))
      {
        break;
      }
 
      key = GetNextKey(key);
    }
 
    return nullptr;
  }

◆ 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 882 of file database.hpp.

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

◆ SetKey()

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 632 of file database.hpp.

  {
    if (KeyInfo* key = SearchKey(name))
    {
      if (key->dataSize == size)
      {
        if (memcmp(GetKeyData(key), data, size) != 0)
        {
          if (AvailableSize() <
              AlignSize(size) + AlignSize(sizeof(KeyInfo)) + AlignSize(key->nameLength))
          {
            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.nameLength = key->nameLength;
          new_key.dataSize = size;
          Write(reinterpret_cast<uint8_t*>(key) -
                    reinterpret_cast<uint8_t*>(flash_.flash_area_.addr_),
                new_key);
          return AddKey(GetKeyName(key), 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 822 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 706 of file database.hpp.

◆ CHECKSUM_BYTE

template<size_t MinWriteSize>

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

staticconstexprprivate

校验字节 (Checksum byte).

Definition at line 701 of file database.hpp.

◆ flash_

template<size_t MinWriteSize>

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

private

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

Definition at line 703 of file database.hpp.

◆ FLASH_HEADER

template<size_t MinWriteSize>

constexpr uint32_t LibXR::DatabaseRaw< MinWriteSize >::FLASH_HEADER

staticconstexprprivate

Initial value:

=

0x12345678 + LIBXR_DATABASE_VERSION

Flash 头部标识 (Flash header identifier).

Definition at line 699 of file database.hpp.

◆ info_backup_

template<size_t MinWriteSize>

FlashInfo* LibXR::DatabaseRaw< MinWriteSize >::info_backup_

private

备份存储区信息 (Backup storage block information).

Definition at line 705 of file database.hpp.

◆ info_main_

template<size_t MinWriteSize>

FlashInfo* LibXR::DatabaseRaw< MinWriteSize >::info_main_

private

主存储区信息 (Main storage block information).

Definition at line 704 of file database.hpp.

◆ KeyInfo

template<size_t MinWriteSize>

LibXR::DatabaseRaw< MinWriteSize >::KeyInfo

private

Definition at line 518 of file database.hpp.

◆ write_buffer_

template<size_t MinWriteSize>

uint8_t* LibXR::DatabaseRaw< MinWriteSize >::write_buffer_

private

写入缓冲区 (Write buffer).

Definition at line 707 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 Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ DatabaseRaw()

Member Function Documentation

◆ __attribute__() [1/2]

◆ __attribute__() [2/2]

◆ Add()

◆ AddKey()

◆ AlignSize()

◆ AvailableSize()

◆ Get()

◆ GetKeyData()

◆ GetKeyName()

◆ GetKeySize()

◆ GetLastKey()

◆ GetNextKey()

◆ Init()

◆ InitBlock()

◆ IsBlockEmpty()

◆ IsBlockError()

◆ IsBlockInited()

◆ Recycle()

◆ Restore()

◆ SearchKey()

◆ Set()

◆ SetKey()

◆ Write()

Field Documentation

◆ block_size_

◆ CHECKSUM_BYTE

◆ flash_

◆ FLASH_HEADER

◆ info_backup_

◆ info_main_

◆ KeyInfo

◆ write_buffer_

◆ attribute() [1/2]

◆ attribute() [2/2]