example_file.c

/**
 * @file example_file.c
 * @brief Example demonstrating file I/O with binary serialization
 */

#include "binserde.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* Example data structure */
typedef struct {
    int32_t id;
    char name[64];
    double balance;
    bool active;
} Account;

int main(void) {
    printf("=== Binary Serialization File I/O Example ===\n\n");
    
    /* Sample data */
    Account account = {
        .id = 12345,
        .balance = 9876.54,
        .active = true
    };
    strncpy(account.name, "John Doe", sizeof(account.name) - 1);
    account.name[sizeof(account.name) - 1] = '\0';
    
    printf("Original data:\n");
    printf("  ID: %d\n", account.id);
    printf("  Name: %s\n", account.name);
    printf("  Balance: %.2f\n", account.balance);
    printf("  Active: %s\n\n", account.active ? "true" : "false");
    
    /* Serialize to buffer */
    uint8_t buffer[1024];
    binserde_writer_t writer;
    binserde_error_t err;
    
    err = binserde_writer_init(&writer, buffer, sizeof(buffer), 1);
    if (err != BINSERDE_OK) {
        fprintf(stderr, "Writer init failed: %s\n", binserde_error_string(err));
        return 1;
    }
    
    /* Write header */
    err = binserde_write_header(&writer);
    if (err != BINSERDE_OK) {
        fprintf(stderr, "Write header failed: %s\n", binserde_error_string(err));
        return 1;
    }
    
    /* Write account data */
    err = binserde_write_int32(&writer, account.id);
    if (err != BINSERDE_OK) {
        fprintf(stderr, "Write ID failed: %s\n", binserde_error_string(err));
        return 1;
    }
    
    err = binserde_write_string(&writer, account.name);
    if (err != BINSERDE_OK) {
        fprintf(stderr, "Write name failed: %s\n", binserde_error_string(err));
        return 1;
    }
    
    err = binserde_write_double(&writer, account.balance);
    if (err != BINSERDE_OK) {
        fprintf(stderr, "Write balance failed: %s\n", binserde_error_string(err));
        return 1;
    }
    
    err = binserde_write_bool(&writer, account.active);
    if (err != BINSERDE_OK) {
        fprintf(stderr, "Write active failed: %s\n", binserde_error_string(err));
        return 1;
    }
    
    /* Write checksum */
    err = binserde_write_checksum(&writer);
    if (err != BINSERDE_OK) {
        fprintf(stderr, "Write checksum failed: %s\n", binserde_error_string(err));
        return 1;
    }
    
    size_t data_size = binserde_writer_position(&writer);
    printf("Serialized %zu bytes\n\n", data_size);
    
    /* Write to file */
    const char *filename = "account.bin";
    err = binserde_write_file(filename, buffer, data_size);
    if (err != BINSERDE_OK) {
        fprintf(stderr, "Write file failed: %s\n", binserde_error_string(err));
        return 1;
    }
    printf("Written to file: %s\n\n", filename);
    
    /* Read from file */
    uint8_t *read_buffer = NULL;
    size_t read_size = 0;
    err = binserde_read_file(filename, &read_buffer, &read_size);
    if (err != BINSERDE_OK) {
        fprintf(stderr, "Read file failed: %s\n", binserde_error_string(err));
        return 1;
    }
    printf("Read %zu bytes from file\n\n", read_size);
    
    /* Deserialize */
    binserde_reader_t reader;
    err = binserde_reader_init(&reader, read_buffer, read_size);
    if (err != BINSERDE_OK) {
        fprintf(stderr, "Reader init failed: %s\n", binserde_error_string(err));
        free(read_buffer);
        return 1;
    }
    
    /* Read header */
    uint32_t version;
    err = binserde_read_header(&reader, &version);
    if (err != BINSERDE_OK) {
        fprintf(stderr, "Read header failed: %s\n", binserde_error_string(err));
        free(read_buffer);
        return 1;
    }
    printf("Schema version: %u\n\n", version);
    
    /* Read account data */
    Account deserialized = {0};
    
    err = binserde_read_int32(&reader, &deserialized.id);
    if (err != BINSERDE_OK) {
        fprintf(stderr, "Read ID failed: %s\n", binserde_error_string(err));
        free(read_buffer);
        return 1;
    }
    
    char *name_ptr = NULL;
    err = binserde_read_string(&reader, &name_ptr);
    if (err != BINSERDE_OK) {
        fprintf(stderr, "Read name failed: %s\n", binserde_error_string(err));
        free(read_buffer);
        return 1;
    }
    strncpy(deserialized.name, name_ptr, sizeof(deserialized.name) - 1);
    deserialized.name[sizeof(deserialized.name) - 1] = '\0';
    free(name_ptr);
    
    err = binserde_read_double(&reader, &deserialized.balance);
    if (err != BINSERDE_OK) {
        fprintf(stderr, "Read balance failed: %s\n", binserde_error_string(err));
        free(read_buffer);
        return 1;
    }
    
    err = binserde_read_bool(&reader, &deserialized.active);
    if (err != BINSERDE_OK) {
        fprintf(stderr, "Read active failed: %s\n", binserde_error_string(err));
        free(read_buffer);
        return 1;
    }
    
    /* Validate checksum */
    err = binserde_validate_checksum(&reader);
    if (err != BINSERDE_OK) {
        fprintf(stderr, "Checksum validation failed: %s\n", binserde_error_string(err));
        free(read_buffer);
        return 1;
    }
    printf("Checksum validated successfully\n\n");
    
    /* Display deserialized data */
    printf("Deserialized data:\n");
    printf("  ID: %d\n", deserialized.id);
    printf("  Name: %s\n", deserialized.name);
    printf("  Balance: %.2f\n", deserialized.balance);
    printf("  Active: %s\n\n", deserialized.active ? "true" : "false");
    
    /* Verify data integrity */
    if (deserialized.id == account.id &&
        strcmp(deserialized.name, account.name) == 0 &&
        deserialized.balance == account.balance &&
        deserialized.active == account.active) {
        printf("✓ Data integrity verified!\n");
    } else {
        printf("✗ Data mismatch!\n");
    }
    
    free(read_buffer);
    return 0;
}