layout.hpp

 
  enum class BlockType : uint8_t
  {
    MAIN = 0,   
    BACKUP = 1  
  };
 
LIBXR_PACKED_BEGIN
  template <size_t BlockSize>
  struct BlockBoolData
  {
    uint8_t data[BlockSize];
  };
LIBXR_PACKED_END
 
  template <size_t BlockSize>
  class BlockBoolUtil
  {
   public:
    static void SetFlag(BlockBoolData<BlockSize>& obj, bool value)
    {
      Memory::FastSet(obj.data, 0xFF, BlockSize);
      if (!value)
      {
        obj.data[BlockSize - 1] &= 0xF0;
      }
    }
 
    static bool ReadFlag(const BlockBoolData<BlockSize>& obj)
    {
      uint8_t last_4bits = obj.data[BlockSize - 1] & 0x0F;
      return last_4bits == 0x0F;
    }
 
    static bool Valid(const BlockBoolData<BlockSize>& obj)
    {
      if (BlockSize == 0)
      {
        return false;
      }
 
      for (size_t i = 0; i < BlockSize - 1; ++i)
      {
        if (obj.data[i] != 0xFF)
        {
          return false;
        }
      }
 
      uint8_t last_byte = obj.data[BlockSize - 1];
      if ((last_byte & 0xF0) != 0xF0)
      {
        return false;
      }
 
      uint8_t last_4bits = last_byte & 0x0F;
      if (!(last_4bits == 0x0F || last_4bits == 0x00))
      {
        return false;
      }
 
      return true;
    }
  };
 
LIBXR_PACKED_BEGIN
  struct KeyInfo
  {
    BlockBoolData<MinWriteSize> no_next_key;     
    BlockBoolData<MinWriteSize> available_flag;  
    BlockBoolData<MinWriteSize> uninit;          
 
    uint32_t raw_info = 0;  
 
    KeyInfo()
    {
      BlockBoolUtil<MinWriteSize>::SetFlag(no_next_key, true);
      BlockBoolUtil<MinWriteSize>::SetFlag(available_flag, true);
      BlockBoolUtil<MinWriteSize>::SetFlag(uninit, true);
    }
 
    void SetNameLength(uint8_t len)
    {
      raw_info = (raw_info & 0x01FFFFFF) | ((len & 0x7F) << 25);
    }
 
    uint8_t GetNameLength() const { return (raw_info >> 25) & 0x7F; }
 
    void SetDataSize(uint32_t size)
    {
      raw_info = (raw_info & 0xFE000000) | (size & 0x01FFFFFF);
    }
 
    uint32_t GetDataSize() const { return raw_info & 0x01FFFFFF; }
  };
LIBXR_PACKED_END
 
LIBXR_PACKED_BEGIN
  struct FlashInfo
  {
    FlashInfo()
    {
      header = 0xFFFFFFFF;
      Memory::FastSet(padding, 0xFF, MinWriteSize);
    }
 
    union
    {
      uint32_t header;  
      uint8_t padding[MinWriteSize];  
    };
    KeyInfo key;  
  };
LIBXR_PACKED_END