Blender  V3.3
BLI_cpp_type_make.hh
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 
3 #pragma once
4 
9 #include "BLI_cpp_type.hh"
10 #include "BLI_utildefines.h"
11 
13 
14 template<typename T> void default_construct_cb(void *ptr)
15 {
16  new (ptr) T;
17 }
18 template<typename T> void default_construct_indices_cb(void *ptr, IndexMask mask)
19 {
20  mask.foreach_index([&](int64_t i) { new (static_cast<T *>(ptr) + i) T; });
21 }
22 
23 template<typename T> void value_initialize_cb(void *ptr)
24 {
25  new (ptr) T();
26 }
27 
28 template<typename T> void value_initialize_indices_cb(void *ptr, IndexMask mask)
29 {
30  mask.foreach_index([&](int64_t i) { new (static_cast<T *>(ptr) + i) T(); });
31 }
32 
33 template<typename T> void destruct_cb(void *ptr)
34 {
35  (static_cast<T *>(ptr))->~T();
36 }
37 template<typename T> void destruct_indices_cb(void *ptr, IndexMask mask)
38 {
39  T *ptr_ = static_cast<T *>(ptr);
40  mask.foreach_index([&](int64_t i) { ptr_[i].~T(); });
41 }
42 
43 template<typename T> void copy_assign_cb(const void *src, void *dst)
44 {
45  *static_cast<T *>(dst) = *static_cast<const T *>(src);
46 }
47 template<typename T> void copy_assign_indices_cb(const void *src, void *dst, IndexMask mask)
48 {
49  const T *src_ = static_cast<const T *>(src);
50  T *dst_ = static_cast<T *>(dst);
51 
52  mask.foreach_index([&](int64_t i) { dst_[i] = src_[i]; });
53 }
54 template<typename T> void copy_assign_compressed_cb(const void *src, void *dst, IndexMask mask)
55 {
56  const T *src_ = static_cast<const T *>(src);
57  T *dst_ = static_cast<T *>(dst);
58 
59  mask.to_best_mask_type([&](auto best_mask) {
60  for (const int64_t i : IndexRange(best_mask.size())) {
61  dst_[i] = src_[best_mask[i]];
62  }
63  });
64 }
65 
66 template<typename T> void copy_construct_cb(const void *src, void *dst)
67 {
68  blender::uninitialized_copy_n(static_cast<const T *>(src), 1, static_cast<T *>(dst));
69 }
70 template<typename T> void copy_construct_indices_cb(const void *src, void *dst, IndexMask mask)
71 {
72  const T *src_ = static_cast<const T *>(src);
73  T *dst_ = static_cast<T *>(dst);
74 
75  mask.foreach_index([&](int64_t i) { new (dst_ + i) T(src_[i]); });
76 }
77 template<typename T> void copy_construct_compressed_cb(const void *src, void *dst, IndexMask mask)
78 {
79  const T *src_ = static_cast<const T *>(src);
80  T *dst_ = static_cast<T *>(dst);
81 
82  mask.to_best_mask_type([&](auto best_mask) {
83  for (const int64_t i : IndexRange(best_mask.size())) {
84  new (dst_ + i) T(src_[best_mask[i]]);
85  }
86  });
87 }
88 
89 template<typename T> void move_assign_cb(void *src, void *dst)
90 {
91  blender::initialized_move_n(static_cast<T *>(src), 1, static_cast<T *>(dst));
92 }
93 template<typename T> void move_assign_indices_cb(void *src, void *dst, IndexMask mask)
94 {
95  T *src_ = static_cast<T *>(src);
96  T *dst_ = static_cast<T *>(dst);
97 
98  mask.foreach_index([&](int64_t i) { dst_[i] = std::move(src_[i]); });
99 }
100 
101 template<typename T> void move_construct_cb(void *src, void *dst)
102 {
103  blender::uninitialized_move_n(static_cast<T *>(src), 1, static_cast<T *>(dst));
104 }
105 template<typename T> void move_construct_indices_cb(void *src, void *dst, IndexMask mask)
106 {
107  T *src_ = static_cast<T *>(src);
108  T *dst_ = static_cast<T *>(dst);
109 
110  mask.foreach_index([&](int64_t i) { new (dst_ + i) T(std::move(src_[i])); });
111 }
112 
113 template<typename T> void relocate_assign_cb(void *src, void *dst)
114 {
115  T *src_ = static_cast<T *>(src);
116  T *dst_ = static_cast<T *>(dst);
117 
118  *dst_ = std::move(*src_);
119  src_->~T();
120 }
121 template<typename T> void relocate_assign_indices_cb(void *src, void *dst, IndexMask mask)
122 {
123  T *src_ = static_cast<T *>(src);
124  T *dst_ = static_cast<T *>(dst);
125 
126  mask.foreach_index([&](int64_t i) {
127  dst_[i] = std::move(src_[i]);
128  src_[i].~T();
129  });
130 }
131 
132 template<typename T> void relocate_construct_cb(void *src, void *dst)
133 {
134  T *src_ = static_cast<T *>(src);
135  T *dst_ = static_cast<T *>(dst);
136 
137  new (dst_) T(std::move(*src_));
138  src_->~T();
139 }
140 template<typename T> void relocate_construct_indices_cb(void *src, void *dst, IndexMask mask)
141 {
142  T *src_ = static_cast<T *>(src);
143  T *dst_ = static_cast<T *>(dst);
144 
145  mask.foreach_index([&](int64_t i) {
146  new (dst_ + i) T(std::move(src_[i]));
147  src_[i].~T();
148  });
149 }
150 
151 template<typename T> void fill_assign_cb(const void *value, void *dst, int64_t n)
152 {
153  const T &value_ = *static_cast<const T *>(value);
154  T *dst_ = static_cast<T *>(dst);
155 
156  for (int64_t i = 0; i < n; i++) {
157  dst_[i] = value_;
158  }
159 }
160 template<typename T> void fill_assign_indices_cb(const void *value, void *dst, IndexMask mask)
161 {
162  const T &value_ = *static_cast<const T *>(value);
163  T *dst_ = static_cast<T *>(dst);
164 
165  mask.foreach_index([&](int64_t i) { dst_[i] = value_; });
166 }
167 
168 template<typename T> void fill_construct_cb(const void *value, void *dst, int64_t n)
169 {
170  const T &value_ = *static_cast<const T *>(value);
171  T *dst_ = static_cast<T *>(dst);
172 
173  for (int64_t i = 0; i < n; i++) {
174  new (dst_ + i) T(value_);
175  }
176 }
177 template<typename T> void fill_construct_indices_cb(const void *value, void *dst, IndexMask mask)
178 {
179  const T &value_ = *static_cast<const T *>(value);
180  T *dst_ = static_cast<T *>(dst);
181 
182  mask.foreach_index([&](int64_t i) { new (dst_ + i) T(value_); });
183 }
184 
185 template<typename T> void print_cb(const void *value, std::stringstream &ss)
186 {
187  const T &value_ = *static_cast<const T *>(value);
188  ss << value_;
189 }
190 
191 template<typename T> bool is_equal_cb(const void *a, const void *b)
192 {
193  const T &a_ = *static_cast<const T *>(a);
194  const T &b_ = *static_cast<const T *>(b);
195  return a_ == b_;
196 }
197 
198 template<typename T> uint64_t hash_cb(const void *value)
199 {
200  const T &value_ = *static_cast<const T *>(value);
201  return get_default_hash(value_);
202 }
203 
204 } // namespace blender::cpp_type_util
205 
206 namespace blender {
207 
208 template<typename T, CPPTypeFlags Flags>
210 {
211  using namespace cpp_type_util;
212 
213  debug_name_ = debug_name;
214  size_ = (int64_t)sizeof(T);
215  alignment_ = (int64_t)alignof(T);
216  is_trivial_ = std::is_trivial_v<T>;
217  is_trivially_destructible_ = std::is_trivially_destructible_v<T>;
218  if constexpr (std::is_default_constructible_v<T>) {
219  default_construct_ = default_construct_cb<T>;
220  default_construct_indices_ = default_construct_indices_cb<T>;
221  value_initialize_ = value_initialize_cb<T>;
222  value_initialize_indices_ = value_initialize_indices_cb<T>;
223  static T default_value;
224  default_value_ = (void *)&default_value;
225  }
226  if constexpr (std::is_destructible_v<T>) {
227  destruct_ = destruct_cb<T>;
228  destruct_indices_ = destruct_indices_cb<T>;
229  }
230  if constexpr (std::is_copy_assignable_v<T>) {
231  copy_assign_ = copy_assign_cb<T>;
232  copy_assign_indices_ = copy_assign_indices_cb<T>;
233  copy_assign_compressed_ = copy_assign_compressed_cb<T>;
234  }
235  if constexpr (std::is_copy_constructible_v<T>) {
236  copy_construct_ = copy_construct_cb<T>;
237  copy_construct_indices_ = copy_construct_indices_cb<T>;
238  copy_construct_compressed_ = copy_construct_compressed_cb<T>;
239  }
240  if constexpr (std::is_move_assignable_v<T>) {
241  move_assign_ = move_assign_cb<T>;
242  move_assign_indices_ = move_assign_indices_cb<T>;
243  }
244  if constexpr (std::is_move_constructible_v<T>) {
245  move_construct_ = move_construct_cb<T>;
246  move_construct_indices_ = move_construct_indices_cb<T>;
247  }
248  if constexpr (std::is_destructible_v<T>) {
249  if constexpr (std::is_move_assignable_v<T>) {
250  relocate_assign_ = relocate_assign_cb<T>;
251  relocate_assign_indices_ = relocate_assign_indices_cb<T>;
252  }
253  if constexpr (std::is_move_constructible_v<T>) {
254  relocate_construct_ = relocate_construct_cb<T>;
255  relocate_construct_indices_ = relocate_construct_indices_cb<T>;
256  }
257  }
258  if constexpr (std::is_copy_assignable_v<T>) {
259  fill_assign_indices_ = fill_assign_indices_cb<T>;
260  }
261  if constexpr (std::is_copy_constructible_v<T>) {
262  fill_construct_indices_ = fill_construct_indices_cb<T>;
263  }
264  if constexpr ((bool)(Flags & CPPTypeFlags::Hashable)) {
265  hash_ = hash_cb<T>;
266  }
267  if constexpr ((bool)(Flags & CPPTypeFlags::Printable)) {
268  print_ = print_cb<T>;
269  }
270  if constexpr ((bool)(Flags & CPPTypeFlags::EqualityComparable)) {
271  is_equal_ = is_equal_cb<T>;
272  }
273 
274  alignment_mask_ = (uintptr_t)alignment_ - (uintptr_t)1;
275  has_special_member_functions_ = (default_construct_ && copy_construct_ && copy_assign_ &&
276  move_construct_ && move_assign_ && destruct_);
277 }
278 
279 } // namespace blender
280 
281 #define BLI_CPP_TYPE_MAKE(IDENTIFIER, TYPE_NAME, FLAGS) \
282  template<> const blender::CPPType &blender::CPPType::get_impl<TYPE_NAME>() \
283  { \
284  static CPPType cpp_type{blender::CPPTypeParam<TYPE_NAME, FLAGS>(), STRINGIFY(IDENTIFIER)}; \
285  return cpp_type; \
286  }
CPPType(CPPTypeParam< T, Flags >, StringRef debug_name)
const void * default_value() const
SyclQueue void void * src
ccl_device_inline float4 mask(const int4 &mask, const float4 &a)
Definition: math_float4.h:513
#define T
static unsigned a[3]
Definition: RandGen.cpp:78
void move_assign_cb(void *src, void *dst)
void relocate_assign_indices_cb(void *src, void *dst, IndexMask mask)
void fill_assign_indices_cb(const void *value, void *dst, IndexMask mask)
void default_construct_indices_cb(void *ptr, IndexMask mask)
void copy_construct_indices_cb(const void *src, void *dst, IndexMask mask)
void copy_assign_compressed_cb(const void *src, void *dst, IndexMask mask)
void fill_construct_indices_cb(const void *value, void *dst, IndexMask mask)
void relocate_construct_cb(void *src, void *dst)
void copy_construct_compressed_cb(const void *src, void *dst, IndexMask mask)
void value_initialize_cb(void *ptr)
void move_assign_indices_cb(void *src, void *dst, IndexMask mask)
void copy_construct_cb(const void *src, void *dst)
void print_cb(const void *value, std::stringstream &ss)
void relocate_assign_cb(void *src, void *dst)
void move_construct_indices_cb(void *src, void *dst, IndexMask mask)
void value_initialize_indices_cb(void *ptr, IndexMask mask)
void fill_assign_cb(const void *value, void *dst, int64_t n)
bool is_equal_cb(const void *a, const void *b)
void copy_assign_cb(const void *src, void *dst)
void destruct_cb(void *ptr)
void destruct_indices_cb(void *ptr, IndexMask mask)
void fill_construct_cb(const void *value, void *dst, int64_t n)
uint64_t hash_cb(const void *value)
void relocate_construct_indices_cb(void *src, void *dst, IndexMask mask)
void default_construct_cb(void *ptr)
void copy_assign_indices_cb(const void *src, void *dst, IndexMask mask)
void move_construct_cb(void *src, void *dst)
void initialized_move_n(T *src, int64_t n, T *dst)
uint64_t get_default_hash(const T &v)
Definition: BLI_hash.hh:218
void uninitialized_copy_n(const T *src, int64_t n, T *dst)
void uninitialized_move_n(T *src, int64_t n, T *dst)
static const pxr::TfToken b("b", pxr::TfToken::Immortal)
_W64 unsigned int uintptr_t
Definition: stdint.h:119
__int64 int64_t
Definition: stdint.h:89
unsigned __int64 uint64_t
Definition: stdint.h:90
PointerRNA * ptr
Definition: wm_files.c:3480