BKE_lib_remap.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
#pragma once
 
#include "BLI_compiler_attrs.h"
#include "BLI_function_ref.hh"
#include "BLI_map.hh"
#include "BLI_set.hh"
#include "BLI_span.hh"
#include "BLI_utildefines.h"
 
struct ID;
struct Main;
 
namespace blender::bke::id {
class IDRemapper;
}
 
/* BKE_libblock_free, delete are declared in BKE_lib_id.hh for convenience. */
 
/* Also IDRemap->flag. */
enum {
  ID_REMAP_SKIP_INDIRECT_USAGE = 1 << 0,
  ID_REMAP_SKIP_NEVER_NULL_USAGE = 1 << 1,
  ID_REMAP_STORE_NEVER_NULL_USAGE = 1 << 2,
  ID_REMAP_FORCE_NEVER_NULL_USAGE = 1 << 3,
  ID_REMAP_SKIP_OVERRIDE_LIBRARY = 1 << 4,
  ID_REMAP_FORCE_INTERNAL_RUNTIME_POINTERS = 1 << 5,
  ID_REMAP_FORCE_UI_POINTERS = 1 << 6,
  ID_REMAP_FORCE_OBDATA_IN_EDITMODE = 1 << 7,
  ID_REMAP_DO_LIBRARY_POINTERS = 1 << 8,
 
  ID_REMAP_ALLOW_IDTYPE_MISMATCH = 1 << 9,
 
  ID_REMAP_SKIP_USER_CLEAR = 1 << 16,
  ID_REMAP_FORCE_USER_REFCOUNT = 1 << 17,
  ID_REMAP_SKIP_USER_REFCOUNT = 1 << 18,
  ID_REMAP_SKIP_UPDATE_TAGGING = 1 << 19,
  ID_REMAP_NO_ORIG_POINTERS_ACCESS = 1 << 20,
};
 
enum eIDRemapType {
  ID_REMAP_TYPE_REMAP = 0,
 
  ID_REMAP_TYPE_CLEANUP = 1,
};
 
void BKE_libblock_remap_multiple_locked(Main *bmain,
                                        blender::bke::id::IDRemapper &mappings,
                                        const int remap_flags);
 
void BKE_libblock_remap_multiple(Main *bmain,
                                 blender::bke::id::IDRemapper &mappings,
                                 const int remap_flags);
 
void BKE_libblock_remap_multiple_raw(Main *bmain,
                                     blender::bke::id::IDRemapper &mappings,
                                     const int remap_flags);
void BKE_libblock_remap_locked(Main *bmain, void *old_idv, void *new_idv, int remap_flags)
    ATTR_NONNULL(1, 2);
void BKE_libblock_remap(Main *bmain, void *old_idv, void *new_idv, int remap_flags)
    ATTR_NONNULL(1, 2);
 
void BKE_libblock_unlink(Main *bmain, void *idv, bool do_skip_indirect) ATTR_NONNULL();
 
void BKE_libblock_relink_ex(Main *bmain, void *idv, void *old_idv, void *new_idv, int remap_flags)
    ATTR_NONNULL(2);
void BKE_libblock_relink_multiple(Main *bmain,
                                  const blender::Span<ID *> ids,
                                  eIDRemapType remap_type,
                                  blender::bke::id::IDRemapper &id_remapper,
                                  int remap_flags);
 
void BKE_libblock_relink_to_newid(Main *bmain, ID *id, int remap_flag) ATTR_NONNULL();
 
using BKE_library_free_notifier_reference_cb = void (*)(const void *);
using BKE_library_remap_editor_id_reference_cb =
    void (*)(const blender::bke::id::IDRemapper &mappings);
 
void BKE_library_callback_free_notifier_reference_set(BKE_library_free_notifier_reference_cb func);
void BKE_library_callback_remap_editor_id_reference_set(
    BKE_library_remap_editor_id_reference_cb func);
 
/* IDRemapper */
enum IDRemapperApplyResult {
  ID_REMAP_RESULT_SOURCE_UNAVAILABLE,
  ID_REMAP_RESULT_SOURCE_NOT_MAPPABLE,
  ID_REMAP_RESULT_SOURCE_REMAPPED,
  ID_REMAP_RESULT_SOURCE_UNASSIGNED,
};
 
enum IDRemapperApplyOptions {
  ID_REMAP_APPLY_UPDATE_REFCOUNT = (1 << 0),
 
  ID_REMAP_APPLY_ENSURE_REAL = (1 << 1),
 
  ID_REMAP_APPLY_UNMAP_WHEN_REMAPPING_TO_SELF = (1 << 2),
 
  ID_REMAP_APPLY_DEFAULT = 0,
};
ENUM_OPERATORS(IDRemapperApplyOptions, ID_REMAP_APPLY_UNMAP_WHEN_REMAPPING_TO_SELF)
 
using IDRemapperIterFunction = void (*)(ID *old_id, ID *new_id, void *user_data);
using IDTypeFilter = uint64_t;
 
namespace blender::bke::id {
 
class IDRemapper {
  Map<ID *, ID *> mappings_;
  IDTypeFilter source_types_ = 0;
 
  Set<ID *> never_null_users_;
 
 public:
  bool allow_idtype_mismatch = false;
 
 public:
  void clear()
  {
    mappings_.clear();
    never_null_users_.clear();
    source_types_ = 0;
  }
 
  bool is_empty() const
  {
    return mappings_.is_empty();
  }
 
  bool contains_mappings_for_any(IDTypeFilter filter) const
  {
    return (source_types_ & filter) != 0;
  }
 
  void add(ID *old_id, ID *new_id);
  void add_overwrite(ID *old_id, ID *new_id);
 
  IDRemapperApplyResult get_mapping_result(ID *id,
                                           IDRemapperApplyOptions options,
                                           const ID *id_self) const;
 
  IDRemapperApplyResult apply(ID **r_id_ptr,
                              IDRemapperApplyOptions options,
                              ID *id_self = nullptr) const;
 
  void never_null_users_add(ID *id)
  {
    never_null_users_.add(id);
  }
 
  const Set<ID *> &never_null_users() const
  {
    return never_null_users_;
  }
 
  void iter(FunctionRef<void(ID *old_id, ID *new_id)> func) const
  {
    for (auto item : mappings_.items()) {
      func(item.key, item.value);
    }
  }
 
  static const StringRefNull result_to_string(const IDRemapperApplyResult result);
 
  void print() const;
};
 
}  // namespace blender::bke::id