mdl_export_io_internal.h

Go to the documentation of this file.

#pragma once
 
#include <stddef.h>
#include <stdint.h>
 
#include "mdl_export.h"
#include "mdl_storage.h"
#include "miniz.h"
#include "ra8_attributes.h"
#include "ra8_err.h"

typedef struct {
  mdl_storage_t* storage; 
  fw_fs_file_t   file;    
  uint64_t       size;    
  uint64_t       offset;  
  uint64_t       hash;    
  uint32_t       calls;   
  ra8_err_t      error;   
} mdl_export_source_t;

typedef struct {
  mdl_storage_txn_t writer; 
  mdl_format_t      format; 
  uint64_t          offset; 
  uint64_t          extent; 
  ra8_err_t         error;  
} mdl_export_output_t;

typedef ra8_err_t (*mdl_export_sink_fn_t)(void* ctx, const uint8_t* bytes, uint32_t length);

RA8_PRIV ra8_err_t priv_mdl_export_output_begin(mdl_export_output_t* output,
                                                mdl_storage_t*       storage,
                                                const char*          destination,
                                                mdl_format_t         format);

RA8_PRIV ra8_err_t priv_mdl_export_output_begin_new(mdl_export_output_t* output,
                                                    mdl_storage_t*       storage,
                                                    const char*          destination,
                                                    mdl_format_t         format);

RA8_PRIV ra8_err_t priv_mdl_export_output_write(mdl_export_output_t* output,
                                                const uint8_t*       bytes,
                                                uint32_t             length);

RA8_PRIV ra8_err_t priv_mdl_export_output_write_at(void*          opaque,
                                                   uint64_t       offset,
                                                   const uint8_t* bytes,
                                                   uint32_t       length,
                                                   uint32_t*      out_written);

RA8_PRIV size_t priv_mdl_export_zip_write(void*       opaque,
                                          mz_uint64   file_offset,
                                          const void* bytes,
                                          size_t      length);

RA8_PRIV ra8_err_t priv_mdl_export_output_commit(mdl_export_output_t*    output,
                                                 mdl_export_workspace_t* workspace,
                                                 bool*                   out_published);

RA8_PRIV ra8_err_t priv_mdl_export_output_abort(mdl_export_output_t* output);

RA8_PRIV ra8_err_t priv_mdl_export_source_open(mdl_export_source_t* source,
                                               mdl_storage_t*       storage,
                                               const char*          path);

RA8_PRIV ra8_err_t priv_mdl_export_source_close(mdl_export_source_t* source);

RA8_PRIV size_t priv_mdl_export_zip_read(void*     opaque,
                                         mz_uint64 file_offset,
                                         void*     destination,
                                         size_t    capacity);

RA8_PRIV ra8_err_t priv_mdl_export_source_verify_close(mdl_export_source_t* source);

RA8_PRIV ra8_err_t priv_mdl_export_zip_add_file(mz_zip_archive* zip,
                                                mdl_storage_t*  storage,
                                                const char*     member,
                                                const char*     path,
                                                mz_uint         flags);

RA8_PRIV ra8_err_t priv_mdl_export_zip_add_memory(mz_zip_archive* zip,
                                                  const char*     member,
                                                  const uint8_t*  bytes,
                                                  size_t          length,
                                                  mz_uint         flags);

RA8_PRIV ra8_err_t priv_mdl_export_source_copy(mdl_export_source_t* source,
                                               mdl_export_sink_fn_t sink,
                                               void*                sink_ctx);

RA8_PRIV ra8_err_t priv_mdl_export_source_slurp(mdl_storage_t* storage,
                                                const char*    path,
                                                uint8_t*       destination,
                                                size_t         capacity,
                                                size_t*        out_length);

RA8_PRIV ra8_err_t priv_mdl_export_path_join(char*       out,
                                             size_t      capacity,
                                             const char* directory,
                                             const char* leaf);