[Bf-blender-cvs] [f0cdfa3539a] virtual-array-attributes: rename to get_internal_single
Jacques Lucke
noreply at git.blender.org
Thu Apr 15 17:14:45 CEST 2021
Commit: f0cdfa3539a3141e836b04ace537890f65ff7c60
Author: Jacques Lucke
Date: Thu Apr 15 16:45:40 2021 +0200
Branches: virtual-array-attributes
https://developer.blender.org/rBf0cdfa3539a3141e836b04ace537890f65ff7c60
rename to get_internal_single
===================================================================
M source/blender/blenlib/BLI_virtual_array.hh
M source/blender/functions/FN_generic_virtual_array.hh
M source/blender/functions/intern/generic_virtual_array.cc
===================================================================
diff --git a/source/blender/blenlib/BLI_virtual_array.hh b/source/blender/blenlib/BLI_virtual_array.hh
index d15ccd695dd..ab71a70bd5f 100644
--- a/source/blender/blenlib/BLI_virtual_array.hh
+++ b/source/blender/blenlib/BLI_virtual_array.hh
@@ -108,13 +108,13 @@ template<typename T> class VArray {
/* Returns the value that is returned for every index. This invokes undefined behavior if the
* virtual array would not return the same value for every index. */
- T get_single() const
+ T get_internal_single() const
{
BLI_assert(this->is_single());
if (size_ == 1) {
return this->get(0);
}
- return this->get_single_impl();
+ return this->get_internal_single_impl();
}
T operator[](const int64_t index) const
@@ -153,7 +153,7 @@ template<typename T> class VArray {
return false;
}
- virtual T get_single_impl() const
+ virtual T get_internal_single_impl() const
{
/* Provide a default implementation, so that subclasses don't have to provide it. This method
* should never be called because `is_single_impl` returns false by default. */
@@ -168,7 +168,7 @@ template<typename T> class VArray {
initialized_copy_n(span.data(), size_, r_span.data());
}
else if (this->is_single()) {
- const T single = this->get_single();
+ const T single = this->get_internal_single();
initialized_fill_n(r_span.data(), size_, single);
}
else {
@@ -186,7 +186,7 @@ template<typename T> class VArray {
uninitialized_copy_n(span.data(), size_, r_span.data());
}
else if (this->is_single()) {
- const T single = this->get_single();
+ const T single = this->get_internal_single();
uninitialized_fill_n(r_span.data(), size_, single);
}
else {
@@ -367,7 +367,7 @@ template<typename T> class VArray_For_Single final : public VArray<T> {
return true;
}
- T get_single_impl() const override
+ T get_internal_single_impl() const override
{
return value_;
}
@@ -536,7 +536,7 @@ inline void devirtualize_varray(const VArray<T> &varray, const Func &func, bool
if (enable) {
if (varray.is_single()) {
/* `VArray_For_Single` can be used for devirtualization, because it is declared `final`. */
- const VArray_For_Single<T> varray_single{varray.get_single(), varray.size()};
+ const VArray_For_Single<T> varray_single{varray.get_internal_single(), varray.size()};
func(varray_single);
return;
}
@@ -575,19 +575,19 @@ inline void devirtualize_varray2(const VArray<T1> &varray1,
}
if (is_span1 && is_single2) {
const VArray_For_Span<T1> varray1_span{varray1.get_internal_span()};
- const VArray_For_Single<T2> varray2_single{varray2.get_single(), varray2.size()};
+ const VArray_For_Single<T2> varray2_single{varray2.get_internal_single(), varray2.size()};
func(varray1_span, varray2_single);
return;
}
if (is_single1 && is_span2) {
- const VArray_For_Single<T1> varray1_single{varray1.get_single(), varray1.size()};
+ const VArray_For_Single<T1> varray1_single{varray1.get_internal_single(), varray1.size()};
const VArray_For_Span<T2> varray2_span{varray2.get_internal_span()};
func(varray1_single, varray2_span);
return;
}
if (is_single1 && is_single2) {
- const VArray_For_Single<T1> varray1_single{varray1.get_single(), varray1.size()};
- const VArray_For_Single<T2> varray2_single{varray2.get_single(), varray2.size()};
+ const VArray_For_Single<T1> varray1_single{varray1.get_internal_single(), varray1.size()};
+ const VArray_For_Single<T2> varray2_single{varray2.get_internal_single(), varray2.size()};
func(varray1_single, varray2_single);
return;
}
diff --git a/source/blender/functions/FN_generic_virtual_array.hh b/source/blender/functions/FN_generic_virtual_array.hh
index bc9c3aa0e56..ea6d79cf16d 100644
--- a/source/blender/functions/FN_generic_virtual_array.hh
+++ b/source/blender/functions/FN_generic_virtual_array.hh
@@ -110,20 +110,20 @@ class GVArray {
/* Copies the value that is used for every element into `r_value`, which is expected to point to
* initialized memory. This invokes undefined behavior if the virtual array would not return the
* same value for every index. */
- void get_single(void *r_value) const
+ void get_internal_single(void *r_value) const
{
BLI_assert(this->is_single());
if (size_ == 1) {
this->get(0, r_value);
}
- this->get_single_impl(r_value);
+ this->get_internal_single_impl(r_value);
}
- /* Same as `get_single`, but `r_value` points to initialized memory. */
+ /* Same as `get_internal_single`, but `r_value` points to initialized memory. */
void get_single_to_uninitialized(void *r_value) const
{
type_->construct_default(r_value);
- this->get_single(r_value);
+ this->get_internal_single(r_value);
}
void materialize_to_uninitialized(const IndexMask mask, void *dst) const;
@@ -147,7 +147,7 @@ class GVArray {
virtual GSpan get_internal_span_impl() const;
virtual bool is_single_impl() const;
- virtual void get_single_impl(void *UNUSED(r_value)) const;
+ virtual void get_internal_single_impl(void *UNUSED(r_value)) const;
virtual const void *try_get_internal_varray_impl() const;
};
@@ -296,7 +296,7 @@ class GVArray_For_SingleValueRef : public GVArray {
GSpan get_internal_span_impl() const override;
bool is_single_impl() const override;
- void get_single_impl(void *r_value) const override;
+ void get_internal_single_impl(void *r_value) const override;
};
class GVArray_For_SingleValue : public GVArray_For_SingleValueRef {
@@ -345,9 +345,9 @@ template<typename T> class GVArray_For_VArray : public GVArray {
return varray_->is_single();
}
- void get_single_impl(void *r_value) const override
+ void get_internal_single_impl(void *r_value) const override
{
- *(T *)r_value = varray_->get_single();
+ *(T *)r_value = varray_->get_internal_single();
}
const void *try_get_internal_varray_impl() const override
@@ -393,10 +393,10 @@ template<typename T> class VArray_For_GVArray : public VArray<T> {
return varray_->is_single();
}
- T get_single_impl() const override
+ T get_internal_single_impl() const override
{
T value;
- varray_->get_single(&value);
+ varray_->get_internal_single(&value);
return value;
}
};
@@ -444,10 +444,10 @@ template<typename T> class VMutableArray_For_GVMutableArray : public VMutableArr
return varray_->is_single();
}
- T get_single_impl() const override
+ T get_internal_single_impl() const override
{
T value;
- varray_->get_single(&value);
+ varray_->get_internal_single(&value);
return value;
}
};
@@ -493,9 +493,9 @@ template<typename T> class GVMutableArray_For_VMutableArray : public GVMutableAr
return varray_->is_single();
}
- void get_single_impl(void *r_value) const override
+ void get_internal_single_impl(void *r_value) const override
{
- *(T *)r_value = varray_->get_single();
+ *(T *)r_value = varray_->get_internal_single();
}
void set_by_copy_impl(const int64_t index, const void *value) override
@@ -718,7 +718,7 @@ template<typename T> class GVArray_Typed {
}
else if (gvarray.is_single()) {
T single_value;
- gvarray.get_single(&single_value);
+ gvarray.get_internal_single(&single_value);
varray_single_.emplace(single_value, gvarray.size());
varray_ = &*varray_single_;
}
diff --git a/source/blender/functions/intern/generic_virtual_array.cc b/source/blender/functions/intern/generic_virtual_array.cc
index 9a9d6f58839..108ff19e83f 100644
--- a/source/blender/functions/intern/generic_virtual_array.cc
+++ b/source/blender/functions/intern/generic_virtual_array.cc
@@ -52,7 +52,7 @@ bool GVArray::is_single_impl() const
return false;
}
-void GVArray::get_single_impl(void *UNUSED(r_value)) const
+void GVArray::get_internal_single_impl(void *UNUSED(r_value)) const
{
BLI_assert(false);
}
@@ -192,7 +192,7 @@ bool GVArray_For_SingleValueRef::is_single_impl() const
return true;
}
-void GVArray_For_SingleValueRef::get_single_impl(void *r_value) const
+void GVArray_For_SingleValueRef::get_internal_single_impl(void *r_value) const
{
type_->copy_to_initialized(value_, r_value);
}
More information about the Bf-blender-cvs
mailing list