BKE_lib_query.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2014 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
#pragma once

 
#include "DNA_ID.h"
 
#include "BLI_function_ref.hh"
 
#include <array>
 
struct IDTypeInfo;
struct LibraryForeachIDData;
struct Main;
 
/* Tips for the callback for cases it's gonna to modify the pointer. */
enum LibraryForeachIDCallbackFlag {
  IDWALK_CB_NOP = 0,
  IDWALK_CB_NEVER_NULL = (1 << 0),
  IDWALK_CB_NEVER_SELF = (1 << 1),

  IDWALK_CB_INDIRECT_USAGE = (1 << 2),
  IDWALK_CB_DIRECT_WEAK_LINK = (1 << 3),

  IDWALK_CB_EMBEDDED = (1 << 4),
  IDWALK_CB_EMBEDDED_NOT_OWNING = (1 << 5),

  IDWALK_CB_LOOPBACK = (1 << 6),

  IDWALK_CB_INTERNAL = (1 << 9),

  IDWALK_CB_READFILE_IGNORE = (1 << 10),

  IDWALK_CB_USER = (1 << 11),
  IDWALK_CB_USER_ONE = (1 << 12),

  IDWALK_CB_OVERRIDE_LIBRARY_REFERENCE = (1 << 16),

  IDWALK_CB_OVERRIDE_LIBRARY_NOT_OVERRIDABLE = (1 << 17),

  IDWALK_CB_OVERRIDE_LIBRARY_HIERARCHY_DEFAULT = (1 << 18),
 
};
ENUM_OPERATORS(LibraryForeachIDCallbackFlag, IDWALK_CB_OVERRIDE_LIBRARY_HIERARCHY_DEFAULT);
 
enum {
  IDWALK_RET_NOP = 0,
  IDWALK_RET_STOP_ITER = 1 << 0,
  IDWALK_RET_STOP_RECURSION = 1 << 1,
};
 
struct LibraryIDLinkCallbackData {
  void *user_data;
  Main *bmain;
  ID *owner_id;
  ID *self_id;
  ID **id_pointer;
  LibraryForeachIDCallbackFlag cb_flag;
};

using LibraryIDLinkCallback = int(LibraryIDLinkCallbackData *cb_data);
 
/* Flags for the foreach function itself. */
enum LibraryForeachIDFlag {
  IDWALK_NOP = 0,
  IDWALK_READONLY = (1 << 0),
  IDWALK_RECURSE = (1 << 1),
  IDWALK_INCLUDE_UI = (1 << 2),
  IDWALK_IGNORE_EMBEDDED_ID = (1 << 3),

  IDWALK_NO_ORIG_POINTERS_ACCESS = (1 << 5),
  IDWALK_IGNORE_MISSING_OWNER_ID = (1 << 6),

  IDWALK_DO_INTERNAL_RUNTIME_POINTERS = (1 << 9),
  IDWALK_DO_LIBRARY_POINTER = (1 << 10),
  IDWALK_DO_DEPRECATED_POINTERS = (1 << 11),
};
ENUM_OPERATORS(LibraryForeachIDFlag, IDWALK_DO_DEPRECATED_POINTERS);

bool BKE_lib_query_foreachid_iter_stop(const LibraryForeachIDData *data);
void BKE_lib_query_foreachid_process(LibraryForeachIDData *data,
                                     ID **id_pp,
                                     LibraryForeachIDCallbackFlag cb_flag);
LibraryForeachIDFlag BKE_lib_query_foreachid_process_flags_get(const LibraryForeachIDData *data);
Main *BKE_lib_query_foreachid_process_main_get(const LibraryForeachIDData *data);
int BKE_lib_query_foreachid_process_callback_flag_override(LibraryForeachIDData *data,
                                                           LibraryForeachIDCallbackFlag cb_flag,
                                                           bool do_replace);

#define BKE_LIB_FOREACHID_PROCESS_ID_NOCHECK(data_, id_, cb_flag_) \
  { \
    BKE_lib_query_foreachid_process((data_), (ID **)&(id_), (cb_flag_)); \
    if (BKE_lib_query_foreachid_iter_stop((data_))) { \
      return; \
    } \
  } \
  ((void)0)
 
#define BKE_LIB_FOREACHID_PROCESS_ID(data_, id_, cb_flag_) \
  { \
    CHECK_TYPE_ANY((id_), ID *, void *); \
    BKE_LIB_FOREACHID_PROCESS_ID_NOCHECK(data_, id_, cb_flag_); \
  } \
  ((void)0)
 
#define BKE_LIB_FOREACHID_PROCESS_IDSUPER_P(data_, id_super_p_, cb_flag_) \
  { \
    CHECK_TYPE(&((*(id_super_p_))->id), ID *); \
    BKE_lib_query_foreachid_process((data_), (ID **)(id_super_p_), (cb_flag_)); \
    if (BKE_lib_query_foreachid_iter_stop((data_))) { \
      return; \
    } \
  } \
  ((void)0)
 
#define BKE_LIB_FOREACHID_PROCESS_IDSUPER(data_, id_super_, cb_flag_) \
  { \
    BKE_LIB_FOREACHID_PROCESS_IDSUPER_P(data_, &(id_super_), cb_flag_); \
  } \
  ((void)0)
 
#define BKE_LIB_FOREACHID_PROCESS_FUNCTION_CALL(data_, func_call_) \
  { \
    func_call_; \
    if (BKE_lib_query_foreachid_iter_stop((data_))) { \
      return; \
    } \
  } \
  ((void)0)

void BKE_library_foreach_ID_embedded(LibraryForeachIDData *data, ID **id_pp);
void BKE_lib_query_idpropertiesForeachIDLink_callback(IDProperty *id_prop, void *user_data);

void BKE_library_foreach_ID_link(Main *bmain,
                                 ID *id,
                                 blender::FunctionRef<LibraryIDLinkCallback> callback,
                                 void *user_data,
                                 LibraryForeachIDFlag flag);

void BKE_library_foreach_subdata_id(
    Main *bmain,
    ID *owner_id,
    ID *self_id,
    blender::FunctionRef<void(LibraryForeachIDData *data)> subdata_foreach_id,
    blender::FunctionRef<LibraryIDLinkCallback> callback,
    void *user_data,
    const LibraryForeachIDFlag flag);

void BKE_library_update_ID_link_user(ID *id_dst, ID *id_src, int cb_flag);

int BKE_library_ID_use_ID(ID *id_user, ID *id_used);

bool BKE_library_id_can_use_idtype(ID *owner_id, short id_type_used);

uint64_t BKE_library_id_can_use_filter_id(const ID *owner_id,
                                          const bool include_ui,
                                          const IDTypeInfo *owner_id_type = nullptr);

bool BKE_library_ID_is_locally_used(Main *bmain, void *idv);
bool BKE_library_ID_is_indirectly_used(Main *bmain, void *idv);
void BKE_library_ID_test_usages(Main *bmain,
                                void *idv,
                                bool *r_is_used_local,
                                bool *r_is_used_linked);

struct LibQueryUnusedIDsData {
  bool do_local_ids = false;
  bool do_linked_ids = false;
  bool do_recursive = false;

  blender::FunctionRef<bool(ID *id)> filter_fn = nullptr;

  std::array<int, INDEX_ID_MAX> num_total;
  std::array<int, INDEX_ID_MAX> num_local;
  std::array<int, INDEX_ID_MAX> num_linked;
};

void BKE_lib_query_unused_ids_amounts(Main *bmain, LibQueryUnusedIDsData &parameters);
void BKE_lib_query_unused_ids_tag(Main *bmain, int tag, LibQueryUnusedIDsData &parameters);

void BKE_library_unused_linked_data_set_tag(Main *bmain, bool do_init_tag);
void BKE_library_indirectly_used_data_tag_clear(Main *bmain);