BLI_cpp_type.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_hash.hh"
#include "BLI_index_mask_fwd.hh"
#include "BLI_map.hh"
#include "BLI_parameter_pack_utils.hh"
#include "BLI_string_ref.hh"
#include "BLI_utility_mixins.hh"

enum class CPPTypeFlags {
  None = 0,
  Hashable = 1 << 0,
  Printable = 1 << 1,
  EqualityComparable = 1 << 2,
  IdentityDefaultValue = 1 << 3,
 
  BasicType = Hashable | Printable | EqualityComparable,
};
ENUM_OPERATORS(CPPTypeFlags, CPPTypeFlags::EqualityComparable)
 
namespace blender {
 
class CPPType : NonCopyable, NonMovable {
 public:
  int64_t size = 0;

  int64_t alignment = 0;

  bool is_trivial = false;

  bool is_trivially_destructible = false;

  bool has_special_member_functions = false;
 
  bool is_default_constructible = false;
  bool is_copy_constructible = false;
  bool is_move_constructible = false;
  bool is_destructible = false;
  bool is_copy_assignable = false;
  bool is_move_assignable = false;
 
 private:
  uintptr_t alignment_mask_ = 0;
 
  void (*default_construct_)(void *ptr) = nullptr;
  void (*default_construct_n_)(void *ptr, int64_t n) = nullptr;
  void (*default_construct_indices_)(void *ptr, const IndexMask &mask) = nullptr;
 
  void (*value_initialize_)(void *ptr) = nullptr;
  void (*value_initialize_n_)(void *ptr, int64_t n) = nullptr;
  void (*value_initialize_indices_)(void *ptr, const IndexMask &mask) = nullptr;
 
  void (*destruct_)(void *ptr) = nullptr;
  void (*destruct_n_)(void *ptr, int64_t n) = nullptr;
  void (*destruct_indices_)(void *ptr, const IndexMask &mask) = nullptr;
 
  void (*copy_assign_)(const void *src, void *dst) = nullptr;
  void (*copy_assign_n_)(const void *src, void *dst, int64_t n) = nullptr;
  void (*copy_assign_indices_)(const void *src, void *dst, const IndexMask &mask) = nullptr;
  void (*copy_assign_compressed_)(const void *src, void *dst, const IndexMask &mask) = nullptr;
 
  void (*copy_construct_)(const void *src, void *dst) = nullptr;
  void (*copy_construct_n_)(const void *src, void *dst, int64_t n) = nullptr;
  void (*copy_construct_indices_)(const void *src, void *dst, const IndexMask &mask) = nullptr;
  void (*copy_construct_compressed_)(const void *src, void *dst, const IndexMask &mask) = nullptr;
 
  void (*move_assign_)(void *src, void *dst) = nullptr;
  void (*move_assign_n_)(void *src, void *dst, int64_t n) = nullptr;
  void (*move_assign_indices_)(void *src, void *dst, const IndexMask &mask) = nullptr;
 
  void (*move_construct_)(void *src, void *dst) = nullptr;
  void (*move_construct_n_)(void *src, void *dst, int64_t n) = nullptr;
  void (*move_construct_indices_)(void *src, void *dst, const IndexMask &mask) = nullptr;
 
  void (*relocate_assign_)(void *src, void *dst) = nullptr;
  void (*relocate_assign_n_)(void *src, void *dst, int64_t n) = nullptr;
  void (*relocate_assign_indices_)(void *src, void *dst, const IndexMask &mask) = nullptr;
 
  void (*relocate_construct_)(void *src, void *dst) = nullptr;
  void (*relocate_construct_n_)(void *src, void *dst, int64_t n) = nullptr;
  void (*relocate_construct_indices_)(void *src, void *dst, const IndexMask &mask) = nullptr;
 
  void (*fill_assign_n_)(const void *value, void *dst, int64_t n) = nullptr;
  void (*fill_assign_indices_)(const void *value, void *dst, const IndexMask &mask) = nullptr;
 
  void (*fill_construct_n_)(const void *value, void *dst, int64_t n) = nullptr;
  void (*fill_construct_indices_)(const void *value, void *dst, const IndexMask &mask) = nullptr;
 
  void (*print_)(const void *value, std::stringstream &ss) = nullptr;
  bool (*is_equal_)(const void *a, const void *b) = nullptr;
  uint64_t (*hash_)(const void *value) = nullptr;
 
  const void *default_value_ = nullptr;
  std::string debug_name_;
 
 public:
  template<typename T, CPPTypeFlags Flags>
  CPPType(TypeTag<T> /*type*/, TypeForValue<CPPTypeFlags, Flags> /*flags*/, StringRef debug_name);
  virtual ~CPPType() = default;

  template<typename T> static const CPPType &get();
  template<typename T> static const CPPType &get_impl();

  StringRefNull name() const;
 
  bool is_printable() const;
  bool is_equality_comparable() const;
  bool is_hashable() const;

  bool pointer_has_valid_alignment(const void *ptr) const;
  bool pointer_can_point_to_instance(const void *ptr) const;

  void default_construct(void *ptr) const;
  void default_construct_n(void *ptr, int64_t n) const;
  void default_construct_indices(void *ptr, const IndexMask &mask) const;

  void value_initialize(void *ptr) const;
  void value_initialize_n(void *ptr, int64_t n) const;
  void value_initialize_indices(void *ptr, const IndexMask &mask) const;

  void destruct(void *ptr) const;
  void destruct_n(void *ptr, int64_t n) const;
  void destruct_indices(void *ptr, const IndexMask &mask) const;

  void copy_assign(const void *src, void *dst) const;
  void copy_assign_n(const void *src, void *dst, int64_t n) const;
  void copy_assign_indices(const void *src, void *dst, const IndexMask &mask) const;

  void copy_assign_compressed(const void *src, void *dst, const IndexMask &mask) const;

  void copy_construct(const void *src, void *dst) const;
  void copy_construct_n(const void *src, void *dst, int64_t n) const;
  void copy_construct_indices(const void *src, void *dst, const IndexMask &mask) const;

  void copy_construct_compressed(const void *src, void *dst, const IndexMask &mask) const;

  void move_assign(void *src, void *dst) const;
  void move_assign_n(void *src, void *dst, int64_t n) const;
  void move_assign_indices(void *src, void *dst, const IndexMask &mask) const;

  void move_construct(void *src, void *dst) const;
  void move_construct_n(void *src, void *dst, int64_t n) const;
  void move_construct_indices(void *src, void *dst, const IndexMask &mask) const;

  void relocate_assign(void *src, void *dst) const;
  void relocate_assign_n(void *src, void *dst, int64_t n) const;
  void relocate_assign_indices(void *src, void *dst, const IndexMask &mask) const;

  void relocate_construct(void *src, void *dst) const;
  void relocate_construct_n(void *src, void *dst, int64_t n) const;
  void relocate_construct_indices(void *src, void *dst, const IndexMask &mask) const;

  void fill_assign_n(const void *value, void *dst, int64_t n) const;
  void fill_assign_indices(const void *value, void *dst, const IndexMask &mask) const;

  void fill_construct_n(const void *value, void *dst, int64_t n) const;
  void fill_construct_indices(const void *value, void *dst, const IndexMask &mask) const;
 
  bool can_exist_in_buffer(const int64_t buffer_size, const int64_t buffer_alignment) const;
 
  void print(const void *value, std::stringstream &ss) const;
  std::string to_string(const void *value) const;
  void print_or_default(const void *value, std::stringstream &ss, StringRef default_value) const;
 
  bool is_equal(const void *a, const void *b) const;
  bool is_equal_or_false(const void *a, const void *b) const;
 
  uint64_t hash(const void *value) const;
  uint64_t hash_or_fallback(const void *value, uint64_t fallback_hash) const;

  const void *default_value() const;
 
  uint64_t hash() const;
 
  void (*destruct_fn() const)(void *);
 
  template<typename T> bool is() const;
 
  template<typename... T> bool is_any() const;

  template<typename... Types, typename Fn> void to_static_type(const Fn &fn) const;
 
 private:
  template<typename Fn> struct TypeTagExecutor {
    const Fn &fn;
 
    template<typename T> void operator()() const
    {
      fn(TypeTag<T>{});
    }
 
    void operator()() const
    {
      fn(TypeTag<void>{});
    }
  };
 
 public:
  template<typename... Types, typename Fn> void to_static_type_tag(const Fn &fn) const
  {
    TypeTagExecutor<Fn> executor{fn};
    this->to_static_type<Types...>(executor);
  }
};

void register_cpp_types();
 
}  // namespace blender
 
/* Utility for allocating an uninitialized buffer for a single value of the given #CPPType. */
#define BUFFER_FOR_CPP_TYPE_VALUE(type, variable_name) \
  blender::DynamicStackBuffer<64, 64> stack_buffer_for_##variable_name((type).size, \
                                                                       (type).alignment); \
  void *variable_name = stack_buffer_for_##variable_name.buffer();
 
namespace blender {
 
/* Give a compile error instead of a link error when type information is missing. */
template<> const CPPType &CPPType::get_impl<void>() = delete;

inline bool operator==(const CPPType &a, const CPPType &b)
{
  return &a == &b;
}
 
inline bool operator!=(const CPPType &a, const CPPType &b)
{
  return !(&a == &b);
}
 
template<typename T> inline const CPPType &CPPType::get()
{
  /* Store the #CPPType locally to avoid making the function call in most cases. */
  static const CPPType &type = CPPType::get_impl<std::decay_t<T>>();
  return type;
}
 
inline StringRefNull CPPType::name() const
{
  return debug_name_;
}
 
inline bool CPPType::is_printable() const
{
  return print_ != nullptr;
}
 
inline bool CPPType::is_equality_comparable() const
{
  return is_equal_ != nullptr;
}
 
inline bool CPPType::is_hashable() const
{
  return hash_ != nullptr;
}
 
inline bool CPPType::pointer_has_valid_alignment(const void *ptr) const
{
  return (uintptr_t(ptr) & alignment_mask_) == 0;
}
 
inline bool CPPType::pointer_can_point_to_instance(const void *ptr) const
{
  return ptr != nullptr && pointer_has_valid_alignment(ptr);
}
 
inline void CPPType::default_construct(void *ptr) const
{
  default_construct_(ptr);
}
 
inline void CPPType::default_construct_n(void *ptr, int64_t n) const
{
  default_construct_n_(ptr, n);
}
 
inline void CPPType::default_construct_indices(void *ptr, const IndexMask &mask) const
{
  default_construct_indices_(ptr, mask);
}
 
inline void CPPType::value_initialize(void *ptr) const
{
  value_initialize_(ptr);
}
 
inline void CPPType::value_initialize_n(void *ptr, int64_t n) const
{
  value_initialize_n_(ptr, n);
}
 
inline void CPPType::value_initialize_indices(void *ptr, const IndexMask &mask) const
{
  value_initialize_indices_(ptr, mask);
}
 
inline void CPPType::destruct(void *ptr) const
{
  destruct_(ptr);
}
 
inline void CPPType::destruct_n(void *ptr, int64_t n) const
{
  destruct_n_(ptr, n);
}
 
inline void CPPType::destruct_indices(void *ptr, const IndexMask &mask) const
{
  destruct_indices_(ptr, mask);
}
 
inline void CPPType::copy_assign(const void *src, void *dst) const
{
  copy_assign_(src, dst);
}
 
inline void CPPType::copy_assign_n(const void *src, void *dst, int64_t n) const
{
  copy_assign_n_(src, dst, n);
}
 
inline void CPPType::copy_assign_indices(const void *src, void *dst, const IndexMask &mask) const
{
  copy_assign_indices_(src, dst, mask);
}
 
inline void CPPType::copy_assign_compressed(const void *src,
                                            void *dst,
                                            const IndexMask &mask) const
{
  copy_assign_compressed_(src, dst, mask);
}
 
inline void CPPType::copy_construct(const void *src, void *dst) const
{
  copy_construct_(src, dst);
}
 
inline void CPPType::copy_construct_n(const void *src, void *dst, int64_t n) const
{
  copy_construct_n_(src, dst, n);
}
 
inline void CPPType::copy_construct_indices(const void *src,
                                            void *dst,
                                            const IndexMask &mask) const
{
  copy_construct_indices_(src, dst, mask);
}
 
inline void CPPType::copy_construct_compressed(const void *src,
                                               void *dst,
                                               const IndexMask &mask) const
{
  copy_construct_compressed_(src, dst, mask);
}
 
inline void CPPType::move_assign(void *src, void *dst) const
{
  move_assign_(src, dst);
}
 
inline void CPPType::move_assign_n(void *src, void *dst, int64_t n) const
{
  move_assign_n_(src, dst, n);
}
 
inline void CPPType::move_assign_indices(void *src, void *dst, const IndexMask &mask) const
{
  move_assign_indices_(src, dst, mask);
}
 
inline void CPPType::move_construct(void *src, void *dst) const
{
  move_construct_(src, dst);
}
 
inline void CPPType::move_construct_n(void *src, void *dst, int64_t n) const
{
  move_construct_n_(src, dst, n);
}
 
inline void CPPType::move_construct_indices(void *src, void *dst, const IndexMask &mask) const
{
  move_construct_indices_(src, dst, mask);
}
 
inline void CPPType::relocate_assign(void *src, void *dst) const
{
  relocate_assign_(src, dst);
}
 
inline void CPPType::relocate_assign_n(void *src, void *dst, int64_t n) const
{
  relocate_assign_n_(src, dst, n);
}
 
inline void CPPType::relocate_assign_indices(void *src, void *dst, const IndexMask &mask) const
{
  relocate_assign_indices_(src, dst, mask);
}
 
inline void CPPType::relocate_construct(void *src, void *dst) const
{
  relocate_construct_(src, dst);
}
 
inline void CPPType::relocate_construct_n(void *src, void *dst, int64_t n) const
{
  relocate_construct_n_(src, dst, n);
}
 
inline void CPPType::relocate_construct_indices(void *src, void *dst, const IndexMask &mask) const
{
  relocate_construct_indices_(src, dst, mask);
}
 
inline void CPPType::fill_assign_n(const void *value, void *dst, int64_t n) const
{
  fill_assign_n_(value, dst, n);
}
 
inline void CPPType::fill_assign_indices(const void *value, void *dst, const IndexMask &mask) const
{
  fill_assign_indices_(value, dst, mask);
}
 
inline void CPPType::fill_construct_n(const void *value, void *dst, int64_t n) const
{
  fill_construct_n_(value, dst, n);
}
 
inline void CPPType::fill_construct_indices(const void *value,
                                            void *dst,
                                            const IndexMask &mask) const
{
  fill_construct_indices_(value, dst, mask);
}
 
inline bool CPPType::can_exist_in_buffer(const int64_t buffer_size,
                                         const int64_t buffer_alignment) const
{
  return this->size <= buffer_size && this->alignment <= buffer_alignment;
}
 
inline void CPPType::print(const void *value, std::stringstream &ss) const
{
  BLI_assert(this->pointer_can_point_to_instance(value));
  print_(value, ss);
}
 
inline bool CPPType::is_equal(const void *a, const void *b) const
{
  return is_equal_(a, b);
}
 
inline bool CPPType::is_equal_or_false(const void *a, const void *b) const
{
  if (this->is_equality_comparable()) {
    return this->is_equal(a, b);
  }
  return false;
}
 
inline uint64_t CPPType::hash(const void *value) const
{
  return hash_(value);
}
 
inline uint64_t CPPType::hash_or_fallback(const void *value, uint64_t fallback_hash) const
{
  if (this->is_hashable()) {
    return this->hash(value);
  }
  return fallback_hash;
}
 
inline const void *CPPType::default_value() const
{
  return default_value_;
}
 
inline uint64_t CPPType::hash() const
{
  return get_default_hash(this);
}
 
inline void (*CPPType::destruct_fn() const)(void *)
{
  return destruct_;
}
 
template<typename T> inline bool CPPType::is() const
{
  return this == &CPPType::get<std::decay_t<T>>();
}
 
template<typename... T> inline bool CPPType::is_any() const
{
  return (this->is<T>() || ...);
}
 
template<typename... Types, typename Fn> inline void CPPType::to_static_type(const Fn &fn) const
{
  using Callback = void (*)(const Fn &fn);
 
  /* Build a lookup table to avoid having to compare the current #CPPType with every type in
   * #Types one after another. */
  static const Map<const CPPType *, Callback> callback_map = []() {
    Map<const CPPType *, Callback> callback_map;
    /* This adds an entry in the map for every type in #Types. */
    (callback_map.add_new(&CPPType::get<Types>(),
                          [](const Fn &fn) {
                            /* Call the templated `operator()` of the given function object. */
                            fn.template operator()<Types>();
                          }),
     ...);
    return callback_map;
  }();
 
  const Callback callback = callback_map.lookup_default(this, nullptr);
  if (callback != nullptr) {
    callback(fn);
  }
  else {
    /* Call the non-templated `operator()` of the given function object. */
    fn();
  }
}
 
}  // namespace blender