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.hh"
#include "BLI_map.hh"
#include "BLI_math_base.h"
#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 {
 private:
  int64_t size_ = 0;
  int64_t alignment_ = 0;
  uintptr_t alignment_mask_ = 0;
  bool is_trivial_ = false;
  bool is_trivially_destructible_ = false;
  bool has_special_member_functions_ = false;
 
  void (*default_construct_)(void *ptr) = nullptr;
  void (*default_construct_indices_)(void *ptr, const IndexMask &mask) = nullptr;
 
  void (*value_initialize_)(void *ptr) = nullptr;
  void (*value_initialize_indices_)(void *ptr, const IndexMask &mask) = nullptr;
 
  void (*destruct_)(void *ptr) = nullptr;
  void (*destruct_indices_)(void *ptr, const IndexMask &mask) = nullptr;
 
  void (*copy_assign_)(const void *src, void *dst) = 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_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_indices_)(void *src, void *dst, const IndexMask &mask) = nullptr;
 
  void (*move_construct_)(void *src, void *dst) = nullptr;
  void (*move_construct_indices_)(void *src, void *dst, const IndexMask &mask) = nullptr;
 
  void (*relocate_assign_)(void *src, void *dst) = nullptr;
  void (*relocate_assign_indices_)(void *src, void *dst, const IndexMask &mask) = nullptr;
 
  void (*relocate_construct_)(void *src, void *dst) = nullptr;
  void (*relocate_construct_indices_)(void *src, void *dst, const IndexMask &mask) = nullptr;
 
  void (*fill_assign_indices_)(const void *value, void *dst, const IndexMask &mask) = 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;
 
  friend bool operator==(const CPPType &a, const CPPType &b)
  {
    return &a == &b;
  }
 
  friend bool operator!=(const CPPType &a, const CPPType &b)
  {
    return !(&a == &b);
  }
 
  template<typename T> static const 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;
  }
  template<typename T> static const CPPType &get_impl();
 
  StringRefNull name() const
  {
    return debug_name_;
  }
 
  int64_t size() const
  {
    return size_;
  }
 
  int64_t alignment() const
  {
    return alignment_;
  }
 
  bool is_trivially_destructible() const
  {
    return is_trivially_destructible_;
  }
 
  bool is_trivial() const
  {
    return is_trivial_;
  }
 
  bool is_default_constructible() const
  {
    return default_construct_ != nullptr;
  }
 
  bool is_copy_constructible() const
  {
    return copy_assign_ != nullptr;
  }
 
  bool is_move_constructible() const
  {
    return move_assign_ != nullptr;
  }
 
  bool is_destructible() const
  {
    return destruct_ != nullptr;
  }
 
  bool is_copy_assignable() const
  {
    return copy_assign_ != nullptr;
  }
 
  bool is_move_assignable() const
  {
    return copy_construct_ != nullptr;
  }
 
  bool is_printable() const
  {
    return print_ != nullptr;
  }
 
  bool is_equality_comparable() const
  {
    return is_equal_ != nullptr;
  }
 
  bool is_hashable() const
  {
    return hash_ != nullptr;
  }
 
  bool has_special_member_functions() const
  {
    return has_special_member_functions_;
  }
 
  bool pointer_has_valid_alignment(const void *ptr) const
  {
    return (uintptr_t(ptr) & alignment_mask_) == 0;
  }
 
  bool pointer_can_point_to_instance(const void *ptr) const
  {
    return ptr != nullptr && pointer_has_valid_alignment(ptr);
  }
 
  void default_construct(void *ptr) const
  {
    BLI_assert(this->pointer_can_point_to_instance(ptr));
 
    default_construct_(ptr);
  }
 
  void default_construct_n(void *ptr, int64_t n) const
  {
    this->default_construct_indices(ptr, IndexMask(n));
  }
 
  void default_construct_indices(void *ptr, const IndexMask &mask) const
  {
    BLI_assert(mask.size() == 0 || this->pointer_can_point_to_instance(ptr));
 
    default_construct_indices_(ptr, mask);
  }
 
  void value_initialize(void *ptr) const
  {
    BLI_assert(this->pointer_can_point_to_instance(ptr));
 
    value_initialize_(ptr);
  }
 
  void value_initialize_n(void *ptr, int64_t n) const
  {
    this->value_initialize_indices(ptr, IndexMask(n));
  }
 
  void value_initialize_indices(void *ptr, const IndexMask &mask) const
  {
    BLI_assert(mask.size() == 0 || this->pointer_can_point_to_instance(ptr));
 
    value_initialize_indices_(ptr, mask);
  }
 
  void destruct(void *ptr) const
  {
    BLI_assert(this->pointer_can_point_to_instance(ptr));
 
    destruct_(ptr);
  }
 
  void destruct_n(void *ptr, int64_t n) const
  {
    this->destruct_indices(ptr, IndexMask(n));
  }
 
  void destruct_indices(void *ptr, const IndexMask &mask) const
  {
    BLI_assert(mask.size() == 0 || this->pointer_can_point_to_instance(ptr));
 
    destruct_indices_(ptr, mask);
  }
 
  void copy_assign(const void *src, void *dst) const
  {
    BLI_assert(this->pointer_can_point_to_instance(src));
    BLI_assert(this->pointer_can_point_to_instance(dst));
 
    copy_assign_(src, dst);
  }
 
  void copy_assign_n(const void *src, void *dst, int64_t n) const
  {
    this->copy_assign_indices(src, dst, IndexMask(n));
  }
 
  void copy_assign_indices(const void *src, void *dst, const IndexMask &mask) const
  {
    BLI_assert(mask.size() == 0 || src != dst);
    BLI_assert(mask.size() == 0 || this->pointer_can_point_to_instance(src));
    BLI_assert(mask.size() == 0 || this->pointer_can_point_to_instance(dst));
 
    copy_assign_indices_(src, dst, mask);
  }
 
  void copy_assign_compressed(const void *src, void *dst, const IndexMask &mask) const
  {
    BLI_assert(mask.size() == 0 || src != dst);
    BLI_assert(mask.size() == 0 || this->pointer_can_point_to_instance(src));
    BLI_assert(mask.size() == 0 || this->pointer_can_point_to_instance(dst));
 
    copy_assign_compressed_(src, dst, mask);
  }
 
  void copy_construct(const void *src, void *dst) const
  {
    BLI_assert(src != dst || is_trivial_);
    BLI_assert(this->pointer_can_point_to_instance(src));
    BLI_assert(this->pointer_can_point_to_instance(dst));
 
    copy_construct_(src, dst);
  }
 
  void copy_construct_n(const void *src, void *dst, int64_t n) const
  {
    this->copy_construct_indices(src, dst, IndexMask(n));
  }
 
  void copy_construct_indices(const void *src, void *dst, const IndexMask &mask) const
  {
    BLI_assert(mask.size() == 0 || src != dst);
    BLI_assert(mask.size() == 0 || this->pointer_can_point_to_instance(src));
    BLI_assert(mask.size() == 0 || this->pointer_can_point_to_instance(dst));
 
    copy_construct_indices_(src, dst, mask);
  }
 
  void copy_construct_compressed(const void *src, void *dst, const IndexMask &mask) const
  {
    BLI_assert(mask.size() == 0 || src != dst);
    BLI_assert(mask.size() == 0 || this->pointer_can_point_to_instance(src));
    BLI_assert(mask.size() == 0 || this->pointer_can_point_to_instance(dst));
 
    copy_construct_compressed_(src, dst, mask);
  }
 
  void move_assign(void *src, void *dst) const
  {
    BLI_assert(this->pointer_can_point_to_instance(src));
    BLI_assert(this->pointer_can_point_to_instance(dst));
 
    move_assign_(src, dst);
  }
 
  void move_assign_n(void *src, void *dst, int64_t n) const
  {
    this->move_assign_indices(src, dst, IndexMask(n));
  }
 
  void move_assign_indices(void *src, void *dst, const IndexMask &mask) const
  {
    BLI_assert(mask.size() == 0 || src != dst);
    BLI_assert(mask.size() == 0 || this->pointer_can_point_to_instance(src));
    BLI_assert(mask.size() == 0 || this->pointer_can_point_to_instance(dst));
 
    move_assign_indices_(src, dst, mask);
  }
 
  void move_construct(void *src, void *dst) const
  {
    BLI_assert(src != dst || is_trivial_);
    BLI_assert(this->pointer_can_point_to_instance(src));
    BLI_assert(this->pointer_can_point_to_instance(dst));
 
    move_construct_(src, dst);
  }
 
  void move_construct_n(void *src, void *dst, int64_t n) const
  {
    this->move_construct_indices(src, dst, IndexMask(n));
  }
 
  void move_construct_indices(void *src, void *dst, const IndexMask &mask) const
  {
    BLI_assert(mask.size() == 0 || src != dst);
    BLI_assert(mask.size() == 0 || this->pointer_can_point_to_instance(src));
    BLI_assert(mask.size() == 0 || this->pointer_can_point_to_instance(dst));
 
    move_construct_indices_(src, dst, mask);
  }
 
  void relocate_assign(void *src, void *dst) const
  {
    BLI_assert(src != dst || is_trivial_);
    BLI_assert(this->pointer_can_point_to_instance(src));
    BLI_assert(this->pointer_can_point_to_instance(dst));
 
    relocate_assign_(src, dst);
  }
 
  void relocate_assign_n(void *src, void *dst, int64_t n) const
  {
    this->relocate_assign_indices(src, dst, IndexMask(n));
  }
 
  void relocate_assign_indices(void *src, void *dst, const IndexMask &mask) const
  {
    BLI_assert(mask.size() == 0 || src != dst);
    BLI_assert(mask.size() == 0 || this->pointer_can_point_to_instance(src));
    BLI_assert(mask.size() == 0 || this->pointer_can_point_to_instance(dst));
 
    relocate_assign_indices_(src, dst, mask);
  }
 
  void relocate_construct(void *src, void *dst) const
  {
    BLI_assert(src != dst || is_trivial_);
    BLI_assert(this->pointer_can_point_to_instance(src));
    BLI_assert(this->pointer_can_point_to_instance(dst));
 
    relocate_construct_(src, dst);
  }
 
  void relocate_construct_n(void *src, void *dst, int64_t n) const
  {
    this->relocate_construct_indices(src, dst, IndexMask(n));
  }
 
  void relocate_construct_indices(void *src, void *dst, const IndexMask &mask) const
  {
    BLI_assert(mask.size() == 0 || src != dst);
    BLI_assert(mask.size() == 0 || this->pointer_can_point_to_instance(src));
    BLI_assert(mask.size() == 0 || this->pointer_can_point_to_instance(dst));
 
    relocate_construct_indices_(src, dst, mask);
  }
 
  void fill_assign_n(const void *value, void *dst, int64_t n) const
  {
    this->fill_assign_indices(value, dst, IndexMask(n));
  }
 
  void fill_assign_indices(const void *value, void *dst, const IndexMask &mask) const
  {
    BLI_assert(mask.size() == 0 || this->pointer_can_point_to_instance(value));
    BLI_assert(mask.size() == 0 || this->pointer_can_point_to_instance(dst));
 
    fill_assign_indices_(value, dst, mask);
  }
 
  void fill_construct_n(const void *value, void *dst, int64_t n) const
  {
    this->fill_construct_indices(value, dst, IndexMask(n));
  }
 
  void fill_construct_indices(const void *value, void *dst, const IndexMask &mask) const
  {
    BLI_assert(mask.size() == 0 || this->pointer_can_point_to_instance(value));
    BLI_assert(mask.size() == 0 || this->pointer_can_point_to_instance(dst));
 
    fill_construct_indices_(value, dst, mask);
  }
 
  bool can_exist_in_buffer(const int64_t buffer_size, const int64_t buffer_alignment) const
  {
    return size_ <= buffer_size && alignment_ <= buffer_alignment;
  }
 
  void print(const void *value, std::stringstream &ss) const
  {
    BLI_assert(this->pointer_can_point_to_instance(value));
    print_(value, ss);
  }
 
  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
  {
    BLI_assert(this->pointer_can_point_to_instance(a));
    BLI_assert(this->pointer_can_point_to_instance(b));
    return is_equal_(a, b);
  }
 
  bool is_equal_or_false(const void *a, const void *b) const
  {
    if (this->is_equality_comparable()) {
      return this->is_equal(a, b);
    }
    return false;
  }
 
  uint64_t hash(const void *value) const
  {
    BLI_assert(this->pointer_can_point_to_instance(value));
    return hash_(value);
  }
 
  uint64_t hash_or_fallback(const void *value, uint64_t fallback_hash) const
  {
    if (this->is_hashable()) {
      return this->hash(value);
    }
    return fallback_hash;
  }
 
  const void *default_value() const
  {
    return default_value_;
  }
 
  uint64_t hash() const
  {
    return get_default_hash(this);
  }
 
  void (*destruct_fn() const)(void *)
  {
    return destruct_;
  }
 
  template<typename T> bool is() const
  {
    return this == &CPPType::get<std::decay_t<T>>();
  }
 
  template<typename... T> bool is_any() const
  {
    return (this->is<T>() || ...);
  }
 
  template<typename... Types, typename Fn> void 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();
    }
  }
 
 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();