this is `Beau.h`. Beau is the name of the Database:

```
#pragma once

#include 
#include 
#include 
#include "BFTL.h"
#include "Beau\_Enum.h"
#if defined(CONFIG\_BEAU\_CACHE)
 #include "Beau\_Cache.h"
#endif

#define BEAU\_DEFAULT\_DB\_NAME "db"

#define BEAU\_KEY\_NONE 0

#pragma pack(push, 1)
typedef struct {
 uint32\_t key\_lo; /\*\*< lower 32-bits of key \*/
 uint32\_t parent\_lo;
 uint32\_t key\_hi; /\*\*< upper 32-bits of key; zero pre-v2.22 \*/
 uint32\_t parent\_hi;
 uint16\_t type;
 uint16\_t data\_len; /\* records limited to < 64kB \*/
 uint32\_t data\_crc;
} beau\_header\_t;
#pragma pack(pop)

/\*\* sentinel to mark valid records \*/
extern const uint32\_t BEAU\_SENTINEL\_LIVE;

/\*\* sentinel to mark deleted records \*/
extern const uint32\_t BEAU\_SENTINEL\_DEAD;

/\*\* marks unused regions of flash \*/
extern const uint32\_t BEAU\_SENTINEL\_EMPTY;

typedef void beau\_list\_t;

void hton\_beau\_header(beau\_header\_t \* header);
#define hton\_beau\_header hton\_beau\_header

typedef void beau\_t;

extern beau\_t \*g\_beau\_db;
extern bool g\_beau\_dont\_create;

#define BEAU\_DEFAULT\_DB\_SIZE 0x400000

#define BEAU\_REC\_MAX\_SIZE 4000 // 96 bytes smaller than ESP32 page size

/\* port-specific public defines \*/

beau\_t \*Beau\_Init(const char \*partition\_name, uint32\_t partition\_default\_size);

void Beau\_Deinit(beau\_t \* b);

/\*\*
 \* find a record and load it to caller buffer
 \* @param key key to search for
 \* @param bh [out] header of discovered (optional)
 \* @param buf buffer to fill with loaded
 \* @param buf\_size size of buffer
 \* @param ntoh function to swap byte order of data structure.
 \* Use this if your data structure contains any multi-byte
 \* types such as uint32\_t or float.
 \* May be NULL, in which case no endianness swap is performed.
 \* @return true if record found
 \* @note It is NOT an error if the buffer is too small,
 \* the output will simply be truncated.
 \* The caller may determine that buffer was
 \* inadequate by comparing buf\_size with bh->data\_len.
 \* If buffer is too large, we will simply only use the beginning.
 \* The buffer will not be initialized to zero.
 \* @note We have an ntoh argument to Beau\_Get/Set so as to enforce the client
 \* to think about endianness. Otherwise we run the risk of having non-portable
 \* data structures stored in the database.
 \*/
bool Beau\_Get(beau\_t \* b,
 uint64\_t key,
 beau\_header\_t \* bh,
 void \*buf, uint32\_t buf\_size, void (\*ntoh)(void \*)
 );

/\*\*
 \* find a record, allocate space for it, and return the buffer
 \* @param key key to search for
 \* @param bh [out] header of discovered (optional)
 \* @param ntoh function to swap byte order of data structure.
 \* Use this if your data structure contains any multi-byte
 \* types such as uint32\_t or float.
 \* May be NULL, in which case no endianness swap is performed.
 \* @return NULL if not found,
 \* otherwise, return buffer of lenth bh->data\_len
 \* @note caller is responsible for freeing return buf with Osal\_Free
 \*/
void \*Beau\_Get\_Alloc(beau\_t \* b,
 uint64\_t key, beau\_header\_t \* bh, void (\*ntoh)(void \*)
 );

/\*\*
 \* write a record to the database (effectively overwriting any existing record)
 \* @param key, parent, type, data\_len [in] header parameters of record to write
 \* @param data [in] buffer of data to write
 \* @param hton function to swap byte order of data structure.
 \* Use this if your data structure contains any multi-byte
 \* types such as uint32\_t or float.
 \* May be NULL, in which case no endianness swap is performed.
 \* @return true if record written successfully
 \* @warning Buffer must not be read or written during Beau\_Set, due to high risk
 \* of reading during endian swap! Make sure to use appropriate mutex
 \* to lock your datastructure!
 \* @note Compaction will occur if required,
 \* and may introduce considerable latency
 \* as the entire database is re-written.
 \*/
bool Beau\_Set(beau\_t \* b,
 uint64\_t key,
 uint64\_t parent,
 uint16\_t type, void \*data, uint32\_t data\_len, void (\*hton)(void \*)
 );

/\*\*
 \* mark a record as deleted
 \* @param key record key to delete
 \* @return true if record found and successfully crossed-out
 \*/
bool Beau\_Delete(beau\_t \* b, uint64\_t key);

/\*\*
 \* lock the database for exclusive access
 \* @note blocks until lock obtained,
 \* which can be a while if compaction is occuring
 \*/
void Beau\_Lock(beau\_t \* b);

/\*\*
 \* release the database mutex
 \*/
void Beau\_Unlock(beau\_t \* b);

/\*\*
 \* start an enumeration of all records of specified type
 \* @param type type to enumerate, or BEAU\_TYPE\_ANY to enumerate all records
 \* @note While multiple (nested) listings can be performed simultaneously,
 \* be sure to lock with Beau\_Lock so that modifications to the
 \* database do not cause missing or duplicate records to be returned.
 \* @note In the future a reader/writer lock could be used here.
 \* @return newly-allocated list object, or NULL if out of memory
 \*/
beau\_list\_t \* Beau\_List\_Start(beau\_t \* b, uint16\_t type);

/\*\*
 \* get next header in enumeration by type
 \* @param list [in] list state from Beau\_List\_Start
 \* This function shall return false if list is NULL.
 \* [out] set to NULL on error, otherwise unmodified
 \* @param bh [out] header found
 \* @return true if bh valid, false if no more records
 \* @note use Beau\_Get to obtain data corresponding to the record
 \*/
bool Beau\_List\_Next(beau\_t \* b, beau\_list\_t \*\* list, beau\_header\_t \* bh);

/\*\*
 \* scan and dump entire database to terminal
 \*/
void Beau\_Print\_Dump(beau\_t \* b);

/\*\*
 \* erase the underlying database partition
 \* @warning: Do NOT use on the BOND ID partition!
 \*/
void Beau\_Factory\_Reset(beau\_t \* b);

/\*\*
 \* get information about geometry of underlying BFTL
 \*/
bftl\_info\_t \*Beau\_Get\_BFTL\_Info(beau\_t \* b);

/\*\*
 \* number of live records
 \*/
int Beau\_Get\_Live\_Records(beau\_t \* b);

/\*\*
 \* register API for specified Beau instance
 \* @param b the beau instance for which to register the debug handler
 \* @param name [optional] if not NULL, overrides the partition name from b
 \*/
bool Beau\_API\_Init(beau\_t \* b, const char \* name);

/\*\*
 \* get number of landmines
 \* @param b
 \* @return count
 \*/
int Beau\_Landmine\_Count(beau\_t \* b);

/\*\*
 \* get the 64-bit key given the beau header
 \* @note Prior to v2.22 where we started storing the upper 32-bits,
 \* we stored 0xFFFFFFFF in the reserved fields now used for key\_hi and
 \* parent\_hi, however, the key/parent had a logical zero in the upper 32-bits.
 \* For this reason, we map \*\_hi==0xFFFFFFFF to zero.
 \* @param bh [description]
 \* @return [description]
 \*/
uint64\_t Beau\_Key\_Get(beau\_header\_t \* bh);
void Beau\_Key\_Set(beau\_header\_t \* bh, uint64\_t key);
uint64\_t Beau\_Parent\_Get(beau\_header\_t \* bh);
void Beau\_Parent\_Set(beau\_header\_t \* bh, uint64\_t parent);
```
이것은 `Beau.h`입니다. Beau는 데이터베이스의 이름입니다:```#프라그마 한 번#포함 #포함 #포함 #include "BFTL.h"#include "Beau\_Enum.h"#if defined(CONFIG\_BEAU\_CACHE) #include "Beau\_Cache.h"#endif#define BEAU\_DEFAULT\_DB\_NAME "db"#define BEAU\_KEY\_NONE 0#프라그마 팩(푸시, 1)typedef 구조체 { uint32\_t key\_lo; /\*\*< 키의 하위 32비트 \*/ uint32\_t parent\_lo; uint32\_t key\_hi; /\*\*< 키의 상위 32비트; v2.22 이전은 0 \*/ uint32\_t parent\_hi; uint16\_t type; uint16\_t data\_len; /\* 레코드는 64KB 이하로 제한 \*/ uint32\_t data\_crc;} beau\_header\_t;#프라그마 팩(팝)/\*\* 유효한 레코드를 표시하는 센티넬 \*/외부 const uint32\_t BEAU\_SENTINEL\_LIVE;/\*\* 삭제된 레코드를 표시하는 센티넬 \*/외부 const uint32\_t BEAU\_SENTINEL\_DEAD;/\*\* 사용하지 않는 플래시 영역을 표시 \*/외부 const uint32\_t BEAU\_SENTINEL\_EMPTY;TYPEEDEF VOID BEAU\_LIST\_T;VOID HTON\_BEU\_헤더(BEU\_헤더\_t \* 헤더);#정의 HTON\_BEU\_헤더 HTON\_BEU\_헤더TYPEEDEF VOID BEau\_t;EXTERN BEAU\_T \*G\_BEU\_DB;EXTERN BULL G\_BEU\_DONT\_CREATE;#define BEAU\_DEFAULT\_DB\_SIZE 0x400000#define BEAU\_REC\_MAX\_SIZE 4000 // ESP32 페이지 크기보다 96바이트 작음/\* 포트별 공용 정의 \*//beau\_t \*Beau\_Init(const char \*partition\_name, uint32\_t partition\_default\_size);void Beau\_Deinit(beau\_t \* b);/\*\* \* 레코드를 찾아서 호출자 버퍼에 로드합니다. \* @param 키 검색할 키 \* @param bh [out] 검색된 헤더 (선택 사항) 로드된 것으로 채울 \* @param buf 버퍼 \* @param buf\_size 버퍼 크기 \* 데이터 구조의 바이트 순서를 바꾸는 @param ntoh 함수. \* 데이터 구조에 다중 바이트가 포함된 경우 이 함수를 사용합니다. \* uint32\_t 또는 float와 같은 다중 바이트 유형을 포함하는 경우에 사용합니다. 엔디안 스왑이 수행되지 않는 경우 \* NULL일 수 있습니다. \* @레코드가 발견되면 참을 반환합니다. \* @주 버퍼가 너무 작아도 에러가 아닙니다, \* 단순히 출력이 잘립니다. \* 호출자는 버퍼가 부적절하다고 판단할 수 있습니다. \* 부적절하다고 판단할 수 있습니다. \* 버퍼가 너무 크면, 단순히 처음 부분만 사용합니다. \* 버퍼가 0으로 초기화되지 않습니다. \* @note 클라이언트가 엔디안을 고려하도록 하기 위해 Beau\_Get/Set에 ntoh 인수가 있습니다. \* 엔디안을 고려하도록 강제합니다. 그렇지 않으면 데이터베이스에 이식 불가능한 \* 데이터 구조가 데이터베이스에 저장될 위험이 있습니다. \*/bool Beau\_Get(beau\_t \* b, uint64\_t 키, beau\_header\_t \* bh, void \*buf, uint32\_t buf\_size, void (\*ntoh)(void \*) );/\*\* \* 레코드를 찾아서 공간을 할당하고 버퍼를 반환합니다. \* @param 키 검색할 키 \* @param bh [out] 발견된 헤더 (선택 사항) 데이터 구조의 바이트 순서를 바꾸는 \* @param ntoh 함수. \* 데이터 구조에 다중 바이트가 포함된 경우 이 함수를 사용합니다. \* uint32\_t 또는 float와 같은 다중 바이트 유형을 포함하는 경우에 사용합니다. 엔디안 스왑이 수행되지 않는 경우 \* NULL일 수 있습니다. \* @찾지 못하면 NULL을 반환합니다, \* 그렇지 않으면, 렌트의 버퍼를 반환합니다 bh->데이터\_len \* @노트 호출자는 Osal\_Free로 반환 버퍼를 해제할 책임이 있습니다. \*/void \*Beau\_Get\_Alloc(beau\_t \* b, uint64\_t 키, beau\_header\_t \* bh, void (\*ntoh)(void \*) );/\*\* \* 데이터베이스에 레코드 쓰기(기존 레코드를 효과적으로 덮어쓰기) \* @param 키, 부모, 타입, 데이터\_len [in] 쓸 레코드의 헤더 매개변수 \* @param 데이터 [in] 쓰기할 데이터 버퍼 \* 데이터 구조의 바이트 순서를 바꾸는 함수입니다. \* 데이터 구조에 다중 바이트가 포함된 경우 이 함수를 사용합니다. \* uint32\_t 또는 float와 같은 다중 바이트 유형을 포함하는 경우에 사용합니다. 엔디안 스왑이 수행되지 않는 경우 \* NULL일 수 있습니다. \* @기록이 성공적으로 쓰여지면 참을 반환합니다. \* @경고 Beau\_Set 동안에는 높은 위험으로 인해 버퍼를 읽거나 쓰지 않아야 합니다. \* 엔디안 스왑 중 읽기의 위험이 높으므로 버퍼를 읽거나 써서는 안 됩니다! 적절한 뮤텍스 \* 를 사용하여 데이터 구조를 잠그세요! \* @주 필요 시 압축이 발생합니다, \* 전체 데이터베이스가 재구성되므로 상당한 지연 시간이 발생할 수 있습니다. \* 전체 데이터베이스가 다시 작성되므로 상당한 지연 시간이 발생할 수 있습니다. \*/bool Beau\_Set(beau\_t \* b, uint64\_t 키, uint64\_t parent, uint16\_t type, void \*data, uint32\_t data\_len, void (\*hton)(void \*) );/\*\* \* 레코드를 삭제된 것으로 표시 \* @param 키 삭제할 레코드 키 \* @레코드가 발견되어 성공적으로 지워지면 참을 반환합니다. \*/bool Beau\_Delete(beau\_t \* b, uint64\_t key);/\*\* \* 독점 액세스를 위해 데이터베이스를 잠급니다. \* @잠금을 얻을 때까지 블록합니다, \* 압축이 발생하면 시간이 걸릴 수 있습니다. \*/void Beau\_Lock(beau\_t \* b);/\*\* \* 데이터베이스 뮤텍스 해제 \*/void Beau\_Unlock(beau\_t \* b);/\*\* \* 지정된 유형의 모든 레코드 열거를 시작합니다. \* @param 유형 열거할 유형, 또는 모든 레코드를 열거하려면 BEAU\_TYPE\_ANY를 입력합니다. \* @주 여러 (중첩된) 목록을 동시에 수행할 수 있습니다, \* 데이터베이스에 대한 수정으로 인해 누락 또는 오류가 발생하지 않도록 \* 데이터베이스 수정으로 인해 누락되거나 중복된 레코드가 반환되지 않도록 해야 합니다. \* @주 향후에는 여기에 읽기/쓰기 잠금을 사용할 수 있습니다. \* 새로 할당된 목록 객체를 반환하거나 NU