BLO_read_write.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
#pragma once
 
#include "DNA_sdna_type_ids.hh"
#include "DNA_windowmanager_types.h" /* for eReportType */
 
#include "BLI_function_ref.hh"
#include "BLI_implicit_sharing.hh"
#include "BLI_memory_utils.hh"
 
namespace blender {
class ImplicitSharingInfo;
}
struct BlendDataReader;
struct BlendFileReadReport;
struct BlendLibReader;
struct BlendWriter;
struct Main;
 
/* -------------------------------------------------------------------- */

int BLO_get_struct_id_by_name(const BlendWriter *writer, const char *struct_name);

void BLO_write_struct_by_name(BlendWriter *writer, const char *struct_name, const void *data_ptr);
void BLO_write_struct_by_id(BlendWriter *writer, int struct_id, const void *data_ptr);
#define BLO_write_struct(writer, struct_name, data_ptr) \
  BLO_write_struct_by_id(writer, blender::dna::sdna_struct_id_get<struct_name>(), data_ptr)

void BLO_write_struct_at_address_by_id(BlendWriter *writer,
                                       int struct_id,
                                       const void *address,
                                       const void *data_ptr);
#define BLO_write_struct_at_address(writer, struct_name, address, data_ptr) \
  BLO_write_struct_at_address_by_id( \
      writer, blender::dna::sdna_struct_id_get<struct_name>(), address, data_ptr)

void BLO_write_struct_at_address_by_id_with_filecode(
    BlendWriter *writer, int filecode, int struct_id, const void *address, const void *data_ptr);
#define BLO_write_struct_at_address_with_filecode( \
    writer, filecode, struct_name, address, data_ptr) \
  BLO_write_struct_at_address_by_id_with_filecode( \
      writer, filecode, blender::dna::sdna_struct_id_get<struct_name>(), address, data_ptr)

void BLO_write_struct_array_by_name(BlendWriter *writer,
                                    const char *struct_name,
                                    int64_t array_size,
                                    const void *data_ptr);
void BLO_write_struct_array_by_id(BlendWriter *writer,
                                  int struct_id,
                                  int64_t array_size,
                                  const void *data_ptr);
#define BLO_write_struct_array(writer, struct_name, array_size, data_ptr) \
  BLO_write_struct_array_by_id( \
      writer, blender::dna::sdna_struct_id_get<struct_name>(), array_size, data_ptr)

void BLO_write_struct_array_at_address_by_id(BlendWriter *writer,
                                             int struct_id,
                                             int64_t array_size,
                                             const void *address,
                                             const void *data_ptr);
#define BLO_write_struct_array_at_address(writer, struct_name, array_size, address, data_ptr) \
  BLO_write_struct_array_at_address_by_id( \
      writer, blender::dna::sdna_struct_id_get<struct_name>(), array_size, address, data_ptr)

void BLO_write_struct_list_by_name(BlendWriter *writer, const char *struct_name, ListBase *list);
void BLO_write_struct_list_by_id(BlendWriter *writer, int struct_id, const ListBase *list);
#define BLO_write_struct_list(writer, struct_name, list_ptr) \
  BLO_write_struct_list_by_id(writer, blender::dna::sdna_struct_id_get<struct_name>(), list_ptr)

void blo_write_id_struct(BlendWriter *writer, int struct_id, const void *id_address, const ID *id);
#define BLO_write_id_struct(writer, struct_name, id_address, id) \
  blo_write_id_struct(writer, blender::dna::sdna_struct_id_get<struct_name>(), id_address, id)

struct BLO_Write_IDBuffer {
 private:
  static constexpr int static_size = 8192;
  blender::DynamicStackBuffer<static_size> buffer_;
 
 public:
  BLO_Write_IDBuffer(ID &id, bool is_undo, bool is_placeholder);
  BLO_Write_IDBuffer(ID &id, BlendWriter *writer);
 
  ID *get()
  {
    return static_cast<ID *>(buffer_.buffer());
  };
};

void BLO_write_raw(BlendWriter *writer, size_t size_in_bytes, const void *data_ptr);
void BLO_write_char_array(BlendWriter *writer, int64_t num, const char *data_ptr);
void BLO_write_int8_array(BlendWriter *writer, int64_t num, const int8_t *data_ptr);
void BLO_write_int16_array(BlendWriter *writer, int64_t num, const int16_t *data_ptr);
void BLO_write_uint8_array(BlendWriter *writer, int64_t num, const uint8_t *data_ptr);
void BLO_write_int32_array(BlendWriter *writer, int64_t num, const int32_t *data_ptr);
void BLO_write_uint32_array(BlendWriter *writer, int64_t num, const uint32_t *data_ptr);
void BLO_write_float_array(BlendWriter *writer, int64_t num, const float *data_ptr);
void BLO_write_double_array(BlendWriter *writer, int64_t num, const double *data_ptr);
void BLO_write_float3_array(BlendWriter *writer, int64_t num, const float *data_ptr);
void BLO_write_pointer_array(BlendWriter *writer, int64_t num, const void *data_ptr);
void BLO_write_string(BlendWriter *writer, const char *data_ptr);
 
/* Misc. */

void BLO_write_shared(BlendWriter *writer,
                      const void *data,
                      size_t approximate_size_in_bytes,
                      const blender::ImplicitSharingInfo *sharing_info,
                      blender::FunctionRef<void()> write_fn);

bool BLO_write_is_undo(BlendWriter *writer);

 
/* -------------------------------------------------------------------- */
 
void *BLO_read_get_new_data_address(BlendDataReader *reader, const void *old_address);
#define BLO_read_data_address(reader, ptr_p) \
  *((void **)ptr_p) = BLO_read_get_new_data_address((reader), *(ptr_p))

void *BLO_read_get_new_data_address_no_us(BlendDataReader *reader,
                                          const void *old_address,
                                          size_t expected_size);

void *BLO_read_struct_array_with_size(BlendDataReader *reader,
                                      const void *old_address,
                                      size_t expected_size);
#define BLO_read_struct(reader, struct_name, ptr_p) \
  *((void **)ptr_p) = BLO_read_struct_array_with_size( \
      reader, *((void **)ptr_p), sizeof(struct_name))
#define BLO_read_struct_array(reader, struct_name, array_size, ptr_p) \
  *((void **)ptr_p) = BLO_read_struct_array_with_size( \
      reader, *((void **)ptr_p), sizeof(struct_name) * (array_size))

void *BLO_read_struct_by_name_array(BlendDataReader *reader,
                                    const char *struct_name,
                                    int64_t items_num,
                                    const void *old_address);
 
/* Read all elements in list
 *
 * Updates all `->prev` and `->next` pointers of the list elements.
 * Updates the `list->first` and `list->last` pointers.
 */
void BLO_read_struct_list_with_size(BlendDataReader *reader,
                                    size_t expected_elem_size,
                                    ListBase *list);
 
#define BLO_read_struct_list(reader, struct_name, list) \
  BLO_read_struct_list_with_size(reader, sizeof(struct_name), list)
 
/* Update data pointers and correct byte-order if necessary. */
 
void BLO_read_char_array(BlendDataReader *reader, int64_t array_size, char **ptr_p);
void BLO_read_int8_array(BlendDataReader *reader, int64_t array_size, int8_t **ptr_p);
void BLO_read_uint8_array(BlendDataReader *reader, int64_t array_size, uint8_t **ptr_p);
void BLO_read_int16_array(BlendDataReader *reader, const int64_t array_size, int16_t **ptr_p);
void BLO_read_int32_array(BlendDataReader *reader, int64_t array_size, int32_t **ptr_p);
void BLO_read_uint32_array(BlendDataReader *reader, int64_t array_size, uint32_t **ptr_p);
void BLO_read_float_array(BlendDataReader *reader, int64_t array_size, float **ptr_p);
void BLO_read_float3_array(BlendDataReader *reader, int64_t array_size, float **ptr_p);
void BLO_read_double_array(BlendDataReader *reader, int64_t array_size, double **ptr_p);
void BLO_read_pointer_array(BlendDataReader *reader, int64_t array_size, void **ptr_p);
 
/* Read null terminated string. */
 
void BLO_read_string(BlendDataReader *reader, char **ptr_p);
void BLO_read_string(BlendDataReader *reader, char *const *ptr_p);
void BLO_read_string(BlendDataReader *reader, const char **ptr_p);
 
/* Misc. */
 
blender::ImplicitSharingInfoAndData blo_read_shared_impl(
    BlendDataReader *reader,
    const void **ptr_p,
    blender::FunctionRef<const blender::ImplicitSharingInfo *()> read_fn);

template<typename T>
const blender::ImplicitSharingInfo *BLO_read_shared(
    BlendDataReader *reader,
    T **data_ptr,
    blender::FunctionRef<const blender::ImplicitSharingInfo *()> read_fn)
{
  blender::ImplicitSharingInfoAndData shared_data = blo_read_shared_impl(
      reader, (const void **)data_ptr, read_fn);
  /* Need const-cast here, because not all DNA members that reference potentially shared data are
   * const yet. */
  *data_ptr = const_cast<T *>(static_cast<const T *>(shared_data.data));
  return shared_data.sharing_info;
}
 
int BLO_read_fileversion_get(BlendDataReader *reader);
bool BLO_read_requires_endian_switch(BlendDataReader *reader);
bool BLO_read_data_is_undo(BlendDataReader *reader);
void BLO_read_data_globmap_add(BlendDataReader *reader, void *oldaddr, void *newaddr);
void BLO_read_glob_list(BlendDataReader *reader, ListBase *list);
BlendFileReadReport *BLO_read_data_reports(BlendDataReader *reader);
struct Library *BLO_read_data_current_library(BlendDataReader *reader);
 
int BLO_read_struct_member_offset(const BlendDataReader *reader,
                                  const char *stype,
                                  const char *vartype,
                                  const char *name);

 
/* -------------------------------------------------------------------- */

ID *BLO_read_get_new_id_address(BlendLibReader *reader,
                                ID *self_id,
                                const bool is_linked_only,
                                ID *id) ATTR_NONNULL(2);

ID *BLO_read_get_new_id_address_from_session_uid(BlendLibReader *reader, uint session_uid)
    ATTR_NONNULL(1);
 
/* Misc. */
 
bool BLO_read_lib_is_undo(BlendLibReader *reader);
Main *BLO_read_lib_get_main(BlendLibReader *reader);
BlendFileReadReport *BLO_read_lib_reports(BlendLibReader *reader);

 
/* -------------------------------------------------------------------- */

void BLO_reportf_wrap(BlendFileReadReport *reports, eReportType type, const char *format, ...)
    ATTR_PRINTF_FORMAT(3, 4);